Question about generics

Question

0.00/5 (No votes)

See more:

I am trying to dig around generics for a bit now, and do not understand the following example:

interface IBaseObject
{
}
interface ITest<T> where T : class, IBaseObject
{
}
abstract class Test<T> : ITest<T> where T : class, IBaseObject
{
}
class BaseObject : IBaseObject
{
}
class ChildObject : BaseObject
{
}
class Specialized : Test<ChildObject>
{
}

class Program
{
    static void Main(string[] args)
    {
        ITest<IBaseObject> test = new Specialized() as ITest<IBaseObject>;
    }
}

ITest<IBaseObject> test

is null.

What I have tried:

I understand, that there is something wrong with this code, but cannot get any idea what it can be. Is it even possible to cast down specialized object to generic interface?
Thanks

Posted 1-Mar-18 7:55am

csrss

Updated 1-Mar-18 8:12am

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Accepted Answer · 2018-03-01T08:13:00

Covariance and Contravariance in Generics | Microsoft Docs[^]

It's not a simple topic. :)

Imagine a world where I<Derived> was equivalent to I<Base>. That would mean that the following code would work:

C#

class Base { }
class Derived : Base { }
class OtherDerived : Base { }

List<Derived> list = new List<Derived>();
IList<Base> baseList = list;
baseList.Add(new OtherDerived());

Now the list is broken - it can only contain Derived objects, but we've managed to sneak a OtherDerived instance into it.

For your sample to work, your ITest<T> interface needs to be covariant:

C#

interface ITest<out T> where T : class, IBaseObject
{
}

With that one change in place, your code will work as expected.

However, your interface will now be subject to the restrictions placed on a covariant interface: you cannot use the type parameter as a method parameter, not even an out parameter; nor can you use it as the type of a writeable property.