it-swarm-eu.dev

Abrufen aller Typen in einem Namespace über Reflection

Wie erhält man alle Klassen in einem Namespace durch Reflektion in C #?

245
Chethan

Der folgende Code gibt die Namen der Klassen in dem angegebenen namespace aus, das in der aktuellen Assembly definiert ist.
Wie bereits erwähnt, kann ein Namespace auf verschiedene Module verteilt sein. Daher müssen Sie zuerst eine Liste der Assemblys abrufen.

string nspace = "...";

var q = from t in Assembly.GetExecutingAssembly().GetTypes()
        where t.IsClass && t.Namespace == nspace
        select t;
q.ToList().ForEach(t => Console.WriteLine(t.Name));
297
aku

Wie FlySwat sagt, können Sie denselben Namespace in mehreren Assemblys haben (z. B. System.Collections.Generic). Sie müssen alle diese Assemblys laden, wenn sie nicht bereits geladen sind. Also für eine vollständige Antwort:

AppDomain.CurrentDomain.GetAssemblies()
                       .SelectMany(t => t.GetTypes())
                       .Where(t => t.IsClass && t.Namespace == @namespace)

Dies sollte funktionieren, es sei denn, Sie möchten Klassen anderer Domänen. Um eine Liste aller Domains zu erhalten, folgen Sie diesen Link.

69
nawfal
using System.Reflection;
using System.Collections.Generic;
//...

static List<string> GetClasses(string nameSpace)
{
    Assembly asm = Assembly.GetExecutingAssembly();

    List<string> namespacelist = new List<string>();
    List<string> classlist = new List<string>();

    foreach (Type type in asm.GetTypes())
    {
        if (type.Namespace == nameSpace)
            namespacelist.Add(type.Name);
    }

    foreach (string classname in namespacelist)
        classlist.Add(classname);

    return classlist;
}

NB: Der obige Code zeigt, was los ist. Um es zu implementieren, kann eine vereinfachte Version verwendet werden:

using System.Linq;
using System.Reflection;
using System.Collections.Generic;
//...

static IEnumerable<string> GetClasses(string nameSpace)
{
    Assembly asm = Assembly.GetExecutingAssembly();
    return asm.GetTypes()
        .Where(type => type.Namespace == nameSpace)
        .Select(type => type.Name);
}
22
Ryan Farley

Für eine bestimmte Assembly, NameSpace und ClassName:

var assemblyName = "Some.Assembly.Name"
var nameSpace = "Some.Namespace.Name";
var className = "ClassNameFilter";

var asm = Assembly.Load(assemblyName);
var classes = asm.GetTypes().Where(p =>
     p.Namespace == nameSpace &&
     p.Name.Contains(className) 
).ToList();

Hinweis: Das Projekt muss auf die Assembly verweisen

15
John Peters

Hier ist eine Korrektur für LoaderException-Fehler, die Sie wahrscheinlich finden, wenn einer der Typen einen Typ in einer anderen Assembly unterordnet:

// Setup event handler to resolve assemblies
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(CurrentDomain_ReflectionOnlyAssemblyResolve);

Assembly a = System.Reflection.Assembly.ReflectionOnlyLoadFrom(filename);
a.GetTypes();
// process types here

// method later in the class:
static Assembly CurrentDomain_ReflectionOnlyAssemblyResolve(object sender, ResolveEventArgs args)
{
    return System.Reflection.Assembly.ReflectionOnlyLoad(args.Name);
}

Dies sollte beim Laden von Typen helfen, die in anderen Baugruppen definiert sind.

Hoffentlich hilft das!

12
tsimon

Sie können nicht alle Typen in einem Namespace abrufen, da ein Namespace mehrere Assemblys überbrücken kann. Sie können jedoch alle Klassen in einer Assembly abrufen und überprüfen, ob sie zu diesem Namespace gehören.

Assembly.GetTypes() funktioniert auf der lokalen Assembly, oder Sie können zuerst eine Assembly laden und dann GetTypes() aufrufen.

9
FlySwat

Genau wie @aku answer, aber mit den folgenden Erweiterungsmethoden:

string @namespace = "...";

var types = Assembly.GetExecutingAssembly().GetTypes()
    .Where(t => t.IsClass && t.Namespace == @namespace)
    .ToList();

types.ForEach(t => Console.WriteLine(t.Name));
5
JoanComasFdz

Holen Sie sich alle Klassen nach einem Teil des Namespace-Namens in nur einer Zeile:

var allClasses = Assembly.GetExecutingAssembly().GetTypes().Where(a => a.IsClass && a.Namespace != null && a.Namespace.Contains(@"..your namespace...")).ToList();
5
Ivo Stoyanov

Namespaces sind eigentlich eher passiv im Design der Laufzeit und dienen in erster Linie als organisatorische Werkzeuge. Der vollständige Name eines Typs in .NET besteht aus dem Namespace und Class/Enum/Etc. kombiniert. Wenn Sie nur eine bestimmte Assembly durchlaufen möchten, durchlaufen Sie einfach die von Assembly zurückgegebenen Typen. . GetExportedTypes () Überprüfen Sie den Wert von type . Namespace . Wenn Sie versuchen würden, alle in der aktuellen AppDomain geladenen Assemblys zu durchsuchen, müssten Sie AppDomain.CurrentDomain . GetAssemblies () verwenden

3
TheXenocide
//a simple combined code snippet 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace MustHaveAttributes
{
  class Program
  {
    static void Main ( string[] args )
    {
      Console.WriteLine ( " START " );

      // what is in the Assembly
      Assembly a = Assembly.Load ( "MustHaveAttributes" );
      Type[] types = a.GetTypes ();
      foreach (Type t in types)
      {

        Console.WriteLine ( "Type is {0}", t );
      }
      Console.WriteLine (
         "{0} types found", types.Length );

      #region Linq
      //#region Action


      //string @namespace = "MustHaveAttributes";

      //var q = from t in Assembly.GetExecutingAssembly ().GetTypes ()
      //        where t.IsClass && t.Namespace == @namespace
      //        select t;
      //q.ToList ().ForEach ( t => Console.WriteLine ( t.Name ) );


      //#endregion Action  
      #endregion

      Console.ReadLine ();
      Console.WriteLine ( " HIT A KEY TO EXIT " );
      Console.WriteLine ( " END " );
    }
  } //eof Program


  class ClassOne
  {

  } //eof class 

  class ClassTwo
  {

  } //eof class


  [System.AttributeUsage ( System.AttributeTargets.Class |
    System.AttributeTargets.Struct, AllowMultiple = true )]
  public class AttributeClass : System.Attribute
  {

    public string MustHaveDescription { get; set; }
    public string MusHaveVersion { get; set; }


    public AttributeClass ( string mustHaveDescription, string mustHaveVersion )
    {
      MustHaveDescription = mustHaveDescription;
      MusHaveVersion = mustHaveVersion;
    }

  } //eof class 

} //eof namespace 
2
Yordan Georgiev

Ziemlich einfach

Type[] types = Assembly.Load(new AssemblyName("mynamespace.folder")).GetTypes();
foreach (var item in types)
{
}
2
Antonio Lopes