Ytukyg

I'm creating code that is using abstract generic class as base. I got a little stuck since I'm try to create factory that will return specific object base on inserted object type.

Lets say that i want to compare to object to check are they are equal or not. In my scenario i want to compare object in way base on that if they are type of IEnumerable or IList

My code :

Interface :

public interface IObjectComparer<in T>

{

    bool Compare(T obj1, T obj2);

}

Base class :

public abstract class ObjectComparerBase<T> : IObjectComparer<T>

{

    public abstract bool Compare(T obj1, T obj2);



    public void SomeUsefullHelperMethod()

    {



    }

}

IList object comparer :

public sealed class ListObjectComparer : ObjectComparerBase<IList>

{

    public override bool Compare(IList obj1, IList obj2)

    {

        throw new NotImplementedException();

    }

}

and IEnumerable object comparer

public sealed class EnumerableObjectComparer : ObjectComparerBase<IEnumerable>

{ 

    public override bool Compare(IEnumerable obj1, IEnumerable obj2)

    {

        throw new System.NotImplementedException();

    }

}

At the end i have my factory that should decide if which comparer i need to use for certain object :

public sealed class ComparerRetriever

{

    public static IObjectComparer<T> Retrieve<T>(T obj)

    {

        IObjectComparer<T> comparer = null;

        switch (typeof(T))

        {

            case IEnumerable o:

            {

                comparer = new EnumerableObjectComparer();

                break;

            }



            case IList o:

            {

                comparer = new ListObjectComparer();

                break;

            }



            default:

                throw new NotSupportedException("Not Supported Type");

        }



        return comparer;

    }

}

My problem :

In current scenario i cannot use my ComparerRetriever class because compilator is say that nether ListObjectComparer nor EnumerableObjectComparer is not IObjectComparer<T> type.

My question is why ? My objects are have ObjectComparerBase<T> class as a parent and this class is implementing IObjectComparer<T> so in my opinion EnumerableObjectComparer and ListObjectComparer should be type of ObjectComparerBase<T>

Probably I'm missing something but at this point I cannot see what.

Can you help me ?

Thanks.

So this works and returns the classes as expected. You will have to put IList first because IList implements IEnumerable and if IEnumerable is first it will also fall to that case.

public sealed class ComparerRetriever

{

    public static IObjectComparer<T> Retrieve<T>(T obj)

    {

        IObjectComparer<T> comparer;

        switch (typeof(T))

        {

            case IList o:

            {

                comparer = new ListObjectComparer() as IObjectComparer<T>;

                break;

            }

            case IEnumerable o:

            {

                comparer = new EnumerableObjectComparer() as IObjectComparer<T>;

                break;

            }





            default:

                throw new NotSupportedException("Not Supported Type");

        }



        return comparer;

    }

}

I do think though that you will always hit the default case as any object you pass to the Retrieve method as it will have a concrete type and the typeof will result in that concrete type not the Intreface

For instance when I did my testing I created

class SimpleList : IList

{

   ... blah

}

and predictably the typeof call resulted in SimpleList and not IList so it always threw

NotSupportedException("Not Supported Type");

obviously I could be wrong and you could be one step ahead of me so I'll leave my answer there as I believe I've answered the original question

UPDATE
After more testing I'm not sure you can use pattern matching on interfaces, I have since changed my implementation to the below and I still hit the default case.

public static IObjectComparer<T> Retrieve<T>(T obj)

{

    IObjectComparer<T> comparer;



    var interf = typeof(T).GetInterfaces().FirstOrDefault();

    switch (interf)

    {

        case IList o:

        {

            comparer = new ListObjectComparer() as IObjectComparer<T>;

            break;

        }

        case IEnumerable o:

        {

            comparer = new EnumerableObjectComparer() as IObjectComparer<T>;

            break;

        }





        default:

            throw new NotSupportedException("Not Supported Type");

    }



    return comparer;

}