Linq to SQL: Bestücken eine erweiterte generierte Klasse in einer Linq-Abfrage

Question

Ok, so habe ich eine Klasse, die generiert wird, wenn ich den Linq to SQL-Verbindung erstellt.

Es sieht im Wesentlichen wie folgt aus:

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

I erweitert es durch eine andere Eigenschaft hinzufügen, wie folgt aus:

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

Jetzt habe ich eine Linq Abfrage, um die Produktdetails zu erhalten, wie folgt:

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

Das neue Feld I hinzugefügt (Kategorie) kann unter Verwendung von „p.Category.Description“ in der Linq Abfrage abgerufen werden.

Also meine Frage ist, was ist der beste Weg, um die Produktklasse einschließlich der neuen Kategorie Eigenschaft zu füllen.

Ich würde es vorziehen, wenn es ein Weg, um automatisch den erzeugten Teil der Produktklasse zu füllen, indem die Daten in der Linq-Abfrage „select p“ verwendet wird.

habe ich auch gedacht einen Konstruktor auf meiner Teil-Klasse zu erstellen, die das Produkt (wählen P) und die Kategorie (select p.Category.Description) akzeptiert

mache ich etwas wie folgt aus:

    // 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;
    }

Aber gibt es eine Möglichkeit, dies zu tun, ohne jede Eigenschaft in der Produktklasse zur Liste mit und stellen Sie jeden von ihnen einzeln ??

Answer 1

Wenn Sie Ihren vorhandenen Code wiederverwenden möchten, würden Sie den Poco erstellen müssen statt:

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

Oder, um es noch einfacher, nur tun:

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

Answer 2

LINQ-to-SQL schön, so lange spielt, wie Sie lassen es von selbst nicht sein Ding. IMO, die am besten Weg, um dieses Szenario zu behandeln ist, die DBML generierte Art an der DAL verlassen - nur diejenigen zurück, wenn das heißt genau 100% fit für das, was Sie wollen zurückzukehren.

Stattdessen würde ich eine neue Art erstellen, die nicht verwaltet von LINQ-to-SQL, und kehren Sie stattdessen (Sie können für nicht-DBML Typen initializer basierte Projektionen tun); zum Beispiel:

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
               };

Auf diese Weise können Sie Ihre Daten herauszuholen, ohne stille n + 1 Fragen und ohne die Daten-Kontext zu beklagen. Es bedeutet auch, Sie in der vollständigen Kontrolle ist, über die Spalten werden abgefragt und wie sie zugeordnet sind.

Im Wesentlichen dieser dann verwendet LINQ-to-SQL nur , um die Datenbank-Integration zu tun, unsere eigene Art für die Hauptanwendung verwendet wird.

Answer 3

Es sieht aus wie das, was Sie versuchen, so etwas wie dies zu tun ist:

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

... das macht keinen Sinn für mich. So starten Sie mit, eine der „Kategorie“ s muss etwas anderes genannt werden.