Record di modellazione del database come tipi

Question

Sto riscrivendo una libreria C# in F # in cui la maggior parte delle classi esegue il mapping one-to-one con le tabelle del database (simile a ActiveRecord). Sto valutando se utilizzare record o classi (forse anche DU?). C'è una buona dose di convalida nei setter per mantenere invarianti. Quale sarebbe il modo migliore per modellare questo in F #? Non desidero che un oggetto che vìola la logica aziendale venga mantenuto nel database. Tutte le idee sono benvenute.

Alcuni pensieri aggiuntivi ... È meglio spostare gli invarianti in una classe 'controller' esterna? Provenendo da C#, è sbagliato consentire a un oggetto che corrisponde a un record del database di contenere tutto ciò che non può essere salvato nel database. Suppongo perché fallire prima sembra meglio che fallire più tardi.

Answer 1

Questo dovrebbe essere un buon modo per gestirlo. Avere la tua logica di validazione nel costruttore ti darà un pezzo di mente più avanti nel tuo codice perché l'oggetto è immutabile. Questo apre anche possibilità multi-threading.

Immutabile Versione

type Customer (id, name) = 

    do // Constructor 
     if id <= 0 then 
      raise(new ArgumentException("Invalid ID.", "id")) 
     elif String.IsNullOrEmpty(name) then 
      raise(new ArgumentException("Invalid Name.", "name"))  

    member this.ID 
     with get() = id 
    member this.Name 
     with get() = name 

    member this.ModifyName value = 
     new Customer(id, value)  

Mutevole Versione

type Customer (id) = 

    let mutable name = "" 

    do // Constructor 
     if id <= 0 then 
      raise(new ArgumentException("Invalid ID.", "id")) 

    member this.ID 
     with get() = id 
    member this.Name 
     with get() = name 
     and set value = 
      if String.IsNullOrEmpty(name) then 
       raise(new ArgumentException("Invalid Name.", "value")) 
      name <- value 

Answer 2

Si possono avere i vostri dati in un record, e ancora mantenere la logica di convalida con il tipo di dati, collegando metodi per il record:

type Person = 
    { First : string; 
     Last : string; } with 
    member x.IsValid() = 
     let hasValue = System.String.IsNullOrEmpty >> not  
     hasValue x.First && hasValue x.Last 

let jeff = { First = "Jeff"; Last = "Goldblum" } 
let jerry = { jeff with First = "Jerry" } 
let broken = { jerry with Last = "" } 

let valid = [jeff; jerry; broken] 
      |> List.filter (fun x -> x.IsValid()) 

La semantica della copia per i record è quasi altrettanto comoda di una proprietà. La convalida non avviene sul set di proprietà, ma è facile filtrare un elenco di record fino a solo quelli validi.

Answer 3

Hai dato un'occhiata al mio progetto FunctionalNHibernate? È progettato come un livello sopra Nhibernate per consentire di mappare in modo dichiarativo i record su un database. E 'ancora presto, ma si tratta solo di utilizzabile: http://bitbucket.org/robertpi/functionalnhibernate/