Question

public EnumA
{
name = 1,
surname = 2
}
public EnumB
{
name = 50,
surname = 60
}

public void myMethod(User u,Enum e)
{
//Enum e can be either EnumA or EnumB
//Do something with the Enum Passed
}

假设我有上面的代码，但是我没有像上面那样在方法中指定Enum，而是想选择通过method参数传递的枚举。有没有办法这样做？

Answer 1

你可以通过反思来做到这一点，但我担心你不能正确理解枚举。它看起来像你试图将它们用作类实例来保存任意数据，在这种情况下，你真的应该使用真正的class。

如果我错了，我会在下面提供代码来做你要求的事情，但我认为这对你没用。

void Main()
{
    Test(EnumA.First);
    Console.WriteLine("-----");
    Test(EnumB.B);
}

void Test(Enum theEnum)
{
    Type t = theEnum.GetType();
    foreach (string element in Enum.GetNames(t))
    {
        Debug.WriteLine(element + " = " + (int) Enum.Parse(t, element));
    }
}

enum EnumA
{
    First = 1,
    Second = 2
}

enum EnumB
{
    A = 1,
    B = 2,
    C = 3
}

它会生成以下输出：

First = 1
Second = 2
-----
A = 1
B = 2
C = 3

我认为这更像是你想要做的事情：

void Main()
{
    Person A = new Person()
    {
        Name = "John",
        Surname = "Doe"
    };

    Person B = new Person()
    {
        Name = "Jane",
        Surname = "Doe"
    };

    A.ShowInfo();
    Console.WriteLine("----");
    B.ShowInfo();
}

class Person
{
    public string Name { get; set; }
    public string Surname { get; set; }

    public void ShowInfo()
    {
        Debug.WriteLine("Name=" + Name);
        Debug.WriteLine("Surname=" + Surname);
    }
}

输出以下内容：

Name=John
Surname=Doe
----
Name=Jane
Surname=Doe

Answer 2

您是否尝试过以下操作：

public void myMethod(User u,Enum e)
{
    if (e is EnumA)
    {
        EnumA ea = (EnumA)e;
        // Do something with ea
    }
    else if (e is EnumB)
    {
        EnumB eb = (EnumB)e;
        ...
    }
}

Answer 3

您已为此操作使用泛型类型。

下面的代码显示了一个示例代码（作为Console应用程序）;

   class Program
    {
        static void Main(string[] args)
        {
            myMethod<EnumA>("deneme", EnumA.name);
        }

        public enum EnumA
        {
            name = 1,
            surname = 2
        }
        public enum EnumB
        {
            name = 50,
            surname = 60
        }

        public static void myMethod<T>(string u, T e)
            where T : struct,IConvertible
        {
            if (typeof(T) == typeof(EnumA))
            {
                Console.WriteLine("EnumA");
            }
           else if (typeof(T) == typeof(EnumB))
            {
                Console.WriteLine("EnumB");
            }

            Console.ReadLine();

        }
    }

Answer 4

您可以使用重载：

public void myMethod(User u, EnumA e)
{
  // Call a function common to both
}


public void myMethod(User u, EnumB e)
{
  // Call a function common to both
}

我想C＃7.3允许您执行以下操作：

public void myMethod(User u, TEnum e) where TEnum : Enum
{
  //Enum e can be either EnumA or EnumB
  //Do something with the Enum Passed
}

我在7.3之前的项目中使用了类似的方法，这有点丑陋，但是比我能找到的任何其他方法都更好，更易读：

public void myMethod(User u, object e)
{
  // Test to make sure object type is either EnumA or EnumB
  // Call a function common to both
  // object e can be either EnumA or EnumB by casting like ((EnumA)e) or ((EnumB)e)
}

Answer 5

这不是枚举行为（或应该表现）的方式。您基本上创建了两个不同的枚举实例。这就是C＃中存在类的原因。考虑创建一个类：

public class SomeEnum
{
    public int Name;
    public int Surname;

    private SomeEnum(int name, int surname)
    {
        Name = name;
        Surname = surname;
    }

    public static SomeEnum EnumA => new SomeEnum(1, 2);
    public static SomeEnum EnumB => new SomeEnum(50, 60);
}

将您的方法更改为：

public void myMethod(User u, SomeEnum e)
{
  // Enum e can be either EnumA or EnumB
  // Do something with the Enum passed
}

我尽可能地更改了代码，因为我不确定这些＆＃39; Enums＆＃39;的目的是什么，但这样你就可以创建尽可能多的实例了想要，没有你的代码弄乱所有这些相同的Enum规范。

例如，要将此方法用于EnumA，您可以拨打myMethod(user, SomeEnum.EnumA)。

这样，它只能使用指定的枚举（EnumA和EnumB）。或者，如果您想要即时创建枚举，则可以将代码更改为：

public class SomeEnum
{
    public int Name;
    public int Surname;

    public SomeEnum(int name, int surname)
    {
        Name = name;
        Surname = surname;
    }
}

这样您就可以使用myMethod(user, new SomeEnum(1, 2))调用方法。

将枚举作为C＃中的参数或任何替代方法传递

5 个答案: