Matthieu MEZIL

T4 for View Generation

2009-06-29T23:49:00Z

EF team blogged about it here and I think that it’s very useful.

First, I think that it’s easier to use than Edmgen.

Moreover, contrary to EdmGen, it allows you to use embedded metadata artifacts.

If you want to use the MS T4 template with VS 2010, don’t forget to change the xml namespaces.

XNamespace edmxns = "http://schemas.microsoft.com/ado/2008/10/edmx";
XNamespace csdlns = "http://schemas.microsoft.com/ado/2008/09/edm";
XNamespace mslns = "http://schemas.microsoft.com/ado/2008/09/mapping/cs";
XNamespace ssdlns = "http://schemas.microsoft.com/ado/2009/02/edm/ssdl";

So you should have the following:

<#@ template language="C#" hostspecific="true"#>
<#@ output extension=".cs" #>

<#@ assembly name="System.Core" #>
<#@ assembly name="System.Data" #>
<#@ assembly name="System.Data.Entity" #>
<#@ assembly name="System.Data.Entity.Design" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="System.Xml.Linq" #>

<#@ import namespace="System" #>
<#@ import namespace="System.IO" #>
<#@ import namespace="System.Diagnostics" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ import namespace="System.Data.Entity.Design" #>
<#@ import namespace="System.Data.Metadata.Edm" #>
<#@ import namespace="System.Data.Mapping" #>
<#@ import namespace="System.Xml" #>
<#@ import namespace="System.Xml.Linq" #>

<#
    // Find EDMX file to process: Model1.Views.tt generates views for Model1.EDMX
    string edmxFileName = Path.GetFileNameWithoutExtension(this.Host.TemplateFile).ToLowerInvariant().Replace(".views", "") + ".edmx";
    string edmxFilePath = Path.Combine(Path.GetDirectoryName(this.Host.TemplateFile), edmxFileName);
    if (File.Exists(edmxFilePath))
    {
        // Call helper class to generate pre-compiled views and write to output
        this.WriteLine(GenerateViews(edmxFilePath));
    }
    else
    {
        this.Error(String.Format("No views were generated. Cannot find file {0}. Ensure the project has an EDMX file and the file name of the .tt file is of the form [edmx-file-name].Views.tt", edmxFilePath));
    }
    // All done!
#>

<#+
    private String GenerateViews(string edmxFilePath)
    {
        String generatedViews = String.Empty;
        try
        {
            using (StreamWriter writer = new StreamWriter(new MemoryStream()))
            {
                XmlReader csdlReader = null;
                XmlReader mslReader = null;
                XmlReader ssdlReader = null;

// Crack open the EDMX file and get readers over the CSDL, MSL and SSDL portions
GetConceptualMappingAndStorageReaders(edmxFilePath, out csdlReader, out mslReader, out ssdlReader);

                // Initialize item collections
                EdmItemCollection edmItems = new EdmItemCollection(new XmlReader[] { csdlReader });
                StoreItemCollection storeItems = new StoreItemCollection(new XmlReader[] { ssdlReader });
                StorageMappingItemCollection mappingItems = new StorageMappingItemCollection(edmItems, storeItems, new XmlReader[] { mslReader });

                // Initialize the view generator to generate views in C#
                EntityViewGenerator viewGenerator = new EntityViewGenerator();
                viewGenerator.LanguageOption = LanguageOption.GenerateCSharpCode;
                IList<EdmSchemaError> errors = viewGenerator.GenerateViews(mappingItems, writer);

                foreach (EdmSchemaError e in errors)
                {
                    // log error
                    this.Error(e.Message);
                }

                MemoryStream memStream = writer.BaseStream as MemoryStream;
                generatedViews = Encoding.UTF8.GetString(memStream.ToArray());
            }
        }
        catch (Exception ex)
        {
            // log error
            this.Error(ex.ToString());
        }

return generatedViews;
}

    private void GetConceptualMappingAndStorageReaders(string edmxFile, out XmlReader csdlReader, out XmlReader mslReader, out XmlReader ssdlReader)
    {
        csdlReader = null;
        mslReader = null;
        ssdlReader = null;

        XNamespace edmxns = "http://schemas.microsoft.com/ado/2008/10/edmx";
        XNamespace csdlns = "http://schemas.microsoft.com/ado/2008/09/edm";
        XNamespace mslns = "http://schemas.microsoft.com/ado/2008/09/mapping/cs";
        XNamespace ssdlns = "http://schemas.microsoft.com/ado/2009/02/edm/ssdl";

        XDocument edmxDoc = XDocument.Load(edmxFile);
        if (edmxDoc != null)
        {
            XElement edmxNode = edmxDoc.Element(edmxns + "Edmx");
            if (edmxNode != null)
            {
                XElement runtimeNode = edmxNode.Element(edmxns + "Runtime");
                if (runtimeNode != null)
                {
                    // Create XmlReader over CSDL in EDMX
                    XElement conceptualModelsNode = runtimeNode.Element(edmxns + "ConceptualModels");
                    if (conceptualModelsNode != null)
                    {
                        XElement csdlContent = conceptualModelsNode.Element(csdlns + "Schema");
                        if (csdlContent != null)
                        {
                            csdlReader = csdlContent.CreateReader();
                        }
                    }

                    // Create XmlReader over MSL in EDMX
                    XElement mappingsNode = runtimeNode.Element(edmxns + "Mappings");
                    if (mappingsNode != null)
                    {
                        XElement mslContent = mappingsNode.Element(mslns + "Mapping");
                        if (mslContent != null)
                        {
                            mslReader = mslContent.CreateReader();
                        }
                    }

                    // Create XmlReader over SSDL in EDMX
                    XElement storageModelsNode = runtimeNode.Element(edmxns + "StorageModels");
                    if (storageModelsNode != null)
                    {
                        XElement ssdlContent = storageModelsNode.Element(ssdlns + "Schema");
                        if (ssdlContent != null)
                        {
                            ssdlReader = ssdlContent.CreateReader();
                        }
                    }
                }
            }
        }
    }
#>

POCO T4

2009-06-26T08:23:00Z

With EF4 features CTP1, we have a great POCO template which is divided in two tt files to allow us to have the entitiy POCO classes and the context in different projects.

It’s very very cool.

However, I think that it’s a shame not to have an interface for the context particularly to mock it.

So I change the .Context.tt like this:

<#@ template language="C#" debug="false" hostspecific="true"#>
<#@ include file="EF.Utility.ctp.CS.ttinclude"#><#@
output extension=".cs"#><#
// Copyright (c) Microsoft Corporation. All rights reserved.

CodeGenerationTools code = new CodeGenerationTools(this);
MetadataLoader loader = new MetadataLoader(this);
CodeRegion region = new CodeRegion(this, 1);
MetadataTools ef = new MetadataTools(this);

string inputFile = @"Northwind.edmx";
EdmItemCollection ItemCollection = loader.CreateEdmItemCollection(inputFile);
string namespaceName = code.VsNamespaceSuggestion();

TemplateFileManager fileManager = TemplateFileManager.Create(this);
EntityContainer container = ItemCollection.GetItems<EntityContainer>().FirstOrDefault();
if (container == null)
{
return "// No EntityContainer exists in the model, so no code was generated";
}

// Emit Entity Types
string interfaceName = "I" + code.Escape(container);
fileManager.StartNewFile(interfaceName + ".cs");
#>
using System;
using System.Collections.Generic;
using System.Data.Objects;
using System.Data.EntityClient;
using Entities;

<#
if (!String.IsNullOrEmpty(namespaceName))
{
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#
    PushIndent(CodeRegion.GetIndent(1));
}
#>
<#=Accessibility.ForType(container)#> interface <#=interfaceName#>
{
<#
        foreach (EntitySet entitySet in container.BaseEntitySets.OfType<EntitySet>())
        {
#>
    IObjectSet<<#=code.Escape(entitySet.ElementType)#>> <#=code.Escape(entitySet)#> { get; }
<#
        }
#>
<#
        if (container.FunctionImports.Any())
        {
#>

<#
        }
        foreach (EdmFunction edmFunction in container.FunctionImports)
        {
            var parameters = FunctionImportParameter.Create(edmFunction.Parameters, code, ef);
            string paramList = String.Join(", ", parameters.Select(p => p.FunctionParameterType + " " + p.FunctionParameterName).ToArray());
            if(edmFunction.ReturnParameter == null)
            {
                continue;
            }
            string returnTypeElement = code.Escape(ef.GetElementType(edmFunction.ReturnParameter.TypeUsage));

#>
    IEnumerable<<#=returnTypeElement#>> <#=code.Escape(edmFunction)#>(<#=paramList#>);
<#
        }
#>
}
<#
if (!String.IsNullOrEmpty(namespaceName))
{
    PopIndent();
#>
}
<#
}
    fileManager.WriteFiles();
#>
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated from a template.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.Data.Objects;
using System.Data.EntityClient;
using Entities;

