Come archiviare il doppio [] array nel database con il codice Entity Framework Primo approccio

Question

Come posso archiviare una serie di duplicati nel database utilizzando Entity Framework Code-First senza alcun impatto sul codice esistente e sulla progettazione dell'architettura?

Ho esaminato Data Annotation e Fluent API, ho anche preso in considerazione la conversione del doppio array in una stringa di byte e l'archiviazione del byte nel database nella propria colonna.

Non riesco ad accedere alla proprietà public double[] Data { get; set; } con API Fluent, il messaggio di errore Allora ottengo è:

Il tipo double[] deve essere un tipo di valore non annullabile al fine di utilizzare come parametro 'T' .

La classe in cui è memorizzato Data è stata memorizzata correttamente nel database e le relazioni con questa classe. Mi manca solo la colonna Data.

Answer 1

Grazie a tutti per i vostri input, grazie al vostro aiuto sono stato in grado di individuare il modo migliore per risolvere questo problema. Quale è:

public string InternalData { get; set; } 
public double[] Data 
{ 
    get 
    { 
     return Array.ConvertAll(InternalData.Split(';'), Double.Parse);     
    } 
    set 
    { 
     _data = value; 
     InternalData = String.Join(";", _data.Select(p => p.ToString()).ToArray()); 
    } 
} 

Grazie a questi posti StackOverflow: String to Doubles array e Array of Doubles to a String

Answer 2

Si può fare una cosa del genere:

[NotMapped] 
    public double[] Data 
    { 
     get 
     { 
      string[] tab = this.InternalData.Split(','); 
      return new double[] { double.Parse(tab[0]), double.Parse(tab[1]) }; 
     } 
     set 
     { 
      this.InternalData = string.Format("{0},{1}", value[0], value[1]); 
     } 
    } 

    [EditorBrowsable(EditorBrowsableState.Never)] 
    public string InternalData { get; set; } 

Answer 3

lo so che è un po 'costoso, ma si potrebbe fare questo

class Primitive 
{ 
    public int PrimitiveId { get; set; } 
    public double Data { get; set; } 

    [Required] 
    public Reference ReferenceClass { get; set; } 
} 

// This is the class that requires an array of doubles 
class Reference 
{ 
    // Other EF stuff 

    // EF-acceptable reference to an 'array' of doubles 
    public virtual List<Primitive> Data { get; set; } 
} 

Questo sarà ora mappare una singola entità (qui 'di riferimento ') a un' elenco 'della tua classe Primitive. Questo è fondamentalmente per consentire al database SQL di essere felice e consentire all'utente di utilizzare l'elenco di dati in modo appropriato.

Questo potrebbe non essere adatto alle vostre esigenze, ma sarà un modo per rendere felice EF.

Answer 4

Sarebbe molto più semplice se si utilizza List<double> anziché double[]. Hai già una tabella che memorizza i tuoi valori Data. Probabilmente hai una chiave esterna da una tabella alla tabella in cui sono memorizzati i tuoi valori double. Creare un altro modello che rifletta la tabella in cui sono memorizzati i doppi e aggiungere i mapping di chiavi esterne nella classe di mapping. In questo modo non avrai bisogno di aggiungere qualche logica di background complessa che recuperi o memorizzi i valori in una proprietà di classe.

Answer 5

Nathan White ha la migliore risposta (ottenuto il mio voto).

Ecco un piccolo miglioramento rispetto la risposta di Joffrey Kern per consentire gli elenchi di qualsiasi lunghezza (non testata):

[NotMapped] 
    public IEnumerable<double> Data 
    { 
     get 
     { 
      var tab = InternalData.Split(','); 
      return tab.Select(double.Parse).AsEnumerable(); 
     } 
     set { InternalData = string.Join(",", value); } 
    } 

    [EditorBrowsable(EditorBrowsableState.Never)] 
    public string InternalData { get; set; }