是否有可能在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); 
    } 
}