Matthieu MEZIL : C#

dynamic and indexer

Matthieu MEZIL — Wed, 21 Oct 2009 19:59:50 GMT

Remember one year ago, I wrote a post on how to use reflection with dynamic keyword. At this moment, I sent an email to MS to add an indexer in dynamic. I don’t know if my email changed any thing but I am very happy to see that from .NET 4.0 Beta 2, we are now able to use it.

So in my sample, instead of

result = dynamicSpBase.get_Item(name);

I can now directly write this:

result = dynamicSpBase[name];

Great!

PFx is good

Matthieu MEZIL — Tue, 01 Sep 2009 20:34:06 GMT

I am sure that the Parallel Framework (PFx) will take more and more importance in future developments.

However, demos often are not in phase with the reality. It’s true that a fractal demo on a 1000 cores machine is ideal for parallel demo, however in real life, I never used the fractal yet and I don’t think that I am the only one in this case.

So my idea was to make an example inspired from my daily work. So I made an example around… the Entity Framework.

Imagine a DB featuring a Customers table with potentially a lot of rows (100 000 in my example which is quite a lot), a WPF application with a DataGrid to show the customers. Note that the WPF DataGrid is better than the Winforms DataGridView for this case because the WPF DataGrid loads only the visible items.

The ObjectQuery class implements IListSource, so it means that we can use it as ItemsSource (the Customers property is of type ObjectSet<Customer> which inherits of ObjectQuery). Then, we add some controls to filter the items (for example, one TextBox per string column). We won’t use the MVVM pattern to avoid complicating this sample. So to filter items, we can change the DataGrid ItemsSource Customers.Where(…) instead of Customers. The result of the Where is also an ObjectQuery instance so no problem. But… this implies a new query into the DB. We should avoid executing a new SQL query each time one of the filter control’s value change. Indeed, on the Window load, we get all the customers.

In addition to the useless query, we have another issue: new non persisted customers aren’t in the DataGrid since we change the filter and we can’t get it in the grid while we don’t call the context SaveChanges method. Conversely, the deleted customers still are in the grid while changes aren’t persisted. Indeed, EF queries get only the DB datas. To fix it, we can persist systematically, the add and delete and include all in a transaction so we are able to cancel the modifications however, this solution isn’t great.

We need to work with the ObjectContext cache as soon as the entities are loaded. For this, we can use the ObjectStateManager property but… with the ObjectStateManager, we will have only an IEnumerable<Customer>, so we won’t be able to automate the add and the deletion.

To fix it, I made my own class:

public class ObjectSetDataSource<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable, INotifyCollectionChanged where T : class, new()
{
    […]
 
    private IEnumerable<T> AllEntities
    {
        get
        {
            if (_isLoaded == false)
            {
                foreach (var e in ObjectSet)
                    yield return e;
                _isLoaded = true;
            }
            else
            {
                foreach (var e in ObjectSet.Context.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified | EntityState.Unchanged).Select(ose => ose.Entity).OfType<T>())
                    yield return e;
            }
        }
    }
 
    private void CreateEntitiesList()
    {
        _entities = null;
        if (_allEntities == null)
            _allEntities = AllEntities;
        if (Predicate == null)
        {
            _entities = _allEntities.ToList();
            return;
        }
        _entities = _allEntities.Where(Predicate).ToList();
       }     
 
    public Func<T, bool> Predicate
    {
        get { return _predicate; }
        set
        {
            _predicate = value;
            CreateEntitiesList();
               OnCollectionChanged(NotifyCollectionChangedAction.Reset);     
        }
    }
}

Ok, it works. On the Window, we can use the TextChanged event like this:

private void lastNameTB_TextChanged(object sender, TextChangedEventArgs e)
{
    Filter();
}
 
private void firstNameTB_TextChanged(object sender, TextChangedEventArgs e)
{
    Filter();
}
 
private void Filter()
{
    string lastName = lastNameTB.Text;
    string firstName = firstNameTB.Text;
    _customers.Predicate = c =>
        {
            int i = 0;
            while (i < 100000) i++;
            return c.LastName.StartsWith(lastName) && c.FirstName.StartsWith(firstName);
        };
}

Note the loop to slow the process in order to see better what happens.

We will quickly see performance issues. Imagine that we want all the customers whose last name starts with “MEZ”.

What happens?

First issue: when we write MEZ, we probably write M then E and then Z. But with our sequential process, we will get the list of the customers whose last name starts with M then with ME and only then with MEZ. The problem is the fact that you can’t cancel the process because while it isn’t finished, the TextChanged event isn’t raised. Another issue is the fact that our code uses only one core of our processor and so 50% of the CPU power with my dual core:

If we parallelize our code, we will fix the second issue:

To use 100% of our CPU, we should execute our LINQ query on several threads. Indeed you can because the customers filter is independent between each customer. However, creating one thread per customer is out of the question! Tasks are very interesting for this and in our case, we will use PLINQ which is really fantastically easy to use. This is the code I propose:

public class ObjectSetDataSource<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable, INotifyCollectionChanged where T : class, new()
{
    […]
 
    private void CreateEntitiesList()
    {
        _entities = null;
        if (_allEntities == null)
            _allEntities = AllEntities;
        if (Predicate == null)
        {
            _entities = _allEntities.ToList();
            return;
        }
        try
        {
            _entities = _allEntities.AsParallel.Where(Predicate).ToList();
        }
        catch (OperationCanceledException)
        {
        }
    }
 
    public Func<T, bool> Predicate
    {
        get { return _predicate; }
        set
        {
            _predicate = value;
            CreateEntitiesList();
            OnCollectionChanged(NotifyCollectionChangedAction.Reset); 
        }
    }
}
The CPU use shows a real improvement:
 
Only with the AsParallel extension method, It’s hard to do it more easily!  With this, our LINQ query is executed on all the cores of our computer. The extension method AsParallel will share the processes by splitting the source by n (2 for my dual core). Note that with execution on more than one thread, the result (without OrderBy) can be in another order than with our first code mono-threaded but in our case, it isn’t important. 
However, there still is the first issue: we need to be able to cancel the list process if the filter changes in order not to have to generate the lists for M and ME when the wanted filter is MEZ. Of course, PFx proposes all we need to do it:
public class ObjectSetDataSource<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable, INotifyCollectionChanged where T : class, new()
{
    […]
 
    private void CreateEntitiesList()
    {
        _entities = null;
        if (_allEntities == null)
            _allEntities = AllEntities;
        if (Predicate == null)
        {
            _entities = _allEntities.ToList();
            return;
        }
        try
        {
            _entities = _allEntities.AsParallel().WithCancellation(_cancellationToken.Token).Where(Predicate).ToList();
        }
        catch (OperationCanceledException)
        {
        }
    }
 
    public Func<T, bool> Predicate
    {
        get { return _predicate; }
        set
        {
            _predicate = value;
            if (_cancellationToken != null)
                _cancellationToken.Cancel();
            _cancellationToken = new CancellationTokenSource();
            new Task(t =>
                 {
                    CreateEntitiesList();
 
                     if (cancellationToken.IsCancellationRequested)
                         return;
 
                     var app = Application.Current;
                     if (app != null)
                        app.Dispatcher.BeginInvoke((Action)(() => OnCollectionChanged(NotifyCollectionChangedAction.Reset)));
                 }, cancellationToken).Start();
        }
    }
}

The CPU use shows one more important improvement:

The WithCancellation extension method allows us to cancel the LINQ query during its execution.

The idea to create the task in the Predicate property is to not be forced to wait the end of the M filter process and then the end of the ME filter process to finally have our MEZ filter. The task runs the filter process asynchronously and avoids the frozen UI.

The last point is the BeginInvoke method which allow us to raise the CollectionChanged event into the principal thread which is inevitable to avoiding the following exception: “This type of CollectionView does not support changes to its SourceCollection from a thread different from the Dispatcher thread”.

This sample, very frequent, shows us the interest of using PFx. However, be careful, as all algorithms aren’t parallelisable. Moreover, the parallel code often adds more complexity and implies bringing parallelism algorithm under control. However if you have time to learn it, I suggest you very very very strongly to learn PFx and the parallelism in general. Indeed, as I wrote it at first, the Parallel Framework (PFx) will take more and more importance in the future.

You can download the complete ObjectSetDataSource class here.

How to get the typed instance in the abstract class?

Matthieu MEZIL — Mon, 03 Aug 2009 13:50:00 GMT

Alex James, PM on EF, publish sometimes some C# posts.

He published a post to explain how to “link” the methods call.

To realize it, he returns the instance in his methods:

public abstract class PropertyConfiguration
{
    private bool _nullable;
    public virtual PropertyConfiguration Nullable()
    {
        _nullable = true;
        return this;
    }
    public virtual PropertyConfiguration NonNullable()
    {
        _nullable = false;
        return this;
    }
}
 
