Come creare i metodi CRUD generici DAO (Data Access Object) con LINQ to SQL

Question

Sono nuovo di LINQ su SQL e sto tentando di creare un DAO (Data Access Object) generico per la creazione, lettura, aggiornamento e distruzione di base (CRUD) in modo da poter riutilizzare il codice. Ho avuto successo nella creazione di un metodo generico che eliminerà qualsiasi entità utilizzando il codice sottostante, ma mi chiedevo se qualcuno sa come creare un metodo generico che selezionerà qualsiasi entità da un campo ID comune esistente su tutte le tabelle.

/// <summary> 
    /// Generic method that deletes an entity of any type using LINQ 
    /// </summary> 
    /// <param name="entity"></param> 
    /// <returns>bool indicating whether or not operation was successful</returns> 
    public bool deleteEntity(Object entity) 
    { 
     try 
     { 
      DomainClassesDataContext db = new DomainClassesDataContext(); 
      db.GetTable(entity.GetType()).Attach(entity); 
      db.GetTable(entity.GetType()).DeleteOnSubmit(entity); 
      db.SubmitChanges(); 
      return true; 
     } 
     catch(Exception ex) 
     { 
      Console.WriteLine(ex.StackTrace); 
      return false; 
     } 
    } 

Sono abbastanza sicuro che la stessa scalpiccio lavorerà per aggiornare e inserire e vorrebbe avere un metodo generico sul GenericDAO che mi recuperare qualsiasi entità (ad esempio clienti, fattura, WorkOrder, ecc ...) in base all'ID entità. Grazie in anticipo per le risposte.

Answer 1

Penso che si sta cercando Repository Pattern, il seguente è una semplice implementazione di esso:

prima cosa è necessario creare un'interfaccia IRepository come questa:

public interface IRepository<T> where T : class 
{ 
    void Add(T entity); 
    void Delete(T entity); 
    void Update(T entity); 
    IEnumerable<T> All(); 
    ... 
} 

Poi:

public class Repository<T> : IRepository<T> 
    where T : class, IEntity 
{ 
    DataContext _db; 
    public Repository() 
    { 
     _db = new DataContext("Database string connection"); 
     _db.DeferredLoadingEnabled = false; 
    } 
    public void Add(T entity) 
    { 
     if (!Exists(entity)) 
      GetTable.InsertOnSubmit(entity); 
     else 
      Update(entity); 
     SaveAll(); 
    } 
    public void Delete(T entity) 
    { 
     GetTable.DeleteOnSubmit(entity); 
     SaveAll(); 
    } 
    public void Update(T entity) 
    { 
     GetTable.Attach(entity, true); 
     SaveAll(); 
    } 
    System.Data.Linq.Table<T> GetTable 
    { 
     get { return _db.GetTable<T>(); } 
    } 
    public IEnumerable<T> All() 
    { 
     return GetTable; 
    } 
} 

Quindi:

public class CustomerRepository : Repository<Customer> 
{ 
    public ProductRepository() 
     : base() 
    { 
    } 
} 

Poi si può avere qualcosa di simile:

Customer newCustomer = new Customer { FistName = "Foo", LastName = "Boo" }; 
_customerRepository.Add(newCustomer); 

Dove Customer è un'entità mappato al database che è definito nella .dbml. Questo è solo un inizio, vedere quanto segue per ulteriori dettagli:

• Implementing Repository Pattern in LINQ-to-SQL.
• LINQ to SQL and Repository Pattern.
• Implementing IRepository Pattern in LINQ to SQL.
• Implementation example of Repository Pattern in LINQ to SQL.