F#
Porting C # naar F #

pocos

Enkele van de eenvoudigste soorten klassen zijn POCO's.

// C#
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime Birthday { get; set; }
}

In F # 3.0 werden auto-eigenschappen geïntroduceerd vergelijkbaar met C # auto-eigenschappen,

// F#
type Person() = 
    member val FirstName = "" with get, set
    member val LastName = "" with get, set
    member val BirthDay = System.DateTime.Today with get, set

Het maken van een instantie van een van beide is vergelijkbaar,

// C#
var person = new Person { FirstName = "Bob", LastName = "Smith", Birthday = DateTime.Today }; 
// F#
let person = new Person(FirstName = "Bob", LastName = "Smith")

Als u onveranderlijke waarden kunt gebruiken, is een recordtype veel idiomatischer F #.

type Person = { 
    FirstName:string; 
    LastName:string; 
    Birthday:System.DateTime 
} 

En deze record kan worden gemaakt:

let person = { FirstName = "Bob"; LastName = "Smith"; Birthday = System.DateTime.Today }

Records kunnen ook worden gemaakt op basis van andere records door de bestaande record op te geven en toe te voegen with vervolgens een lijst met velden die moeten worden genegeerd:

let formal = { person with FirstName = "Robert" }

Klasse die een interface implementeert

Klassen implementeren een interface om te voldoen aan het contract van de interface. Een C # -klasse kan bijvoorbeeld IDisposable ,

public class Resource : IDisposable
{ 
    private MustBeDisposed internalResource;
    
    public Resource() 
    { 
        internalResource = new MustBeDisposed();
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing){
        if (disposing){
            if (resource != null) internalResource.Dispose();
        }
    }
}

Om een interface in F # te implementeren, gebruikt u de interface in de typedefinitie,

type Resource() = 
    let internalResource = new MustBeDisposed()

    interface IDisposable with
        member this.Dispose(): unit = 
            this.Dispose(true)
            GC.SuppressFinalize(this)

    member __.Dispose disposing = 
        match disposing with 
        | true  -> if (not << isNull) internalResource then internalResource.Dispose()
        | false -> ()