c# where for generic type constraint class may NOT be

Question

I would like to exclude some types for being used in a generic class. I know how to make constrains in order to make sure a generic type is some kind of (interface) type. But I can't seem to figure out how to exclude (multiple) types.

For instance: I want a generic class to exclude ints and uints (but don't exclude DateTime for instance, so not all Primitives may be excluded).

I can't do something like this:

public class SomeWhereTest2<T> where T : !System.Int32 
{ 
}

Can someone help me out how to exclude multiple types at once?

I made a special class that acts like a dictionary and is also a FiFo collection with an index, where 0 is the most recent value, 1 the previous etc. (public class FiFoDictionary<K, V>: IDictionary<K, V>, which uses OrderedDictionary as the internal dict.)

But since the index is given via an int, this gives issues when the key of the dictionary is an int. Because then you get the value linked to the key, instead of the index. Or is there any way to force the use of the index instead of the key for an OrderedDictionary?

That's not how constraints work. The point of constraints is that a constraint on `T` provides `T` with capabilities. If you constrain to a particular interface or class, then you can call methods/properties that are defined in that interface or class. If you add a `new` constraint, then you can instantiate an object of type `T`. You'll need to do this check at runtime (check the type, throw an exception if the type is wrong) — Flydog57, Jan 28 '21 at 14:25
I'm curious what code you can write that you guarantee can work for all possible types, including types not yet written, but somehow is incapable of working with two types specifically. — Damien_The_Unbeliever, Jan 28 '21 at 14:39
@Damien_The_Unbeliever I made a special class that acts like a dictionary and is also a FiFo collection with an index, where 0 is the most recent value, 1 the previous etc. (public class FiFoDictionary: IDictionary, which uses OrderedDictionary as the internal dict.) But since the index is given via an int, this gives issues when the key of the dictionary is an int. Because then you get the value linked to the key, instead of the index. Or is there any way to force the use of the index instead of the key for an OrderedDictionary? — user369122, Jan 28 '21 at 14:45
@Flydog57 I kind of figured, but hoped for something I haven't seen yet. So, guess the only way is check on runtime. Thanks anyway — user369122, Jan 28 '21 at 14:47

NineBerry · Accepted Answer · 2021-01-28T15:41:38.530

Given the explanation in the comment, why you think you need this: No, you don't need to exclude int from the generic type.

When overloaded methods in a class (methods that differ by type of their parameters only) are used in a generic class, then the decision which of the methods is called is already made while the Generic class is compiled independently of the concrete type then used later on.

Example:

class Test<T>
{
    public void Trigger(T test)
    {
        // Will always call Internal(object) and never call Internal(int) even when T is int.
        Internal(test);
    }

    private void Internal(int test)
    {
        MessageBox.Show("Triggered int");
    }

    private void Internal(object test)
    {
        MessageBox.Show("Triggered object");
    }
}

private void buttonTest_Click(object sender, EventArgs e)
{
    Test<int> test = new Test<int>();
    test.Trigger(42);
}

The output is

"Triggered object"

Even when T is int, the overloaded Internal method that takes an int is never called because the decision that Trigger calls the Internal method that expects an object is already made for the whole generic class independently of the concrete type used.

The same is true when you use an OrderedDictionary internally. myOrderedDictionary[x] where x is a generic type will always use the index property that accesses entries by key and not the one that accesses them by order because this decision is made based on the known constraints of the generic type independently of the concrete type used later on.

class TestDictionary<TKey, TValue> 
{
    OrderedDictionary orderedDictionary = new OrderedDictionary();

    public void Add(TKey key, TValue value)
    {
        orderedDictionary.Add(key, value);
    }

    public TValue GetByIndex(int index)
    {
        return (TValue)orderedDictionary[index];
    }

    public TValue GetByKey(TKey key)
    {
        return (TValue)orderedDictionary[key];
    }
}

private void buttonTest_Click(object sender, EventArgs e)
{
    TestDictionary<int, string> test = new TestDictionary<int, string>();

    test.Add(42, "Test");

    MessageBox.Show(test.GetByIndex(0)); // Correct output "Test"
    MessageBox.Show(test.GetByKey(42)); // Correct output "Test"
}

Thanks for taking the time to help me out, really appreciate it. I think this approach will work fine. It makes sence. (I did a fast test and so far I did work). Regards, Matthijs — user369122, Jan 28 '21 at 15:54

score 0 · Answer 2 · answered Jan 28 '21 at 14:45

0

There is no such thing in C# however you can scope the generic type in a way that may help you to achieve that. This is just a sample and I don't consider this as a solution to your problem

class MyGeneric<T> where T : new() { } // T must be a class with default constructor
class MyGeneric<T> where T : System.IComparable<T> { }// T must implement IComparable interface 
class MyGeneric<T> where T : System.IComparable<T>, new () { }

answered Jan 28 '21 at 14:45

Sameh

1,318
11
11

Int32 does implement IComparable. So this will allow int. – NineBerry Jan 28 '21 at 15:10

score -1 · Answer 3 · answered Jan 28 '21 at 14:36

-1

its no posible to do, The != and == operators can't be used because there's no guarantee that the concrete type argument will support these operators. here you can read more about

answered Jan 28 '21 at 14:36

Cristian Mendoza

36
1
2

c# where for generic type constraint class may NOT be

3 Answers3

Linked