Performance optimization for Linq To SQL I have been working with C# for quite some time but relatively new to the concepts of lambdas and Linq. I was working with a Linq To SQL example and trying to write a generic solution for executing a search against a collection of entities (eg. list of Customer objects) where the search parameter will be specified by passing a partially filled object of the entity class itself. I was doing this just to ensure that a person does not have to go on specifying different overloads for different searches based on the entity class attributes and trying to write a generic solution which will cater to any entity class. 

Hence I used reflection and an array of predicates to successively apply the Where clauses to the collection.

Client App

using (CustomerManager oCustomerManager = new CustomerManager())
{
   IEnumerable&lt;Customer&gt; customers = oCustomerManager.Load();

   Customer oSearchCustomer = new Customer();
   oSearchCustomer.City = "London";
   oSearchCustomer.ContactName = "Thomas Hardy";

   IEnumerable&lt;Customer&gt; customerList = oCustomerManager.Search(oSearchCustomer);

   foreach (Customer customer in customerList)
   {
      Console.WriteLine(customer.ToString());
   }
}


Manager Class

public IEnumerable&lt;Customer&gt; Search(Customer searchObject)
{
    IEnumerable&lt;Customer&gt; customers = DataContext.Customers;
    List&lt;Func&lt;Customer, bool&gt;&gt; result = 

    DataContext.Customers.GenerateFilterClause&lt;Customer&gt;(searchObject);

    foreach (var item in result)
    {
        customers = customers.Where(item);
    }

    return customers;
 }


Extension Method Utility Class

public static class UtilityExtensions
{
   public static List&lt;Func&lt;T, bool&gt;&gt; GenerateFilterClause&lt;T&gt;(this IEnumerable&lt;T&gt; 
          collection, T searchEntity)
   {
        List&lt;Func&lt;T, bool&gt;&gt; whereFilterList = new List&lt;Func&lt;T, bool&gt;&gt;();
        Func&lt;T, bool&gt; predicate = null;

        var propertyList = searchEntity.GetType().GetProperties();

        foreach (PropertyInfo p in propertyList)
        {
            if (p.GetCustomAttributes(false).OfType&lt;ColumnAttribute&gt;().Count() &gt; 0)
            {
               string propName = p.Name;
               var searchVal = 

               searchEntity.GetType().GetProperty(propName).GetValue(searchEntity,null);
               if (searchVal != null)
               {
                  predicate = new Func&lt;T, bool&gt;(entity =&gt; propertyWhereClause(entity, 
                         searchEntity, propName, searchVal));
                  whereFilterList.Add(predicate);
               }
            }
         }

         return whereFilterList;
     }

      private static bool propertyWhereClause&lt;T&gt;(T obj, T searchEntity, string    propertyName, object searchVal)
     {
           return obj.GetType().GetProperty(propertyName).GetValue(obj, 
                                   null).Equals(searchVal);
      }
  }


While the solution is working, I have two specific questions:


What are the drawbacks of this solution? I was hoping to have inputs regarding performance and cleaner way to rewrite the code.
Can anyone suggest a more efficient and better solution? That would help me to understand the proper way to utilize the power of lambdas and Linq.
How much did you look into LINQ to SQL? Unless you have a reason not to expose the DataContext, you can just perform queries on it without using the 'search object'.

from c in DataContext.Customers
where c.City == "London" &amp;&amp; c.ContactName == "Thomas Hardy"
select c


I haven't used LINQ to SQL myself yet, so I can't really tell much about the best practices and whether or not exposing DataContext is a good idea. Probably it's best to use an existing ORM framework. DataObjects.NET looks really nice.

A nice ORM overview can be found on ORMbattle.