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 사용할 필요가 : 파생 타입의 메소드를 오버라이드 (override)하기

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

을, 당신이 쓸 수 있습니다 :

type Derived() = 
    inherit Virtual() 

    override this.Foo(n) = n + 2