it-swarm-ko.tech

리플렉션을 통해 네임 스페이스의 모든 유형 가져 오기

C #에서 리플렉션을 통해 네임 스페이스의 모든 클래스를 어떻게 얻습니까?

245
Chethan

다음 코드는 현재 어셈블리에 정의 된 지정된 namespace의 클래스 이름을 인쇄합니다.
다른 사람들이 지적했듯이 네임 스페이스는 다른 모듈간에 분산 될 수 있으므로 먼저 어셈블리 목록을 가져와야합니다.

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

FlySwat이 말했듯이 여러 어셈블리에 동일한 네임 스페이스를 사용할 수 있습니다 (예 : System.Collections.Generic). 해당 어셈블리가 아직로드되지 않은 경우 해당 어셈블리를 모두로드해야합니다. 완전한 대답을 얻으려면 :

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

다른 도메인 클래스를 원하지 않는 한 작동합니다. 모든 도메인 목록을 얻으려면 this 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;
}

주의 : 위의 코드는 진행 상황을 보여줍니다. 그것을 구현했다면 단순화 된 버전을 사용할 수 있습니다.

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

특정 어셈블리, 네임 스페이스 및 클래스 이름의 경우 :

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

참고 : 프로젝트는 어셈블리를 참조해야합니다.

15
John Peters

다음은 유형 중 하나가 다른 어셈블리에서 유형을 소급하는 경우 찾을 수있는 LoaderException 오류에 대한 수정 사항입니다.

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

다른 어셈블리에 정의 된로드 유형에 도움이됩니다.

희망이 도움이됩니다!

12
tsimon

네임 스페이스가 여러 어셈블리를 브리지 할 수 있기 때문에 네임 스페이스에서 모든 유형을 가져올 수는 없지만 어셈블리의 모든 클래스를 가져 와서 해당 네임 스페이스에 속하는지 확인할 수 있습니다.

Assembly.GetTypes()은 로컬 어셈블리에서 작동하거나 먼저 어셈블리를로드 한 다음 GetTypes()을 (를) 호출 할 수 있습니다.

9
FlySwat

@aku 답변과 마찬가지로 확장 방법을 사용하십시오.

string @namespace = "...";

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

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

한 줄에 네임 스페이스 이름의 일부로 모든 클래스를 가져옵니다.

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

네임 스페이스는 실제로 런타임 디자인에서 수동적이며 주로 조직 도구로 사용됩니다. .NET에서 유형의 전체 이름은 네임 스페이스와 클래스/Enum/Etc로 구성됩니다. 결합. 특정 어셈블리 만 통과하려면 Assembly에서 반환 한 형식을 반복합니다 . GetExportedTypes () 형식 값 확인 . Namespace . 현재 AppDomain에로드 된 모든 어셈블리를 살펴 보려고하면 AppDomain.CurrentDomain을 사용해야합니다 . GetAssemblies ()

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

아주 간단한

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