C# 如何在枚举中创建逻辑

在C#中，我知道我们不能将对象分配给枚举。我想要的功能是，当声明枚举时，它会触发一个事件

因此，与其

enum MyEnum
{
  string, int, etc
}

我本来可以的

enum MyEnum
{
    classType1, classType2
}

这样还可以调用类classType1/classType2构造函数，例如，在声明枚举时，该构造函数可能对日志记录非常有用

提出我的问题的另一种方式可能是

enum MyEnum
{
   string1
      {
          //logic
      },
   string2
      {
          //logic
      }
}

---

这有什么办法吗

代替

enum

您可以使用具有静态属性的

静态类

，它可以与

枚举

相同，但您可以在getter和setter内部编写代码。

代替

enum

您可以使用具有静态属性的

静态类

，它可以与

enum

一样使用，但您可以在getter和setter中编写代码。

您可以使用

属性

而不是

enum

（然后您可以编写自己的逻辑，该逻辑将在分配变量之后/之前调用）。应使用

enum

结构创建类似stuff的标志

private string _myVar;
public string MyVar
{
   get { return _myVar; }
   set
   {
      // logic 1 here
      _myVar = value;
      // logic 2 here
   }
}

---

您可以使用

属性

而不是

枚举

（然后您可以编写自己的逻辑，该逻辑将在分配变量之后/之前调用）。应使用

enum

结构创建类似stuff的标志

private string _myVar;
public string MyVar
{
   get { return _myVar; }
   set
   {
      // logic 1 here
      _myVar = value;
      // logic 2 here
   }
}

---

我认为，你的期望与语言不符，因此没有变通办法。例如，考虑一下会发生什么：

if (myEnumValue == MyEnum.classType1)

您的问题意味着在右侧，将为相等测试实例化一个“classType1”类，然后结果将取决于该类型的相等实现。当左边的项目是枚举时，这会令人困惑。。。但假设它是“classType1”类型的对象，这意味着左侧和右侧都是临时对象

你可以看到这是行不通的

但是。。。我认为您真正想要的是从枚举创建对象的工厂。提出其他问题的整个其他问题（对不起）。像这样的枚举意味着一个状态。。。那么，如果您有一个状态，为什么该状态需要枚举？这本身就是一个大问题，请查看状态模式

---

希望我能帮上忙。

没有解决办法，因为我认为您的期望与语言不符。例如，考虑一下会发生什么：

if (myEnumValue == MyEnum.classType1)

您的问题意味着在右侧，将为相等测试实例化一个“classType1”类，然后结果将取决于该类型的相等实现。当左边的项目是枚举时，这会令人困惑。。。但假设它是“classType1”类型的对象，这意味着左侧和右侧都是临时对象

你可以看到这是行不通的

但是。。。我认为您真正想要的是从枚举创建对象的工厂。提出其他问题的整个其他问题（对不起）。像这样的枚举意味着一个状态。。。那么，如果您有一个状态，为什么该状态需要枚举？这本身就是一个大问题，请查看状态模式

---

希望我能帮上忙。

枚举是一种基于

Int##

类型的值类型。这和问问题一样：我能在

inti=7的赋值中加入一些逻辑吗直接回答是否

除整数类型外，您也不能将
enum
基于任何其他类型

但您的需求似乎与跟踪实例有关。这对属性来说很容易。但您只能对特定属性执行此操作，而不能将其构建到类型中
 枚举是基于
Int##
类型的值类型。这和问问题一样：我能在
inti=7的赋值中加入一些逻辑吗直接回答是否

除整数类型外，您也不能将
enum
基于任何其他类型

但您的需求似乎与跟踪实例有关。这对属性来说很容易。但您只能对特定属性执行此操作，而不能将其构建到类型中
 枚举仅仅是带有综合标签的整数。据我所知，您要查找的内容无法使用枚举完成

然而，正如@Grumbler85所述，可以使用工厂模拟这种行为。
工厂是一种特殊类型的对象，用于创建其他对象的实例

