Abrufen aller Typen, die eine Schnittstelle implementieren

Wie kann ich mithilfe von Reflection alle Typen ermitteln, die eine Schnittstelle mit C # 3.0 / .NET 3.5 mit dem geringsten Code implementieren und Iterationen minimieren?

Folgendes möchte ich neu schreiben:

foreach (Type t in this.GetType().Assembly.GetTypes())
    if (t is IMyInterface)
        ; //do stuff

Meins wäre das in c # 3.0 :)

var type = typeof(IMyInterface);
var types = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(s => s.GetTypes())
    .Where(p => type.IsAssignableFrom(p));

Grundsätzlich ist die geringste Anzahl von Iterationen immer:

loop assemblies  
 loop types  
  see if implemented.

Das hat bei mir funktioniert. Es durchläuft die Klassen und prüft, ob sie von myInterface abgeleitet sind

 foreach (Type mytype in System.Reflection.Assembly.GetExecutingAssembly().GetTypes()
                 .Where(mytype => mytype .GetInterfaces().Contains(typeof(myInterface)))) {
    //do stuff
 }

So finden Sie alle Typen in einer Assembly, die die IFoo-Schnittstelle implementieren:

var results = from type in someAssembly.GetTypes()
              where typeof(IFoo).IsAssignableFrom(type)
              select type;

Beachten Sie, dass der Vorschlag von Ryan Rinaldi falsch war. Es werden 0 Typen zurückgegeben. Du kannst nicht schreiben

where type is IFoo

weil type eine System.Type-Instanz ist und niemals vom Typ IFoo sein wird. Stattdessen überprüfen Sie, ob IFoo vom Typ zuweisbar ist. Das wird Ihre erwarteten Ergebnisse erhalten.

Auch der Vorschlag von Adam Wright, der derzeit als Antwort markiert ist, ist aus demselben Grund ebenfalls falsch. Zur Laufzeit werden 0 Typen zurückgegeben, da alle System.Type-Instanzen keine IFoo-Implementierer waren.

Ich schätze, dass dies eine sehr alte Frage ist, aber ich dachte, ich würde eine weitere Antwort für zukünftige Benutzer hinzufügen, da alle bisherigen Antworten irgendeine Form von verwenden Assembly.GetTypes.

GetTypes () gibt zwar alle Typen zurück, bedeutet jedoch nicht unbedingt, dass Sie sie aktivieren und somit möglicherweise a auslösen können ReflectionTypeLoadException.

Ein klassisches Beispiel dafür, dass ein Typ nicht aktiviert werden kann, ist, wenn der zurückgegebene Typ derivedvon stammt, baseaber basein einer anderen Assembly als der von derivedeiner Assembly definiert ist, auf die die aufrufende Assembly nicht verweist.

Sagen wir also, wir haben:

Class A // in AssemblyA
Class B : Class A, IMyInterface // in AssemblyB
Class C // in AssemblyC which references AssemblyB but not AssemblyA

Wenn in ClassCwas AssemblyCdrin ist, dann tun wir etwas gemäß der akzeptierten Antwort:

var type = typeof(IMyInterface);
var types = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(s => s.GetTypes())
    .Where(p => type.IsAssignableFrom(p));

Dann wird es ein werfen ReflectionTypeLoadException.

Dies liegt daran, dass Sie ohne einen Verweis auf AssemblyA in AssemblyCnicht in der Lage wären:

var bType = typeof(ClassB);
var bClass = (ClassB)Activator.CreateInstance(bType);

Mit anderen Worten ClassBist nicht ladbar das ist etwas, dass der Aufruf von GetTypes Kontrollen und wirft auf.

Um die Ergebnismenge sicher für ladbare Typen zu qualifizieren, führen Sie stattdessen gemäß diesem Phil Haacked- Artikel Get All Types in a Assembly und Jon Skeet-Code Folgendes aus :

public static class TypeLoaderExtensions {
    public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly) {
        if (assembly == null) throw new ArgumentNullException("assembly");
        try {
            return assembly.GetTypes();
        } catch (ReflectionTypeLoadException e) {
            return e.Types.Where(t => t != null);
        }
    }
}

Und dann:

private IEnumerable<Type> GetTypesWithInterface(Assembly asm) {
    var it = typeof (IMyInterface);
    return asm.GetLoadableTypes().Where(it.IsAssignableFrom).ToList();
}

Andere Antworten hier verwenden IsAssignableFrom. Sie können auch FindInterfacesaus dem SystemNamespace verwenden, wie hier beschrieben .

Hier ist ein Beispiel, das alle Assemblys im Ordner der aktuell ausgeführten Assembly überprüft und nach Klassen sucht, die eine bestimmte Schnittstelle implementieren (wobei LINQ aus Gründen der Übersichtlichkeit vermieden wird).