<#
if (!String.IsNullOrEmpty(namespaceName))
{
#>
namespace <#=code.EscapeNamespace(namespaceName)#>
{
<#
    PushIndent(CodeRegion.GetIndent(1));
}
#>
<#=Accessibility.ForType(container)#> partial class <#=code.Escape(container)#> : ObjectContext, <#= interfaceName #>
{
    public const string ConnectionString = "name=<#=container.Name#>";
    public const string ContainerName = "<#=container.Name#>";

#region Constructors

    public <#=code.Escape(container)#>()
        : base(ConnectionString, ContainerName)
    {
        ContextOptions.DeferredLoadingEnabled = true;
    }

    public <#=code.Escape(container)#>(string connectionString)
        : base(connectionString, ContainerName)
    {
        ContextOptions.DeferredLoadingEnabled = true;
    }

    public <#=code.Escape(container)#>(EntityConnection connection)
        : base(connection, ContainerName)
    {
        ContextOptions.DeferredLoadingEnabled = true;
    }

#endregion

<#
region.Begin("ObjectSet Properties");

foreach (EntitySet entitySet in container.BaseEntitySets.OfType<EntitySet>())
{
#>

    <#=AccessibilityAndVirtual(Accessibility.ForReadOnlyProperty(entitySet))#> ObjectSet<<#=code.Escape(entitySet.ElementType)#>> <#=code.Escape(entitySet)#>
    {
        get { return <#=code.FieldName(entitySet) #> ?? (<#=code.FieldName(entitySet)#> = CreateObjectSet<<#=code.Escape(entitySet.ElementType)#>>("<#=entitySet.Name#>")); }
    }
    private ObjectSet<<#=code.Escape(entitySet.ElementType)#>> <#=code.FieldName(entitySet)#>;
    IObjectSet<<#=code.Escape(entitySet.ElementType)#>> <#=interfaceName#>.<#=code.Escape(entitySet)#>
    {
        get { return <#=code.Escape(entitySet)#>; }
    }
<#
        }

region.End();
#>

<#
region.Begin("Function Imports");

        foreach (EdmFunction edmFunction in container.FunctionImports)
        {
            var parameters = FunctionImportParameter.Create(edmFunction.Parameters, code, ef);
            string paramList = String.Join(", ", parameters.Select(p => p.FunctionParameterType + " " + p.FunctionParameterName).ToArray());
            if(edmFunction.ReturnParameter == null)
            {
                continue;
            }
            string returnTypeElement = code.Escape(ef.GetElementType(edmFunction.ReturnParameter.TypeUsage));

#>
    <#=AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction))#> ObjectResult<<#=returnTypeElement#>> <#=code.Escape(edmFunction)#>(<#=paramList#>)
    {
<#
            foreach (var parameter in parameters)
            {
                if (!parameter.NeedsLocalVariable)
                {
                    continue;
                }
#>

ObjectParameter <#=parameter.LocalVariableName#>;

        if (<#=parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null"#>)
        {
            <#=parameter.LocalVariableName#> = new ObjectParameter("<#=parameter.EsqlParameterName#>", <#=parameter.FunctionParameterName#>);
        }
        else
        {
            <#=parameter.LocalVariableName#> = new ObjectParameter("<#=parameter.EsqlParameterName#>", typeof(<#=parameter.RawClrTypeName#>));
        }
<#
            }
#>
        return base.ExecuteFunction<<#=returnTypeElement#>>("<#=edmFunction.Name#>"<#=code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()))#>);
    }
    IEnumerable<<#=returnTypeElement#>> <#=interfaceName#>.<#=code.Escape(edmFunction)#>(<#=paramList#>)
    {
        return <#=code.Escape(edmFunction)#>(<#=String.Join(", ", parameters.Select(p => p.FunctionParameterName).ToArray())#>);
    }
<#
        }

        region.End();
#>
}
<#
if (!String.IsNullOrEmpty(namespaceName))
{
    PopIndent();
#>
}
<#
}
#>
<#+
string AccessibilityAndVirtual(string accessibility)
{
    if (accessibility != "private")
    {
        return accessibility + " virtual";
    }

return accessibility;
}
#>

Enjoy

SubObjectSet

2009-06-16T17:22:00Z

With EF, when you use TPH or TPC inheritance mapping scenarii, the EntitySet is on the base class.

As I mentioned often in the past with EF v1, you can add a property in your context which returns the EntitySet.OfType<MySubType>().

Ok it’s interesting but… In EF v1, the EntitySet is an ObjectQuery<T> property and our property also but in EF v2 the EntitySet is an ObjectSet<T>. This class implements the IObjectSet<T> interface which has three methods to add, attach and delete entities.

One guy tells me that he wants to be able to use these methods directly on the “sub EntitySet” property.

To realize it, I made the following class:

public class SubObjectSet<TBase, TInherited> : ObjectQuery<TInherited>, IObjectSet<TInherited>
    where TBase : class
    where TInherited : class, TBase
{
    public ObjectSet<TBase> ObjectSet { get; private set; }
 
    public SubObjectSet(ObjectSet<TBase> objectSet)
        : base(objectSet.OfType<TInherited>().CommandText, objectSet.Context)
    {
        ObjectSet = objectSet;
    }
 
    #region IObjectSet<TInherited> Members
    public void AddObject(TInherited entity)
    {
        ObjectSet.AddObject(entity);
    }
    public void Attach(TInherited entity)
    {
        ObjectSet.Attach(entity);
    }
    public void DeleteObject(TInherited entity)
    {
        ObjectSet.DeleteObject(entity);
    }
    #endregion
}

Entity Framework v2: How to get only one entity easier with EF4

2009-06-13T01:26:00Z

Alex James wrote an extension method which allows to get only one entity from a query and the entity key.

If we have the key, I think it’s useless to allow it for all queries and it’s useful only for EntitySet. With EF4, this extension method can be applied on ObjectSet class instead of ObjectQuery class.

// In the first version of Entity Framework, the ObjectSet class doesn’t exist, EntitySet were some ObjectQuery.

// ObjectSet<T> class inherits from ObjectQuery<T>

This simplifies the code because we can directly use the (Try)GetObjectByKey method:

public static class ObjectSetExtension
{
    public static T Get<T>(this ObjectSet<T> objectSet, object key) where T : class
    {
        object value;
        objectSet.Context.TryGetObjectByKey(new EntityKey(string.Concat(objectSet.Context.DefaultContainerName, ".", objectSet.EntitySet.Name), objectSet.EntitySet.ElementType.KeyMembers.Single().Name, key), out value);
        return (T)value;
    }
    public static T Get<T>(this ObjectSet<T> objectSet, params EntityKeyMember[] keys) where T : class
    {
        object value;
        objectSet.Context.TryGetObjectByKey(new EntityKey(string.Concat(objectSet.Context.DefaultContainerName, ".", objectSet.EntitySet.Name), keys), out value);
        return (T)value;
    }
}

We can use the second extension method for entities with composite key.

Entity Framework: Undo Redo v2

2009-06-10T07:12:00Z

After my first Undo Redo POC version, one of my customers wanted to be able to manage many actions per Undo / Redo.

So I added two extension methods: BeginGroupOfUndoActions and EndGroupOfUndoActions.

My code is now this one:

public static class ObjectContextExtension
{
    private static Dictionary<ObjectContext, ObjectContextUndoRedo> _objectContextUndoRedo = new Dictionary<ObjectContext, ObjectContextUndoRedo>();
 
    public static void ActivateUndoRedoTracking(this ObjectContext context, int undoStackLength)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
        {
            objectContextUndoRedo = new ObjectContextUndoRedo { Context = context };
            _objectContextUndoRedo.Add(context, objectContextUndoRedo);
        }
        objectContextUndoRedo.ActivateUndoRedoTracking(undoStackLength);
    }
 
    public static bool CanUndo(this ObjectContext context)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
            throw new InvalidOperationException();
        return objectContextUndoRedo.CanUndo;
    }
 
    public static void Undo(this ObjectContext context)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
            throw new InvalidOperationException();
        objectContextUndoRedo.Undo();
    }
 
    public static bool CanRedo(this ObjectContext context)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
            throw new InvalidOperationException();
        return objectContextUndoRedo.CanRedo;
    }
 
    public static void Redo(this ObjectContext context)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
            throw new InvalidOperationException();
        objectContextUndoRedo.Redo();
    }
 
    public static void BeginGroupOfUndoActions(this ObjectContext context)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
            throw new InvalidOperationException();
        objectContextUndoRedo.MultipleActions = true;
    }
 
    public static void EndGroupOfUndoActions(this ObjectContext context)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        _objectContextUndoRedo.TryGetValue(context, out objectContextUndoRedo);
        if (objectContextUndoRedo == null)
            throw new InvalidOperationException();
        objectContextUndoRedo.MultipleActions = false;
    }
 
    private class ObjectContextUndoRedo
    {
        private List<List<UndoRedoAction>> _undo, _redo;
        private int _undoStackLength;
        private bool _trackChanges;
 
        public ObjectContext Context { get; set; }
 
        private bool _multipleActions;
        public bool MultipleActions 
        {
            get { return _multipleActions; }
            set
            {
                _multipleActions = value;
                if (value)
                    _undo.Insert(0, new List<UndoRedoAction>());
            }
        }
 
        public void ActivateUndoRedoTracking(int undoStackLength)
        {
            _undoStackLength = undoStackLength;
            _undo = new List<List<UndoRedoAction>>(undoStackLength);
            _redo = new List<List<UndoRedoAction>>(undoStackLength);
            _trackChanges = true;
 
            var objectStateEntries = Context.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged).ToList();
 
            PropertyChangingEventHandler entityModifing = null;
            entityModifing = (sender, e) =>
            {
                var propInfo = sender.GetType().GetProperty(e.PropertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                var value = propInfo.GetValue(sender, null);
                var undoRedoAction = new UndoRedoAction { EntityState = EntityState.Modified, UndoAction = () => propInfo.SetValue(sender, value, null) };
                var inpc = sender as INotifyPropertyChanged;
                if (inpc != null)
                {
                    PropertyChangedEventHandler entityModified = null;
                    entityModified = (s, e2) =>
                        {
                            if (e.PropertyName == e2.PropertyName && _trackChanges)
                            {
                                var newValue = propInfo.GetValue(sender, null);
                                undoRedoAction.RedoAction = () => propInfo.SetValue(sender, newValue, null);
                                if (MultipleActions)
                                    _undo[0].Add(undoRedoAction);
                                else
                                    _undo.Insert(0, new List<UndoRedoAction>() { undoRedoAction });
                                if (_undo.Count > _undoStackLength)
                                    _undo.RemoveAt(_undoStackLength);
                                _redo.Clear();
                            }
                            inpc.PropertyChanged -= entityModified;
                        };
                    inpc.PropertyChanged += entityModified;
                }
            };
            foreach (var e in objectStateEntries.Select(ose => ose.Entity as INotifyPropertyChanging).Where(inpc => inpc != null))
                e.PropertyChanging += entityModifing;
 
            Context.ObjectStateManager.ObjectStateManagerChanged += (sender, e) =>
            {
                switch (e.Action)
                {
                    case CollectionChangeAction.Add:
                        var inpc = e.Element as INotifyPropertyChanging;
                        if (inpc != null)
                            inpc.PropertyChanging += entityModifing;
                        break;
                }
            };
        }
 
        public bool CanUndo
        {
            get { return _undo != null && _undo.Any(); }
        }
 
        public void Undo()
        {
            if (!CanUndo)
                throw new InvalidOperationException();
            var undoRedoAction = _undo.First();
            _undo.RemoveAt(0);
            _trackChanges = false;
            foreach (var undoAction in undoRedoAction)
                undoAction.UndoAction();
            _trackChanges = true;
            _redo.Insert(0, undoRedoAction);
        }
 
        public bool CanRedo
        {
            get { return _redo != null && _redo.Any(); }
        }
 
        public void Redo()
        {
            if (!CanRedo)
                throw new InvalidOperationException();
            var undoRedoAction = _redo.First();
            _redo.RemoveAt(0);
            _trackChanges = false;
            foreach (var redoAction in undoRedoAction)
                redoAction.RedoAction();
            _trackChanges = true;
            _undo.Insert(0, undoRedoAction);
        }
    }
 
    private class UndoRedoAction
    {
        public EntityState EntityState { get; set; }
        public Action UndoAction { get; set; }
        public Action RedoAction { get; set; }
    }
}

And to make a demo about it, I did an unit test:

[TestClass]
public class ObjectContextExtensionTest
{
    [TestMethod]
    public void Test()
    {
        using (var context = new NorthwindEntities())
        {
            var c = context.Categories.First();
            context.ActivateUndoRedoTracking(5);
            var cOriginalCategoryName = c.CategoryName;
            c.CategoryName = "CN";
            var c2 = context.Categories.OrderBy(c3 => c3.CategoryID).Skip(1).First();
            var c2OriginalCategoryName = c2.CategoryName;
            c2.CategoryName = "C2N";
            c.CategoryName = "CN2";
            context.Undo();
            Assert.AreEqual("CN", c.CategoryName);
            Assert.AreEqual("C2N", c2.CategoryName);
            context.Undo();
            Assert.AreEqual("CN", c.CategoryName);
            Assert.AreEqual(c2OriginalCategoryName, c2.CategoryName);
            context.Undo();
            Assert.AreEqual(cOriginalCategoryName, c.CategoryName);
            Assert.AreEqual(c2OriginalCategoryName, c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN", c.CategoryName);
            Assert.AreEqual(c2OriginalCategoryName, c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN", c.CategoryName);
            Assert.AreEqual("C2N", c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN2", c.CategoryName);
            Assert.AreEqual("C2N", c2.CategoryName);
 
            context.BeginGroupOfUndoActions();
            c.CategoryName = "CN3";
            c2.CategoryName = "C2N2";
            context.BeginGroupOfUndoActions();
            c.CategoryName = "CN4";
            c2.CategoryName = "C2N3";
            context.EndGroupOfUndoActions();
            c.CategoryName = "CN5";
            c2.CategoryName = "C2N4";
            context.Undo();
            Assert.AreEqual("CN5", c.CategoryName);
            Assert.AreEqual("C2N3", c2.CategoryName);
            context.Undo();
            Assert.AreEqual("CN4", c.CategoryName);
            Assert.AreEqual("C2N3", c2.CategoryName);
            context.Undo();
            Assert.AreEqual("CN3", c.CategoryName);
            Assert.AreEqual("C2N2", c2.CategoryName);
            context.Undo();
            Assert.AreEqual("CN2", c.CategoryName);
            Assert.AreEqual("C2N", c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN3", c.CategoryName);
            Assert.AreEqual("C2N2", c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN4", c.CategoryName);
            Assert.AreEqual("C2N3", c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN5", c.CategoryName);
            Assert.AreEqual("C2N3", c2.CategoryName);
            context.Redo();
            Assert.AreEqual("CN5", c.CategoryName);
            Assert.AreEqual("C2N4", c2.CategoryName);
        }
    }
} 
 
 

EF : Undo Redo

2009-06-08T22:57:00Z

How to use Undo/Redo with EntityFramework? This isn’t managed by EF.

So we will have to do it ourselves.

We could clone the entities and group them into a Stack but in this case I worry about my memory usage growing too much.

So I prefer another solution with Action.

Note that for this POC, I just manage Undo/Redo on scalar properties.

public static class ObjectContextExtension
{
    private static Dictionary<ObjectContext, ObjectContextUndoRedo> _objectContextUndoRedo = new Dictionary<ObjectContext, ObjectContextUndoRedo>();
 
    public static void ActivateUndoRedoTracking(this ObjectContext context, int undoStackLength)
    {
        ObjectContextUndoRedo objectContextUndoRedo;
        if (_objectContextUndoRedo.ContainsKey(context))
            objectContextUndoRedo = _objectContextUndoRedo[context];
        else
        {
            objectContextUndoRedo = new ObjectContextUndoRedo { Context = context };
            _objectContextUndoRedo.Add(context, objectContextUndoRedo);
        }
        objectContextUndoRedo.ActivateUndoRedoTracking(undoStackLength);
    }
 
    public static bool CanUndo(this ObjectContext context)
    {
        if (!_objectContextUndoRedo.ContainsKey(context))
            throw new InvalidOperationException();
        return _objectContextUndoRedo[context].CanUndo;
    }
 
    public static void Undo(this ObjectContext context)
    {
        if (!_objectContextUndoRedo.ContainsKey(context))
            throw new InvalidOperationException();
        _objectContextUndoRedo[context].Undo();
    }
 
    public static bool CanRedo(this ObjectContext context)
    {
        if (!_objectContextUndoRedo.ContainsKey(context))
            throw new InvalidOperationException();
        return _objectContextUndoRedo[context].CanRedo;
    }
 
    public static void Redo(this ObjectContext context)
    {
        if (!_objectContextUndoRedo.ContainsKey(context))
            throw new InvalidOperationException();
        _objectContextUndoRedo[context].Redo();
    }
 
    private class ObjectContextUndoRedo
    {
        private List<UndoRedoAction> _undo, _redo;
        private int _undoStackLength;
        private bool _trackChanges;
 
        public ObjectContext Context { get; set; }
 
        public void ActivateUndoRedoTracking(int undoStackLength)
        {
            _undoStackLength = undoStackLength;
            _undo = new List<UndoRedoAction>(undoStackLength);
            _redo = new List<UndoRedoAction>(undoStackLength);
            _trackChanges = true;
 
            var objectStateEntries = Context.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified | EntityState.Unchanged).ToList();
 
            PropertyChangingEventHandler entityModifing = null;
            entityModifing = (sender, e) =>
            {
                var propInfo = sender.GetType().GetProperty(e.PropertyName);
                var value = propInfo.GetValue(sender, null);
                var undoRedoAction = new UndoRedoAction { EntityState = EntityState.Modified, UndoAction = () => propInfo.SetValue(sender, value, null) };
                var inpc = sender as INotifyPropertyChanged;
                if (inpc != null)
                {
                    PropertyChangedEventHandler entityModified = null;
                    entityModified = (s, e2) =>
                        {
                            if (e.PropertyName == e2.PropertyName && _trackChanges)
                            {
                                var newValue = propInfo.GetValue(sender, null);
                                undoRedoAction.RedoAction = () => propInfo.SetValue(sender, newValue, null);
                                _undo.Insert(0, undoRedoAction);
                                if (_undo.Count > _undoStackLength)
                                    _undo.RemoveAt(_undoStackLength);
                                _redo.Clear();
                            }
                            inpc.PropertyChanged -= entityModified;
                        };
                    inpc.PropertyChanged += entityModified;
                }
            };
            foreach (var e in objectStateEntries.Select(ose => ose.Entity as INotifyPropertyChanging).Where(inpc => inpc != null))
                e.PropertyChanging += entityModifing;
 
            Context.ObjectStateManager.ObjectStateManagerChanged += (sender, e) =>
            {
                switch (e.Action)
                {
                    case CollectionChangeAction.Add:
                        var inpc = e.Element as INotifyPropertyChanging;
                        if (inpc != null)
                            inpc.PropertyChanging += entityModifing;
                        break;
                }
            };
        }
 
        public bool CanUndo
        {
            get { return _undo != null && _undo.Any(); }
        }
 
        public void Undo()
        {
            if (!CanUndo)
                throw new InvalidOperationException();
            var undoRedoAction = _undo.First();
            _undo.RemoveAt(0);
            _trackChanges = false;
            undoRedoAction.UndoAction();
            _trackChanges = true;
            _redo.Insert(0, undoRedoAction);
        }
 
        public bool CanRedo
        {
            get { return _redo != null && _redo.Any(); }
        }
 
        public void Redo()
        {
            if (!CanRedo)
                throw new InvalidOperationException();
            var undoRedoAction = _redo.First();
            _redo.RemoveAt(0);
            _trackChanges = false;
            undoRedoAction.RedoAction();
            _trackChanges = true;
            _undo.Insert(0, undoRedoAction);
        }
    }
 
    private class UndoRedoAction
    {
        public EntityState EntityState { get; set; }
        public Action UndoAction { get; set; }
        public Action RedoAction { get; set; }
    }
}

The main question in my opinion is: does a complete unod/redo make sense? Indeed, we will have some big issues with cascade, Identity, concurrent access...

How to split your EDM v2?

2009-06-02T21:10:00Z

After my previous post about it, my customer asks me the following question: how to get a complete graph (with categories, suppliers, products, order details, orders, customers and employees)?

To realize it, we have to add “sort of” navigation properties for the entities like this:

private Supplier _supplier;
/// <remarks>
/// Changes aren't saved
/// </remarks>
public Supplier Supplier
{
    get 
    {
        if (_supplier == null)
            _supplier = this.GetSupplier();
        return _supplier; 
    }
    set { _supplier = value; }
}
 
private IEnumerable<Orders.OrderDetail> _orderDetails;
/// <remarks>
/// Changes aren't saved
/// </remarks>
public IEnumerable<Orders.OrderDetail> OrderDetails
{
    get 
    {
        if (_orderDetails == null)
            _orderDetails = this.GetOrderDetails();
        return _orderDetails; 
    }
    set { _orderDetails = value; }
}

Then, the idea is to set these informations at first.

For this, we can do the following:

using (var stockContext = new StocksEntities())
{
    var categories = stockContext.Categories.Include("Products").ToList(); 
    foreach (var p in stockContext.ObjectStateManager.GetObjectStateEntries(EntityState.Unchanged).Select(e => e.Entity).OfType<Entities.Stocks.Product>())
    {
        using (var supplierContext = new SuppliersEntities())
        {
            p.Supplier = (from p2 in supplierContext.Products
                          where p2.ProductID == p.ProductID
                          select p2.Supplier).FirstOrDefault();
        }
        using (var orderContext = new OrdersEntities())
        {
            p.OrderDetails = (from od in orderContext.OrderDetails.Include("Order.Customer")
                              where od.ProductID == p.ProductID
                              select od).ToList();
            foreach (var o in orderContext.ObjectStateManager.GetObjectStateEntries(EntityState.Unchanged).Select(e => e.Entity).OfType<Entities.Orders.Order>())
            {
                using (var employeeContext = new EmployeesEntities())
                {
                    o.Employee = (from oe in employeeContext.Orders
                                  where oe.OrderID == o.OrderID
                                  select oe.Employee).FirstOrDefault();
                }
            }
        }
    }
}

However, this way can generate a lot of SQL queries and so the execution isn’t very fast. If we want to get only part of the categories (with all their graphs), we can use this code:

using (var stockContext = new StocksEntities())
{
    using (var supplierContext = new SuppliersEntities())
    {
        using (var orderContext = new OrdersEntities())
        {
            using (var employeeContext = new EmployeesEntities())
            {
                var categories = stockContext.Categories.Include("Products").ToList();
                var products = categories.SelectMany(c => c.Products);
                var suppliers = supplierContext.Suppliers.Where(BuildContainsExpression<Supplier, int>(s => s.SupplierID, (from p in products
               where p.SupplierID.HasValue
               select p.SupplierID.Value).Distinct())).ToList();
                var orderDetails = orderContext.OrderDetails.Include("Order.Customer").Where(BuildContainsExpression<Entities.Orders.OrderDetail, int>(od => od.ProductID, products.Select(p => p.ProductID))).ToList();
                var orders = orderDetails.Select(od => od.Order);
                var employees = employeeContext.Employees.Where(BuildContainsExpression<Employee, int>(e => e.
EmployeeID, (from o in orders
             where o.EmployeeID.HasValue
             select o.EmployeeID.Value).Distinct())).ToList(); 
                foreach (var p in products)
                {
                    p.Supplier = suppliers.FirstOrDefault(s => s.SupplierID == p.SupplierID);
                    p.OrderDetails = (from od in orderDetails
                                      where od.ProductID == p.ProductID
                                      select od);
                    foreach (var o in orders)
                        o.Employee = employees.FirstOrDefault(e => o.EmployeeID == e.EmployeeID);
                }
            }
        }
    }
}

If we want to get all entities, we can directly use the following code:

using (var stockContext = new StocksEntities())
{
    using (var supplierContext = new SuppliersEntities())
    {
        using (var orderContext = new OrdersEntities())
        {
            using (var employeeContext = new EmployeesEntities())
            {
                var categories = stockContext.Categories.Include("Products").ToList();
                var products = categories.SelectMany(c => c.Products);
                var suppliers = supplierContext.Suppliers.ToList();
                var orderDetails = orderContext.OrderDetails.Include("Order.Customer").ToList();
                var orders = orderDetails.Select(od => od.Order);
                var employees = employeeContext.Employees.ToList(); 
                foreach (var p in products)
                {
                    p.Supplier = suppliers.FirstOrDefault(s => s.SupplierID == p.SupplierID);
                    p.OrderDetails = (from od in orderDetails
                                      where od.ProductID == p.ProductID
                                      select od);
                    foreach (var o in orders)
                        o.Employee = employees.FirstOrDefault(e => o.EmployeeID == e.EmployeeID);
                }
            }
        }
    }
}

ValidateOnBuild

2009-05-29T13:44:43Z

The VS 2008 SP1 EDM designer doesn’t support all the mapping scenarii:

Complex Types (supported with VS 2010 Beta 1)
TPC
Horizontal Entity Splitting

I know another (free) designer which does .

The most irritating thing with VS 2008 EDM designer (it isn’t true, likely, with VS 2010 Beta 1) is the fact that it generates wrong errors. And these F… errors are shown when we compile our project even if our project do compile. Indeed, the emdx file isn’t compiled. It’s the code generated from the edmx which is compiled.

When the errors are like: “Error 11005: ComplexType elements are not supported in the Entity Designer.”, you can be irritated: but WTF!

An edmx is divided into four parts:

the 3 EDM parts:
- SSDL // DB description
- CSDL // entity description
- MSL // mapping between SSDL ans CSDL description
a designer own part

In this last part, you have an option.

<edmx:Options>
  <DesignerInfoPropertySet>
    <DesignerProperty Name="ValidateOnBuild" Value="false" />
  </DesignerInfoPropertySet>
</edmx:Options>

When it is false, no error message with compilation and you keep zen.

How to split your EDM?

2009-05-27T08:46:00Z

One of my customers wants to code an ERP. To make it, he wants to use EF. His DB has more than 600 tables with a lot of relationships between all of them. The problem is the fact that Entity Framework has some difficulties with big models. You should look at Srikanth Mandadi two posts about it (working-with-large-models-in-entity-framework-part-1.aspx et working-with-large-models-in-entity-framework-part-2.aspx).

If you have a big model, the best is to split it in multiple EDM.

An ERP is composed of several modules. The idea is to make one model per module. The problem is the fact that an entity can be useful in several modules. For example, with Northwind (I know it isn’t a big DB, comment joke are useless ), a product can be used:

by a stock management module

by a supplier module

by an order module

So, in theory, it implies that we shouldn’t be able to split Category (Stocks module), Product (Stocks, Suppliers and Orders modules), Supplier (Suppliers module), OrderDetail (Orders module), Order (Orders module) and Customer (Orders module).

We will add a fourth EDM used by an employee management module. This EDM will contain an entity Employee, Order and OrderDetail.

So, how to work with four EDM?

First point, we will make these four EDM. To reduce the conflict risk, we will consider that an entity can be modified by only one module. For this, we will set all the properties except the entity key properties private in other EDM.

It is also possible to “reduce” the entity types. For example, in Supplier module, we don’t need the stock management information.

Ok nice!

So the problem now is when we want to do some queries relative to several modules.

At first, we will get the best supplier per category.

The supplier and the category entities aren’t in the same model. If this query is called often, it’s better to add Category entity in Suppliers module EDM (or the opposite). Then it will be possible to map it on the real table or on an SSDL view.

If the query speed isn’t extremely important and we can do two SQL queries instead of only one, we can use the following way.

The first idea is, for each “double” entity, to implement an interface which has only the properties of the entity key:

public interface IProduct
{
    int ProductID { get; }
}
 

public interface IOrder
{
    int OrderID { get; }
}
 

public interface IOrderDetail
{
    int ProductID { get; }
    int OrderID { get; }
}

Then we can use methods to get all the entity relationships:

public static class Product
{
    public static Category GetCategory(this IProduct product)
    {
        return GetCategory(product.ProductID);
    }
    public static Category GetCategory(int productID)
    {
        using (var context = new StocksEntities())
        {
            var p = new Stocks.Product { ProductID = productID };
            context.AttachTo("Products", p);
            p.CategoryReference.Load();
            return p.Category;
        }
    }
 
    public static Supplier GetSupplier(this IProduct product)
    {
        return GetSupplier(product.ProductID);
    }
    public static Supplier GetSupplier(int productID)
    {
        using (var context = new SuppliersEntities())
        {
            var p = new Suppliers.Product { ProductID = productID };
            context.AttachTo("Products", p);
            p.SupplierReference.Load();
            return p.Supplier;
        }
    }
 
    public static IEnumerable<IOrderDetail> GetOrderDetails(this IProduct product)
    {
        return GetOrderDetails(product.ProductID);
    }
    public static IEnumerable<IOrderDetail> GetOrderDetails(int productID)
    {
        using (var context = new OrdersEntities())
        {
            var p = new Orders.Product { ProductID = productID };
            context.AttachTo("Products", p);
            p.OrderDetails.Load();
            return p.OrderDetails.AsEnumerable().OfType<IOrderDetail>();
        }
    }
}
 

public static class Order
{
    public static Employee GetEmployee(this IOrder o)
    {
        return GetEmployee(o.OrderID);
    }
    public static Employee GetEmployee(int orderID)
    {
        using (var context = new EmployeesEntities())
        {
            var o = new Employees.Order { OrderID = orderID };
            context.AttachTo("Orders", o);
            o.EmployeeReference.Load();
            return o.Employee;
        }
    }
 
    public static Customer GetCustomer(this IOrder o)
    {
        return GetCustomer(o.OrderID);
    }
    public static Customer GetCustomer(int orderID)
    {
        using (var context = new OrdersEntities())
        {
            var o = new Orders.Order { OrderID = orderID };
            context.AttachTo("Orders", o);
            o.CustomerReference.Load();
            return o.Customer;
        }
    }
}
 

public static class OrderDetail
{
    public static IProduct GetProduct(this IOrderDetail od)
    {
        return GetProduct(od.OrderID, od.ProductID);
    }
    public static IProduct GetProduct(int orderID, int productID)
    {
        using (var context = new OrdersEntities())
        {
            var od = new Orders.OrderDetail { OrderID = orderID, ProductID = productID };
            context.AttachTo("OrderDetails", od);
            od.ProductReference.Load();
            return od.Product;
        }
    }
 
    public static Category GetCategory(this IOrderDetail od)
    {
        return Product.GetCategory(od.ProductID);
    }
 
    public static Employee GetEmployee(this IOrderDetail od)
    {
        return Order.GetEmployee(od.OrderID);
    }
 
    public static Customer GetCustomer(this IOrderDetail od)
    {
        return Order.GetCustomer(od.OrderID);
    }
}

Here, we can write the query like this:

using (var stockContext = new StocksEntities())
{
    var bestSupplierPerCategory = from c in stockContext.Categories.Include("Products").AsEnumerable()
                                  let productSuppliers = from p in c.Products
                                                         select p.GetSupplier()
                                  let suppliers = from s in productSuppliers.Distinct()
                                                  orderby productSuppliers.Count(su => su.SupplierID == s.SupplierID) descending
                                                  select s
                                  select new { Category = c, Supplier = suppliers.FirstOrDefault() };
}

However, it isn’t great because the most part of the query is a LINQ To Objects query. We can do better than this.

To illustrate it, we will take a more complex case: get the best employee per category.

To optimize the query, it’s better not to do the group by with LINQ To Object (getting the category products OrderDetails, then OrderDetail Employee). So we won’t use the extension methods defined previously. Instead of these, we will use two contexts and we will mix them in a LINQ query like this:

using (var stockContext = new StocksEntities())
{
    using (var employeesContext = new EmployeesEntities())
    {
        var bestEmployeePerCategory =
            from c in
                (from c in stockContext.Categories
                 select new
                 {
                     Category = c,
                     ProductsID = (from p in c.Products
                                   select p.ProductID)
                 }).AsEnumerable()
            let bestEmployee = (from od in employeesContext.OrderDetails.Where(BuildContainsExpression<Entities.Employees.OrderDetail, int>(od2 => od2.ProductID, c.ProductsID))
                                let e = od.Order.Employee
                                group od by new { e.EmployeeID, e.LastName, e.FirstName } into g
                                let sold = g.Sum(od => (double)od.UnitPrice * (double)od.Quantity * (1D - (double)od.Discount))
                                orderby sold descending
                                select new { g.Key.EmployeeID, g.Key.LastName, g.Key.FirstName, Sold = sold }).FirstOrDefault()
            select new { Category = c.Category, Employee = bestEmployee };
    }
}

You can find the DB generation script, the project and the unit tests here.

EF4 POCO: my tests

2009-05-25T20:54:00Z

I published an unit tests project to show how POCO works with EF4. I also wrote a BetaBugs test class in order to illustrate the POCO implementation Beta bugs.

EF: SQL queries

2009-05-25T08:41:00Z

With EF4, it’s possible to execute some SQL queries. (It was possible with EF v1 with EF extensions).

I don’t like it. Indeed, it implies to break the EDM abstraction against the DataBase.

Moreover, we can do without. In the V1, it was possible, with SSDL Functions, to write the SQL query to execute.

I think that the ability to write our own SQL queries is interesting, particularly in an iterative development process but I think that loosing the abstraction against the DB is a pity.

However, I just found a case where this new feature is useful: the unit tests. Indeed, it’s a shame to have to define SSDL Functions if they are used only by tests. Imagine that we have to initialize the DB for our tests. We will start by deleting the existing DataRows. To do it, we can use EF “basic” deletion:

using (var context = new MyNorthwindEFEntities())
{
    foreach (var c in context.Categories.ToList())
        context.DeleteObject(c);
    context.SaveChanges();
}

But it isn’t good to have to load all the entities in order to delete them. Moreover, we will have n DELETE queries instead of only one.

We can improve it by loading only the entity id:

using (var context = new MyNorthwindEFEntities())
{
    foreach (var cId in context.Categories.Select(c => c.CategoryID))
    {
        var c = new Categories{ CategoryID = cId };
        context.AttachTo("Categories", c);
        context.DeleteObject(c);
    }
    context.SaveChanges();
}

It’s better but we still have one SELECT and n DELETE.

As I wrote up, it is possible to use an SSDL Function which make the DELETE for us.

With EF4, it is also possible to execute directly the SQL query:

context.ExecuteStoreCommand("DELETE FROM Products");

which is, I admit, very useful.

With EF4, we also have the ExecuteStoreQuery<TResult> method which can be used to let EF materialize the SQL DataRows (from the SQL query) to entities.

POCO: CreateObject and object initializer

2009-05-22T08:31:00Z

When we work with POCO entities, queries return instances of proxy class which inherits entity types. Having some proxy instances allow us to use lazy loading.

When we create an entity in order to attach it to the context, we can do a new on our entity type but it can be better to instanciate the proxy class. To do this, we can use CreateObject<T>() method on the context.

However, in this case, it’s a shame because we can’t use object initializers.

My idea is to make some methods on the context: CreateCategory, CreateProduct, etc. and to use their parameters to initialize my entities. To do this, I use optional parameters (new C#4 feature) to have something like Object Initializers.

Writing these methods can be boring.

So, I update my code generation template and, with it, these methods are automatically generated.

If you look at my template code, you’ll be able to see that I use another new C#4 feature: the variance. I use it to cast an IEnumerable<PrimitiveTypePropertyWrapper> to IEnumerable<DataPropertyWrapper>.

Now, I can write the following code:

context.CreateCategory(id:1, name:"C1", description:"D1");

Play with T4

2009-05-19T20:41:00Z

One of the most important new thing with EF4 (EF v2) is POCO entities (no dependency with EF).

Having independent classes is good but code generation also is. Indeed, if we want to change entities we don’t have to do the work twice (one for edmx and one for the entity class).

So what would be very cool is to be able to generate POCO entities. To realize this, T4 template is very cool. You can download here the tt file I made from the default one.

POO is so pretty with C#

2009-05-18T12:20:23Z

I will take a major risk with this post but, never mind, I will write about POO today. It’s a major risk because I think that every architect has different ideas and even if I use some design patterns, I know that some architects would use different ones in my sample. Moreover, I know that in my English blog, a lot of gurus will be able to read it.

In this post, no Entity Framework (oh my god Matthieu can blog on something else ), only POO.

We will start with a very easy problem to see how to make an elegant, reusable and extensible architecture to solve it.

From a file, I want to read lines, process them and write them into a new file.

At first, I want to propose two processes:

Characters inversion line per line
Line numbering

Moreover, I want to be able to combine my processes.

How to do this?

In a first step, I will define two layers:

Then I will start with the Business Logic Layer. I will expose to my UI the available processes. I will return a generic collection. So I have to define a common type between all the processes. In this case, I think that the use of an interface is the best way.

What do we need in this interface?

In fact we just need a method Process with a collection of string parameter and which return a collection of string. I won’t use the file path directly because with this way my processes are independent of any file notion, so more reusable. To manage every collection type, I will use the IEnumerable<string> interface. IStringsProcess will be the following:

public interface IStringsProcess
{
    IEnumerable<string> Process(IEnumerable<string> lines);
}

The two processes I want are somewhat similar: they are applied line per line. So it can be interesting to define a base class to factorize the common code. This class will be abstract because it doesn’t correspond to a real process. This class will implement the IStringsProcess interface.

public abstract class PerStringProcessBase : IStringsProcess
{
    public IEnumerable<string> Process(IEnumerable<string> lines)
    {
        foreach (string line in lines)
            yield return Process(line);
    }
 
    protected abstract string Process(string line);
}

Now we have to code the NumberPerStringProcess and ReverseCharsPerStringProcess classes .

public class NumberPerStringProcess : PerStringProcessBase
{
    private int _cpt = 0;
 
    protected override string Process(string line)
    {
        return string.Concat((++_cpt).ToString("000"), " : ", line);
    }
}
 
public class ReverseCharsPerStringProcess : PerStringProcessBase
{
    protected override string Process(string line)
    {
        return new string(line.Reverse().ToArray());
    }
}

We could do without the abstract class like this:

public class NumberPerStringProcess : IStringsProcess
{
    public IEnumerable<string> Process(IEnumerable<string> lines)
    {
        return lines.Select((l, index) => string.Concat((index + 1).ToString("000"), " : ", l));
    }
}
 
public class ReverseCharsPerStringProcess : IStringsProcess
{
    public IEnumerable<string> Process(IEnumerable<string> lines)
    {
        return lines.Select(l => new string(l.Reverse().ToArray()));
    }
}

However for this post, oriented on POO, I will use let the base class PerStringProcessBase.

Ok we have the two processes. We now need the file management.

The read file can be big. So we have to be careful to not load all file lines in memory. In this case, the yield return is very useful. Indeed it allows to process in a “streaming” mode. So in our case, the processing will be line per line.

public static class FileUtil
{
    public static IEnumerable<string> GetLines(string filePath)
    {
        using (var sr = new StreamReader(filePath))
        {
            string line;
            while ((line = sr.ReadLine()) != null)
                yield return line;
        }
    }
 
    public static void WriteLines(string filePath, IEnumerable<string> lines)
    {
        using (var sw = new StreamWriter(filePath))
        {
            foreach (string line in lines)
                sw.WriteLine(line);
        }
    }
}
 
public static class FileProcess
{
    public static void Process(string fileInPath, string fileOutPath, IStringsProcess process)
    {
        FileUtil.WriteLines(fileOutPath, process.Process(FileUtil.GetLines(fileInPath)));
    }
}

The step by step debuging execution can feel strange if you don’t master yield return. Indeed the WriteLines method will be called before the Process method. And this one will be called before the GetLines method. It’s another effect of yield return: the execution is differed and will be executed only when the IEnumerable<T> will be iterated.

Then we will expose to UI layer the list of available processes.

public static class Processes
{
    private static List<IStringsProcess> _processes;
    public static List<IStringsProcess> ProcessesAllowed
    {
        get
        {
            if (_processes == null)
                _processes = new List<IStringsProcess>() 
                    { 
                        new NumberPerStringProcess(),
                        new ReverseCharsPerStringProcess()
                    };
            return _processes;
        }
    }
}

Now in the UI layer, we will use a ComboBox to choose the process.

This combo will be bound to Processes.ProcessesAllowed.

What is great with the ComboBox is the fact that the items are objects. So the item will be an IStringsProcess.

However, the first problem we can see immediately is the combo items text.

By default, the text is the result of the ToString method. So we will override this method for the two processes. To do this, we will use a resources file. Like this, our application will be localizable.

Note: for web application, the DropDownList doesn’t work like the ComboBox.

The second problem is the following: if we run twice the lines numbering without restarting the application. The line index won’t be reinitialized because we use the same instance of the NumberPerStringProcess class. To fix it, we will add a virtual method Init on PerStringProcessBase and we will override it on NumberPerStringProcess to reinitialize the line index.

public abstract class PerStringProcessBase : IStringsProcess
{
    public IEnumerable<string> Process(IEnumerable<string> lines)
    {
        Init();
        foreach (string line in lines)
            yield return Process(line);
    }
 
    protected abstract string Process(string line);
 
    protected virtual void Init()
    {
    }
}
 
public class NumberPerStringProcess : PerStringProcessBase
{
    private int _cpt;
 
    protected override string Process(string line)
    {
        return string.Concat((++_cpt).ToString("000"), " : ", line);
    }
 
    protected override void Init()
    {
        base.Init();
        _cpt = 0;
    }
 
    public override string ToString()
    {
        return ProcessResources.NumberPerStringProcess;
    }
}
 
public class ReverseCharsPerStringProcess : PerStringProcessBase
{
    protected override string Process(string line)
    {
        return new string(line.Reverse().ToArray());
    }
 
    public override string ToString()
    {
        return ProcessResources.ReverseCharsPerStringProcess;
    }
}

In the instruction, I wrote that I want to be able the aggregate the processes. To do this, we will use the composite design pattern.

Wikipedia advices to use this pattern in this case:

“Composite can be used when clients should ignore the difference between compositions of objects and individual objects. If programmers find that they are using multiple objects in the same way, and often have nearly identical code to handle each of them, then composite is a good choice; it is less complex in this situation to treat primitives and composites as homogeneous.”

In this implementation, we will use a class to manage all the processes. This class will itself implement the IStringsProcess interface and the implementation of this interface will easily aggregate the result of each process.

public class CompositeStringsProcess : IStringsProcess
{
    private List<IStringsProcess> _processes = new List<IStringsProcess>();
 
    public CompositeStringsProcess(IEnumerable<IStringsProcess> processes)
    {
        _processes.AddRange(processes);
    }
    public CompositeStringsProcess(params IStringsProcess[] processes)
        : this((IEnumerable<IStringsProcess>)processes)
    {
    }
 
    public List<IStringsProcess> Processes
    {
        get { return _processes; }
    }
 
    public IEnumerable<string> Process(IEnumerable<string> lines)
    {
        foreach (var process in Processes)
            lines = process.Process(lines);
        return lines;
    }
 
    public override string ToString()
    {
        var sb = new StringBuilder();
        foreach (var process in Processes)
        {
            sb.Append(" & ");
            sb.Append(process);
        }
        return sb.ToString().Substring(3);
    }
}

All the needs are now covered. However, it isn’t finished.

Indeed, there is no error management.

The problem is the following: error management has to be in Business Logic Layer but the BLL doesn’t know what it should do with errors. Show it in a MessageBox, a text in the console, an asp page, log it?

The BLL can’t know it. The BLL could throw an exception and could let the UI catch it but it’s a shame to throw an exception when it isn’t necessary.

In fact the only thing that changes is the way to show the error. So to do it, we will use a delegate.

For this, we will change the FileProcess.Process method to add a delegate parameter in addition to the files path and the process. This delegate will be used to show the errors.

Some errors can allow the user to retry (ex: the output file is locked). So we will use two delegates.

public static class FileProcess
{
    public static bool Process(string inFilePath, string outFilePath, IStringsProcess process, Action<string> showError, Func<string, bool> showErrorWithRetry)
    {
        if (!File.Exists(inFilePath))
            FileNotFoundShowError(inFilePath, showError);
        else if (!Directory.Exists(Path.GetDirectoryName(outFilePath)))
            DirectoryNotFoundShowError(outFilePath, showError);
        else
            while (true)
            {
                try
                {
                    FileUtil.WriteLines(outFilePath, process.Process(FileUtil.GetLines(inFilePath)));
                    return true;
                }
                catch (FileNotFoundException)
                {
                    FileNotFoundShowError(inFilePath, showError);
                }
                catch (DirectoryNotFoundException)
                {
                    DirectoryNotFoundShowError(outFilePath, showError);
                }
                catch (IOException)
                {
                    if (showErrorWithRetry(string.Format(FileErrorResources.IOException, outFilePath)))
                        continue;
                }
                catch (Exception ex)
                {
                    showError(string.Format(FileErrorResources.UnknowException, string.Concat(ex.GetType(), " : ", ex.Message)));
                }
                break;
            }
        return false;
    }
 
    private static void DirectoryNotFoundShowError(string directoryPath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.DirectoryNotFoundException, Path.GetDirectoryName(directoryPath)));
    }
 
    private static void FileNotFoundShowError(string filePath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.FileNotFoundException, filePath));
    }
}

Ok. It’s better but however, we aren’t finished yet. Indeed, files can be very big so the process can be long. In this case, the process can freeze the UI.

So we will use a second thread to run the processes. To make it, I will use a BackgroundWorker. I know that the purists don’t like it because it implies to need the System.ComponentModel namespace in BLL. However, it’s so easy to use the BackgroundWorker that I will do it.

So the FileProcess class becomes the following:

public static class FileProcess
{
    public static void Process(string inFilePath, string outFilePath, IStringsProcess process,
        Action<string> showError, Func<string, bool> showErrorWithRetry, Action<bool> traitmentDone)
    {
        if (!File.Exists(inFilePath))
            FileNotFoundShowError(inFilePath, showError);
        else if (!Directory.Exists(Path.GetDirectoryName(outFilePath)))
            DirectoryNotFoundShowError(outFilePath, showError);
        else
        {
            var bg = new BackgroundWorker();
            bg.DoWork += (s, e) =>
            {
                e.Result = false;
                while (true)
                {
                    try
                    {
                        FileUtil.WriteLines(outFilePath, process.Process(FileUtil.GetLines(inFilePath)));
                        e.Result = true;
                    }
                    catch (FileNotFoundException)
                    {
                        FileNotFoundShowError(inFilePath, showError);
                    }
                    catch (DirectoryNotFoundException)
                    {
                        DirectoryNotFoundShowError(outFilePath, showError);
                    }
                    catch (IOException)
                    {
                        if (showErrorWithRetry(string.Format(FileErrorResources.IOException, outFilePath)))
                            continue;
                    }
                    catch (Exception ex)
                    {
                        showError(string.Format(FileErrorResources.UnknowException,
                            string.Concat(ex.GetType(), " : ", ex.Message)));
                    }
                    break;
                }
            };
            bg.RunWorkerCompleted += (s, e) =>
            {
                if (traitmentDone != null)
                    traitmentDone((bool)e.Result);
            };
            bg.RunWorkerAsync();
        }
    }
 
    private static void DirectoryNotFoundShowError(string directoryPath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.DirectoryNotFoundException, Path.GetDirectoryName(directoryPath)));
    }
 
