Matthieu MEZIL

Use Roslyn to improve C#/VB compiler

I published a POC using Roslyn to improve C# compiler.

Enjoy! :)

WCF Async Queryable Services: the architecture

If you follow me on twitter, you probably know that I’m working on a project named WCF Async Queryable Services.

I made my first video on WCF Async Queryable Services to explain my architecture.

WCF Async Queryable Services - Architecture

Thanks for your feedbacks

LINQ Expressions are more permissive than C#

When we use Collection initializers, we can’t write many instructions in the initialization:

public class C

{

    public int MyProperty { get; set; }

var test = new List<C>() { new C { MyProperty = { int i = 1; i += 1 ; return i; } } };

This code does not compile.

But, using LINQ Expressions, it does!

var v = Expression.Variable(typeof(int));

var test = Expression.Lambda<Func<List<C>>>(

    Expression.ListInit(

        Expression.New(typeof(List<C>)), 

        Expression.ElementInit(

            typeof(List<C>).GetMethod("Add"), 

            Expression.MemberInit(

                Expression.New(typeof(C)), 

                Expression.Bind(typeof(C).GetProperty("MyProperty"), 

                Expression.Block(

                    new ParameterExpression[] { v }, 

                    Expression.Assign(v, Expression.Constant(1)), 

                    Expression.AddAssign(v, Expression.Constant(1)), 

EF: why Include method is an anti-pattern IMHO? Part 5: many to many relationships

I recently blogged to explain why I found that Include method is an anti-pattern IMHO.

EF: Why Include method is an anti-pattern IMHO?

EF: Why Include method is an anti-pattern IMHO even with many to one navigation properties? 2/3

EF: Why Include method is an anti-pattern IMHO? 3/3

EF- Why Include method is an anti-pattern IMHO- Conclusion

But I didn’t show how to do it with many to many relationships.

I will do on this post.

This is my model:

I have 1000 products, 100 categories and 4497 associations in my DB.

I use a local DB what is better for EF Include. // Don’t forget it, it would be worse for EF Include method with SQL Azure or any far DB… Moreover, the bigger entities are, the worse it is for the EF Include. In my case, entities are really very very short

The “official” way to get the 100 first Products with their Categories is the following:

var products = context.Products.Include("Categories").Take(100).ToList();

Now my way is the following:

object categoriesLock = new object();

object productsCategoriesLock = new object();

Task productsCategoriesTask = new Task(() =>

    {

        using (var productsCategoriesContext = new Many2ManyIncludeEntities())

        {

            var productsCategoriesIds = productsCategoriesContext.Products.Take(100).SelectMany(p => p.Categories.Select(c => new { p.ProductId, c.CategoryId })).ToList();

            lock (productsCategoriesLock)

            {

                var loadedProducts = context.ObjectStateManager.GetObjectStateEntries(EntityState.Unchanged).Select(ose => ose.Entity).OfType<Product>().ToList();

                var loadedCategories = context.ObjectStateManager.GetObjectStateEntries(EntityState.Unchanged).Select(ose => ose.Entity).OfType<Category>().ToList();

                foreach (var pc in productsCategoriesIds)

                {

                    var product = loadedProducts.FirstOrDefault(p => p.ProductId == pc.ProductId);

                    var category = loadedCategories.FirstOrDefault(c => c.CategoryId == pc.CategoryId);

                    if (product != null && category != null)

                        product.Categories.Attach(category);

                }

            }

        }

    });

Task categoriesTask = new Task(() =>

    {

        lock (productsCategoriesLock)

        {

            productsCategoriesTask.Start();

            using (var categoriesContext = new Many2ManyIncludeEntities())

            {

                categoriesContext.Categories.MergeOption = MergeOption.NoTracking;

                var categories = categoriesContext.Categories.Where(c => c.Products.Any(p => categoriesContext.Products.Take(100).Contains(p))).ToList();

                lock (categoriesLock)

                {

                    foreach (var c in categories)

                        context.Categories.Attach(c);

                }

            }

        }

    });

lock (categoriesLock)

{

    categoriesTask.Start();

    var products = context.Products.Take(100).ToList();

}

Task.WaitAll(categoriesTask, productsCategoriesTask);

So my code is really more complex but what about performance?

Even with best condition for EF way (local DB, very short entities), my way is really better: for the first execution, EF Include executes it on 835 ms when mine is 130 (6.42 faster). For the second an other ones, EF Include executes it on 342 ms vs 72 for mine (4.75 faster).

Now you have the choice between performance vs simplicity.

TechDays Paris Roslyn compiler demo

Two days ago, I spoke at Microsoft TechDays in Paris, France on Roslyn.

I made several demos including one where I build my own C# compiler that allows me to add features on C#.

This compiler supports AOP in order to implement INotifyPropertyChanged.

So with this code:

[NotifyPropertyChanged]

public class TestNotifyPropertyChanged

{

    public int P1 { get; set; }

    private string _p2;

    public string P2

    {

        get { return _p2; }

        set 

        {

            if (_p2 != null)

                _p2 = value;

        }

    }

}

the compilation works like if you wrote this one:

public class TestNotifyPropertyChanged : System.ComponentModel.INotifyPropertyChanged

{

    public int P1

    {

        get

        {

            return _p1;

        }

        set

        {

            _p1 = value;

            if (PropertyChanged != null)

                PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs("P1"));

        }

    }

    private string _p2;

    public string P2

    {

        get

        {

            return _p2;

        }

        set

        {

            if (_p2 != null)

                _p2 = value;

            if (PropertyChanged != null)

                PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs("P2"));

        }

    }

    private int _p1;

    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

}

My second C# improvement was to be able to combine return and yield return on the same method and to introduce yield return many keyword.

In this case, this code:

public IEnumerable<int> GetInts(bool b)

{

    if (b)

        return Enumerable.Range(1, 2);

    yield return many Enumerable.Range(1, 2);

    yield return 4;

will be translated (still on compilation process) by the following:

public IEnumerable<int> GetInts(bool b)

{

    if (b)

    {

        foreach (int yieldReturnVarLoop in Enumerable.Range(1, 2))

            yield return yieldReturnVarLoop;

        yield break;

    }

    foreach (int yieldReturnVarLoop in Enumerable.Range(1, 2))

        yield return yieldReturnVarLoop;

    yield return 4;

The last one was to support generic constraint constructor with parameters.

With my own compiler, I can use the following code:

public class C<T>

    where T : new(string, bool)

{

    public T CreateT(string s, bool b)

    {

        return new T(s, b);

    }

}

public class Test

{

    public static string Foo()

    {

        return new C<C2>().CreateT("A", true).S; 

    }

which will be translated by this one:

public class Test

{

    public static string Foo()

    {

        return new C<C2>() { FactoryT = (aT0, aT1) => new ConsoleApplication1.C2(aT0, aT1) }.CreateT("A", true).S;

    }

}

public class C<T>

{

    public T CreateT(string s, bool b)

    {

        return FactoryT(s, b);

    }

    public System.Func<string, bool, T> FactoryT

    {

        get;

        set;

    }

If you want to see how to do it, you can download the source code here.

WCF with async await logic

I found this very interesting post to get a Task<T> from a WCF call.

I change it a little bit to fix a bug and to allow usage of async / await using AsyncCtpLibrary.

So I propose this implementation:

public static class TaskFactoryExtensions

{

    public static async Task<TResult> ToTask<TResult>(this IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)

    {

        var taskCompletionSource = new TaskCompletionSource<TResult>();

        if (asyncResult.IsCompleted)

            taskCompletionSource.TrySetResult(asyncResult, endMethod);

        else

        {

            object lockObject = new object();

            bool proccessed = false;

            ThreadPool.RegisterWaitForSingleObject(asyncResult.AsyncWaitHandle, (state, timeOut) =>

            {

                if (proccessed)

                    return;

                lock (lockObject)

                {

                    if (proccessed)

                        return;

                    proccessed = true;

                }

                taskCompletionSource.TrySetResult(asyncResult, endMethod);

            }, null, -1, true);

            if (asyncResult.IsCompleted)

            {

                lock (lockObject)

                {

                    if (!proccessed)

                    {

                        proccessed = true;

                        taskCompletionSource.TrySetResult(asyncResult, endMethod);

                    }

                }

            }

        }

        TResult value = await taskCompletionSource.Task;

        return value;

    }

    private static void TrySetResult<TResult>(this TaskCompletionSource<TResult> taskCompletionSource, IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod)

    {

        try

        {

            var result = endMethod(asyncResult);

            taskCompletionSource.TrySetResult(result);

        }

        catch (OperationCanceledException)

        {

            taskCompletionSource.TrySetCanceled();

        }

        catch (Exception e)

        {

            taskCompletionSource.TrySetException(e);

        }

    }

}

So now, I can use this code to call my WCF Service:

private async Task<List<Customer>> GetCustomers()

{

    var service = new MyService();

    return await service.BeginGetCustomers(null, null).ToTask(ar => service.EndGetCustomers(ar));

Enjoy! :)

Update : With AsyncCtpLibrary, we could just do it:

return await Task.Factory.FromAsync(service.BeginGetCustomers(null, null), ar => service.EndGetCustomers(ar));

WPF/SL: lazy loading TreeView

01/26/2012: Code update

Imagine the following scenario: you have a WCF service with two methods:

List<Customer> GetCustomers();
List<Order> GetOrders(int CustomerId);

You want a treeview with lazy loading in a WPF Window.

There is many way to do it.

I identify three main in my searches:

• you can use event on your treeview implemented in code-behind
• you can makes your TreeView control inheriting the framework one’s
• you can use all the logic on ViewModels and use binding

The last point is realized by adding a CustomerViewModel, having a collection of CustomerViewModel in the VM that encapsulated a Customer and adding IsExpanded property and add the logic of loading orders.

It’s a way often saw in the web and that seems a good way with MVVM for many developers but I think, IMHO, it is NOT a good way.

Indeed, what happens if under Orders, I want OrderDetails? You will add a new OrderViewModel class that encapsulates an Order and the CustomerViewModel class will have a collection of OrderViewModel?

I don’t want to make again my Model in my ViewModel.

I could use the ICustomTypeDescriptor (ICustomTypeProvider in SL) as I did here but I think that if this solution is interesting to add business logic on entity, it is not to add control logic.

I think that the lazy loading control logic should be encapsulated in a behavior and the ViewModel should just have the lazy loading WCF calls logic.

So, I use an ILazyLoader interface:

public interface ILazyLoader

{

    string GetChildPropertyName(object obj);

    bool IsLoaded(object obj);

    void Load(object obj);

and an implementation of it using delegate:

public class LazyLoader : ILazyLoader

{

    private Func<object, string> _getChildPropertyName;

    private Func<object, bool> _isLoaded;

    private Action<object> _load;

    public LazyLoader(Func<object, string> getChildPropertyName, Func<object, bool> isLoaded, Action<object> load)

    {

        _getChildPropertyName = getChildPropertyName;

        _isLoaded = isLoaded;

        _load = load;

    }

    public string GetChildPropertyName(object obj)

    {

        return _getChildPropertyName(obj);

    }

    public bool IsLoaded(object obj)

    {

        return _isLoaded(obj);

    }

    public void Load(object obj)

    {

        _load(obj);

    }

Then, in my ViewModel, I use the following code:

public class CustomerViewModel

{

    private ObservableCollection<Customer> _customers;

    public ObservableCollection<Customer> Customers

    {

        get

        {

            if (_customers == null)

            {

                _customers = new ObservableCollection<Customer>();

                var customersService = new CustomerServiceClient();

                EventHandler<GetCustomersCompletedEventArgs> serviceGetCustomersCompleted = null;

                serviceGetCustomersCompleted = (sender, e) =>

                    {

                        customersService.GetCustomersCompleted -= serviceGetCustomersCompleted;

                        foreach (var ht in e.Result)

                            _customers.Add(ht);

                    };

                customersService.GetCustomersCompleted += serviceGetCustomersCompleted;

                customersService.GetCustomersAsync();

            }

            return _customers;

        }

    }

    private ILazyLoader _lazyLoader;

    public ILazyLoader LazyLoader

    {

        get { return _lazyLoader ?? (_lazyLoader = new LazyLoader(obj => 

            {

                if (obj is HardwareType)

                    return PropertyName.GetPropertyName((Expression<Func<HardwareType, object>>)(ht => ht.Hardwares));

                return null;

            }, obj => _loadedHardwareTypes.Contains((HardwareType)obj), obj => LoadHardwares((HardwareType)obj))); }

    private List<Customer> _loadedCustomers = new List<Customer>();

    private void LoadOrders(Customer c)

    {

        var customerService = new CustomerServiceClient();

        c.Orders.Clear();

        EventHandler<GetOrdersCompletedEventArgs> serviceGetOrdersCompleted = null;

        serviceGetOrdersCompleted = (sender, e) =>

        {

            customerService.GetOrdersCompleted -= serviceGetOrdersCompleted;

            foreach (var o in e.Result)

                c.Orders.Add(o);

            _loadedCustomers.Add(c);

        };

        customerService.GetOrdersCompleted += serviceGetCustomersCompleted;

        customerService.GetOrdersAsync(c.Id);

    }

Now, this is the code of my behavior:

public static class LazyLoadTreeViewItemBehavior

{

    public static ILazyLoader GetLazyLoader(DependencyObject obj)

    {

        return (ILazyLoader)obj.GetValue(LazyLoaderProperty);

    }

    public static void SetLazyLoader(DependencyObject obj, ILazyLoader value)

    {

        obj.SetValue(LazyLoaderProperty, value);

    }

    public static readonly DependencyProperty LazyLoaderProperty =

        DependencyProperty.RegisterAttached("LazyLoader", typeof(ILazyLoader), typeof(LazyLoadTreeViewItemBehavior), new PropertyMetadata(ApplyingLazyLoadingLogic));

    private static void ApplyingLazyLoadingLogic(DependencyObject o, DependencyPropertyChangedEventArgs e)

    {

        var tvi = o as TreeViewItem;

        if (tvi == null)

            throw new InvalidOperationException();

        ILazyLoader lazyLoader= GetLazyLoader(o);

        PropertyInfo childrenProp;

        if (lazyLoader == null)

            return;

        object itemValue = tvi.DataContext;

        string childrenPropName = lazyLoader.GetChildPropertyName(itemValue);

        if (childrenPropName == null || (childrenProp = itemValue.GetType().GetProperty(childrenPropName)) == null)

            return;

        IEnumerable children = (IEnumerable)childrenProp.GetValue(itemValue, null);

        RoutedEventHandler tviExpanded = null;

        RoutedEventHandler tviUnloaded = null;

        tviExpanded = (sender, e2) =>

            {

                tvi.Expanded -= tviExpanded;

                tvi.Unloaded -= tviUnloaded;
                if (!lazyLoader.IsLoaded(itemValue))

                {

                    lazyLoader.Load(itemValue);

                    tvi.Items.Clear();

                    tvi.ItemsSource = children;

                }

            };

        tviUnloaded = (sender, e2) =>

            {

                tvi.Expanded -= tviExpanded;

                tvi.Unloaded -= tviUnloaded;

            };

        if (!children.GetEnumerator().MoveNext())

        {

            tvi.ItemsSource = null;

            tvi.Items.Add(new TreeViewItem());

        }

        tvi.Expanded += tviExpanded;

        tvi.Unloaded += tviUnloaded;

The thing very interesting with it is the fact that my behavior is not dependent of my model or my ViewModel and can be used with other lazy loading TreeViews.

To do it, I just have to apply our behavior into our TreeView, what can be done in xaml:

<TreeView ItemsSource="{Binding Customers}">

    <TreeView.ItemContainerStyle>

        <Style TargetType="{x:Type TreeViewItem}">

            <Setter Property="local:LazyLoadTreeViewItemBehavior.LazyLoader" 

                    Value="{Binding DataContext.LazyLoader, RelativeSource={RelativeSource AncestorType=local:CustomersWindow}}" />

        </Style>

    </TreeView.ItemContainerStyle>

    <TreeView.ItemTemplate>

        <HierarchicalDataTemplate>

            <HierarchicalDataTemplate.ItemTemplate>

                <DataTemplate>

                    …

                </DataTemplate>

            </HierarchicalDataTemplate.ItemTemplate>

            …

        </HierarchicalDataTemplate>

    </TreeView.ItemTemplate>

I really like this way. What do you think about it?

Of course, I write my sample with WPF but it’s still true with SL.

Hope this helps…

SL5 with AsyncCtp: The type 'System.Threading.Tasks.Task' exists in both mscorlib.dll and AsyncCtpLibrary_Silverlight.dll

If you use AsyncCtp With SL5, you could have the following issue: The type 'System.Threading.Tasks.Task' exists in both mscorlib.dll and AsyncCtpLibrary_Silverlight.dll.

So you can’t compile your project if you use Task class!

In this case, you could use an alias on the assembly but, you could not use async / await keywords.

I found a trick to do it: using two aliases on AsyncCtpLibrary_Silverlight. For this, in the aliases property of the assembly reference, I use “global,AsyncCtpLibrary” instead of only “global”.

Like this, I can use async/await because I have global alias on AsyncCtpLibrary_Silverlight.dll and I can use Task class with the following using:

extern alias AsyncCtpLibrary;

 
using AsyncCtpLibrary.System.Threading.Tasks;

Update:

Note that if you use AsyncCtpLibrary_Silverlight5.dll instead of AsyncCtpLibrary_Silverlight.dll, you don’t need to do it!

Coding for fun: Write your code in comments with Roslyn

Sometimes, you have some very basic methods and you could find useless to comment them but sometimes you have to comment them in order to generate help file.

Some tools allow you to generate comments using the method signature.

For fun, I will use another way: I will write the method code in the comment.

I have a ConsoleApplication:

class Program
{
     static void Main(string[] args)
     {
         Console.WriteLine("a ?");
         int a = int.Parse(Console.ReadLine());
         Console.WriteLine("b ?");
         int b = int.Parse(Console.ReadLine());
         Console.WriteLine("{0} + {1} = {2}", a, b, Add(a, b));
         Console.ReadLine();
     }


 
     /// <summary>
     /// return a + b;
     /// </summary>
     /// <param name="a"></param>
     /// <param name="b"></param>
     /// <returns></returns>
     public static int Add(int a, int b)
     {
         throw new NotImplementedException();
     }
}

The code of the Add method (return a + b;) is commented.

Now I will write my own C# compiler using Roslyn:

class Program
{
     static void Main(string[] args)
     {
         string solutionPath = args[0];
         string binaryDirectory = args[1];
         var solution = Solution.Load(solutionPath);
         List<IProject> notSortedProjects = solution.Projects.ToList();
         List<IProject> projects = new List<IProject>();
         do
         {
             foreach (IProject project in notSortedProjects.ToList())
             {
                 if (project.ProjectReferences.All(prId => projects.Any(p => p.Id == prId)))
                 {
                     projects.Add(project);
                     notSortedProjects.Remove(project);
                 }
             }
         } while (notSortedProjects.Count != 0);

 
         foreach (var project in projects)
         {
             foreach (var document in project.Documents)
             {
                 var documentTree = document.GetSyntaxTree();
                 var newDocumentTree = new CodeInCommentsRewriter().Visit((SyntaxNode)documentTree.Root);
                 var newDocumentTreeText = new StringText(newDocumentTree.ToString());
                 solution = solution.UpdateDocument(document.Id, newDocumentTreeText);
             }
             using (var stream = new FileStream(string.Format("{0}.{1}",
                  Path.Combine(binaryDirectory, project.AssemblyName),
                  project.CompilationOptions.AssemblyKind == AssemblyKind.DynamicallyLinkedLibrary ? "dll" : "exe"), FileMode.Create))
             {
                 var emitResult = solution.Projects.First(p => p.Id == project.Id).GetCompilation().Emit(stream);
                 if (!emitResult.Success)
                     throw new InvalidOperationException();
             }
         }
     }
}

public class CodeInCommentsRewriter : SyntaxRewriter
{
     protected override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
     {
         IEnumerator<SyntaxNode> bodySyntaxNodesEnumerator = node.BodyOpt.ChildNodes().GetEnumerator();
         if (bodySyntaxNodesEnumerator.MoveNext())
         {
             ThrowStatementSyntax childNode = bodySyntaxNodesEnumerator.Current as ThrowStatementSyntax;
             if (!bodySyntaxNodesEnumerator.MoveNext()// only one child node
                && childNode != null)
             {
                 var comment = node.GetLeadingTrivia().Select(t => Regex.Match(t.GetText(), "return (.?)*").Value).FirstOrDefault(v => ! string.IsNullOrEmpty(v));
                 if (comment != null)
                 {
                     return Syntax.MethodDeclaration(
                         node.Attributes,
                         node.Modifiers,
                         node.ReturnType,
                         node.ExplicitInterfaceSpecifierOpt,
                         node.Identifier,
                         node.TypeParameterListOpt,
                         node.ParameterList,
                         node.ConstraintClauses,
                         Syntax.Block(
                             node.BodyOpt.OpenBraceToken,
                             Syntax.List(
                                 Syntax.ParseStatement(comment)),
                             node.BodyOpt.CloseBraceToken),
                         node.SemicolonTokenOpt);
                 }
             }
         }
         return base.VisitMethodDeclaration(node);
     }
}

And here we are! // I use some shortcut (the code is a return in one line)

If I execute my compiler and then the generated exe, I can see in the Console that 1 + 2 = 3.

EF: Why Include method is an anti-pattern IMHO? Conclusion

First, I admit that Anti-pattern word was excessive but I see so many catastrophic performances in my audits where developers use Include method.

I presented you a very « special » way to realize Include. If you use Include ONLY on the one side, performance difference is not huge and my code is really longer and more complex. But I consider that my solution would become very interesting if this code could be generated.

In a future post, I will share with you a T4 that do the job.

Note that if my DB was not local but far (SQL Azure for example), difference would be really better for my solution. Indeed, bytes received from server are really much important using Include method because you will probably have duplicated data if you have more than one row.

The main idea of these posts was not to give you a better way to write Include but to help you to realize what happens when you use Include method and what can we do if performance is something very important on your project.

Just note that, as I already mentioned, with my code, you will lose the IQueryable.

Note also that Include method is perfect for table splitting.

You also have to take in consideration that, because I don’t use DB lock, I can have incoherence with my way contrary to Include method. For example, if you first get Customers and the someone adds a new OnlineSale with a new Customer, and then you get the OnlineSales, you will get an OnlineSale without its Customer.

EF: Why Include method is an anti-pattern IMHO? 3/3

I will continue on my sample with Contoso.

I won’t use a Repository and I will directly querying my DB on my ViewModel. The main reason is because it is easier for demo and because the main topic is the Include method.

I will use Include method with the best case for it: navigation property to one side.

Imagine that you want to use a WPF DataGrid read only based on OnlineSales where you want to see the OnlineSale.SalesQuantity, OnlineSale.SalesAmount, Customer.LastName, Customer.FirstName, Store.StoreName, Product.ProductName, ProductSubcategory.ProductSubcategoryName and ProductCategory.ProductCategoryName.

This is typically a case where most of developers (and sessions I saw) use the Include method.

public class OnlineOrdersViewModel : INotifyPropertyChanged, IDisposable

{

    private ContosoRetailDWEntities _context = new ContosoRetailDWEntities();

    private ObservableCollection<OnlineSale> _onlineSales;

    public ObservableCollection<OnlineSale> OnlineSales

    {

        get 

        {

            if (_onlineSales == null)

            {

                Stopwatch sw = new Stopwatch();

                sw.Start();

                _onlineSales = new ObservableCollection<OnlineSale>(_context.OnlineSales.Take(100).Include(os => os.Customer).Include(os => os.Product.ProductSubcategory.ProductCategory).Include(os => os.Store));

                sw.Stop();

                ElapsedMilliseconds = sw.ElapsedMilliseconds;

            }

            return _onlineSales; 

        }

    }

    private long _elapsedMilliseconds;

    public long ElapsedMilliseconds

    {

        get { return _elapsedMilliseconds; }

        set

        {

            _elapsedMilliseconds = value;

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs("ElapsedMilliseconds"));

        }

    }

    public void Dispose()

    {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

    protected virtual void Dispose(bool disposing)

    {

        if (disposing)

        {

            if (_context != null)

            {

                _context.Dispose();

                _context = null;

            }

        }

    }

    public event PropertyChangedEventHandler PropertyChanged;

}

The OnlineSales loading needs 1135ms.

IMHO, this is an anti-pattern. Why loading complete entities only for one or two properties?

Here you can use a OnlineSaleDTO that has only these properties. It would be the easier.

You can also use your entities. But in this case, how to do it?

There is one restriction with L2E: you can’t use a new on en entity (I hope it will be fix in the future).

So I use this code:

_onlineSales = new ObservableCollection<OnlineSale>(

    _context.OnlineSales.Take(100).

    Select(os =>

        new

        {

            os.OnlineSalesKey,

            os.SalesQuantity,

            os.SalesAmount,

            os.Customer.LastName,

            os.Customer.FirstName,

            os.Product.ProductName,

            os.Product.ProductSubcategory.ProductSubcategoryName,

            os.Product.ProductSubcategory.ProductCategory.ProductCategoryName,

            os.Store.StoreName

        }).

    AsEnumerable().

    Select(os =>

        new OnlineSale

        {

            OnlineSalesKey = os.OnlineSalesKey,

            SalesQuantity = os.SalesQuantity,

            SalesAmount = os.SalesAmount,

            Customer = new Customer

            {

                LastName = os.LastName,

                FirstName = os.FirstName,

            },

            Product = new Product

            {

                ProductName = os.ProductName,

                ProductSubcategory = (os.ProductSubcategoryName == null ? null : new ProductSubcategory

                {

                    ProductSubcategoryName = os.ProductSubcategoryName,

                    ProductCategory = (os.ProductCategoryName == null ? null : new ProductCategory

                    {

                        ProductCategoryName = os.ProductCategoryName

                    })

                })

            },

            Store = new Store

            {

                StoreName = os.StoreName

            }

        }));

Note that because ProductSubcategory.ProductSubcategoryName and ProductCategory.ProductCategoryName properties are not nullable, I can used it in order to know if ProductSubCategory or ProductCategory ar null.

Mine needs only 518 ms so more than twice fast!

Note that if you compare performance with my previous post, you can see that these performances are very bad comparing to what they were. In fact it’s because in my previous post, query execution plans were on SQL Server cache. Here it was not the case. In this case the comparison is really on favor of my way.

When execution plans are in SQL Server cache, Include method needs 507ms and mine 350. So the ratio is less important in this case.

Now what happens if the grid is not read only. In 90 % of cases, you won’t modify the related entities but only the OnlineSale entity.

So we will use a TextBox for SalesQuantity and SalesAmount, a ComboBox for Customer, Product and Store.

<DataGrid ItemsSource="{Binding OnlineSales}"

            AutoGenerateColumns="False">

    <DataGrid.Columns>

        <DataGridTextColumn Binding="{Binding SalesQuantity}" />

        <DataGridTextColumn Binding="{Binding SalesAmount}" />

        <DataGridTemplateColumn>

            <DataGridTemplateColumn.CellTemplate>

                <DataTemplate>

                    <ComboBox ItemsSource="{Binding Path=DataContext.Customers, RelativeSource={RelativeSource AncestorType={x:Type Window}}}"

                                SelectedItem="{Binding Customer}">

                        <ComboBox.ItemTemplate>

                            <DataTemplate>

                                <StackPanel Orientation="Horizontal">

                                    <TextBlock Text="{Binding LastName}"

                                                Margin="0,0,5,0" />

                                    <TextBlock Text="{Binding FirstName}" />

                                </StackPanel>

                            </DataTemplate>

                        </ComboBox.ItemTemplate>

                    </ComboBox>

                </DataTemplate>

            </DataGridTemplateColumn.CellTemplate>

        </DataGridTemplateColumn>

        <DataGridTemplateColumn>

            <DataGridTemplateColumn.CellTemplate>

                <DataTemplate>

                    <ComboBox ItemsSource="{Binding Path=DataContext.Stores, RelativeSource={RelativeSource AncestorType={x:Type Window}}}"

                                DisplayMemberPath="StoreName"

                                SelectedItem="{Binding Store}" />

                </DataTemplate>

            </DataGridTemplateColumn.CellTemplate>

        </DataGridTemplateColumn>

        <DataGridTemplateColumn>

            <DataGridTemplateColumn.CellTemplate>

                <DataTemplate>

                    <ComboBox ItemsSource="{Binding Path=DataContext.Products, RelativeSource={RelativeSource AncestorType={x:Type Window}}}"

                                SelectedItem="{Binding Product}">

                        <ComboBox.ItemTemplate>

                            <DataTemplate>

                                <StackPanel Orientation="Horizontal">

                                    <TextBlock Text="{Binding ProductSubcategory.ProductCategory.ProductCategoryName}"

                                                Margin="0,0,5,0" />

                                    <TextBlock Text="/"

                                                Margin="0,0,5,0" />

                                    <TextBlock Text="{Binding ProductSubcategory.ProductSubcategoryName}"

                                                Margin="0,0,5,0" />

                                    <TextBlock Text="/"

                                                Margin="0,0,5,0" />

                                    <TextBlock Text="{Binding ProductName}" />

                                </StackPanel>

                            </DataTemplate>

                        </ComboBox.ItemTemplate>

                    </ComboBox>

                </DataTemplate>

            </DataGridTemplateColumn.CellTemplate>

        </DataGridTemplateColumn>

    </DataGrid.Columns>

</DataGrid>

On my audits I often see this code for ViewModel:

public class OnlineOrdersViewModel : INotifyPropertyChanged, IDisposable

{

    private ContosoRetailDWEntities _context = new ContosoRetailDWEntities();

    public OnlineOrdersViewModel()

    {

        Stopwatch sw = new Stopwatch();

        sw.Start();

        // In Real life don't do it in the constructor but in another thread in order to not freeze UI

        _onlineSales = new ObservableCollection<OnlineSale>(_context.OnlineSales.Take(100).Include(os => os.Customer).Include(os => os.Product.ProductSubcategory.ProductCategory).Include(os => os.Store));

        _customers = new ObservableCollection<Customer>(_context.Customers);

        _stores = new ObservableCollection<Store>(_context.Stores);

        _products = new ObservableCollection<Product>(_context.Products.Include(p => p.ProductSubcategory.ProductCategory));

        sw.Stop();

        ElapsedMilliseconds = sw.ElapsedMilliseconds;

    }

    private ObservableCollection<OnlineSale> _onlineSales;

    public ObservableCollection<OnlineSale> OnlineSales

    {

        get { return _onlineSales ?? (_onlineSales = new ObservableCollection<OnlineSale>()); }

    }

    private ObservableCollection<Customer> _customers;

    public ObservableCollection<Customer> Customers

    {

        get { return _customers ?? (_customers = new ObservableCollection<Customer>()); }

    }

    private ObservableCollection<Product> _products;

    public ObservableCollection<Product> Products

    {

        get { return _products ?? (_products = new ObservableCollection<Product>()); }

    }

    private ObservableCollection<Store> _stores;

    public ObservableCollection<Store> Stores

    {

        get { return _stores ?? (_stores = new ObservableCollection<Store>()); }

    }

    private long _elapsedMilliseconds;

    public long ElapsedMilliseconds

    {

        get { return _elapsedMilliseconds; }

        set

        {

            _elapsedMilliseconds = value;

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs("ElapsedMilliseconds"));

        }

    }

    public void Dispose()

    {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

    protected virtual void Dispose(bool disposing)

    {

        if (disposing)

        {

            if (_context != null)

            {

                _context.Dispose();

                _context = null;

            }

        }

    }

    public event PropertyChangedEventHandler PropertyChanged;

}

This is useless to use Include method when you load OnlineSales because, with foreign keys, EF ObjectContext will attach navigation property alone because we load all related elements (when we load customers, stores, products with ProductSubcategory with ProductCategory).

This first sample needs 2338 ms for loading and 1244 when SQL Server uses its cache.

Now if we remove the useless Include:

_onlineSales = new ObservableCollection<OnlineSale>(_context.OnlineSales.Take(100));

_customers = new ObservableCollection<Customer>(_context.Customers);

_stores = new ObservableCollection<Store>(_context.Stores);

_products = new ObservableCollection<Product>(_context.Products.Include(p => p.ProductSubcategory.ProductCategory));

With it, loading needs 1685 ms and 1152 ms when SQL Server uses its cache.

Now I will try to do it with my way loading needs 1459 ms and 1007 ms when SQL Server uses its cache.

object lockObject = new object();

Task onlineSalesTask = new Task(() =>

    {

        using (var context2 = new ContosoRetailDWEntities())

        {

            _onlineSales = new ObservableCollection<OnlineSale>(

                context2.OnlineSales.Take(100).

                Select(os =>

                    new

                    {

                        os.OnlineSalesKey,

                        os.SalesQuantity,

                        os.SalesAmount,

                        os.CustomerKey,

                        os.ProductKey,

                        os.StoreKey

                    }).

                AsEnumerable().

                Select(os =>

                    new OnlineSale

                    {

                        OnlineSalesKey = os.OnlineSalesKey,

                        SalesQuantity = os.SalesQuantity,

                        SalesAmount = os.SalesAmount,

                        CustomerKey = os.CustomerKey,

                        ProductKey = os.ProductKey,

                        StoreKey = os.StoreKey,

                    }));

        }

        lock (lockObject)

        {

            foreach (var os in _onlineSales)

                _context.OnlineSales.Attach(os);

        }

    });

onlineSalesTask.Start();

Task customersTask = new Task(() =>

    {

        using (var context2 = new ContosoRetailDWEntities())

        {

            _customers = new ObservableCollection<Customer>(

                _context.Customers.