实现工厂最简单的方法是使用switch语句，但也存在其他方法（例如反射）。下面是一个简单的示例，说明您在寻找什么：

Class A
{
   ...
}

Class B
{
   ... 
}

enum eKnownTypes
{
     A,
     B
}

Class Factory
{
    /* 
         Implement Singleton here
         ....
    */
    public object CreateInstance(eKnownTypes t)
    {
         /*
               Raise any event needed here
               ...
         */
         switch (t):
         {
              case eKnownTypes.A: return new A(); break;
              case eKnownTypes.B: return new B(); break;
         }          
         return null;
    }

}

/* 
         Set Event Handlers here
         Factory.Instance.CustomEvent += new EventHandler ... 
         ....
*/
A objectA = Factory.Instance.CreateInstance(eKnownTypes.A) as A;
...

枚举仅仅是带有综合标签的整数。据我所知，您要查找的内容无法使用枚举完成

然而，正如@Grumbler85所述，可以使用工厂模拟这种行为。
工厂是一种特殊类型的对象，用于创建其他对象的实例

实现工厂最简单的方法是使用switch语句，但也存在其他方法（例如反射）。下面是一个简单的示例，说明您在寻找什么：

Class A
{
   ...
}

Class B
{
   ... 
}

enum eKnownTypes
{
     A,
     B
}

Class Factory
{
    /* 
         Implement Singleton here
         ....
    */
    public object CreateInstance(eKnownTypes t)
    {
         /*
               Raise any event needed here
               ...
         */
         switch (t):
         {
              case eKnownTypes.A: return new A(); break;
              case eKnownTypes.B: return new B(); break;
         }          
         return null;
    }

}

/* 
         Set Event Handlers here
         Factory.Instance.CustomEvent += new EventHandler ... 
         ....
*/
A objectA = Factory.Instance.CreateInstance(eKnownTypes.A) as A;
...

您可以使用枚举来完成，但也可以

public struct MyType
{
    public const int OneValue = 1;
    public const int TwoValue = 2;

    private static readonly MyType one = new MyType(OneValue);
    private static readonly MyType two = new MyType(TwoValue); 

    private readonly value int;

    private MyType(int value)
    {
        this.value = value;
    }

    public static One
    {
        get { return this.one; }
    }

    public static Two
    {
        get { return this.two; }
    }

    public static implicit operator int(MyType source)
    {
        return source.value;
    }
}

为您提供一个行为类似于枚举但完全可扩展的类

例如，你可以

var myType = MyType.One;

switch (myType)
{
   case MyType.OneValue:
       ...

   case MyType.TwoValue:
       ...

   default:
       ...
}

这些实例是不可变的，可以使用从
对象
中继承的实现，即引用质量，准确地测试它们的相等性。
您可以使用枚举进行测试，但也可以这样做

public struct MyType
{
    public const int OneValue = 1;
    public const int TwoValue = 2;

    private static readonly MyType one = new MyType(OneValue);
    private static readonly MyType two = new MyType(TwoValue); 

    private readonly value int;

    private MyType(int value)
    {
        this.value = value;
    }

    public static One
    {
        get { return this.one; }
    }

    public static Two
    {
        get { return this.two; }
    }

    public static implicit operator int(MyType source)
    {
        return source.value;
    }
}

为您提供一个行为类似于枚举但完全可扩展的类

例如，你可以

var myType = MyType.One;

switch (myType)
{
   case MyType.OneValue:
       ...

   case MyType.TwoValue:
       ...

   default:
       ...
}

这些实例是不可变的，可以使用从
对象
中继承的实现，即参考质量，准确地测试它们是否相等。
听起来像是在寻找工厂（工厂模式）
enum
都是无效的或不可能的。@HenkHolterman很好-如果你想把它作为一个答案，那么我可以这样做。@Grumbler85我知道工厂模式，但没有想到将它与enum结合起来，谢谢你的建议。@DaveRook也许你应该解释一下