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

¿Cómo se obtienen todas las clases en un espacio de nombres a través de la reflexión en C #?

El siguiente código imprime los nombres de las clases en el namespace especificado definido en el ensamblaje actual.
Como otros chicos señalaron, 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)); 

Como dice FlySwat, puede tener el mismo espacio de nombres en múltiples conjuntos (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 este enlace.

 using System.Reflection; using System.Collections.Generic; //... static List GetClasses(string nameSpace) { Assembly asm = Assembly.GetExecutingAssembly(); List namespacelist = new List(); List classlist = new List(); 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: el código anterior ilustra lo que está sucediendo. Si lo implementara, se puede usar una versión simplificada:

 using System.Linq; using System.Reflection; using System.Collections.Generic; //... static IEnumerable GetClasses(string nameSpace) { Assembly asm = Assembly.GetExecutingAssembly(); return asm.GetTypes() .Where(type => type.Namespace == nameSpace) .Select(type => type.Name); } 

Aquí hay una solución para los errores LoaderException que es probable que encuentres si uno de los tipos sublaciona un tipo en otro ensamblado:

 // 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 definidos en otros ensambles.

¡Espero que ayude!

Para una Asamblea específica, con un filtro de nombre de 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 ensamblaje

No podrá obtener todos los tipos en un espacio de nombres, porque un espacio de nombres puede unir múltiples ensamblajes, pero puede obtener todas las clases en un ensamblado y verificar si pertenecen a ese espacio de nombres.

Assembly.GetTypes() funciona en el ensamblado local, o puede cargar un ensamblado primero y luego llamar a GetTypes() en él.

Al igual que @aku answer, pero usando 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)); 

Obtenga todas las clases por parte del nombre del 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(); 

Los espacios de nombres en realidad son 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 de tipo. Espacio de nombres Si estuviera tratando de pasar por todos los ensamblados cargados en el actual AppDomain, implicaría el uso de AppDomain.CurrentDomain. GetAssemblies ()

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

Bastante sencillo

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