Diseño del código LINQ

Question

¿Cuáles son sus sugerencias para diseñar código linq en el proyecto? Especialmente, ¿me interesa el diseño de código de consultas de linq grandes y complejas?

Por ejemplo, se sabe, que tiene que escribir una gran cantidad de asuntos muy fuertes LINQ, tal vez algunos de su código tendrá partes duplicadas, tal vez no, y lo que necesita:

1. que el código sea fácilmente apoyo - significa, si necesita cambiar algo. - Está cambiando una cosa, no muchas

2. Haga que el código sea fácil de leer, es decir, si necesita encontrar algo, puede hacerlo fácilmente.

Puede usar sus ejemplos, tal vez su práctica. Tal vez algunos patrones, que viste en cualquier parte, cualquier cosa.

Decir LINQ me refiero a cualquier LINQ, LINQ to SQL, LINQ a objetos, LINQ to XML, etc.

TNX

Answer 1

puede escribir extensiones para sus objetos;

Código principal;

IQuerable itemList = _coreRepository.GetSomeItems() 
       .WithStates(OperationIdentity.SendToSomeWhere) 
       .BetweenDates(StartDate, EndDate); 

Extensión;

public static IQueryable<SomeObject> BetweenDates(this IQueryable<SomeObject> query, DateTime startDate, DateTime endDate) 
     { 
      return from p in query 
        where p.CompletedDate >= startDate && p.CompletedDate < endDate 
        select p; 
     } 

Answer 2

Me gusta dejar de lado las instrucciones de selección grandes que se utilizan muchas veces utilizando métodos de extensión.

public static IQueryable<SomeEntityPM> SelectEntityPM(this IQueryable<SomeEntity> entities) 
{ 
    return entities.Select(a => new SomeEntityPM { ... }); 
} 

Uso:

ObjectCtx.SomeEntities.SelectEntityPM(); 

Answer 3

Un patrón útil para esto está creando una biblioteca predicado reutilizable. Echa un vistazo a esta página en el LINQ PredicateBuilder para obtener más información.

Answer 4

A vew cosas que hago a menudo:

1) Diseño: Siempre iniciar una consulta en la siguiente línea. Ejemplo: no hacen esto

var allCustomersThatDontContainUnpayedOrders = from customer in db.Customers 
               where customer.Orders ... 
               select customer; 

Pero hacer esto:

var allCustomersThatDontContainUnpayedOrders = 
    from customer in db.Customers 
    where customer.Orders ... 
    select customer; 

2) El uso de múltiples where cláusulas donde se puede. Trato de encontrar el segundo fragmento más legible que la primera:

var results = 
    from customer in db.Customers 
    where customer.Name.Contains(search) && customer.Address.City != null && 
     customer.Employee.IsSenior 
    select customer; 

var results = 
    from customer in db.Customers 
    where customer.Name.Contains(search) 
    where customer.Address.City != null 
    where customer.Employee.IsSenior 
    select customer; 

3) Prevenir une si es posible. LINQ to SQL a menudo le permite 'salpicar' sobre todas las relaciones padre-hijo sin usar declaraciones join difíciles de entender.

4) A menudo verá que muchas consultas se parecen. Es posible que siempre desee filtrar ciertos registros según los derechos de un usuario.Puede extraer este código en un método:

var customers = db.Customers; 

customers = FilterBasedOnUserRights(customers, currentUser); 

public static IQueryable<Customer> FilterBasedOnUserRights(
    IQueryable<Customers customers, User currentUser) 
{ 
    return 
     from customer in customers 
     where [big complicated where clause] 
     select customer; 
}