    private static void FileNotFoundShowError(string filePath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.FileNotFoundException, filePath));
    }
}

An interesting point with this is the fact the processes will be run in parallel. This is great but it can also be a problem. Imagine that we want to run a batch with many file processes. If there are some dependences between the file processes (the output file becomes an input process for another process), we have to wait. For this, we have to change again the FileProcess.Process method:

public static class FileProcess
{
    private static Dictionary<string, BackgroundWorker> _traitmentsRunning = new Dictionary<string, BackgroundWorker>();
    private static object _lockObject = new object();
    private static object _bwLockObject = new object();
 
    public static void Process(string inFilePath, string outFilePath, IStringsProcess process,
        Action<string> showError, Func<string, bool> showErrorWithRetry, Action<bool> traitmentDone)
    {
        if (!Directory.Exists(Path.GetDirectoryName(outFilePath)))
            DirectoryNotFoundShowError(outFilePath, showError);
        else
        {
            lock (_lockObject)
            {
                if (!(File.Exists(inFilePath) || _traitmentsRunning.ContainsKey(inFilePath)))
                    FileNotFoundShowError(inFilePath, showError);
                else
                {
                    var bw = new BackgroundWorker();
                    bw.DoWork += (s, e) =>
                    {
                        e.Result = false;
                        while (true)
                        {
                            try
                            {
                                FileUtil.WriteLines(outFilePath, process.Process(FileUtil.GetLines(inFilePath)));
                                e.Result = true;
                            }
                            catch (FileNotFoundException)
                            {
                                FileNotFoundShowError(inFilePath, showError);
                            }
                            catch (DirectoryNotFoundException)
                            {
                                DirectoryNotFoundShowError(outFilePath, showError);
                            }
                            catch (IOException)
                            {
                                if (showErrorWithRetry(string.Format(FileErrorResources.IOException, outFilePath)))
                                    continue;
                            }
                            catch (Exception ex)
                            {
                                showError(string.Format(FileErrorResources.UnknowException,
                                    string.Concat(ex.GetType(), " : ", ex.Message)));
                            }
                            break;
                        }
                        _traitmentsRunning.Remove(outFilePath);
                    };
                    bw.RunWorkerCompleted += (s, e) =>
                    {
                        if (traitmentDone != null)
                            traitmentDone((bool)e.Result);
                    };
                    StartBWAndCache(inFilePath, outFilePath, bw);
                }
            }
        }
    }
 
