Come posso modificare oggetti immutabili in WPF senza duplicare il codice?

Question

Abbiamo un sacco di oggetti valore immutabili nel nostro modello di dominio, un esempio di questo è una posizione, definita da una latitudine, longitudine & altezza.

/// <remarks>When I grow up I want to be an F# record.</remarks> 
public class Position 
{ 
    public double Latitude 
    { 
     get; 
     private set; 
    } 

    // snip 

    public Position(double latitude, double longitude, double height) 
    { 
     Latitude = latitude; 
     // snip 
    } 
} 

Il modo ovvio per consentire la modifica di una posizione è quello di costruire una ViewModel che ha getter e incastonatori, nonché un metodo ToPosition() per estrarre l'istanza posizione immutabile convalidato. Mentre questa soluzione sarebbe ok, risulterebbe in un sacco di codice duplicato, specialmente XAML.

Gli oggetti valore in questione sono composti da tre a cinque proprietà, che di solito sono alcune varianti di X, Y, Z & alcune cose ausiliarie. Detto questo, avevo preso in considerazione la creazione di tre ViewModels per gestire le varie possibilità, in cui ciascun ViewModel avrebbe bisogno di esporre le proprietà per il valore di ogni proprietà e una descrizione da visualizzare per ogni etichetta (ad esempio "Latitude").

Andando oltre, sembra che potrei semplificarlo con un ViewModel generale che può gestire le proprietà N e collegare tutto usando la riflessione. Qualcosa come una griglia di proprietà, ma per oggetti immutabili. Un problema con una griglia proprietà è che voglio essere in grado di cambiare l'aspetto in modo da poter avere etichette e caselle di testo come ad esempio:

Latitude: [  32 ] <- TextBox 
Longitude: [  115 ] 
Height:  [  12 ] 

o metterlo in un DataGrid come ad esempio:

Latitude | Longitude | Height 
     32   115   12 

Quindi la mia domanda è:

si può pensare a un modo elegante per risolvere questo problema? Ci sono librerie che fanno questo o articoli su qualcosa di simile?

Sono soprattutto alla ricerca di:

• duplicazione del codice da minimizzare
• Facile aggiungere nuovi tipi di oggetto valore
• possibile estendere con qualche tipo di convalida

Answer 1

Ho trovato questa vecchia domanda mentre ricercavo le mie possibili opzioni nella stessa situazione. Ho pensato che dovrei aggiornarlo nel caso in cui qualcun altro si imbattesse in esso:

Un'altra opzione (non disponibile quando Paul ha offerto la sua soluzione poiché .Net 4 non era ancora disponibile) è di usare la stessa strategia, ma invece di implementare usando CustomTypeDescriptors, usa una combinazione di generici, oggetti dinamici e riflessioni per ottenere lo stesso effetto.

In questo caso, si definisce una classe

class Mutable<ImmutableType> : DynamicObject 
{ 
    //... 
} 

costruttore di Ci vuole un esempio del tipo di immutabile e un delegato che costruisce una nuova istanza di fuori di un dizionario, proprio come nella risposta di Paolo. La differenza, tuttavia, è che si sostituiscono TryGetMember e TrySetMember per popolare un dizionario interno che verrà utilizzato come argomento per il delegato del costruttore. Si utilizza la riflessione per verificare che le sole proprietà che si accettano siano quelle effettivamente implementate in ImmutableType.

Per quanto riguarda le prestazioni, scommetto che la risposta di Paul è più veloce e non coinvolge oggetti dinamici, che sono noti per mettere gli sviluppatori C# in crisi. Ma l'implementazione di questa soluzione è anche un po 'più semplice, perché i descrittori di tipi sono un po' arcani.

---

Ecco l'implementazione proof-of-concept/example richiesto:

https://bitbucket.org/jwrush/mutable-generic-example

Answer 2

Riesci a pensare a un modo elegante per risolvere questo problema?

Onestamente, si balla intorno al problema, ma non parlare del problema stesso;).

Se indovino correttamente il problema, la combinazione di MultiBinding e IMultiValueConverter dovrebbe fare la differenza.

HTH.

P.S. A proposito, hai istanze di classe immutabili, non oggetti di valore. Con oggetti valore (che sono descritti dalla parola chiave struct) si balla molto di più, non importa se ci fossero setter o meno :).

Answer 3

I descrittori di tipo personalizzato potrebbero essere utilizzati per risolvere questo problema. Prima di eseguire il binding a una posizione, il descrittore di tipo potrebbe eseguire il kick-in e fornire i metodi get e set per creare temporaneamente i valori. Quando vengono eseguite le modifiche, è possibile creare l'oggetto immutabile.

Potrebbe sembrare qualcosa di simile:

DataContext = new Mutable(position, 
    dictionary => new Position(dictionary["lattitude"], ...) 
); 

le associazioni possono ancora apparire come segue:

<TextBox Text="{Binding Path=Lattitude}" /> 

Poiché l'oggetto Mutevole sarà 'finta' di avere immobili come Lattitude grazie alla sua TypeDescriptor .

In alternativa è possibile utilizzare un convertitore nei binding e ottenere una sorta di convenzione.

La classe Mutable prende l'attuale oggetto immutabile e un Func<IDictionary, object> che consente di creare il nuovo oggetto immutabile una volta completata la modifica. La tua classe Mutable farebbe uso del descrittore di tipi, che creerebbe PropertyDescriptors che crea il nuovo oggetto immutabile dopo essere stato impostato.

Per un esempio di come utilizzare tipo descrittori, vedere qui:

http://www.paulstovell.com/editable-object-adapter

Edit: se si desidera limitare la frequenza vengono creati gli oggetti immutabili, si potrebbe anche guardare BindingGroups e IEditableObject, che il tuo Mutable può anche implementare.