Wie kann ich einen bestimmten Typ in einer Assembly * effizient finden *?

Question

Ich suche nach einer effizienteren Möglichkeit, einen Typ in einer Assembly zu finden, die von einem bekannten spezifischen Typ abgeleitet ist. Im Grunde habe ich eine Plugin-Architektur in meiner Anwendung, und für die längste Zeit, die wir haben das getan:

For Each t As Type In assem.GetTypes() 
    If t.BaseType Is pluginType Then 
     'Do Stuff here' 
    End If 
Next 

Einige der Plugins haben eine große Anzahl von Arten und wir beginnen, um zu sehen, das eine nehmen ein paar Sekunden. Gibt es eine Möglichkeit, nach allen Typen zu fragen, die einen BaseType von "pluginType" haben?

EDIT: Ich habe mein Codebeispiel zu stark vereinfacht. Ich habe .GetExportedTypes() in meinem tatsächlichen Code verwendet. Allerdings waren viele Klassen als "öffentlich" markiert, was nicht sehr hilfreich war. Ich habe die Projekte durchgekämmt und alles "Freund" markiert, mit Ausnahme der eigentlichen Plugin-Klasse, und es dauert immer noch fast die gleiche Zeit, um die Assemblys zu untersuchen. Ich schneide vielleicht 100 ms von 1,3 Sekunden (was weniger als 10% ist). Ist das nur die Mindestzeit, mit der ich mich auseinandersetzen muss? Ich habe auch den Assembly-Attribut-Vorschlag ausprobiert und es ergab immer noch keinen großen Unterschied (vielleicht wieder 100ms). Ist der Rest der Zeit der Overhead, den ich bezahlen muss, um Baugruppen dynamisch zu laden?

Answer 1

Assembly.GetExportedTypes() gibt nur öffentliche Klassen zurück. Könnte das helfen?

Answer 2

Als Erstes können Sie versuchen, GetExportedTypes() zu verwenden, um die Liste der möglichen Typen einzuschränken. Abgesehen davon können Sie den Iterationsprozess nicht beschleunigen. Sie können jedoch umfassen ein Plugin, das Mainfest den genauen Typ (Typen) von Plugins innerhalb einer bestimmten Assembly angeben würde:

<manifest> 
    <plugin type="FooBar.Plugins.BazPlugin, FooBar" /> 
</manifest> 

, so dass Sie in der Lage sein würde Type.GetType(string)

IPlugin plugin = (IPlugin)Type.GetType("manifest/plugin/@type" /* for the sake of this discussion */); 

Answer 3

Unsere zu tun Plug-in-System verwendet Attribute, um die Plug-in-Typen zu identifizieren. Wir scannen dann einfach die Baugruppe nach dem spezifischen Attribut.

Answer 4

Lösung von mono-devel mailing list post by Jonathan Pryor und Plug-in Framework (Part1): Marking Types for Consumption: verwenden Sie Attribute auf Baugruppenebene.

Kurz gesagt, würden Sie ein neues Attribut hinzu:

[AttributeUsage(AttributeTargets.Assembly, AllowMultiple=true)] 
class PluginAttribute : Attribute { 
    public PluginAttribute (Type type) {this.Type = type;} 
    public Type Type {get; private set;} 
} 

Dann dieses Attribut festlegen, auf Baugruppenebene:

[assembly:Plugin (typeof(Plugin1))] 
[assembly:Plugin (typeof(Plugin2))] 

Dann die Montage für alle PluginAttributes abfragen:

Assembly a = ...; 
PluginAttribute[] plugins = 
    (PluginAttribute[]) a.GetCustomAttributes (
     typeof(PluginAttribute), true); 
foreach (var plugin in plugins) 
// plugin.Type is the type to use as a plugin 

Dies kann erheblich schneller sein als mit Assembly.GetTypes()/Assembly.GetExportedTypes(), als nur die Typen, die in [assembly:Plugin] aufgeführt sind Attribute tatsächlich geladen werden müssen, die die Menge an Speicher verbraucht deutlich verringern kann (abhängig von der Anzahl der Typen in der Baugruppe).

Answer 5

Gegeben mein Kommentar zu der Frage, wenn Sie können alle Typen in einem anderen Thread aufzählen, während Sie andere Dinge tun. Dann, wenn Sie bereit sind, die Typen aufzulisten, die Sie benötigen, sollte es mindestens zwei Größenordnungen schneller sein, laut my tests.