是否有可能在c＃中模仿这个Java枚举代码＃

Question

是否有可能复制这种提供抽象方法的功能，在一个枚举中，内部枚举常量必须覆盖并提供功能？

public enum Logic { 
    PAY_DAY { 
     @Override 
     public void acceptPlayer(Player player) { 
      // Perform logic 
     } 
    }, 
    COLLECT_CASH { 
     @Override 
     public void acceptPlayer(Player player) { 
      // Perform logic 
     } 
    } 
    , 
    ETC_ETC { 
     @Override 
     public void acceptPlayer(Player player) { 
      // Perform logic 
     } 
    }; 

    public abstract void acceptPlayer(Player player); 
} 

如果不能:: 你能提供，我可以实现很多特殊的逻辑类似的方式的方式？

编辑::我知道C＃中的枚举实际上并不像Java中的'对象'，但我希望执行类似的逻辑。

编辑::为了澄清，我不想为每个特定的逻辑位提供具体的类。 IE浏览器，创建接口acceptPlayer和创造了许多新的类不appropiate

Answer 1

这里有一个选项 - 不使用枚举，但类似的十岁上下的东西...

public abstract class Logic 
{ 
    public static readonly Logic PayDay = new PayDayImpl(); 
    public static readonly Logic CollectCash = new CollectCashImpl(); 
    public static readonly Logic EtcEtc = new EtcEtcImpl(); 

    // Prevent other classes from subclassing 
    private Logic() {} 

    public abstract void AcceptPlayer(Player player); 

    private class PayDayImpl : Logic 
    { 
     public override void AcceptPlayer(Player player) 
     { 
      // Perform logic 
     } 
    } 

    private class CollectCashImpl : Logic 
    { 
     public override void AcceptPlayer(Player player) 
     { 
      // Perform logic 
     } 
    } 

    private class EtcEtcImpl : Logic 
    { 
     public override void AcceptPlayer(Player player) 
     { 
      // Perform logic 
     } 
    } 
} 

你说，你不希望为每一个逻辑提供一个具体的类 - 但基本上你会用Java来做什么，只是这个类对你来说会稍微隐藏一点。

下面是使用代理的不同行为的另一种方法：

public sealed class Logic 
{ 
    public static readonly Logic PayDay = new Logic(PayDayAccept); 
    public static readonly Logic CollectCash = new Logic(CollectCashAccept); 
    public static readonly Logic EtcEtc = new Logic(player => { 
     // An alternative using lambdas... 
    }); 

    private readonly Action<Player> accept; 

    private Logic(Action<Player> accept) 
    { 
     this.accept = accept; 
    } 

    public void AcceptPlayer(Player player) 
    { 
     accept(player); 
    } 

    private static void PayDayAccept(Player player) 
    { 
     // Logic here 
    } 

    private static void CollectCashAccept(Player player) 
    { 
     // Logic here 
    } 
} 

在这两种情况下，你仍然可以得到一组固定的值 - 但你不能对他们进行切换。你可能会有一个单独的“真正的”枚举，但这会有点混乱。

Answer 2

在c＃中，你使用类而不是枚举。用你想覆盖的虚拟方法创建一个基类。

Java枚举的每个成员都将是具有所需实现的子类。

最后，在每个枚举成员的基类中创建一个只读静态字段，并使用该枚举值的子类实例对其进行初始化。

Answer 3

如果你不想使用接口和一个类层次结构，你可以使用委托，是这样的：

public class Player{} 

public static class Logic 
{ 
    public static readonly Action<Player> PAY_DAY = p => Console.WriteLine("Pay day : " + p.ToString()); 

    public static readonly Action<Player> COLLECT_CASH = p=> Console.WriteLine(p.ToString()); 

    public static void AcceptPlayer(this Action<Player> PlayerAction, Player ActingPlayer) 
    { 
     PlayerAction(ActingPlayer); 
    } 
} 

class MainClass 
{ 
    public static void Main (string[] args) 
    { 
     var player = new Player(); 

     Logic.PAY_DAY.AcceptPlayer(player); 
    } 
}