LINQ to SQL: Compilazione di una classe generata esteso in una query LINQ

Question

Ok, ho una classe che è generato quando ho creato il LINQ to SQL collegamento.

Si presenta sostanzialmente in questo modo:

    public partial class Product
    {
        public string Name { get; set; }
        public string Description { get; set; }
    }

ho esteso con l'aggiunta di un altro immobile, in questo modo:

    public partial class Product
    {
        public string Category { get; set; }    
    }

Ora ho una query LINQ per ottenere i dettagli del prodotto, in questo modo:

    public List GetProducts()
    {
        using(MyDataContext dc = new MyDataContext())
        {
            var products = from p in dc.Products
                           select p;
        }
    }

Il nuovo campo ho aggiunto (categoria) possono essere recuperate nella query LINQ utilizzando "p.Category.Description".

Quindi la mia domanda è, che è quella modo migliore per popolare la classe di prodotto tra cui la nuova proprietà Categoria.

Io preferirei se ci fosse un modo per popolare automaticamente la porzione generato della classe del prodotto utilizzando i dati nella query LINQ "selezionare p".

Ho anche pensato di creare un costruttore sulla mia classe parziale che accetta il prodotto (selezionare P) e Categoria (select p.Category.Description)

fare qualcosa di simile:

    // Linq query calling the constructor
    var products = from p in dc.Products
                   select new Product(p, p.Category.Description)

    // Product Constructor in my extended partial class
    public Product(Product p, string CategoryDescription)
    {
        this = p; // there must be a way to do something like this
        Category = CategoryDescription;
    }

Ma c'è un modo per farlo senza dover elencare ogni proprietà nella classe del prodotto e impostare ciascuno di loro singolarmente ??

Answer 1

Se si vuole riutilizzare il codice esistente che avrebbe dovuto creare di Poco, invece:

var products = from p in dc.Products
               select new Product
               {
                   Name = p.Name,
                   Description = p.Description,
                   Category = p.Category.Description
               }

O, per rendere ancora più facile, basta fare:

public partial class Product
{
    public string Category
    {
        get { return this.Category.Description; }
        set { this.Category.Description = value; }
    }
}

Answer 2

LINQ to SQL gioca bene fino a quando si lascia fare la sua cosa di per sé. IMO, il migliore modo per gestire questo scenario è quello di lasciare il tipo DBML generata al DAL - solo tornare quelli se questo è esattamente una misura del 100% per ciò che si vuole per tornare.

Invece, vorrei creare un nuovo tipo che è non gestito da LINQ to SQL, e restituire il presente invece (si può fare proiezioni di inizializzazione-based per i tipi non DBML); per esempio:

var products = from p in dc.Products // p is implicitly a Product
               select new ExtendedProduct  // our completely unrelated type
               {
                   Id = p.Id,
                   Name = p.Name,
                   //...
                   Category = p.Category.Description
               };

Questo dovrebbe consentire di ottenere i dati fuori, senza silenziosi n + 1 problemi, e senza il contesto dati lamentarsi. Significa anche si è in controllo completo su quali colonne vengono interrogati e come essi vengono mappati.

In sostanza, questo utilizza quindi LINQ to SQL solo per fare l'integrazione di database, utilizzando il nostro tipo per l'applicazione principale.

Answer 3

Sembra che ciò che si sta cercando di fare è qualcosa di simile:

using(MyDataContext dc = new MyDataContext())
{
    var products = from p in dc.Products
                   select p;
    foreach(Product p in products)
        p.Category = p.Category.Description;
}

... che non ha alcun senso per me. Per cominciare, una delle s "Categoria" dovrà essere chiamato qualcos'altro.