public class StringPropertyConfiguration : PropertyConfiguration
{
    private int? _maxLength;
    public StringPropertyConfiguration MaxLength(int maxLength)
    {
        _maxLength = maxLength;
        return this;
    }
}

With this way, he can do:

var nameConfiguration = new StringPropertyConfiguration()
                            .MaxLength(100)
                            .Nullable(); 

But the following code doesn’t compile:

var nameConfiguration = new StringPropertyConfiguration()
                            .Nullable()
                            .MaxLength(100);

The idea of Damien Guard (one of the last MS guy who works on LINQ to SQL) was to use the extension methods:

public abstract class PropertyConfiguration
{
    private bool _nullable;
    public bool Nullable
    {
        get { return _nullable; }
        set { _nullable = value; }
    }
}
 
public static class PropertyConfigurationExtension
{
    public static T Nullable<T>(this T propertyConfiguration) where T: PropertyConfiguration 
    { 
         propertyConfiguration.Nullable = true; 
         return propertyConfiguration; 
    }
}

Cool!

Now the question is: is it possible to do it with C#2 (so without extension methods)?

For this, I suggest the following solution:

public abstract class PropertyConfiguration<T> where T : PropertyConfiguration<T>
{
    private bool _nullable;
    public virtual T Nullable()
    {
        _nullable = true;
        return (T)this;
    }
    public virtual T NonNullable()
    {
        _nullable = false;
        return (T)this;
    }
}
 
public class StringPropertyConfiguration : PropertyConfiguration<StringPropertyConfiguration>
{
    private int? _maxLength;
    public StringPropertyConfiguration MaxLength(int maxLength)
    {
        _maxLength = maxLength;
        return this;
    }
}

This one is more complex but is interesting because I give the type of the derived class to the base class using generics.

The problem with this approach is the fact that it isn’t possible to use directly the base class (ie to have a parameter of type PropertyConfiguration or a List of PropertyConfiguration) because of the generics. To fix it, we can use an interface:

public interface IPropertyConfiguration
{
    IPropertyConfiguration Nullable();
    IPropertyConfiguration NonNullable();
}
 
public abstract class PropertyConfiguration<T> : IPropertyConfiguration where T : PropertyConfiguration<T>
{
    private bool _nullable;
    public virtual T Nullable()
    {
        _nullable = true;
        return (T)this;
    }
    public virtual T NonNullable()
    {
        _nullable = false;
        return (T)this;
    }
 
    IPropertyConfiguration IPropertyConfiguration.Nullable()
    {
        return Nullable();
    }
    IPropertyConfiguration IPropertyConfiguration.NonNullable()
    {
        return NonNullable();
    }
}

Enjoy

How to have FK in EF v1?

Matthieu MEZIL — Tue, 21 Jul 2009 21:03:08 GMT

Before answering this question, I will start with another one: why do we need FK?

to be able to change a relationship without loading the related entity but we can already do it with the EntityReference property.
for the binding

With the windows forms ComboBox, we don’t need it because you don’t have to systematically set the ValueMember property:

categoriesComboBox.DataSource = context.Categories;
categoriesComboBox.DisplayMember = "CategoryName";
categoriesComboBox.DataBindings.Add("SelectedItem", product, "Category");

But the problem is for the DataGridViewComboBoxColumn and the ASP DropDownList. In these cases, we really need the FK property.

My first idea was to add the property:

partial class Product
{
    public int CategoryID
    {
        get { return (int)CategoryReference.EntityKey.EntityKeyValues.First().Value; }
        set { CategoryReference.EntityKey = new EntityKey("NorthwindEntities.Categories", "CategoryID", value); }
    }
}

Ok, it works. However, the problem is the fact that we can been tempted to use it in a LINQ To Entities query. But, of course, in this case, it fails.

The binding doesn’t directly use the property of the class but the PropertyDescriptor which are, by default, generated from the properties. My idea is not to add a new property but to add a new PropertyDescriptor. For this, we have to implement the ICustomTypeDescriptor.

partial class Product : ICustomTypeDescriptor
{
    AttributeCollection ICustomTypeDescriptor.GetAttributes()
    {
        return TypeDescriptor.GetAttributes(this, true);
    }
 
    string ICustomTypeDescriptor.GetClassName()
    {
        return TypeDescriptor.GetClassName(this);
    }
 
    string ICustomTypeDescriptor.GetComponentName()
    {
        return TypeDescriptor.GetComponentName(this);
    }
 
