在c#或任何替代方法中将enum作为参数传递

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
}

您可以通过反射来做到这一点，但是我担心您不能正确地理解枚举。在我看来，你试图使用它们作为类实例来保存任意数据，在这种情况下，你真的应该使用一个真正的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

您试过以下方法吗:

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;
        ...
    }
}

您使用的是泛型类型。

下面的代码显示一个示例代码(作为控制台应用程序);

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

你可以使用重载:

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

这不是枚举的行为(或应该的行为)。你基本上是在创建两个不同的枚举实例。这就是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
}

我改变了尽可能少的代码，因为我不确定这些'枚举'的目的是什么，但这样你就可以创建尽可能多的实例，而不会因为所有这些相同的枚举规范而使代码变得混乱。

以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))来调用这个方法。