Wie man Listenobjekt erhält, indem man nur die Liste <T> für 2 Entity verwendet?

Question

In meinem Projekt, ich habe 2 Entity-Objekte (Delegierter für 2 Tabellen in db) wie folgt:

• Tbl_Person {ID, Name}
• Tbl_Class {ID, Name, PersonID}

In DAL, erstelle ich zwei Klassen für diese Entitäten und Schreibfunktion GetList(): - Klasse Person:

012.351.

public List<Tbl_Person> GetList() 
{ 
    using (var db = DatabaseHelper.DataContext()) 
    { 
     try 
     { 
      var _t = (from info in db.**tbPerson** 
         select info).ToList(); 
      return _t.ToList<**Tbl_Person**>(); 
     } 
     catch (Exception ex) 
     { 
      throw ex; 
     } 
    } 
} 

Klasse MyClass:

public List<Tbl_Class> GetList() 
{ 
    using (var db = DatabaseHelper.DataContext()) 
    { 
     try 
     { 
      var _t = (from info in db.**tbClass** 
         select info).ToList(); 
      return _t.ToList<**Tbl_Class**>(); 
     } 
     catch (Exception ex) 
     { 
      throw ex; 
     } 
    } 
} 

Wenn ich zwei Klassen verwenden, kann ich GetList() korrekt Liste Objekt zu erhalten. Aber es scheint, wir haben die Funktion GetList() hier doppelt. Was ich gerade will, ist nur 1 Funktion GetList() wie diese:

public List<T> GetList() 
{ 
    using (var db = DatabaseHelper.DataContext()) 
    { 
     try 
     { 
      var _t = (from info in db.**????????** 
         select info).ToList(); 
      return _t.ToList<**T**>(); 
     } 
     catch (Exception ex) 
     { 
      throw ex; 
     } 
    } 
} 

Answer 1

Erstens loszuwerden, die sinnlos try/catch-Blöcke. Jede dieser Methoden ist doppelt so lang wie sie sein muss, weil Sie Ausnahmen abfangen und sie einfach neu erstellen - aber gleichzeitig Informationen verlieren! (Wenn Sie erneut drucken müssen, verwenden Sie nur throw; anstelle von throw ex;.)

Zweitens ist es absolut sinnlos, hier einen Abfrageausdruck zu verwenden. Du interessierst dich nur für den ganzen Tisch. (Sind Sie sicher, dass Sie bei jedem Aufruf die gesamte Tabelle holen wollen, übrigens?)

Drittens diese Annahme richtig sind-stark typisierten Daten Kontexte, würde ich nicht erwarten, dass Sie den Typen müssen angeben, Argument für ToList an erster Stelle.

So können Sie Ihre zwei Methoden * tatsächlich zu reduzieren:

// In MyClass 
public List<Tbl_Class> GetList() 
{ 
    using (var db = DatabaseHelper.DataContext()) 
    { 
     return db.tbClass.ToList(); 
    } 
} 

// In Person 
public List<Tbl_Person> GetList() 
{ 
    using (var db = DatabaseHelper.DataContext()) 
    { 
     return db.tbPerson.ToList(); 
    } 
} 

Sie jetzt konnte hier die Redundanz entfernen DataContext.GetTable<TEntity> mit:

// In DatabaseHelper: 
public static List<T> GetList<T>() 
{ 
    using (var db = DataContext()) 
    { 
     return db.GetTable<T>().ToList(); 
    } 
} 

// In MyClass 
public List<Tbl_Class> GetList() 
{ 
    return DatabaseHelper.GetList<Tbl_Class>(); 
} 

// In Person 
public List<Tbl_Person> GetList() 
{ 
    return DatabaseHelper.GetList<Tbl_Person>(); 
} 

Es ist nicht wirklich klar, ob Sie Notwendigkeit die Methoden in den einzelnen Klassen ...

(Zusätzlich dazu möchte ich Ihnen dringend raten, Ihre Typen umzubenennen, um das Präfix aus dem Mapping zu entfernen. Es sieht ziemlich schrecklich in Code, IMO.)

Answer 2

Sie könnte erreichen, was Sie für die Verwendung von Entity Framework und IObjectSet. Ich bin mir nicht sicher, ob es sinnvoll ist, dies zu tun.

public class Repository 
{ 
    private readonly IObjectContext _context; 

    public void Repository(IObjectContext context) 
    { 
     _context = context; 
    } 

    public IEnumerable<T> GetList<T>() where T : class 
    { 
     return _context.CreateObjectSet<T>().ToList(); 
    }   
}