F # properties design

Question

Quindi, quando mai sto creando alcune proprietà nel mio codice F #, dato che F # non supporta le proprietà auto, per quanto ne so. Devo creare campi di supporto e inizializzarli su null, il che non sembra corretto in termini di programmazione funzionale. Ad es.

 

let mutable albums : DbSet = null 
let mutable genres : DbSet = null
 

member x.Albums 
    with get() = albums 
    and set(value) = albums <- value 


member x.Genres 
    with get() = genres 
    and set (value) = genres <- value 

c'è un modo migliore di fare questo?. Mille grazie per i tuoi suggerimenti.

Answer 1

F # non supporta le proprietà di auto quando si ha bisogno di un mutevole proprietà , ma supporta una sintassi leggero quando si ha bisogno solo di una proprietà di sola lettura . Se si scrive un po 'di codice funzionale, quindi utilizzando sola lettura proprietà potrebbe in realtà essere più appropriato:

type Music(genres : DbSet, albums : DbSet) = 
    member x.Albums = albums 
    member x.Genres = genres 

Questo è essenzialmente lo stesso di record suggerite dal pad, ma può essere più appropriato se si desidera avere controllo migliore su come appaiono i tipi (e come appaiono in C# o per l'associazione dati).

Se DbSet è un tipo mutabile, è possibile utilizzare il tipo precedente e inizializzarlo solo una volta (sarà comunque possibile modificare i valori DbSet). Se si desidera modificare il valore DbSet, è possibile aggiungere un metodo che restituisce un oggetto clonato:

member x.WithAlbums(newAlbums) = 
    Music(genres, newAlbums) 

Utilizzando null o Unchecked.defaultOf<_> in F # è considerato una pessima pratica e si dovrebbe sempre cercare di creare l'oggetto completamente initlized. Se il valore è mancante, è possibile utilizzare il tipo option per rappresentarlo, ma in tal caso è necessario scrivere sempre il gestore per il valore mancante, per rendere sicuro il proprio programma.

Answer 2

A meno che non si stia facendo qualcosa di complesso, consiglierei di utilizzare i record anziché le classi. In sostanza, essi sono classi con caratteristiche extra: immutabilità, l'uguaglianza strutturale, pattern matching, ecc:

type Playlists = { 
    Albums: DbSet; 
    Genres: DbSet 
    } 

È possibile ottenere i campi di registrare facilmente:

let p = {Albums = ...; Genres = ...} 
let albums = p.Albums 
let genres = p.Genres 

Nei campi di record predefiniti sono immutabili; puoi dichiarare campi mutabili nei record, ma è considerato una cattiva pratica. Sebbene non sia possibile impostare le proprietà, è possibile creare un nuovo record da uno vecchio. immutabilità di default non è normalmente un problema, inoltre, rende il codice più funzionale e più facile ragionare su:

let p = {Albums = a; Genres = g} 

    // Create new records by updating one field 
    let p1 = {p with Albums = a1} 
    let p2 = {p with Genres = g2} 

Se si insiste a creare classi, utilizzando un costruttore con parametri espliciti è consigliato:

type Playlists(a: DbSet, g: DbSet) = 
    let mutable albums = a 
    let mutable genres = g 
    // ... 

Quando un costruttore di default è necessario, è possibile utilizzare Unchecked.default<'T> per i campi non annullabili, o meglio usare i loro costruttori predefiniti:

// Set fields using dump values 
let mutable albums = new DbSet() 
let mutable genres = new DbSet() 

Ma assicurati di aver impostato quei campi prima di usarli effettivamente.

Answer 3

FYI - le proprietà automatiche sono pianificate per F # 3.0. Vedi lo preview documentation ^[MSDN].Sembra che il tuo esempio sarebbe diventato:

type Music() = 
    member val Albums : DbSet = null with get, set 
    member val Genres : DbSet = null with get, set