    private static void StartBWAndCache(string inFilePath, string outFilePath, BackgroundWorker bw)
    {
        lock (_bwLockObject)
        {
            string filePath = null;
            if (_traitmentsRunning.ContainsKey(inFilePath))
                filePath = inFilePath;
            else if (_traitmentsRunning.ContainsKey(outFilePath))
                filePath = outFilePath;
            if (filePath != null)
                _traitmentsRunning[filePath].RunWorkerCompleted +=
                    (s, e) => StartBWAndCache(inFilePath, outFilePath, bw);
            else
            {
                _traitmentsRunning.Add(outFilePath, bw);
                bw.RunWorkerAsync();
            }
        }
    }
 
    private static void DirectoryNotFoundShowError(string directoryPath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.DirectoryNotFoundException, Path.GetDirectoryName(directoryPath)));
    }
 
    private static void FileNotFoundShowError(string filePath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.FileNotFoundException, filePath));
    }
}

With our implementation, it should be the developer, in the Processes.ProcessesAllowed, who will choose the possible processes aggregate.

We will add two new needs in specifications.

The user should choose himself the processes aggregation.
You have to be able to add some new processes in a new assembly

For this, we will change our architecture.

For this, the user can directly instantiate the processes in the UI or we can use a Factory in BLL.

