C＃到F＃類轉換

Question

我是一個C＃dev，很久以前。

我學習F＃並將其用於科學目的/研究/認可工作。我發現很多功能強大的功能，但我很難編寫類 - 我知道在C＃中做的很好。

什麼可以幫助我（和社區）翻譯下面的C＃代碼。

class CoolAttribute : Attribute 
{ 
} 

class BaseClass 
{ 
    public BaseClass(int zzz) 
    { 
     // zzz doesn't matter; what matters is that zzz is required 
    } 

    public virtual void XHello() 
    { 
     Console.WriteLine("I'm BaseClass."); 
    } 
} 

interface IFirst 
{ 
    void Hello(); 
} 

interface ISecond 
{ 
    int MagicNumber(); 
} 

[DebuggerDisplay("pubI = {pubI}")] 
class SampleClass : BaseClass, IFirst, ISecond 
{ 
    private int privI; 
    protected int protI; 
    public int pubI; 

    private static string s_privStr; 

    static SampleClass() 
    { 
     s_privStr = ""; 
    } 

    public event Action<string> OnSomething = (el) => { }; 

    public int PubI 
    { 
     get { return pubI; } 
     set { pubI = value; } 
    } 

    public static string StatStr 
    { 
     get { return s_privStr; } 
    } 

    // Default constructor 
    SampleClass() 
     : base(0) 
    { 
     privI = 1; 
     protI = 2; 
     pubI = 3; 
    } 

    // Other constructor 
    SampleClass(int a, int b, int c) 
     : base(a + b + c) 
    { 
     privI = a; 
     protI = b; 
     pubI = c; 
    } 

    [Conditional("DEBUG")] 
    public void PubSimpleMethod() 
    { 
    } 

    protected virtual void ProtVirtMethod() 
    { 
     OnSomething("From the virt method."); 
    } 

    private static void PrivStatMethod() 
    { 
    } 

    public void Hello() 
    { 
     Console.WriteLine("Hello (IFirst)"); 
    } 

    public override void XHello() 
    { 
     Console.WriteLine("I'm SampleClass"); 
    } 

    public int MagicNumber() 
    { 
     return privI + protI + pubI; 
    } 

    public void Additional([Cool] int i) 
    { 
    } 

    public static SampleClass operator +(SampleClass a, SampleClass b) 
    { 
     return new SampleClass(a.privI + b.privI, 
      a.protI + b.protI, 
      a.pubI + b.pubI); 
    } 
} 

F＃翻譯[工作進展情況，與答案進行更新]：

//// wrong ... 
//type CoolAtribute = 
// extend Attribute 

type BaseClass(zzz : int) = 
    // virtual 
    abstract XHello : unit -> unit 
    default this.XHello() = 
     printfn "I'm BaseClass." 

// seems Ok 
type IFirst = 
    abstract Hello : unit 

type ISecond = 
    abstract MagicNumber : int 

[<DebuggerDisplay("pubI = {pubI}")>] // ???? 
type SampleClass() = 
    inherit BaseClass(0) // necessary argument ? 1 constructor 
    // implements IFirst, ISecond 

    let mutable privI = 0 // initialization required 
    // protI 
    // pubI 

    // wrong: 
    //let static mutable s_privStr = "" 

    // static constructor 

    // event OnSomething 

    // seems Ok 
    member this.PubI 
     with get() = privI 
     and set(value) = privI <- value 

    // ?? 
    //static member StatStr 
    // with get() = s_privStr 
    // and set(value) = s_privStr <- value 


    // Default constructor 


    // Other constructor 
    // C#: SampleClass(int a, int b, int c) 

    [<Conditional("DEBUG")>] 
    member this.PubSimpleMethod() = 
     do ignore 

    abstract ProtVirtMethod : unit -> unit 
    //protected 
    default this.ProtVirtMethod() = 
     // raise event OnSomething("From the virt method."); 

    //private 
    //static 
    member this.PrivStatMethod() = 
     do ignore 

    member this.Hello() = 
     printfn "Hello (IFirst)" 

    // override 
    member this.XHello() = 
     printfn "I'm SampleClass" 

    member this.MagicNumber() : int = 
     privI + protI + pubI 

    // apply attribute to the argument 
    member this.Additional((*[Cool*) i :int) = 
     do ignore 

    // operator + 

Answer 1

大部分的代碼對我來說很好，但你不能使用純member定義虛擬方法。 （這是因爲F＃代碼通常不使用實現繼承，所以經常不需要）。

定義虛擬方法，你需要使用abstract和default：

type Virtual() = 
    abstract Foo : int -> int 
    default this.Foo(n) = n + 1 

要覆蓋在派生類的方法，你可以寫：

type Derived() = 
    inherit Virtual() 

    override this.Foo(n) = n + 2