Obtention de tous les types dans un espace de nom par réflexion

Question

Comment obtenir toutes les classes d'un espace de nom par réflexion en C#?

Answer 1

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; 
} 

Answer 2

Vous ne serez pas en mesure d'obtenir tous les types dans un espace de noms, car un espace de noms peut combler plusieurs ensembles, mais vous pouvez obtenir toutes les classes dans un ensemble et vérifier si elles appartiennent à cet espace de noms.

Assembly.GetTypes() fonctionne sur l'assembly local, ou vous pouvez charger un assembly en premier, puis appeler le GetTypes() dessus.

Answer 3

Le code suivant affiche les noms des classes définies dans l'assembly en cours namespace.
Comme d'autres personnes l'ont souligné, un espace de noms peut être dispersé entre différents modules, vous devez donc d'abord obtenir une liste des assemblages.

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)); 

Answer 4

Les espaces de noms sont plutôt passifs dans la conception de l'environnement d'exécution et servent principalement d'outils d'organisation. Le nom complet d'un type dans .NET se compose de l'espace de noms et de la classe/Enum/Etc. combiné. Si vous souhaitez uniquement passer par un assemblage spécifique, vous devez simplement parcourir les types renvoyés par assembly. GetExportedTypes() en vérifiant la valeur du type. Namespace. Si vous essayez de parcourir tous les assemblys chargés dans l'AppDomain actuel, cela impliquera d'utiliser AppDomain.CurrentDomain. GetAssemblies()

Answer 5

est ici un correctif pour les erreurs de LoaderException que vous êtes susceptible de trouver si l'un des types sublasses un type dans un autre ensemble:

// 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); 
} 

Cela devrait aider avec les types de charge définis dans d'autres assemblées.

Espérons que ça aide!

Answer 6

//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 

Answer 7

Comme réponse @aku, mais en utilisant des méthodes d'extension:

string @namespace = "..."; 

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

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

Answer 8

Comme le dit FlySwat, vous pouvez avoir le même espace couvrant dans plusieurs ensembles (pour par exemple System.Collections.Generic). Vous devrez charger tous ces assemblages s'ils ne sont pas déjà chargés. Donc, pour une réponse complète:

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

Cela devrait fonctionner sauf si vous voulez des classes d'autres domaines. Pour obtenir une liste de tous les domaines, suivez this link.

Answer 9

Obtenez toutes les classes par une partie du nom Namespace en une seule ligne:

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

Answer 10

Pour une assemblée spécifique, avec un filtre de nom de classe:

var asm = Assembly.Load("Some.Assembly.Name"); 
var nameSpace = "Some.Namespace.Name"; 

var classes = asm.GetTypes().Where(p => 
    p.Namespace == nameSpace && 
    p.Name.Contains("ClassNameFilter") 
).ToList(); 

note: le projet doit faire référence à l'ensemble

Answer 11

est très simple

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