    TypeConverter ICustomTypeDescriptor.GetConverter()
    {
        return TypeDescriptor.GetConverter(this);
    }
 
    EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
    {
        return TypeDescriptor.GetDefaultEvent(this);
    }
 
    PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
    {
        return TypeDescriptor.GetDefaultProperty(this);
    }
 
    object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
    {
        return TypeDescriptor.GetEditor(this, editorBaseType);
    }
 
    EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
    {
        return TypeDescriptor.GetEvents(attributes);
    }
 
    EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
    {
        return TypeDescriptor.GetEvents(this);
    }
 
    PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
    {
        var props = TypeDescriptor.GetProperties(this, attributes, true).Cast<PropertyDescriptor>().ToList();
        props.Add(new FKPropertyDescriptor<Product>(p => p.CategoryReference, "CategoryID", "CategoryCategoryID", typeof(int)));
        return new PropertyDescriptorCollection(props.ToArray());
    }
 
    PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
    {
        return ((ICustomTypeDescriptor)this).GetProperties(null);
    }
 
    object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
    {
        return this;
    }
}
 
public class FKPropertyDescriptor<T> : PropertyDescriptor
{
    private Type _propertyDescriptorType;
    private Func<T, EntityReference> _getEntityReference;
 
    public string PropertyName { get; private set; }
 
    public FKPropertyDescriptor(Func<T, EntityReference> getEntityReference, string propertyName, string propertyDescriptorName, Type propertyDescriptorType)
        : base(propertyDescriptorName, new Attribute[0])
    {
        _getEntityReference = getEntityReference;
        PropertyName = propertyName;
        _propertyDescriptorType = propertyDescriptorType;
    }
 
    public override bool CanResetValue(object component)
    {
        return false;
    }
 
    public override Type ComponentType
    {
        get { return typeof(T); }
    }
 
    public override object GetValue(object component)
    {
        return _getEntityReference((T)component).EntityKey.EntityKeyValues.First(ekv => ekv.Key == PropertyName).Value;
    }
 
    public override bool IsReadOnly
    {
        get { return false; }
    }
 
    public override Type PropertyType
    {
        get { return _propertyDescriptorType; }
    }
 
    public override void ResetValue(object component)
    {
    }
 
    public override void SetValue(object component, object value)
    {
        var entityKey = _getEntityReference((T)component).EntityKey;
        _getEntityReference((T)component).EntityKey = new EntityKey(string.Concat(entityKey.EntityContainerName, ".", entityKey.EntitySetName), entityKey.EntityKeyValues.Where(ekm => ekm.Key != PropertyName).Union(new[] { new EntityKeyMember(PropertyName, value) }));
    }
 
    public override bool ShouldSerializeValue(object component)
    {
        return false;
    }
}

Great, it works!

However, it would be very boring to do it for each FK!

As Danny wrote here, it’s possible to use the T4 template with VS 2008. So my idea is to change the default template to add it automatically.

You can download it here.

The most important part of the template is this one:

PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
{
    var props = TypeDescriptor.GetProperties(this, attributes, true).Cast<PropertyDescriptor>().ToList();
<#         
    foreach(NavigationProperty property in entity.NavigationProperties.Where(n => n.DeclaringType == entity && n.ToEndMember.RelationshipMultiplicity != RelationshipMultiplicity.Many))
    {
        string elementTypeName = GetEntityType(property.ToEndMember).Name;
        EntityType elementType = Edm.AllEntities.First(et => et.Name == elementTypeName);
        foreach (EdmMember keyMember in elementType.KeyMembers)
        {
            string keyMemberName = keyMember.Name;
#>
    props.Add(new FKPropertyDescriptor<<#= entity.Name #>>(p => p.<#= property.Name #>Reference, "<#= keyMemberName #>", "<#= string.Concat(property.Name, keyMemberName) #>", typeof(<#= new CSharpCodeLanguage().Format(keyMember.TypeUsage) #>)));
<#
        }
    }
#>
    return new PropertyDescriptorCollection(props.ToArray());
}

What is cool now is the fact that with zero effort, you can use the FK in your bindings.

Enjoy

POCO: CreateObject and object initializer

Matthieu MEZIL — Fri, 22 May 2009 08:31:00 GMT

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");

POO is so pretty with C#

Matthieu MEZIL — Mon, 18 May 2009 12:20:00 GMT

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.

French ALT .NET Demo

Matthieu MEZIL — Tue, 28 Apr 2009 21:13:00 GMT

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.

How to use LINQ extension methods on non generic IEnumerable?

Matthieu MEZIL — Wed, 01 Apr 2009 12:17:00 GMT

LINQ extension methods are great but... it's not so cool when we use non generic collections as it is often the case with Sharepoint or TFS APIs.

Likely, we have two LINQ extension methods Cast and OfType which allow us to transform our non generic collection into a generic one.

For example, with a StoredQueryCollection sqc, it is possible de do sqc.Cast<StoredProcedure>().FirstOrDefault(predicate);

Ok great but the Cast is boring. I think it would be better if we were be able to do sqc.FirstOrDefault<StoredProcedure>(predicate);

To do this, I redefine LINQ extension methods for non generic IEnumerable :

public static class IEnumerableExtension
{
    public static TSource Aggregate<TSource>(this IEnumerable source, Func<TSource, TSource, TSource> func)
    {
        return source.Cast<TSource>().Aggregate(func);
    }
    public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
    {
        return source.Cast<TSource>().Aggregate(seed, func);
    }
    public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
    {
        return source.Cast<TSource>().Aggregate(seed, func, resultSelector);
    }
    public static bool All<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().All(predicate);
    }
    public static bool Any(this IEnumerable source)
    {
        var enumerator = source.GetEnumerator();
        return enumerator.MoveNext();
    }
    public static bool Any<TSource>(this IEnumerable source)
    {
        return source.OfType<TSource>().Any();
    }
    public static bool Any<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().Any(predicate);
    }
    public static decimal? Average<TSource>(this IEnumerable source, Func<TSource, decimal?> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static decimal Average<TSource>(this IEnumerable source, Func<TSource, decimal> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static double? Average<TSource>(this IEnumerable source, Func<TSource, double?> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static double Average<TSource>(this IEnumerable source, Func<TSource, double> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static float? Average<TSource>(this IEnumerable source, Func<TSource, float?> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static float Average<TSource>(this IEnumerable source, Func<TSource, float> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static double? Average<TSource>(this IEnumerable source, Func<TSource, int?> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static double Average<TSource>(this IEnumerable source, Func<TSource, int> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static double? Average<TSource>(this IEnumerable source, Func<TSource, long?> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static double Average<TSource>(this IEnumerable source, Func<TSource, long> selector)
    {
        return source.Cast<TSource>().Average(selector);
    }
    public static IEnumerable<TSource> Concat<TSource>(this IEnumerable first, IEnumerable second)
    {
        return first.Cast<TSource>().Concat(second.Cast<TSource>());
    }
    public static bool Contains(this IEnumerable source, object value)
    {
        foreach (var item in source)
            if (item == value)
                return true;
        return false;
    }
    public static bool Contains<TSource>(this IEnumerable source, TSource value, IEqualityComparer<TSource> comparer)
    {
        return source.Cast<TSource>().Contains(value, comparer);
    }
    public static int Count(this IEnumerable source)
    {
        int count = 0;
        foreach (var item in source)
            count++;
        return count;
    }
    public static int Count<TSource>(this IEnumerable source)
    {
        return source.OfType<TSource>().Count();
    }
    public static int Count<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().Count(predicate);
    }
    public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().DefaultIfEmpty();
    }
    public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this IEnumerable source, TSource defaultValue)
    {
        return source.Cast<TSource>().DefaultIfEmpty(defaultValue);
    }
    public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().Distinct();
    }
    public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable source, IEqualityComparer<TSource> comparer)
    {
        return source.Cast<TSource>().Distinct(comparer);
    }
    public static TSource ElementAt<TSource>(this IEnumerable source, int index)
    {
        return source.Cast<TSource>().ElementAt(index);
    }
    public static TSource ElementAtOrDefault<TSource>(this IEnumerable source, int index)
    {
        return source.Cast<TSource>().ElementAtOrDefault(index);
    }
    public static IEnumerable<TSource> Except<TSource>(this IEnumerable first, IEnumerable second)
    {
        return first.Cast<TSource>().Except(second.Cast<TSource>());
    }
    public static IEnumerable<TSource> Except<TSource>(this IEnumerable first, IEnumerable second, IEqualityComparer<TSource> comparer)
    {
        return first.Cast<TSource>().Except(second.Cast<TSource>(), comparer);
    }
    public static TSource First<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().First();
    }
    public static TSource First<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().First(predicate);
    }
    public static TSource FirstOrDefault<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().FirstOrDefault();
    }
    public static TSource FirstOrDefault<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().FirstOrDefault(predicate);
    }
    public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector)
    {
        return source.Cast<TSource>().GroupBy(keySelector);
    }
    public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector)
    {
        return source.GroupBy(keySelector, resultSelector);
    }
    public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return source.Cast<TSource>().GroupBy(keySelector, elementSelector);
    }
    public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().GroupBy(keySelector, comparer);
    }
    public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().GroupBy(keySelector, resultSelector, comparer);
    }
    public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector)
    {
        return source.Cast<TSource>().GroupBy(keySelector, elementSelector, resultSelector);
    }
    public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().GroupBy(keySelector, elementSelector, comparer);
    }
    public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().GroupBy(keySelector, elementSelector, resultSelector, comparer);
    }
    public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable outer, IEnumerable inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector)
    {
        return outer.Cast<TOuter>().GroupJoin(inner.Cast<TInner>(), outerKeySelector, innerKeySelector, resultSelector);
    }
    public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable outer, IEnumerable inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey> comparer)
    {
        return outer.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
    }
    public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable first, IEnumerable second)
    {
        return first.Cast<TSource>().Intersect(second.Cast<TSource>());
    }
    public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
    {
        return first.Cast<TSource>().Intersect(second.Cast<TSource>(), comparer);
    }
    public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable outer, IEnumerable inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
    {
        return outer.Cast<TOuter>().Join(inner.Cast<TInner>(), outerKeySelector, innerKeySelector, resultSelector);
    }
    public static IEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IEnumerable outer, IEnumerable inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
    {
        return outer.Cast<TOuter>().Join(inner.Cast<TInner>(), outerKeySelector, innerKeySelector, resultSelector, comparer);
    }
    public static TSource Last<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().Last();
    }
    public static TSource Last<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().Last(predicate);
    }
    public static TSource LastOrDefault<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().LastOrDefault();
    }
    public static TSource LastOrDefault<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().LastOrDefault(predicate);
    }
    public static long LongCount<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().LongCount();
    }
    public static long LongCount(this IEnumerable source, Func<TSource, bool> predicate)
    {
        long count = 0;
        foreach (var item in source)
            count++;
        return count;
    }
    public static long LongCount<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.OfType<TSource>().LongCount(predicate);
    }
    public static TSource Max<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().Max();
    }
    public static decimal? Max<TSource>(this IEnumerable source, Func<TSource, decimal?> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static decimal Max<TSource>(this IEnumerable source, Func<TSource, decimal> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static double? Max<TSource>(this IEnumerable source, Func<TSource, double?> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static double Max<TSource>(this IEnumerable source, Func<TSource, double> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static float? Max<TSource>(this IEnumerable source, Func<TSource, float?> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static float Max<TSource>(this IEnumerable source, Func<TSource, float> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static int? Max<TSource>(this IEnumerable source, Func<TSource, int?> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static int Max<TSource>(this IEnumerable source, Func<TSource, int> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static long? Max<TSource>(this IEnumerable source, Func<TSource, long?> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static long Max<TSource>(this IEnumerable source, Func<TSource, long> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static TResult Max<TSource, TResult>(this IEnumerable source, Func<TSource, TResult> selector)
    {
        return source.Cast<TSource>().Max(selector);
    }
    public static TSource Min<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().Min();
    }
    public static decimal? Min<TSource>(this IEnumerable source, Func<TSource, decimal?> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static decimal Min<TSource>(this IEnumerable source, Func<TSource, decimal> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static double? Min<TSource>(this IEnumerable source, Func<TSource, double?> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static double Min<TSource>(this IEnumerable source, Func<TSource, double> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static float? Min<TSource>(this IEnumerable source, Func<TSource, float?> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static float Min<TSource>(this IEnumerable source, Func<TSource, float> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static int? Min<TSource>(this IEnumerable source, Func<TSource, int?> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static int Min<TSource>(this IEnumerable source, Func<TSource, int> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static long? Min<TSource>(this IEnumerable source, Func<TSource, long?> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static long Min<TSource>(this IEnumerable source, Func<TSource, long> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static TResult Min<TSource, TResult>(this IEnumerable source, Func<TSource, TResult> selector)
    {
        return source.Cast<TSource>().Min(selector);
    }
    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector)
    {
        return source.Cast<TSource>().OrderBy(keySelector);
    }
    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
    {
        return source.Cast<TSource>().OrderBy(keySelector, comparer);
    }
    public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector)
    {
        return source.Cast<TSource>().OrderByDescending(keySelector);
    }
    public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
    {
        return source.Cast<TSource>().OrderByDescending(keySelector, comparer);
    }
    public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().Reverse();
    }
    public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable source, Func<TSource, int, TResult> selector)
    {
        return source.Cast<TSource>().Select(selector);
    }
    public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable source, Func<TSource, TResult> selector)
    {
        return source.Cast<TSource>().Select(selector);
    }
    public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable source, Func<TSource, IEnumerable<TResult>> selector)
    {
        return source.Cast<TSource>().SelectMany(selector);
    }
    public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable source, Func<TSource, int, IEnumerable<TResult>> selector)
    {
        return source.Cast<TSource>().SelectMany(selector);
    }
    public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
    {
        return source.Cast<TSource>().SelectMany(collectionSelector, resultSelector);
    }
    public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
    {
        return source.Cast<TSource>().SelectMany(collectionSelector, resultSelector);
    }
    public static bool SequenceEqual<TSource>(this IEnumerable first, IEnumerable second)
    {
        return first.Cast<TSource>().SequenceEqual(second.Cast<TSource>());
    }
    public static bool SequenceEqual<TSource>(this IEnumerable first, IEnumerable second, IEqualityComparer<TSource> comparer)
    {
        return first.Cast<TSource>().SequenceEqual(second, comparer);
    }
    public static TSource Single<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().Single();
    }
    public static TSource Single<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().Single(predicate);
    }
    public static TSource SingleOrDefault<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().SingleOrDefault();
    }
    public static TSource SingleOrDefault<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().SingleOrDefault(predicate);
    }
    public static IEnumerable<TSource> Skip<TSource>(this IEnumerable source, int count)
    {
        return source.Cast<TSource>().Skip(count);
    }
    public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().SkipWhile(predicate);
    }
    public static IEnumerable<TSource> SkipWhile<TSource>(this IEnumerable source, Func<TSource, int, bool> predicate)
    {
        return source.Cast<TSource>().SkipWhile(predicate);
    }
    public static decimal? Sum<TSource>(this IEnumerable source, Func<TSource, decimal?> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static decimal Sum<TSource>(this IEnumerable source, Func<TSource, decimal> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static double? Sum<TSource>(this IEnumerable source, Func<TSource, double?> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static double Sum<TSource>(this IEnumerable source, Func<TSource, double> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static float? Sum<TSource>(this IEnumerable source, Func<TSource, float?> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static float Sum<TSource>(this IEnumerable source, Func<TSource, float> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static int? Sum<TSource>(this IEnumerable source, Func<TSource, int?> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static int Sum<TSource>(this IEnumerable source, Func<TSource, int> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static long? Sum<TSource>(this IEnumerable source, Func<TSource, long?> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static long Sum<TSource>(this IEnumerable source, Func<TSource, long> selector)
    {
        return source.Cast<TSource>().Sum(selector);
    }
    public static IEnumerable<TSource> Take<TSource>(this IEnumerable source, int count)
    {
        return source.Cast<TSource>().Take(count);
    }
    public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().TakeWhile(predicate);
    }
    public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable source, Func<TSource, int, bool> predicate)
    {
        return source.Cast<TSource>().TakeWhile(predicate);
    }
    public static TSource[] ToArray<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().ToArray();
    }
    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector)
    {
        return source.Cast<TSource>().ToDictionary(keySelector);
    }
    public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return source.ToDictionary(keySelector, elementSelector);
    }
    public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().ToDictionary(keySelector, comparer);
    }
    public static Dictionary<TKey, TElement> ToDictionary<TSource, TKey, TElement>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().ToDictionary(keySelector, elementSelector, comparer);
    }
    public static List<TSource> ToList<TSource>(this IEnumerable source)
    {
        return source.Cast<TSource>().ToList();
    }
    public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector)
    {
        return source.Cast<TSource>().ToLookup(keySelector);
    }
    public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
    {
        return source.Cast<TSource>().ToLookup(keySelector, elementSelector);
    }
    public static ILookup<TKey, TSource> ToLookup<TSource, TKey>(this IEnumerable source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().ToLookup(keySelector, comparer);
    }
    public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement>(this IEnumerable source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer)
    {
        return source.Cast<TSource>().ToLookup(keySelector, elementSelector, comparer);
    }
    public static IEnumerable<TSource> Union<TSource>(this IEnumerable first, IEnumerable second)
    {
        return first.Cast<TSource>().Union(second.Cast<TSource>());
    }
    public static IEnumerable<TSource> Union<TSource>(this IEnumerable first, IEnumerable second, IEqualityComparer<TSource> comparer)
    {
        return first.Cast<TSource>().Union(second.Cast<TSource>(), comparer);
    }
    public static IEnumerable<TSource> Where<TSource>(this IEnumerable source, Func<TSource, bool> predicate)
    {
        return source.Cast<TSource>().Where(predicate);
    }
    public static IEnumerable<TSource> Where<TSource>(this IEnumerable source, Func<TSource, int, bool> predicate)
    {
        return source.Cast<TSource>().Where(predicate);
    }
}

Enjoy

Code factorization with delegate

Matthieu MEZIL — Wed, 11 Feb 2009 11:56:00 GMT

I want to write an extension method Sum on IEnumerable<int> and an extension method Sum on IEnumerable<decimal>.

public static int Sum(this IEnumerable<int> source)
{
    int value = 0;
    foreach (int item in source)
        value += item;
    return value;
}
public static decimal Sum(this IEnumerable<decimal> source)
{
    decimal value = 0;
    foreach (decimal item in source)
        value += item;
    return value;
}

Now I want to factorize this code but the problem is: how to factorize the initialization (= 0 with an int and = 0 with a decimal) and the addition? To do this, we can use delegate:

private static T Sum<T>(this IEnumerable<T> source, Func<T, T, T> addition)
{
    T value = default(T);
    foreach (T item in source)
        value = addition(value, item);
    return value;
}
public static int Sum(this IEnumerable<int> source)
{
    return source.Sum((i1, i2) => i1 + i2);
}
public static decimal Sum(this IEnumerable<decimal> source)
{
    return source.Sum((d1, d2) => d1 + d2);
}

In this case, we can replace the foreach loop by an Aggregate:

private static T Sum<T>(this IEnumerable<T> source, Func<T, T, T> addition)
{
    return source.Aggregate(default(T), (elt1, elt2) => addition(elt1, elt2));
}

EDM Designer

Matthieu MEZIL — Wed, 07 Jan 2009 09:36:00 GMT

I didn’t blog for a (too) long time which is strange for me.

I received some emails asking if I was ok and I found in this a similitude between Scott Guthrie and myself. Lol

So what did I do during my nights this last month? No I don’t sleep more and no I wasn’t in a 6 weeks’ vacation.

In fact, I'm beginning a very funny project: doing an EDM designer! And I thought that it was time I did my first WPF project.

If you look at the code, you will see a VB project. Yes Julie, you read well. This project is used to write an edmx file from my classes and, instead of using serialization, I choose to play with VB9 XML Literal. For all other projects, I use C# of course.

The first version is only a CSDL read-only designer.

I think it makes two interesting points compared to the current MS designer:

The ability to show only some entity types and not all
The ability to show Complex Type

What do I want to add in the following versions?

The ability to add or remove csdl type / property / relation / inheritance (fixing these bugs of course) and to save it into an edmx file
The ability to change csdl type / property properties like the name, the visibility, etc.
The ability to show and change the mapping (including TPC which isn’t supported by current MS designer)
The ability to (re)generate csdl entity types from ssdl entity types. (In current MS designer, it generates it when you add the table / view from the wizard but if you delete your csdl entity type, you have to regenerate it yourself or to delete your ssdl entity type and to use the wizard to add it again. Moreover, for SSDL View, you have nothing to generate the CSDL entity type)
The ability to add SSDL Views or Functions
Integrate it in VS
The ability to save your designer

You can download it here.

As I said previously, I am a WPF beginner so if you have time to audit it and if you have some remarks, advices, criticism, post a comment please.

C# compiler and implicit keyword: can be better

Matthieu MEZIL — Mon, 03 Nov 2008 07:51:00 GMT

Imagine the following code:

class A
{
    public static implicit operator B(A a)
    {
        return new B(a);
    }
}
class B
{
    public B(A a)
    {
    }
}

This code compile without error and it's normal.

Now imagine the following one:

class A
{
    public static implicit operator B(A a)
    {
        return new A();
    }
}

The compiler generates no error with this code but it should!

Less annoying, the compiler generates an error with this code (Cannot implicitly convert type 'A' to 'C') even though it would be able to use B to convert A to C:

class Program
{
    static void Main(string[] args)
    {
        C c = new A();
    }
}
 
class A
{
    public static implicit operator B(A a)
    {
        return new B(a);
    }
}
class B
{
    public B(A a)
    {
    }
 
    public static implicit operator C(B b)
    {
        return new C(b);
    }
}
 
class C
{
    public C(B b)
    {
    }
}