Function Declarations with Generics in C#

Question

I have a function that is declared like so:

public static string MultiWhereToString(List<WhereCondition<T>> whereConditions)

I am trying to pass it a variable called whereAnd which is delcared like so:

private List<WhereAndCondition<T>> whereAnd = new List<WhereAndCondition<T>>();

WhereAndCondition is a sub class of WhereCondition. It is declared like so:

public class WhereAndCondition<T> : WhereCondition<T>, IConditional where T : DatabaseObject

My issue is, if I try to execute the following code:

private List<WhereAndCondition<T>> whereAnd = new List<WhereAndCondition<T>>();
MultiWhereToString(whereAnd);

I get the following error:

Error 3 Argument 1: cannot convert from 'System.Collections.Generic.List<BrainStorm.WhereAndCondition<T>>' to 'System.Collections.Generic.List<BrainStorm.WhereCondition<T>>'

Any ideas on why? I think it has to do with the generics of the WhereCondition classes.

Can you `public static string MultiWhereToString(IList> whereConditions)` ? — Joe, Nov 15 '11 at 20:33
[In C#, is it possible to cast a List to List?](http://stackoverflow.com/questions/1777800/in-c-is-it-possible-to-cast-a-listchild-to-listparent) — Michał Powaga, Nov 15 '11 at 20:36
If you were to pass around IEnumerable instead of List, you could take advantage of covariance features. http://blogs.msdn.com/b/csharpfaq/archive/2010/02/16/covariance-and-contravariance-faq.aspx — spender, Nov 15 '11 at 20:39
@MichałPowaga No. There isn't a way to guarantee proper use. — McKay, Nov 15 '11 at 20:46
@IAbstractDownvoteFactory Thats actually what I wound up doing. Worked nicely — user489041, Nov 15 '11 at 20:59
I put it down as an answer, feel free to mark it or not. Glad to help — Joe, Nov 15 '11 at 21:03

score 2 · Answer 1 · answered Nov 15 '11 at 20:35

Given:

class A {}
class A : B {}

An object of List<B> is not an instance of List<A>. So you can't cast a List<WhereAndCondition> to a List<WhereCondition>. You could use:

MultiWhereToString(whereAnd.OfType<WhereCondition>().ToList());

(There might also be a solution involving the in and out variance annotations, but I'm not terribly familiar with them.)

score 2 · Answer 2 · edited May 23 '17 at 10:34

2

Your function is defined as taking a WhereCondition List, but you're passing it a WhereAndCondition List:

MultiWhereToString(List<WhereCondition<T>> whereConditions)

private List<WhereAndCondition<T>> whereAnd = new List<WhereAndCondition<T>>(); 
MultiWhereToString(whereAnd);

List variance has limited supported in .NET 4. See this question.

edited May 23 '17 at 10:34

Community

1
1

answered Nov 15 '11 at 20:35

Esoteric Screen Name

6,082
4
29
38

The reason is the fact the cast is simply not typesafe – where does loss of data come into it? – millimoose Nov 15 '11 at 20:40
@Inerdia - I realized that as soon as I posted; I had a brain fart and was thinking of converting a parent to child, rather than the other way around. Edited with link to a better explanation than I could easily provide. And I realize that 'data loss' isn't really the correct term for that either. My language skills are garbage. – Esoteric Screen Name Nov 15 '11 at 20:43

score 2 · Answer 3 · edited Nov 15 '11 at 20:44

2

Generics have to be known explicitly at compile time because they are generated.

Why not use:

private List<WhereCondition<T>> whereAnd = new List<WhereCondition<T>>();

So you can still add WhereAndCondition objects to whereAnd.

edited Nov 15 '11 at 20:44

Tad Donaghe

6,625
1
29
64

answered Nov 15 '11 at 20:39

Kay

12,918
4
55
77

score 2 · Answer 4 · answered Nov 15 '11 at 20:42

You can replace the entire WhereCondition<T> in your MultiWhereToString method with another generic type which is restricted to WhereCondition<T>.

Replace:

public static string MultiWhereToString(List<WhereCondition<T>> whereConditions)

With:

public static string MultiWhereToString<TType>(List<TType> whereConditions) where TType: WhereCondition<T>

Or alternatively change:

private List<WhereAndCondition<T>> whereAnd = new List<WhereAndCondition<T>>();

to:

private List<WhereCondition<T>> whereAnd = new List<WhereCondition<T>>();

And let inheritance take care of the rest for you.

score 2 · Answer 5 · answered Nov 15 '11 at 20:42

This appears to be a covariance / contravariance issue.

Simplified to this:

    public class WhereCondition
    {
    }

    public class WhereAndCondition : WhereCondition
    {
    }

    public class blah
    {
        public static void Blah()
        {
            List<WhereAndCondition> whereAnd = new List<WhereAndCondition>();
            MultiWhereToString(whereAnd);
        }

        public static string MultiWhereToString(List<WhereCondition> whereConditions)
        {
            return null;
        }
    }

It's not going to work, because the list of WhereAndConditions can't be cast to List of WhereConditions:

Imagine it this way. You've got a list of giraffes, and the method is asking for a list of animals.

Without knowing what they are going to do with the list animals (like try adding a horse) the types are incompatible, but if you change it to something like this:

        public static string MultiWhereToString(IEnumerable<WhereCondition> whereConditions)
        {
            return null;
        }

Then the variance can kick in, and give you what you're looking for.

score 2 · Accepted Answer · answered Nov 15 '11 at 21:02

2

I would suggest using interfaces:

public static string MultiWhereToString(IEnumerable<ICondition<T>> whereConditions)

This would allow you a lot more freedom when calling this method.

answered Nov 15 '11 at 21:02

Joe

80,724
18
127
145

Function Declarations with Generics in C#

6 Answers6