The first point is very easy to do but it isn’t great because it means that UI layer has to know how the BLL works. Moreover, if we want to add a new process, we would also have to change the UI layer. So we will use the Factory to reduce dependences between our UI layer and our BLL.

To answer the second new need, we will use an Abstract Factory (note that we will change the CompositeStringsProcess class).

public interface IStringsProcessInstanciator
{
    IStringsProcess CreateInstance();
}
 
public class ReverseCharsPerStringProcessInstanciator : IStringsProcessInstanciator
{
    public IStringsProcess CreateInstance()
    {
        return new ReverseCharsPerStringProcess();
    }
 
    public override string ToString()
    {
        return ProcessResources.ReverseCharsPerStringProcess;
    }
}
 
public class NumberPerStringProcessInstanciator : IStringsProcessInstanciator
{
    public IStringsProcess CreateInstance()
    {
        return new NumberPerStringProcess();
    }
 
    public override string ToString()
    {
        return ProcessResources.NumberPerStringProcess;
    }
}
 
public class CompositeStringsProcess : IStringsProcess
{
    private List<IStringsProcessInstanciator> _processes = new List<IStringsProcessInstanciator>();
 
    public CompositeStringsProcess(IEnumerable<IStringsProcessInstanciator> processes)
    {
        _processes.AddRange(processes);
    }
 
    public CompositeStringsProcess(params IStringsProcessInstanciator[] processes)
        : this((IEnumerable<IStringsProcessInstanciator>)processes)
    {
    }
 
    public List<IStringsProcessInstanciator> Processes
    {
        get { return _processes; }
    }
 
    public IEnumerable<string> Process(IEnumerable<string> lines)
    {
        foreach (var process in Processes)
            lines = process.CreateInstance().Process(lines);
        return lines;
    }
 
    public override string ToString()
    {
        var sb = new StringBuilder();
        foreach (var process in Processes)
        {
            sb.Append(" & ");
            sb.Append(process);
        }
        return sb.ToString().Substring(3);
    }
}
 
public static class FileProcess
{
    private static Dictionary<string, BackgroundWorker> _processesRunning =
        new Dictionary<string, BackgroundWorker>();
    private static object _lockObject = new object();
 
    public static void Process(string inFilePath, string outFilePath,
        IEnumerable<IStringsProcessInstanciator> processes, Action<string> showError,
        Func<string, bool> showErrorWithRetry, Action<bool> processDone)
    {
        if (!(File.Exists(inFilePath) || _processesRunning.ContainsKey(inFilePath)))
            FileNotFoundShowError(inFilePath, showError);
        else if (!Directory.Exists(Path.GetDirectoryName(outFilePath)))
            DirectoryNotFoundShowError(outFilePath, showError);
        else
        {
            var bg = new BackgroundWorker();
            bg.DoWork += (s, e) =>
            {
                e.Result = false;
                while (true)
                {
                    try
                    {
                        FileUtil.WriteLines(outFilePath,
                            new CompositeStringsProcess(processes).Process(FileUtil.GetLines(inFilePath)));
                        e.Result = true;
 
                    }
                    catch (FileNotFoundException)
                    {
                        FileNotFoundShowError(inFilePath, showError);
                    }
                    catch (DirectoryNotFoundException)
                    {
                        DirectoryNotFoundShowError(outFilePath, showError);
                    }
                    catch (IOException)
                    {
                        if (showErrorWithRetry(string.Format(FileErrorResources.IOException, outFilePath)))
                            continue;
                    }
                    catch (Exception ex)
                    {
                        showError(string.Format(FileErrorResources.UnknowException,
                            string.Concat(ex.GetType(), " : ", ex.Message)));
                    }
                    break;
                }
                lock (_lockObject)
                {
                    _processesRunning.Remove(outFilePath);
                }
            };
            bg.RunWorkerCompleted += (s, e) =>
            {
                if (processDone != null)
                    processDone((bool)e.Result);
            };
            StartBGAndCache(inFilePath, outFilePath, bg);
        }
    }
 
    private static void StartBGAndCache(string inFilePath, string outFilePath, BackgroundWorker bg)
    {
        lock (_lockObject)
        {
            RunWorkerCompletedEventHandler runWorkerCompletedTryAgain = null;
            Action<BackgroundWorker> tryAgain = (bgTryAgain) =>
            {
                StartBGAndCache(inFilePath, outFilePath, bg);
                bgTryAgain.RunWorkerCompleted -= runWorkerCompletedTryAgain;
            };
            if (_processesRunning.ContainsKey(inFilePath))
            {
                var bgTryAgain = _processesRunning[inFilePath];
                runWorkerCompletedTryAgain = (s, e) => tryAgain(bgTryAgain);
                bgTryAgain.RunWorkerCompleted += runWorkerCompletedTryAgain;
            }
            else if (_processesRunning.ContainsKey(outFilePath))
            {
                var bgTryAgain = _processesRunning[outFilePath];
                runWorkerCompletedTryAgain = (s, e) => tryAgain(bgTryAgain);
                bgTryAgain.RunWorkerCompleted += runWorkerCompletedTryAgain;
            }
            else
            {
                _processesRunning.Add(outFilePath, bg);
                bg.RunWorkerAsync();
            }
        }
    }
 
    private static void DirectoryNotFoundShowError(string directoryPath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.DirectoryNotFoundException, Path.GetDirectoryName(directoryPath)));
    }
 
    private static void FileNotFoundShowError(string filePath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.FileNotFoundException, filePath));
    }
}

Our property Processes.ProcessesAllowed will now return some IStringsProcessInstanciator instead of IStringsProcess.

