F # diseño de propiedades

Question

Así que cuando alguna vez estoy creando algunas propiedades en mi código F #, como F # no admite propiedades automáticas, por lo que yo sé. Tengo que crear campos de respaldo e inicializarlos en nulo, lo que no parece correcto en términos de programación funcional. Por ej.

 

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 

¿Hay una mejor manera de hacer esto?. Muchas gracias por sus sugerencias.

Answer 1

F # no admite propiedades de auto cuando se necesita un mutable propiedad, pero soporta una sintaxis de peso ligero cuando se necesita sólo una propiedad de sólo lectura . Si va a escribir algo de código funcional, a continuación, utilizando sólo lectura propiedades en realidad podría ser más apropiado:

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

Ésta es esencialmente la misma que los registros sugeridos por la almohadilla, pero puede ser más apropiado si usted quiere tener mejor control sobre cómo se ven los tipos (y cómo aparecen en C#, o para el enlace de datos).

Si DbSet es un tipo mutable, entonces probablemente solo pueda usar el tipo anterior e inicializarlo solo una vez (aún podrá modificar los valores DbSet). Si desea cambiar el valor DbSet, se puede añadir un método que devuelve un objeto clonado:

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

Usando null o Unchecked.defaultOf<_> en F # se considera una muy mala práctica y siempre se debe tratar de crear el objeto totalmente initlized. Si es posible que falte el valor, puede usar el tipo option para representarlo, pero luego debe escribir siempre el controlador para el valor faltante, para que su programa sea seguro.

Answer 2

A menos que esté haciendo algo complejo, le recomendaría utilizar registros en lugar de clases. Básicamente, son clases con características adicionales: la inmutabilidad, la igualdad estructural, la coincidencia de patrones, etc:

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

Puede obtener campos de grabar fácilmente:

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

En los campos de registros por defecto son inmutables; puede declarar campos mutables en los registros, pero se considera una mala práctica. Aunque no puede establecer propiedades, puede crear un nuevo registro a partir de uno anterior. inmutabilidad por defecto no es normalmente un problema, además, hace que el código sea más funcional y más fácil de razonar acerca de:

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} 

Si insiste para crear clases, usando un constructor con parámetros explícitos se recomienda:

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

Cuando es necesario un constructor por defecto, se puede utilizar para Unchecked.default<'T> campos no anulables, o mejor uso de sus constructores por defecto:

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

Pero asegúrese de establecer esos campos antes de usarlos realmente.

Answer 3

FYI - las propiedades automáticas están planificadas para F # 3.0. Vea el preview documentation ^[MSDN].Parece que tu ejemplo se convertiría en:

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