static void Main() {
    const string qualifiedInterfaceName = "Interfaces.IMyInterface";
    var interfaceFilter = new TypeFilter(InterfaceFilter);
    var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
    var di = new DirectoryInfo(path);
    foreach (var file in di.GetFiles("*.dll")) {
        try {
            var nextAssembly = Assembly.ReflectionOnlyLoadFrom(file.FullName);
            foreach (var type in nextAssembly.GetTypes()) {
                var myInterfaces = type.FindInterfaces(interfaceFilter, qualifiedInterfaceName);
                if (myInterfaces.Length > 0) {
                    // This class implements the interface
                }
            }
        } catch (BadImageFormatException) {
            // Not a .net assembly  - ignore
        }
    }
}

public static bool InterfaceFilter(Type typeObj, Object criteriaObj) {
    return typeObj.ToString() == criteriaObj.ToString();
}

Sie können eine Liste von Schnittstellen einrichten, wenn Sie mehr als eine übereinstimmen möchten.

Durchlaufen Sie alle geladenen Assemblys, durchlaufen Sie alle ihre Typen und prüfen Sie, ob sie die Schnittstelle implementieren.

etwas wie:

Type ti = typeof(IYourInterface);
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) {
    foreach (Type t in asm.GetTypes()) {
        if (ti.IsAssignableFrom(t)) {
            // here's your type in t
        }
    }
}

Dies hat bei mir funktioniert (wenn Sie möchten, können Sie Systemtypen in der Suche ausschließen):

Type lookupType = typeof (IMenuItem);
IEnumerable<Type> lookupTypes = GetType().Assembly.GetTypes().Where(
        t => lookupType.IsAssignableFrom(t) && !t.IsInterface); 

Bearbeiten: Ich habe gerade die Bearbeitung gesehen, um zu verdeutlichen, dass die ursprüngliche Frage die Reduzierung von Iterationen / Code betraf und das alles gut und gut als Übung ist, aber in realen Situationen werden Sie unabhängig davon die schnellste Implementierung wünschen wie cool der zugrunde liegende LINQ aussieht.

Hier ist meine Utils-Methode zum Durchlaufen der geladenen Typen. Es behandelt sowohl reguläre Klassen als auch Schnittstellen, und die Option excludeSystemTypes beschleunigt die Arbeit erheblich, wenn Sie nach Implementierungen in Ihrer eigenen Codebasis / Drittanbieter-Codebasis suchen.

public static List<Type> GetSubclassesOf(this Type type, bool excludeSystemTypes) {
    List<Type> list = new List<Type>();
    IEnumerator enumerator = Thread.GetDomain().GetAssemblies().GetEnumerator();
    while (enumerator.MoveNext()) {
        try {
            Type[] types = ((Assembly) enumerator.Current).GetTypes();
            if (!excludeSystemTypes || (excludeSystemTypes && !((Assembly) enumerator.Current).FullName.StartsWith("System."))) {
                IEnumerator enumerator2 = types.GetEnumerator();
                while (enumerator2.MoveNext()) {
                    Type current = (Type) enumerator2.Current;
                    if (type.IsInterface) {
                        if (current.GetInterface(type.FullName) != null) {
                            list.Add(current);
                        }
                    } else if (current.IsSubclassOf(type)) {
                        list.Add(current);
                    }
                }
            }
        } catch {
        }
    }
    return list;
}

Es ist nicht schön, gebe ich zu.

Andere Antworten funktionierten nicht mit einer generischen Schnittstelle .

In diesem Fall ersetzen Sie einfach typeof (ISomeInterface) durch typeof (T).

List<string> types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes())
            .Where(x => typeof(ISomeInterface).IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract)
            .Select(x => x.Name).ToList();

Also mit

AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes())

Wir bekommen alle Baugruppen

!x.IsInterface && !x.IsAbstract

wird verwendet, um die Schnittstelle und abstrakte auszuschließen und

.Select(x => x.Name).ToList();

um sie in einer Liste zu haben.

Es gibt keine einfache Möglichkeit (in Bezug auf die Leistung), das zu tun, was Sie tun möchten.

Reflection funktioniert hauptsächlich mit Baugruppen und Typen, sodass Sie alle Baugruppentypen abrufen und nach der richtigen Schnittstelle abfragen müssen. Hier ist ein Beispiel:

Assembly asm = Assembly.Load("MyAssembly");
Type[] types = asm.GetTypes();
Type[] result = types.where(x => x.GetInterface("IMyInterface") != null);

Damit erhalten Sie alle Typen, die das IMyInterface in der Assembly MyAssembly implementieren

Noch besser bei der Auswahl des Montageorts. Filtern Sie die meisten Assemblys, wenn Sie wissen, dass sich alle implementierten Schnittstellen in derselben Assembly befinden. DefinedTypes.

// We get the assembly through the base class
var baseAssembly = typeof(baseClass).GetTypeInfo().Assembly;

// we filter the defined classes according to the interfaces they implement
var typeList = baseAssembly.DefinedTypes.Where(type => type.ImplementedInterfaces.Any(inter => inter == typeof(IMyInterface))).ToList();

Von Can Bilgin

Die OfType Linq-Methode kann genau für diese Art von Szenarien verwendet werden:

https://docs.microsoft.com/fr-fr/dotnet/api/system.linq.enumerable.oftype?view=netframework-4.8

Es gibt bereits viele gültige Antworten, aber ich möchte eine weitere Implementierung als Typerweiterung und eine Liste von Komponententests hinzufügen, um verschiedene Szenarien zu demonstrieren:

public static class TypeExtensions
{
    public static IEnumerable<Type> GetAllTypes(this Type type)
    {
        var typeInfo = type.GetTypeInfo();
        var allTypes = GetAllImplementedTypes(type).Concat(typeInfo.ImplementedInterfaces);
        return allTypes;
    }

    private static IEnumerable<Type> GetAllImplementedTypes(Type type)
    {
        yield return type;
        var typeInfo = type.GetTypeInfo();
        var baseType = typeInfo.BaseType;
        if (baseType != null)
        {
            foreach (var foundType in GetAllImplementedTypes(baseType))
            {
                yield return foundType;
            }
        }
    }
}

Dieser Algorithmus unterstützt die folgenden Szenarien:

public static class GetAllTypesTests
{
    public class Given_A_Sample_Standalone_Class_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        protected override void Given()
        {
            _sut = typeof(SampleStandalone);

            _expectedTypes =
                new List<Type>
                {
                    typeof(SampleStandalone),
                    typeof(object)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    public class Given_A_Sample_Abstract_Base_Class_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        protected override void Given()
        {
            _sut = typeof(SampleBase);

            _expectedTypes =
                new List<Type>
                {
                    typeof(SampleBase),
                    typeof(object)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    public class Given_A_Sample_Child_Class_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        protected override void Given()
        {
            _sut = typeof(SampleChild);

            _expectedTypes =
                new List<Type>
                {
                    typeof(SampleChild),
                    typeof(SampleBase),
                    typeof(object)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    public class Given_A_Sample_Base_Interface_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        protected override void Given()
        {
            _sut = typeof(ISampleBase);

            _expectedTypes =
                new List<Type>
                {
                    typeof(ISampleBase)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    public class Given_A_Sample_Child_Interface_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        protected override void Given()
        {
            _sut = typeof(ISampleChild);

            _expectedTypes =
                new List<Type>
                {
                    typeof(ISampleBase),
                    typeof(ISampleChild)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    public class Given_A_Sample_Implementation_Class_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        protected override void Given()
        {
            _sut = typeof(SampleImplementation);

            _expectedTypes =
                new List<Type>
                {
                    typeof(SampleImplementation),
                    typeof(SampleChild),
                    typeof(SampleBase),
                    typeof(ISampleChild),
                    typeof(ISampleBase),
                    typeof(object)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    public class Given_A_Sample_Interface_Instance_Type_When_Getting_All_Types
        : Given_When_Then_Test
    {
        private Type _sut;
        private IEnumerable<Type> _expectedTypes;
        private IEnumerable<Type> _result;

        class Foo : ISampleChild { }

        protected override void Given()
        {
            var foo = new Foo();
            _sut = foo.GetType();

            _expectedTypes =
                new List<Type>
                {
                    typeof(Foo),
                    typeof(ISampleChild),
                    typeof(ISampleBase),
                    typeof(object)
                };
        }

        protected override void When()
        {
            _result = _sut.GetAllTypes();
        }

        [Fact]
        public void Then_It_Should_Return_The_Right_Type()
        {
            _result.Should().BeEquivalentTo(_expectedTypes);
        }
    }

    sealed class SampleStandalone { }
    abstract class SampleBase { }
    class SampleChild : SampleBase { }
    interface ISampleBase { }
    interface ISampleChild : ISampleBase { }
    class SampleImplementation : SampleChild, ISampleChild { }
}

   public IList<T> GetClassByType<T>()
   {
        return AppDomain.CurrentDomain.GetAssemblies()
                          .SelectMany(s => s.GetTypes())
                          .ToList(p => typeof(T)
                          .IsAssignableFrom(p) && !p.IsAbstract && !p.IsInterface)
                          .SelectList(c => (T)Activator.CreateInstance(c));
   }

Ich habe Ausnahmen im Linq-Code, also mache ich es so (ohne eine komplizierte Erweiterung):

private static IList<Type> loadAllImplementingTypes(Type[] interfaces)
{
    IList<Type> implementingTypes = new List<Type>();

    // find all types
    foreach (var interfaceType in interfaces)
        foreach (var currentAsm in AppDomain.CurrentDomain.GetAssemblies())
            try
            {
                foreach (var currentType in currentAsm.GetTypes())
                    if (interfaceType.IsAssignableFrom(currentType) && currentType.IsClass && !currentType.IsAbstract)
                        implementingTypes.Add(currentType);
            }
            catch { }

    return implementingTypes;
}

Sie könnten etwas LINQ verwenden, um die Liste zu erhalten:

var types = from type in this.GetType().Assembly.GetTypes()
            where type is ISomeInterface
            select type;

Aber ist das wirklich besser lesbar?