Ndtyjky

I'm doing assembly analysis project and I encountered a problem.

What I want to achieve is list of all interfaces implemented by a class, but without derived interfaces (and interfaces implemented by derived classes).

Here's an example to illustrate (from LinqPad, .Dump() is a printing to result window):

void Main()

{

    typeof(A).GetInterfaces().Dump(); //typeof(IT), typeof(IT<Int32>) 

    typeof(B).GetInterfaces().Dump(); //typeof(IT<Int32>) 

    typeof(C).GetInterfaces().Dump(); //typeof(IT), typeof(IT<Int32>) 

}



class C : A {}



class A : IT {}



class B : IT<int> {}



public interface IT : IT <int> {}



public interface IT<T> {}

What I would like to get is

    typeof(A).GetInterfaces().Dump();  //typeof(IT)

    typeof(B).GetInterfaces().Dump();  //typeof(IT<Int32>) 

    typeof(C).GetInterfaces().Dump();  //

I found this post Type.GetInterfaces() for declared interfaces only with an answer

Type type = typeof(E);

var interfaces = type.GetInterfaces()

    .Where(i => type.GetInterfaceMap(i).TargetMethods.Any(m => m.DeclaringType == type))

    .ToList();

But I'm looking if there is an alternative that iterating through methods.

Is there any way to achieve this?

I tried to write my answer as self-documenting as possible.Variables names are also such that they explain what they are doing. So I will let the code do the talking :)

public static class InterfaceDumperExtension

{



    public static Type DumpInterface(this Type @type)

    {

        //From your question, I think that you only want to handle

        //class case so I am throwing here but you can handle accordingly

        if (@type.IsClass == false)

        {

            throw new NotSupportedException($"{@type} must be a class but it is not!");

        }



        //All of the interfaces implemented by the class

        var allInterfaces = new HashSet<Type>(@type.GetInterfaces());



        //Type one step down the hierarchy

        var baseType = @type.BaseType;



        //If it is not null, it might implement some other interfaces

        if (baseType != null)

        {

            //So let us remove all the interfaces implemented by the base class

            allInterfaces.ExceptWith(baseType.GetInterfaces());

        }



        //NOTE: allInterfaces now only includes interfaces implemented by the most derived class and

        //interfaces implemented by those(interfaces of the most derived class)



        //We want to remove interfaces that are implemented by other interfaces

        //i.e

        //public interface A : B{}

        //public interface B {}

        //public class Top : A{}→ We only want to dump interface A so interface B must be removed



        var toRemove = new HashSet<Type>();

        //Considering class A given above allInterfaces contain A and B now

        foreach (var implementedByMostDerivedClass in allInterfaces)

        {

            //For interface A this will only contain single element, namely B

            //For interface B this will an empty array

            foreach (var implementedByOtherInterfaces in implementedByMostDerivedClass.GetInterfaces())

            {

                toRemove.Add(implementedByOtherInterfaces);

            }

        }



        //Finally remove the interfaces that do not belong to the most derived class.

        allInterfaces.ExceptWith(toRemove);



        //Result

        return allInterfaces.ToArray();

    }

}

Test code:

public interface Interface1 { }

public interface Interface2 { }

public interface Interface3 { }

public interface DerivedInterface1 : Interface1 { }

public interface DerivedInterface2 : Interface2 { }

public class Test : DerivedInterface1, DerivedInterface2, Interface3 { }



var result = typeof(Test).DumpInterface();

//Contains only DerivedInterface1, DerivedInterface2, Interface3