Cómo crear objetos genéricos de acceso a datos (DAO) Métodos CRUD con LINQ to SQL

Question

Soy nuevo en LINQ to SQL y intento crear un Objeto de acceso a datos genérico (DAO) para los básicos Crear, Leer, Actualizar y Destruir (CRUD) métodos para que pueda reutilizar el código. Tuve éxito en la creación de un método genérico que eliminará cualquier entidad mediante el uso del siguiente código, pero me preguntaba si alguien sabe cómo crear un método genérico que seleccionará cualquier entidad mediante un campo Id común que exista en todas las tablas.

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

Estoy bastante seguro de que el mismo golpeteo trabajará para la actualización e inserte y le gustaría tener un método genérico en el GenericDAO que me va a recuperar cualquier entidad (es decir, al cliente, Factura, WorkOrder, etc ...) basado en las entidades Id. Gracias de antemano por las respuestas.

Answer 1

creo que busca Repository Pattern, la siguiente es una implementación sencilla de la misma:

En primer lugar es necesario crear una interfaz IRepository así:

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

continuación:

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

Entonces:

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

A continuación, puede tener algo como:

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

Dónde Customer es una entidad asignada a su base de datos que se define en el .dbml. Esto es solo un comienzo. Consulte lo siguiente para obtener más información:

• 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.