public static class Processes
{
    private static List<IStringsProcessInstanciator> _processes;
    public static List<IStringsProcessInstanciator> ProcessesAllowed
    {
        get
        {
            if (_processes == null)
                _processes = new List<IStringsProcessInstanciator>() 
                { 
                    new NumberPerStringProcessInstanciator(),
                    new ReverseCharsPerStringProcessInstanciator()
                };
            return _processes;
        }
    }
}

Now, we just need other assemblies (which will add new processes) to create two classes per process: one which implements IStringsProcessInstanciator and the “real” process class which implements IStringsProcess.

However, we already have a problem: the UI has to know the processes to mix between the different assemblies.

It should be better if this list of processes could be made dynamically. Moreover, it allows us to add some processes library without modifying the UI. For this, we can use Reflection to get from a list of assemblies all the classes which implements IStringsProcessInstanciator but there is a new technology which is very useful for what we want to do: MEF.

With MEF, the class Processes is useless.

To use MEF, we have to download it from codeplex first.

Then, we have to reference the dll in the UI layer and BLL.

We also have to decorate the processes with Export attributes and specify to MEF what is the “saw process type” for the MEF consumer (the UI in our case).

[Export(typeof(IStringsProcessInstanciator))]
public class ReverseCharsPerStringProcessInstanciator : IStringsProcessInstanciator
{
    public IStringsProcess CreateInstance()
    {
        return new ReverseCharsPerStringProcess();
    }
 
    public override string ToString()
    {
        return ProcessResources.ReverseCharsPerStringProcess;
    }
}
 
[Export(typeof(IStringsProcessInstanciator))]
public class NumberPerStringProcessInstanciator : IStringsProcessInstanciator
{
    public IStringsProcess CreateInstance()
    {
        return new NumberPerStringProcess();
    }
 
    public override string ToString()
    {
        return ProcessResources.NumberPerStringProcess;
    }
}

Now, we will add a new assembly in which we will add a new process: UpperProcess.

public class UpperProcess : PerStringProcessBase
{
    protected override string Process(string line)
    {
        return line.ToUpper();
    }
 
    public override string ToString()
    {
        return ProcessResources.UpperProcess;
    }
}
 
[Export(typeof(IStringsProcessInstanciator))]
public class UpperProcessInstanciator : IStringsProcessInstanciator
{
    public IStringsProcess CreateInstance()
    {
        return new UpperProcess();
    }
 
    public override string ToString()
    {
        return ProcessResources.UpperProcess;
    }
}

This assembly isn’t referenced by the UI. However, we will be able to use the UpperProcess. First, we will define a directory in which all processes libraries will be copied. For example, we choose the exe directory. Then, we have to copy these libraries in this directory. In the debug mode, we can use the Post-build events in VS:

copy $(TargetFileName) ..\..\..\FileProcessUI\bin\Debug\

Then, we just need to use MEF and let it discover the available processes in the UI:

[Import]
IEnumerable<IStringsProcessInstanciator> _processes;
 
private void FileProcessForm_Load(object sender, EventArgs e)
{
    var processesContainer = new CompositionContainer(new DirectoryCatalog("."));
    var batch = new CompositionBatch();
    batch.AddPart(this);
    processesContainer.Compose(batch);
    processesCombo.DataSource = _processes;
}

Instead of the ComboBox, we will use two ListBox to let the user aggregate the available processes himself.

Then, we will change the processDone argument of the FileProcess.Process method from Action<bool> to Action<bool, string>:

public static class FileProcess
{
    private static Dictionary<string, BackgroundWorker> _processesRunning =
        new Dictionary<string, BackgroundWorker>();
    private static object _lockObject = new object();
 
    public static void Process(string inFilePath, string outFilePath,
        IEnumerable<IStringsProcessInstanciator> processes, Action<string> showError,
        Func<string, bool> showErrorWithRetry, Action<bool, string> processDone)
    {
        var process = new CompositeStringsProcess(processes);
        if (!(File.Exists(inFilePath) || _processesRunning.ContainsKey(inFilePath)))
            FileNotFoundShowError(inFilePath, showError);
        else if (!Directory.Exists(Path.GetDirectoryName(outFilePath)))
            DirectoryNotFoundShowError(outFilePath, showError);
        else
        {
            var bg = new BackgroundWorker();
            bg.DoWork += (s, e) =>
            {
                e.Result = false;
                while (true)
                {
                    try
                    {
                        FileUtil.WriteLines(outFilePath, process.Process(FileUtil.GetLines(inFilePath)));
                        e.Result = true;
                    }
                    catch (FileNotFoundException)
                    {
                        FileNotFoundShowError(inFilePath, showError);
                    }
                    catch (DirectoryNotFoundException)
                    {
                        DirectoryNotFoundShowError(outFilePath, showError);
                    }
                    catch (IOException)
                    {
                        if (showErrorWithRetry(string.Format(FileErrorResources.IOException, outFilePath)))
                            continue;
                    }
                    catch (Exception ex)
                    {
                        showError(string.Format(FileErrorResources.UnknowException,
                            string.Concat(ex.GetType(), " : ", ex.Message)));
                    }
                    break;
                }
                lock (_lockObject)
                {
                    _processesRunning.Remove(outFilePath);
                }
            };
            bg.RunWorkerCompleted += (s, e) =>
            {
                if (processDone != null)
                    processDone((bool)e.Result, process.ToString());
            };
            StartBGAndCache(inFilePath, outFilePath, bg);
        }
    }
 
    private static void StartBGAndCache(string inFilePath, string outFilePath, BackgroundWorker bg)
    {
        lock (_lockObject)
        {
            RunWorkerCompletedEventHandler runWorkerCompletedTryAgain = null;
            Action<BackgroundWorker> tryAgain = (bgTryAgain) =>
            {
                StartBGAndCache(inFilePath, outFilePath, bg);
                bgTryAgain.RunWorkerCompleted -= runWorkerCompletedTryAgain;
            };
            if (_processesRunning.ContainsKey(inFilePath))
            {
                var bgTryAgain = _processesRunning[inFilePath];
                runWorkerCompletedTryAgain = (s, e) => tryAgain(bgTryAgain);
                bgTryAgain.RunWorkerCompleted += runWorkerCompletedTryAgain;
            }
            else if (_processesRunning.ContainsKey(outFilePath))
            {
                var bgTryAgain = _processesRunning[outFilePath];
                runWorkerCompletedTryAgain = (s, e) => tryAgain(bgTryAgain);
                bgTryAgain.RunWorkerCompleted += runWorkerCompletedTryAgain;
            }
            else
            {
                _processesRunning.Add(outFilePath, bg);
                bg.RunWorkerAsync();
            }
        }
    }
 
    private static void DirectoryNotFoundShowError(string directoryPath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.DirectoryNotFoundException, Path.GetDirectoryName(directoryPath)));
    }
 
    private static void FileNotFoundShowError(string filePath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.FileNotFoundException, filePath));
    }
}

Now, in the UI, the method associated to the run button Click event will be the following:

private void runBtn_Click(object sender, EventArgs e)
{
    FileProcess.Process(inFilePathTB.Text, outFilePathTB.Text, processesLB.Items.Cast<IStringsProcessInstanciator>(),
        message => MessageBox.Show(message, Resources.ErrorTitle, MessageBoxButtons.OK, MessageBoxIcon.Error),
        message => MessageBox.Show(message, Resources.ErrorTitle, MessageBoxButtons.RetryCancel, MessageBoxIcon.Error)
            == DialogResult.Retry,
        (result, processName) =>
        {
            if (result)
                processesDoneLB.Items.Add(
                    string.Concat(processName, " ", Resources.Done, ". ",
                    inFilePathTB.Text, " -> ", outFilePathTB.Text));
        });
}

We will add a last need: the ability to cancel the running processes. In order to do this, we will add a Cancel method and a read only Cancelled property on the IStringsProcess interface:

public interface IStringsProcess
{
    IEnumerable<string> Process(IEnumerable<string> lines);
    void Cancel();
    bool Cancelled { get; }
}

To factorize our code, we will define a StringsProcessBase class:

public abstract class StringsProcessBase : IStringsProcess
{
    public abstract IEnumerable<string> Process(IEnumerable<string> lines);
 
    public void Cancel()
    {
        Cancelled = true;
    }
 
    public bool Cancelled { get; private set; }
}
 
public abstract class PerStringProcessBase : StringsProcessBase
{
    public override IEnumerable<string> Process(IEnumerable<string> lines)
    {
        Init();
        foreach (string line in lines)
        {
            if (Cancelled)
                yield break;
            yield return Process(line);
        }
    }
 
    protected abstract string Process(string line);
 
    protected virtual void Init()
    {
    }
}
 
public class CompositeStringsProcess : StringsProcessBase
{
    private List<IStringsProcessInstanciator> _processes = new List<IStringsProcessInstanciator>();
 
    public CompositeStringsProcess(IEnumerable<IStringsProcessInstanciator> processes)
    {
        _processes.AddRange(processes);
    }
    public CompositeStringsProcess(params IStringsProcessInstanciator[] processes)
        : this((IEnumerable<IStringsProcessInstanciator>)processes)
    {
    }
 
    public List<IStringsProcessInstanciator> Processes
    {
        get { return _processes; }
    }
 
    public override IEnumerable<string> Process(IEnumerable<string> lines)
    {
        foreach (var process in Processes)
        {
            if (Cancelled)
                break;
            lines = process.CreateInstance().Process(lines);
        }
        return lines;
    }
 
    public override string ToString()
    {
        var sb = new StringBuilder();
        foreach (var process in Processes)
        {
            sb.Append(" & ");
            sb.Append(process);
        }
        return sb.ToString().Substring(3);
    }
}

In the UI, we will add two ListBox: one for running processes and one for run processes.

We will add a new class in the BLL which will be used for these ListBox binding.

public class FileProcessInfo
{
    internal FileProcessInfo()
    {
    }
 
    public IStringsProcess Process { get; internal set; }
    public string InFilePath { get; internal set; }
    public string OutFilePath { get; internal set; }
 
    public override string ToString()
    {
        return string.Concat(Process, " (", InFilePath, "  -->  ", OutFilePath, ")");
    }
}

Then , we will modify the FileProcess.Process method to return a FileProcessInfo and integrate the cancellation:

public static class FileProcess
{
    private static Dictionary<string, BackgroundWorker> _processesRunning = new Dictionary<string, BackgroundWorker>();
    private static object _lockObject = new object();
 
