如何獲取定義的枚舉數？

Question

我有3枚Enum。 MyEnumA，MyEnumB，MyEnumC。

我需要確定類或命名空間中的Enum數量。

代碼應返回3。

enum MyEnumA{ }
enum MyEnumB{ }
enum MyEnumC{ }

Answer 1

您可以使用反射從程序集中獲取類型。 我將包含一個控制台應用程序，它將獲取執行程序集中的所有枚舉類型，計算它們，並打印正確的值。 請注意，這可能會根據框架而改變，例如在UWP中獲取類型（ GetTypes() ）只是略有不同。 總的來說，我認為這個控制台應用示例可以回答您

簡單示例：

using System;
using System.Linq;
using System.Reflection;

namespace Question_Answer_Console_App
{
    class Program
    {
        static void Main(string[] args)
        {
            var enumsInAssembly = Assembly.GetExecutingAssembly()
                                          .GetTypes()
                                          .Where(type => type.IsEnum);

            Console.WriteLine(enumsInAssembly.Count());
            Console.Read();
        }
    }

    enum MyEnumA { }
    enum MyEnumB { }
    enum MyEnumC { }
}

輸出：

3

以下是相同示例應用程序的更深入版本，它將幫助您瀏覽命名空間和類（正如您可能希望搜索特定命名空間或類的注釋中所指出的那樣）。查看此示例應該可以幫助您編寫或者了解如何編寫所需的正確邏輯以獲得所需的結果。 無論哪種方式，只需知道在搜索類型，屬性，修飾符，ETC的程序集時所需的一切; 發現是使用反射。

更深的例子：

using System;
using System.Linq;
using System.Reflection;

namespace Question_Answer_Console_App
{
    class Program
    {
        static void Main(string[] args)
        {
            var assemblyTypes = Assembly.GetExecutingAssembly()
                                        .GetTypes()
                                        .OrderBy(type => type.Name);

            var namespacesInAssembly = assemblyTypes.Select(type => type.Namespace)
                                                    .Distinct()
                                                    .OrderBy(name => name);

            var enumsInAssembly = assemblyTypes.Where(type => type.IsEnum)
                                               .OrderBy(type => type.Name); ;

            var enumsInNamespaceB = enumsInAssembly.Where(@enum => @enum.Namespace.EndsWith(nameof(NamespaceB)))
                                                   .OrderBy(type => type.Name); ;

            var enumsInClassC = assemblyTypes.Where(type => type.IsClass)
                                             .Where(type => type.Name == nameof(NamespaceC.ClassC))
                                             .SelectMany(type => type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
                                             .Where(type => type.IsEnum)
                                             .OrderBy(type => type.Name);

            foreach (var @namespace in namespacesInAssembly)
                Console.WriteLine($"Namespace found: {@namespace}");

            Console.WriteLine();
            Console.WriteLine($"Enums in Assembly: {enumsInAssembly.Count()}");
            Console.WriteLine();
            Console.WriteLine($"Enums in Namespace B: {enumsInNamespaceB.Count()}");
            Console.WriteLine();
            Console.WriteLine($"Enums in Class C: {enumsInClassC.Count()}");
            Console.WriteLine();

            foreach (var x in enumsInClassC)
                Console.WriteLine(x.Name);

            Console.Read();
        }
    }

    namespace NamespaceA
    {
        enum MyEnumA { }
    }

    namespace NamespaceB
    {
        enum MyEnumB { }
    }

    namespace NamespaceC
    {
        public class ClassC
        {
            enum MyEnumC { }
            enum MyEnumD { }
        }
    }
}

輸出：

Namespace found: Question_Answer_Console_App
Namespace found: Question_Answer_Console_App.NamespaceA
Namespace found: Question_Answer_Console_App.NamespaceB
Namespace found: Question_Answer_Console_App.NamespaceC

Enums in Assembly: 4

Enums in Namespace B: 1

Enums in Class C: 2

MyEnumC
MyEnumD

Answer 2

您可以在通用方法中編寫它來定位class ， assembly或namespace

例

  private static int GetEnumCountFromClass<T>()
  {
    return typeof(T).GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)
         .Count(x => x.IsEnum);
  }

  private static int GetEnumFromAssembly(Assembly assembly, string nameSpace = null)
  {
     assembly = assembly ?? Assembly.GetExecutingAssembly();
     var types = assembly.GetTypes().AsEnumerable();

     if (nameSpace != null)
     {
        types = types.Where(x => x.Namespace == nameSpace);
     }
     return types.Count(x => x.IsEnum);

  }

用法

public static void Main(string[] args)
{
   Console.WriteLine("Enum Count from class : " + GetEnumCountFromClass<Program>());
   Console.WriteLine("Enum Count from assembly : " + GetEnumFromAssembly(Assembly.GetExecutingAssembly()));
}

完整的演示在這里

---

Type.GetNestedTypes方法

獲取嵌套在當前Type中的類型。

BindingFlags枚舉

指定控制綁定的標志以及通過反射搜索成員和類型的方式。

Assembly.GetTypes方法

獲取此程序集中定義的類型。