Obtener todos los tipos en un espacio de nombres a través de la reflexión

Question

¿Cómo se obtienen todas las clases en un espacio de nombres a través de la reflexión 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

Usted no será capaz de obtener todo tipo en un espacio de nombres, debido a que un espacio de nombres puede conectar varias asambleas, pero se puede llegar a todas las clases en una asamblea y comprobar para ver si pertenecen a ese espacio de nombres.

Assembly.GetTypes() trabaja en el ensamblaje local, o puede cargar un ensamblaje primero y luego llamar al GetTypes().

Answer 3

El siguiente código imprime los nombres de las clases en namespace especificado en el ensamblaje actual.
Como señalaron otros tipos, un espacio de nombres puede estar disperso entre diferentes módulos, por lo que primero debe obtener una lista de ensamblajes.

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

Los espacios de nombres son realmente bastante pasivos en el diseño del tiempo de ejecución y sirven principalmente como herramientas de organización. El nombre completo de un tipo en .NET consiste en Namespace y Class/Enum/Etc. conjunto. Si solo desea pasar por un ensamblaje específico, simplemente recorrerá los tipos devueltos por el ensamblaje. GetExportedTypes() comprobando el valor del tipo. Namespace. Si estuviera tratando de pasar por todos los ensamblados cargados en el actual AppDomain, implicaría el uso de AppDomain.CurrentDomain. GetAssemblies()

Answer 5

Aquí es una solución para los errores LoaderException es muy probable que encontrar si uno de los tipos sublasses un tipo en otro montaje:

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

Eso debería ayudar con los tipos de carga definidas en otros conjuntos.

Espero que ayude!

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

Al igual que la respuesta @aku, pero utilizando métodos de extensión:

string @namespace = "..."; 

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

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

Answer 8

Como dice flyswat, que pueden tener el mismo espacio de nombres que abarca en varios ensamblados (por ejemplo System.Collections.Generic). Deberá cargar todos los ensamblajes si aún no están cargados. Entonces para una respuesta completa:

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

Esto debería funcionar a menos que desee clases de otros dominios. Para obtener una lista de todos los dominios, siga this link.

Answer 9

conseguir todas las clases por parte del nombre de espacio de nombres en una sola fila:

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

Answer 10

Para una Asamblea específica, con un filtro de nombre de la clase:

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

Nota: el proyecto debe hacer referencia al ensamblado

Answer 11

Muy sencillo

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