    public static FileProcessInfo Process(string inFilePath, string outFilePath,
        IEnumerable<IStringsProcessInstanciator> processes, Action<string> showError,
        Func<string, bool> showErrorWithRetry, Action<bool, FileProcessInfo> processDone)
    {
        var process = new CompositeStringsProcess(processes);
        var result = new FileProcessInfo
        {
            Process = process,
            InFilePath = inFilePath,
            OutFilePath = outFilePath
        };
        if (!(File.Exists(inFilePath) || _processesRunning.ContainsKey(inFilePath)))
            FileNotFoundShowError(inFilePath, showError);
        else if (!Directory.Exists(Path.GetDirectoryName(outFilePath)))
            DirectoryNotFoundShowError(outFilePath, showError);
        else
        {
            var bg = new BackgroundWorker();
            bg.DoWork += (s, e) =>
            {
                e.Result = false;
                while (true)
                {
                    try
                    {
                        FileUtil.WriteLines(outFilePath, process.Process(FileUtil.GetLines(inFilePath)));
                        e.Result = !process.Cancelled;
                    }
                    catch (FileNotFoundException)
                    {
                        FileNotFoundShowError(inFilePath, showError);
                    }
                    catch (DirectoryNotFoundException)
                    {
                        DirectoryNotFoundShowError(outFilePath, showError);
                    }
                    catch (IOException)
                    {
                        if (showErrorWithRetry(string.Format(FileErrorResources.IOException, outFilePath)))
                            continue;
                    }
                    catch (Exception ex)
                    {
                        showError(string.Format(FileErrorResources.UnknowException,
                            string.Concat(ex.GetType(), " : ", ex.Message)));
                    }
                    break;
                }
                lock (_lockObject)
                {
                    _processesRunning.Remove(outFilePath);
                }
            };
            bg.RunWorkerCompleted += (s, e) =>
            {
                ProcessDone(processDone, result, (bool)e.Result);
            };
            StartBGAndCache(result, bg, processDone);
        }
        return result;
    }
 
    private static void ProcessDone(Action<bool, FileProcessInfo> processDone,
        FileProcessInfo fileProcessInfo, bool processResult)
    {
        if (processDone != null)
            processDone(processResult, fileProcessInfo);
    }
 
    private static void StartBGAndCache(FileProcessInfo fileProcessInfo, BackgroundWorker bg,
        Action<bool, FileProcessInfo> processDone)
    {
        lock (_lockObject)
        {
            if (fileProcessInfo.Process.Cancelled)
            {
                ProcessDone(processDone, fileProcessInfo, false);
                return;
            }
            var inFilePath = fileProcessInfo.InFilePath;
            var outFilePath = fileProcessInfo.OutFilePath;
            RunWorkerCompletedEventHandler runWorkerCompletedTryAgain = null;
            Action<BackgroundWorker> tryAgain = (bgTryAgain) =>
            {
                StartBGAndCache(fileProcessInfo, bg, processDone);
                bgTryAgain.RunWorkerCompleted -= runWorkerCompletedTryAgain;
            };
            if (_processesRunning.ContainsKey(inFilePath))
            {
                var bgTryAgain = _processesRunning[inFilePath];
                runWorkerCompletedTryAgain = (s, e) => tryAgain(bgTryAgain);
                bgTryAgain.RunWorkerCompleted += runWorkerCompletedTryAgain;
            }
            else if (_processesRunning.ContainsKey(outFilePath))
            {
                var bgTryAgain = _processesRunning[outFilePath];
                runWorkerCompletedTryAgain = (s, e) => tryAgain(bgTryAgain);
                bgTryAgain.RunWorkerCompleted += runWorkerCompletedTryAgain;
            }
            else
            {
                _processesRunning.Add(outFilePath, bg);
                bg.RunWorkerAsync();
            }
        }
    }
 
    private static void DirectoryNotFoundShowError(string directoryPath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.DirectoryNotFoundException, Path.GetDirectoryName(directoryPath)));
    }
 
    private static void FileNotFoundShowError(string filePath, Action<string> showError)
    {
        showError(string.Format(FileErrorResources.FileNotFoundException, filePath));
    }
}

The fact that the execution of only one process uses a CompositeStringsProcess is a shame (or not, according to your scenario). However, for this post, we will consider that it’s a shame and we will “fix” it.

To manage the case where there is no process in the collection, we will use a StringsNoProcess class:

internal class StringsNoProcess : StringsProcessBase
{
    public override IEnumerable<string> Process(IEnumerable<string> lines)
    {
        return lines;
    }
 
    public override string ToString()
    {
        return "";
    }
}

Then, we will change (again) the FileProcess.Process method:

Instead of this:

var process = new CompositeStringsProcess(processes);

we will have this:

IStringsProcess process;
if (processes.Skip(1).Any())
    process = new CompositeStringsProcess(processes);
else
{
    var transformInstanciator = processes.FirstOrDefault();
    process = transformInstanciator == null ? new StringsNoProcess() :
    transformInstanciator.CreateInstance();
}

Now in the UI, the runBtn_Click will become the following:

private void runBtn_Click(object sender, EventArgs e)
{
    lock (_lockObject)
    {
        runningProcessesLB.Items.Add(FileProcess.Process(inFilePathTB.Text, outFilePathTB.Text,
            processesLB.Items.Cast<IStringsProcessInstanciator>(),
            message => MessageBox.Show(message, Resources.ErrorTitle, MessageBoxButtons.OK, MessageBoxIcon.Error),
            message =>
                MessageBox.Show(message, Resources.ErrorTitle, MessageBoxButtons.RetryCancel, MessageBoxIcon.Error)
                == DialogResult.Retry,
            (result, fileProcess) =>
            {
                lock (_lockObject)
                {
                    if (result)
                        processesDoneLB.Items.Add(fileProcess);
                    runningProcessesLB.Items.Remove(fileProcess);
                }
            }));
    }
}

There is a last thing to do: make this code generic. Indeed, an important part of our code isn’t specific to string processes so we will use genericity to make our code more reusable.

public interface IProcess<TSource, TDestination>
{
    IEnumerable<TDestination> Process(IEnumerable<TSource> source);
    void Cancel();
    bool Cancelled { get; }
}

 
public abstract class ProcessBase<TSource, TDestination> : IProcess<TSource, TDestination>
{
    public abstract IEnumerable<TDestination> Process(IEnumerable<TSource> lines);
 
    public void Cancel()
    {
        Cancelled = true;
    }
 
    public bool Cancelled { get; private set; }
}

 
public interface IProcessInstanciator<TSource, TDestination>
{
    IProcess<TSource, TDestination> CreateInstance();
}

 
public class EmptyProcess<T> : ProcessBase<T, T>
{
    public override IEnumerable<T> Process(IEnumerable<T> lines)
    {
        return lines;
    }
 
    public override string ToString()
    {
        return "";
    }
}

 
public class CompositeProcess<T> : ProcessBase<T, T>
{
    private List<IProcess<T, T>> _processes = new List<IProcess<T, T>>();
 
    public CompositeProcess(IEnumerable<IProcessInstanciator<T, T>> processes)
    {
        _processes.AddRange(processes.Select(s => s.CreateInstance()));
    }
    public CompositeProcess(params IProcessInstanciator<T, T>[] processes)
        : this((IEnumerable<IProcessInstanciator<T, T>>)processes)
    {
    }
 
    public List<IProcess<T, T>> Processes
    {
        get { return _processes; }
    }
 
    public override IEnumerable<T> Process(IEnumerable<T> elts)
    {
        foreach (var process in Processes)
        {
            if (Cancelled)
                break;
            elts = process.Process(elts);
        }
        return elts;
    }
 
    public override string ToString()
    {
        var sb = new StringBuilder();
        foreach (var process in Processes)
        {
            sb.Append(" & ");
            sb.Append(process);
        }
        return sb.ToString().Substring(3);
    }
}

Finally, to make our code even more reusable, we will divide the BLL on multiple dll: one specific for file, one specific for string processes and one specific for generic processes.

To conclude, I know that there are many notions seen very quickly but I hope that this post can be helpful in your future architecture.

If you have some critics or different points of view, don’t hesitate to add a comment.

You can download the last version of my code here.

EF with WCF recent demos

2009-05-15T22:42:00Z

I recently made a demo of WCF and EF with POCO for French ALT .NET event.

Danny made a great demo for Tech Ed with EF, T4 generation template, WCF and ASP.NET MVC.

I now post a new EF and WCF demo that I made this week with DAL EF entities and BLL Entities.

EF4 will improve the use of EF with WCF but it isn't really a problem to use these two technologies together with EF v1.

French ALT .NET Demo

2009-04-28T21:13:00Z

Last week, I spoke at an EF session for the french ALT .NET community.

During its course, I made a WCF demo with EF POCO and a sort of LINQ provider in the client part.

This provider is very simplistic (made in less than 15 minutes), isn't thread safe but is interesting for the POC and because if my provider doesn't support a LINQ method, it will use LINQ To Object method.

I just want to come back on this provider, which is very different than normal LINQ providers, and particularly on this code:

public static class CategoryClient
{
    public static MyQueryable<Category> Categories
    {
        get
        {
            ClientLINQ.AllEntities = true;
            return GetCategories().ToMyQueryable();
        }
    }
 
    private static IEnumerable<Category> GetCategories()
    {
        List<Category> value;
        if (ClientLINQ.AllEntities)
            value = Context.Instance.CategoryContract.GetAllCategories();
        else
            value = Context.Instance.CategoryContract.GetCategories(ClientLINQ.IncludeValues, ClientLINQ.WhereValue, ClientLINQ.OrderByValue, ClientLINQ.SkipValue, ClientLINQ.TakeValue);
        foreach (var category in value)
            yield return category;
    }
}

How does it work? The set of AllEntities to true initializes IncludeValues, WhereValues, etc

IncludeValues = null;
WhereValue = null;
OrderByValue = null;
SkipValue = 0;
TakeValue = 0;

How can AllEntities be false in GetCategories method whereas the instruction which follows AllEntities = true is the GetCategories call and this method starts with a test on AllEntities ?

In fact, you should see that this method uses yield return syntax. So, it will be run only when Categories properties will be iterated. This means that the different LINQ methods are called before. That's why it's works.

EDM Designer: one more new feature

2009-04-12T13:52:00Z

I just added a new feature in my EDM Designer: when an entity type isn't mapped or is only partially mapped (so we aren't able to use our edmx), I reduce its opacity:

I do the same for Model Browser:

I also do the same for associations:

EDM Designer: new feature

2009-04-11T23:56:00Z

I added a new feature in my EDM Designer: the ability to see with context menu in which views the selected type (entity type or complex type) is present and the ability to navigate to this view.

Or directly from the Model Browser

EDM Designer: new version

2009-04-07T21:22:00Z

I just published my EDM Designer.

After a lot of talks about it, particularly at the MVP summit, I changed my tasks priorities. With this new version, my EDM Designer doesn't manage SSDL functions (including Stored Procedure) and is not integrated in VS. For this version, I added two features :

designer entities location saving
Abilty to see different views of the same edmx, which simplifies the big edmx management. Note that an entity type can appear in multiple views.

EF: Working with the context cache

2009-04-07T21:11:00Z

When we want to work with ObjectContext cache, we have to use the ObjectStateManager with its boring syntax.

products = context.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Unchanged).Select(ose => ose.Entity).OfType<Product>();

My idea is to make it into an extension method:

public static class ContextCacheExtension
{
    public static IEnumerable<T> GetEntitiesInCache<T>(this ObjectContext context)
    {
        return context.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Unchanged).Select(ose => ose.Entity).OfType<T>();
    }
}

Now, I can have a "nicer" code:

products = context.GetEntitiesInCache<Product>();