Matthieu MEZIL

Utiliser Roslyn pour améliorer le compilateur C# ou VB

J’ai publié un POC qui permet d’enrichir le langage C# en utilisant Roslyn.

Enjoy! :)

Posté le jeudi 12 avril 2012 11:21 par Matthieu MEZIL | 5 commentaire(s)

Après-midi du dev Roslyn

J’aurais le plaisir d’animer un après-midi du dev sur Roslyn le jeudi 12 avril avec Mitsu, Jean-Baptiste, Florent, Simon et David.

Si vous voulez voir du code qui pique, inscrivez-vous !

Posté le mercredi 14 mars 2012 21:34 par Matthieu MEZIL | 0 commentaire(s)

Ma session TechDays sur Roslyn

Ma session des TechDays 2012 sur Roslyn que j’ai co-animé avec Léonard Labat est disponible ici.

Posté le mercredi 14 mars 2012 21:25 par Matthieu MEZIL | 0 commentaire(s)

Podcast sur T4 pour Visual Studio Talk Show

J’ai récemment enregistré un podcast sur T4 avec Guy Barrette et Mario Cardinal que vous pouvez retrouver ici.

Posté le samedi 10 mars 2012 00:32 par Matthieu MEZIL | 0 commentaire(s)

WCF Async Queryable Services : the architecture

Si vous me suivez sur twitter, vous devez probablement savoir que je travaille sur un projet que j’ai appelé WCF Async Queryable Services.

Je viens de faire une première vidéo sur l’architecture de WCF Async Queryable Services.

Merci d’avance pour vos feedbacks

Posté le vendredi 9 mars 2012 23:05 par Matthieu MEZIL | 0 commentaire(s)

Article sur Roslyn

Si vous êtes intéressé par Roslyn, je vous invite à lire l’article que j’ai écrit sur le sujet.

Posté le vendredi 25 novembre 2011 08:26 par Matthieu MEZIL | 2 commentaire(s)

Roslyn : générer des InvokeActivity avec T4

Le titre peut paraître bizarre mais c’est un vrai besoin rencontré chez un client pour lequel je vais utiliser Roslyn.

Imaginez le scénario suivant : dans un projet, il y a des développeurs et des experts fonctionnels. Les experts fonctionnels doivent "développer" des Workflows. Les développeurs vont développer des méthodes qui seront utilisées dans les workflows.

Le problème avec ça c’est les InvokeActivity. Pour les utiliser, ils doivent connaîtrent la signature de la méthode pour spécifier les bons types des paramètres / résultat. Un autre problème c’est qu’il faut écrire manuellement le nom de la méthode avec potentiellement le risque de faute de frappe / mise à jour.

Les experts fonctionnels préfèreraient faire du drag and drop des activités dans le workflow.

Donc mon idée est d’encapsuler les InvokeActivity dans des Activity. Maintenant, ça peut être très pénible pour les développeurs de faire ces activités.

Pour cela, il serait plus simple que les développeurs décorent les méthodes en utilisant un Attribut et ils pourraient utiliser un T4 pour générer ces activités.

Le T4 utilise Roslyn pour récupérer les informations sur les méthodes.

Ce T4 va utiliser le ttinclude d’Entity Framework EF.Utility.CS.ttinclude qui intègre déjà la création de plusieurs fichiers depuis un T4 (dans mon casje veux un fichier par méthode).

<#@ include file="EF.Utility.CS.ttinclude"#>

Ensuite, le T4 référence les assemblies de Roslyn :

<#@ assembly name="C:\Program Files (x86)\Reference Assemblies\Microsoft\Roslyn\v1.0\Roslyn.Compilers.dll"#>

<#@ assembly name="C:\Program Files (x86)\Reference Assemblies\Microsoft\Roslyn\v1.0\Roslyn.Compilers.CSharp.dll"#>

<#@ assembly name="C:\Program Files (x86)\Reference Assemblies\Microsoft\Roslyn\v1.0\Roslyn.Services.dll"#>

<#@ assembly name="C:\Program Files (x86)\Reference Assemblies\Microsoft\Roslyn\v1.0\Roslyn.Services.CSharp.dll"#>

<#@ assembly name="C:\Program Files (x86)\Reference Assemblies\Microsoft\Roslyn\v1.0\Roslyn.Services.VisualBasic.dll"#>

Le chemin vers la solution et le nom de projet sont spécifiés au début du T4. Donc maintenant, on peut charger la solution en utilisant Roslyn et récupérer les méthodes décorées avec l’attribut dans le projet spécifié.

var solution = Solution.Load(solutionPath);

var project = solution.Projects.First(p => p.AssemblyName == projectAssemblyName);

foreach (var document in project.Documents)

{

    //…

}

Ensuite, pour identifier les méthodes, on utilisera un SyntaxVisitor:

public class InvokeActivityAttributeVisitor : SyntaxVisitor<object>

{

    protected override object VisitCompilationUnit(CompilationUnitSyntax node)

    {

        foreach (var n in node.ChildNodes())

            Visit(n);

        return null;

    }

    protected override object VisitNamespaceDeclaration(NamespaceDeclarationSyntax node)

    {

        foreach (var n in node.ChildNodes())

            Visit(n);

        return null;

    }

    protected override object VisitTypeDeclaration(TypeDeclarationSyntax node)

    {

        foreach (var n in node.ChildNodes())

            Visit(n);

        return null;

    }

    protected override object VisitMethodDeclaration(MethodDeclarationSyntax node)

    {

        if (node.Modifiers.Any(st => st.Kind == SyntaxKind.PublicKeyword) && node.Attributes.Any(a => a.Attributes.Any(a2 => Regex.IsMatch(a2.Name.GetFullText(), @"^(Roslyn.WF.ActivityGenerator.)?InvokeActivity$"))))

        {

            string methodName = node.Identifier.GetText();

            var returnTypeAsPredefinedTypeSyntax = node.ReturnType as PredefinedTypeSyntax;

            if (returnTypeAsPredefinedTypeSyntax == null || returnTypeAsPredefinedTypeSyntax.Keyword.Kind != SyntaxKind.VoidKeyword)

            {

                //…       

            }

            foreach (var parameter in node.ParameterList.Parameters)

            {

                //…       

            }

        }

    }

}

Maintenant le point important est de connaître le namespace et l’assembly des types utilisés dans les méthodes. Pour cela, on utilisera les symbols de compilation :

_syntaxTree = (SyntaxTree)_document.GetSyntaxTree();

_semanticModel = _document.Project.GetCompilation().GetSemanticModel(_syntaxTree);

var returnTypeSymbol = _semanticModel.GetSemanticInfo(node.ReturnType).Symbol;

string returnTypeAssemblyName = returnTypeSymbol.ContainingAssembly.AssemblyName.Name;

string returnTypeNamespaceName = returnTypeSymbol.ContainingNamespace.ToString();

Il faut également savoir si les paramètres sont en In/Out/InOut:

parameter.Modifiers.Any(st => st.Kind == SyntaxKind.RefKeyword) ? Direction.InOut : (parameter.Modifiers.Any(st => st.Kind == SyntaxKind.OutKeyword) ? Direction.Out : Direction.In)

Le reste du code est basique, utilisé pour générer les activités.

Vous pouvez télécharger le code ici.

Posté le jeudi 20 octobre 2011 09:02 par Matthieu MEZIL | 0 commentaire(s)

Comment ajouter des comportements à l’ObjectContext ?

Imaginons que l’on veuille ajouter un comportement à la classe ObjectContext dans le but de catché certaines exceptions par exemple. Si vous essayez de supprimer une entité déjà supprimée en base, vous ne voulez pas avoir d’exception. Dans la même idée, si vous supprimez une entité modifiée par un tiers, vous ne voulez pas non plus avoir d’exception.

Comme faire cela avec un code réutilisable ?

Une solution pourrait passer par une classe ExceptionHandlingObjectContext qui hérite d’ObjectContext et qui serait héritée par l’ObjectContext spécifique (ex : NorthwindEntities).

Cependant, on peut imaginer d’avoir également un TracingObjectContext qui serait ou non utiliser en fonction d’une configuration, en utilisant Unity par exemple, ce qui rend cette solution non viable.

Je vais donc opter pour une solution différente.

Je veux créer une classe CustomizableObjectContext qui ne connait pas les behaviors. Mon ObjectContext spécifique va en hériter et je vais ensuite lui renseigner mes behaviors en utilisant les delegates.

public class CustomizableObjectContext : ObjectContext
{
    public CustomizableObjectContext(EntityConnection connection)
        : base(connection)
    {
    }
    public CustomizableObjectContext(string connectionString)
        : base(connectionString)
    {
    }
    protected CustomizableObjectContext(EntityConnection connection, string defaultContainerName)
        : base(connection, defaultContainerName)
    {
    }
    protected CustomizableObjectContext(string connectionString, string defaultContainerName)
        : base(connectionString, defaultContainerName)
    {
    }
    
    private List<Func<ObjectContext, SaveOptions, Func<SaveOptions, int>, int>> _saveActions = 
        new List<Func<ObjectContext, SaveOptions, Func<SaveOptions, int>,int>>();
    
    public void AddSaveAction(Func<ObjectContext, SaveOptions, Func<SaveOptions, int>, int> saveAction)
    {
        _saveActions.Add(saveAction);
    }
        
    public override int SaveChanges(SaveOptions options)
    {
        Func<int, SaveOptions, int> saveAction = null;
        saveAction = (index, saveOptions) =>
            {
                if (index == -1)
                    return base.SaveChanges(saveOptions);
                return _saveActions[index](this, saveOptions, so => saveAction(index - 1, so));
            };
        return saveAction(_saveActions.Count - 1, options);
    }
}

Maintenant je peux rajouter mon ExceptionHandling behavior :

public abstract class ObjectContextCustomizerBase<T> 
    where T : ObjectContextCustomizerBase<T>
{
    protected ObjectContext ObjectContext { get; set; }
    
    protected abstract int SaveChanges(ObjectContext context, SaveOptions options, Func<SaveOptions, int> baseSaveChanges);

}

public abstract class ObjectContextCustomizer<T>  : ObjectContextCustomizerBase<T>
    where T : ObjectContextCustomizer<T>, new()
{
    public static OC CreateObjectContext<OC>(OC objectContext)
        where OC : CustomizableObjectContext
    {
        objectContext.AddSaveAction(new T { ObjectContext = objectContext }.SaveChanges);
        return objectContext;
    }
}

public class ExceptionHandlerObjectContext : ObjectContextCustomizer<ExceptionHandlerObjectContext>
{
    protected override int SaveChanges(ObjectContext context, SaveOptions options, Func<SaveOptions, int> baseSaveChanges)
    {
        int value = 0;
        try
        {
            value = baseSaveChanges(options);
        }
        catch (OptimisticConcurrencyException e)
        {
            bool canHandle = true;
            if (e.StateEntries.Any() && e.StateEntries.Select(se =>
                {
                    if (se.State != System.Data.EntityState.Deleted)
                        return false;
                    object dbEntity;
                    if (ObjectContext.TryGetObjectByKey(se.EntityKey, out dbEntity))
                        ObjectContext.ApplyOriginalValues(se.EntitySet.Name, dbEntity);
                    else
                        ObjectContext.Detach(se.Entity);
                    return true;
                }).TakeWhile(b => canHandle).Aggregate((b1, b2) => canHandle = b2)) // Aggregate for execute select on each of them
                try
                {
                    value = baseSaveChanges(options);
                }
                catch (System.Exception e2)
                {
                    throw e2;
                }
            else
                throw e2;
        }
        return value;
    }
}

Enfin, pour l’utiliser avec Unity, je peux utiliser le code suivant :

unityContainer.RegisterType<NorthwindEntities, NorthwindEntities>(new InjectionFactory(c => ExceptionHandlerObjectContext.CreateObjectContext(new NorthwindEntities())));

Posté le mardi 13 septembre 2011 21:36 par Matthieu MEZIL | 0 commentaire(s)

SL5 : ICustomTypeProvider

On a souvent le problème suivant avec SL4 : dans le Model on récupère une collection d’entités et dans le ViewModel, on veut récupérer cette collection en y ajoutant de l’intelligence (par exemple des propriétés calculées).

Dans ce cas, il faut gérer deux collections et propager les modifications dans les deux sens. Une bonne pratique consiste à utiliser des "RelayCollection" pour s’occuper de cette propagation.

En .NET, on peut ajouter de "fausses" propriétés utilisées pour le binding en implémentant l’interface ICustomTypeDescriptor mais celle-ci n’existe pas dans Silverlight.

Cependant, avec SL5, on peut utiliser l’interface ICustomTypeProvider.

J’ai repris le code d’Alexandra et j’ai tenté de l’améliorer.

Cela nous donne le code suivant :

public abstract class DynamicBaseType
{
    public abstract object GetPropertyValue(string propertyName);
    public abstract void SetPropertyValue(string propertyName, object value);
}
 
public abstract class DynamicBaseType<T> : DynamicBaseType, ICustomTypeProvider, INotifyPropertyChanged
    where T : DynamicBaseType<T>
{
    private static List<CustomPropertyInfo> _customProperties = new List<CustomPropertyInfo>();
    private Dictionary<string, object> _customPropertyValues;
    private CustomType _customtype;
 
    protected DynamicBaseType()
    {
        _customPropertyValues = new Dictionary<string, object>();
        foreach (var property in _customProperties)
            _customPropertyValues.Add(property.Name, null);
    }
 
    public static void AddProperty(string name, Type type, object value = null, List<Attribute> attributes = null)
    {
        if (!CheckIfNameExists(name))
            _customProperties.Add(new CustomPropertyInfo(name, type, value, attributes));
    }
 
    public static void AddProperty<V>(string name, Func<T, V> get, Action<T, V> set = null, List<Attribute> attributes = null, string[] properties = null)
    {
        if (!CheckIfNameExists(name))
            _customProperties.Add(new CustomPropertyInfo<V>(name, get, set, attributes, properties));
    }
 
    private static bool CheckIfNameExists(string name)
    {
        if (_customProperties.Select(p => p.Name).Contains(name) || typeof(T).GetProperties().Select(p => p.Name).Contains(name))
            throw new Exception("The property with this name already exists: " + name);
        return false;
    }
 
    private bool ValidateValueType(object value, Type type)
    {
        if (value == null)
        {
            if (!type.IsValueType)
                return true;
            return (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>));
        }
        return type.IsAssignableFrom(value.GetType());
    }
 
    public override object GetPropertyValue(string propertyName)
    {
        object customPropertyValue;
        if (_customPropertyValues.TryGetValue(propertyName, out customPropertyValue))
            return customPropertyValue ?? _customProperties.First(p => p.Name == propertyName).GetDefaultValue(this);
        throw new Exception("There is no property " + propertyName);
    }
 
    public override void SetPropertyValue(string propertyName, object value)
    {
        CustomPropertyInfo propertyInfo = _customProperties.FirstOrDefault(prop => prop.Name == propertyName);
        object customPropertyValue;
        if (!_customPropertyValues.TryGetValue(propertyName, out customPropertyValue))
            throw new Exception("There is no property " + propertyName);
        if (ValidateValueType(value, propertyInfo.PropertyType))
        {
            if (customPropertyValue != value)
            {
                _customPropertyValues[propertyName] = value;
                OnPropertyChanged(propertyName);
            }
        }
        else throw new Exception("Value is of the wrong type or null for a non-nullable type.");
    }
 
    public PropertyInfo[] GetProperties()
    {
        return this.GetCustomType().GetProperties();
    }
 
    public Type GetCustomType()
    {
        return _customtype ?? (_customtype = new CustomType(typeof(T)));
    }
 
    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            foreach (var dependantCustomPropertyInfo in _customProperties.OfType<IDependantCustomPropertyInfo>().Where(dcpi => dcpi.Properties.Contains(propertyName)))
                PropertyChanged(this, new PropertyChangedEventArgs(dependantCustomPropertyInfo.Name));
        }
    }
    public event PropertyChangedEventHandler PropertyChanged;
 
    private class CustomType : Type
    {
        Type _baseType;
        public CustomType(Type delegatingType)
        {
            _baseType = delegatingType;
        }
        public override Assembly Assembly
        {
            get { return _baseType.Assembly; }
        }
 
        public override string AssemblyQualifiedName
        {
            get { return _baseType.AssemblyQualifiedName; }
        }
 
        public override Type BaseType
        {
            get { return _baseType.BaseType; }
        }
 
        public override string FullName
        {
            get { return _baseType.FullName; }
        }
 
        public override Guid GUID
        {
            get { return _baseType.GUID; }
        }
 
        protected override TypeAttributes GetAttributeFlagsImpl()
        {
            throw new NotImplementedException();
        }
 
        protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
        { 
            throw new NotImplementedException();
        }
 
        public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
        {
            return _baseType.GetConstructors(bindingAttr);
        }
 
        public override Type GetElementType()
        {
            return _baseType.GetElementType();
        }
 
        public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
        {
            return _baseType.GetEvent(name, bindingAttr);
        }
 
        public override EventInfo[] GetEvents(BindingFlags bindingAttr)
        {
            return _baseType.GetEvents(bindingAttr);
        }
 
        public override FieldInfo GetField(string name, BindingFlags bindingAttr)
        {
            return _baseType.GetField(name, bindingAttr);
        }
 
        public override FieldInfo[] GetFields(BindingFlags bindingAttr)
        {
            return _baseType.GetFields(bindingAttr);
        }
 
        public override Type GetInterface(string name, bool ignoreCase)
        {
            return _baseType.GetInterface(name, ignoreCase);
        }
 
        public override Type[] GetInterfaces()
        {
            return _baseType.GetInterfaces();
        }
 
        public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
        {
            return _baseType.GetMembers(bindingAttr);
        }
 
        protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
        {
            throw new NotImplementedException();
        }
 
        public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
        {
            return _baseType.GetMethods(bindingAttr);
        }
 
        public override Type GetNestedType(string name, BindingFlags bindingAttr)
        {
            return _baseType.GetNestedType(name, bindingAttr);
        }
 
        public override Type[] GetNestedTypes(BindingFlags bindingAttr)
        {
            return _baseType.GetNestedTypes(bindingAttr);
        }
 
        public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
        {
            PropertyInfo[] clrProperties = _baseType.GetProperties(bindingAttr);
            if (clrProperties != null)
                return clrProperties.Concat(_customProperties).ToArray();
            return _customProperties.ToArray();
        }
 
        protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
        {
            return GetProperties(bindingAttr).FirstOrDefault(prop => prop.Name == name) ?? _customProperties.FirstOrDefault(prop => prop.Name == name);
        }
 
        protected override bool HasElementTypeImpl()
        {
            throw new NotImplementedException();
        }
 
        public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
        {
            return _baseType.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
        }
 
        protected override bool IsArrayImpl()
        {
            throw new NotImplementedException();
        }
 
        protected override bool IsByRefImpl()
        {
            throw new NotImplementedException();
        }
 
        protected override bool IsCOMObjectImpl()
        {
            throw new NotImplementedException();
        }
 
        protected override bool IsPointerImpl()
        {
            throw new NotImplementedException();
        }
 
        protected override bool IsPrimitiveImpl()
        {
            return _baseType.IsPrimitive;
        }
 
        public override Module Module
        {
            get { return _baseType.Module; }
        }
 
        public override string Namespace
        {
            get { return _baseType.Namespace; }
        }
 
        public override Type UnderlyingSystemType
        {
            get { return _baseType.UnderlyingSystemType; }
        }
 
        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return _baseType.GetCustomAttributes(attributeType, inherit);
        }
 
        public override object[] GetCustomAttributes(bool inherit)
        {
            return _baseType.GetCustomAttributes(inherit);
        }
 
        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return _baseType.IsDefined(attributeType, inherit);
        }
 
        public override string Name
        {
            get { return _baseType.Name; }
        }
    }
 
    private class CustomPropertyInfo : PropertyInfo
    {
        private string _name;
        private Type _type;
        private object _defaultValue;
        private List<Attribute> _attributes;
 
        public CustomPropertyInfo(string name, Type type, object defaultValue = null, List<Attribute> attributes = null)
            : this(name, type, attributes)
        {
            _defaultValue = defaultValue;
        }
 
        protected CustomPropertyInfo(string name, Type type, List<Attribute> attributes = null)
        {
            _name = name;
            _type = type;
            _attributes = attributes;
        }
 
        public virtual object GetDefaultValue(DynamicBaseType entity)
        {
            return _defaultValue;
        }
 
        public override PropertyAttributes Attributes
        {
            get { throw new NotImplementedException(); }
        }
 
        public override bool CanRead
        {
            get { return true; }
        }
 
        public override bool CanWrite
        {
            get { return true; }
        }
 
        public override MethodInfo[] GetAccessors(bool nonPublic)
        {
            throw new NotImplementedException();
        }
 
        public override MethodInfo GetGetMethod(bool nonPublic)
        {
            throw new NotImplementedException();
        }
 
        public override ParameterInfo[] GetIndexParameters()
        {
            throw new NotImplementedException();
        }
 
        public override MethodInfo GetSetMethod(bool nonPublic)
        {
            throw new NotImplementedException();
        }
 
        public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
        {
            return ((DynamicBaseType)obj).GetPropertyValue(_name);
        }
 
        public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
        {
            ((DynamicBaseType)obj).SetPropertyValue(_name, value);
        }
 
        public override Type PropertyType
        {
            get { return _type; }
        }
 
        public override Type DeclaringType
        {
            get { throw new NotImplementedException(); }
        }
 
        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return _attributes == null ? new object[0] : _attributes.Where(a => a.GetType() == attributeType).ToArray();
        }
 
        public override object[] GetCustomAttributes(bool inherit)
        {
            return _attributes == null ? new object[0] : _attributes.ToArray();
        }
 
        public override bool IsDefined(Type attributeType, bool inherit)
        {
            throw new NotImplementedException();
        }
 
        public override string Name
        {
            get { return _name; }
        }
 
        public override Type ReflectedType
        {
            get { throw new NotImplementedException(); }
        }
    }
 
    private interface IDependantCustomPropertyInfo
    {
        string Name { get; }
        string[] Properties { get; }
    }
 
    private class CustomPropertyInfo<V> : CustomPropertyInfo, IDependantCustomPropertyInfo
    {
        private Func<T, V> _get;
        private Action<T, V> _set;
        private string[] _properties;
 
        public CustomPropertyInfo(string name, Func<T, V> get, Action<T, V> set = null, List<Attribute> attributes = null, string[] properties = null)
            : base(name, typeof(V), attributes)
        {
            _get = get;
            _set = set;
            _properties = properties;
        }
 
        public string[] Properties
        {
            get { return _properties; }
        }
 
        public override object GetDefaultValue(DynamicBaseType entity)
        {
            return _get((T)entity);
        }
 
        public override bool CanWrite
        {
            get { return _set != null; }
        }
 
        public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
        {
            return _get((T)obj);
        }
 
        public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, System.Globalization.CultureInfo culture)
        {
            if (_set == null)
                throw new InvalidOperationException();
            _set((T)obj, (V)value);
        }
    }
}

Que je peux utiliser très facilement.

Avec ma classe Customer par exemple :

public class Customer : DynamicBaseType<Customer>
{
    private String firstName;
    public String FirstName
    {
        get { return firstName; }
        set
        {
            firstName = value;
            OnPropertyChanged("FirstName");
        }
    }
 
    private String lastName;
    public String LastName
    {
        get { return lastName; }
        set
        {
            lastName = value;
            OnPropertyChanged("LastName");
        }
    }
}

Dans le ViewModel, je peux désormais utiliser le code suivant :

Customer.AddProperty("Age", typeof(int));
Customer.AddProperty("Married", typeof(bool));
Customer.AddProperty("FullName", c => string.Format("{0} {1}", c.LastName, c.FirstName), properties:new string[] { "LastName", "FirstName" });
 
customers[0].SetPropertyValue("Age", 40);
customers[0].SetPropertyValue("Married", true);
 
customers[1].SetPropertyValue("Age", 45);
customers[1].SetPropertyValue("Married", true);

Ce qui est nouveau dans ma solution par rapport au code de départ c’est que FullName est calculé à partir de d’autres propriétés. Si on change la propriété LastName ou FirstName d’un Customer, celui-ci lèvera également l’évènement PropertyChanged avec FullName.

Posté le lundi 12 septembre 2011 23:58 par Matthieu MEZIL | 0 commentaire(s)

Utiliser un repository depuis WF

Imaginons le repository suivant :

public class FooRepository
{
    public void Add(FooEntity entity) { /*TODO*/ }
    public void Update(FooEntity entity) { /*TODO*/ }
    public void Delete(FooEntityentity) { /*TODO*/ }
    public void SaveChanges() { /*TODO*/ }
    public void Dispose() { /*TODO*/ }
}

L’idée est de l’utiliser dans un contexte Workflow.

Pour cela j’utilise un WCF workflow service.

Le receive de la méthode GetFooEntity retourne une instance de FooEntity que j’affecte ensuite dans la variable fooEntity du type FooEntity.

Imaginons qu’entre le Receive et le SendReply, je veuille ajouter une instance de fooEntity en utilisant mon repository, puis persister mon repository et enfin le disposer.

On peut le faire en instanciant et initialisant une variable de type FooRepository et en utilisant des activités de type InvokeMethod :

Comme vous pouvez le voir, c’est un peu pénible…

Mon idée est donc de définir une activité RepositoryScope pour simplifier cela.

Tout d’abord, nous allons créer une interface IRepository que ma classe FooRepository va implémenter :

public interface IRepository : IDisposable
{
     void Add(object entity);
     void Update(object entity);
     void Delete(object entity);
     void SaveChanges();
}
 
public class FooRepository : IRepository
{
     public void Add(FooEntity entity) { /*TODO*/ }
     public void Update(FooEntity entity) { /*TODO*/ }
     public void Delete(FooEntity entity) { /*TODO*/ }
     public void SaveChanges() { /*TODO*/ }
     public void Dispose() { /*TODO*/ }

 
     void IRepository.Add(object entity)
     {
         Add((FooEntity)entity);
     }
     void IRepository.Update(object entity)
     {
         Update((FooEntity)entity);
     }
     void IRepository.Delete(object entity)
     {
         Delete((FooEntity)entity);
     }
}

Maintenant, nous allons définir notre activité RepositoryScope qui hérite de NativeActivity.

Dans le RepositoryScope, il faudrait être capable d’ajouter plusieurs entités. Pour cela, on pourrait utiliser une propriété de type Activity et utiliser une séquence mais autant directement utiliser une collection d’activité.

public class RepositoryScope<RepositoryType> : NativeActivity
     where RepositoryType : IRepository, new()
{
     private Collection<Activity> _activities;
     public Collection<Activity> Activities
     {
         get { return _activities ?? (_activities = new Collection<Activity>()); }
     }
 
     protected override void Execute(NativeActivityContext context)
     {
         // TODO
     }
}

Maintenant la première question est : comment renseigner cette propriété dans le designer ? Pour cela, nous allons définir notre propre ActivityDesigner et ajouter l’attribut Designer dans notre classe RepositoryScope<RepositoryType>.

[Designer(typeof(RepositoryScopeDesigner))]
 
 

<sap:ActivityDesigner x:Class="MyNamespace.RepositoryScopeDesigner"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:sap="clr-namespace:System.Activities.Presentation;assembly=System.Activities.Presentation"

    xmlns:sapv="clr-namespace:System.Activities.Presentation.View;assembly=System.Activities.Presentation">

    <sap:ActivityDesigner.Resources>

        <Style TargetType="sap:WorkflowItemsPresenter">

            <Setter Property="SpacerTemplate">

                <Setter.Value>

                    <DataTemplate>

                        <Rectangle Height="1"

                                   Stroke="Gray"

                                   Width="50"

                                   Margin="0,10,0,10" />

                    </DataTemplate>

                </Setter.Value>

            </Setter>

            <Setter Property="ItemsPanel">

                <Setter.Value>

                    <ItemsPanelTemplate>

                        <StackPanel Orientation="Vertical" />

                    </ItemsPanelTemplate>

                </Setter.Value>

            </Setter>

        </Style>

    </sap:ActivityDesigner.Resources>

    <Grid>

        <sap:WorkflowItemsPresenter Items="{Binding Path=ModelItem.Activities}"

                                    HintText="Insert Activities Here" />

    </Grid>

</sap:ActivityDesigner>

Ensuite, on peut maintenant l’utiliser comme ceci :

Maintenant notre activité ScopeRepository doit scheduler ses activités. La manière la plus aisée est d’utiliser une séquence, de la scheduler dans la méthode Execute, de les retirer les activités des metadatas, de les ajouter dans la séquence et d’ajouter la Sequence dans les enfants de l’activité :

[Designer(typeof(RepositoryScopeDesigner))]
public class RepositoryScope<RepositoryType> : NativeActivity
     where RepositoryType : IRepository, new()
{
     private Collection<Activity> _activities;
     public Collection<Activity> Activities
     {
         get { return _activities ?? (_activities = new Collection<Activity>()); }
     }

 
     private Sequence _scopeSequence;
     private Sequence ScopeSequence
     {
         get { return _scopeSequence ?? (_scopeSequence = new Sequence()); }
     }
 
     protected override void Execute(NativeActivityContext context)
     {
         context.ScheduleActivity(ScopeSequence);
    }
 
     protected override void CacheMetadata(NativeActivityMetadata metadata)
     {
         base.CacheMetadata(metadata);
         metadata.SetChildrenCollection(null);
        foreach (Activity activity in Activities)
             ScopeSequence.Activities.Add(activity);
        metadata.AddChild(ScopeSequence);
    }
}

Notez que le metadata.SetChildrenCollection(null) est obligatoire pour les affecter à la séquence.

Maintenant l’idée est d’utiliser ce scope pour faire plus que ce que ne fait déjà la séquence. Le scope va instancier le repository et va le disposer à la fin. Nous allons également utiliser un bloc Try / Finally pour disposer le repository quoi qu’il arrive.

[Designer(typeof(RepositoryScopeDesigner))]
public class RepositoryScope<RepositoryType> : NativeActivity
     where RepositoryType : IRepository, new()
{
     public OutArgument<RepositoryType> Repository { get; set; }

 
     private Collection<Activity> _activities;
     public Collection<Activity> Activities
     {
         get { return _activities ?? (_activities = new Collection<Activity>()); }
     }
 
     private Sequence _scopeSequence;
     private Sequence ScopeSequence
     {
         get { return _scopeSequence ?? (_scopeSequence = new Sequence()); }
     }
 
     private TryCatch _tryCatch;
     private TryCatch TryCatch
     {
         get { return _tryCatch ?? (_tryCatch = new TryCatch()); }
     }
 
     private Activity _finallyActivity;
     public Activity FinallyActivity
     {
         get { return _finallyActivity ?? (_finallyActivity = new DisposeActivity()); }
     }
 
     protected override void Execute(NativeActivityContext context)
     {
         var repo = new RepositoryType();
         Repository.Set(context, repo);
        context.ScheduleActivity(TryCatch);
     }
 
     protected override void CacheMetadata(NativeActivityMetadata metadata)
     {
         metadata.AddChild(FinallyActivity);
         base.CacheMetadata(metadata);
         metadata.SetChildrenCollection(null);
         foreach (Activity activity in Activities)
             ScopeSequence.Activities.Add(activity);
         TryCatch.Try = ScopeSequence;
         TryCatch.Finally = FinallyActivity;
         metadata.AddChild(TryCatch);
     }
}

C’est un bon début mais encore faudrait-il que l’activité DisposeActivity connaisse le repository.

On pourrait utiliser un InArgument<IRepository>, cependant, il y a un meilleur moyen avec les NativeActivity : utiliser la propriété Properties. En effet, les instances contenues dans la propriété Properties sont partagées entre l’activité et ses descendants.

Nous pouvons donc procéder comme ceci :

[Designer(typeof(RepositoryScopeDesigner))]
public class RepositoryScope<RepositoryType> : NativeActivity
     where RepositoryType : IRepository, new()
{
     public OutArgument<RepositoryType> Repository { get; set; }
 
     private Collection<Activity> _activities;
     public Collection<Activity> Activities
     {
         get { return _activities ?? (_activities = new Collection<Activity>()); }
     }
 
     private Sequence _scopeSequence;
     private Sequence ScopeSequence
     {
         get { return _scopeSequence ?? (_scopeSequence = new Sequence()); }
     }
 
     private TryCatch _tryCatch;
     private TryCatch TryCatch
     {
         get { return _tryCatch ?? (_tryCatch = new TryCatch()); }
     }
 
     private DisposeActivity _disposeActivity;
     public Activity DisposeActivity
     {
         get { return _disposeActivity ?? (_disposeActivity = new DisposeActivity()); }
     }
 
     protected override void Execute(NativeActivityContext context)
     {
         var repo = new RepositoryType();
         Repository.Set(context, repo);
         context.Properties.Add("Repository", repo);
        context.ScheduleActivity(TryCatch);
     }
 
     protected override void CacheMetadata(NativeActivityMetadata metadata)
     {
         base.CacheMetadata(metadata);
         metadata.SetChildrenCollection(null);
         foreach (Activity activity in Activities)
             ScopeSequence.Activities.Add(activity);
         TryCatch.Try = ScopeSequence;
         TryCatch.Finally = DisposeActivity;
         metadata.AddChild(TryCatch);
     }
}



 
internal class DisposeActivity : NativeActivity
{
     protected override void Execute(NativeActivityContext context)
     {
         ((IRepository)context.Properties.Find("Repository")).Dispose();
    }
}

Cool ! Maintenant, nous n’avons plus besoin d’initialiser la variable fooRepository que nous allons récupérer comme OutArgument de notre RepositoryScope. Nous n’avons plus besoin de l’InvokeMethod sur Dispose (puisque le RepositoryScope s’en charge désormais).

A présent nous allons améliorer l’utilisation du RepositoryScope.

Tout d’abord, je ne pense pas qu’il soit souhaitable de passer la méthode à appeler sous la forme d’une string.

Nous allons donc créer des activités AddEntity, UpdateEntity, DeleteEntity et SaveChanges que nous allons utiliser dans le workflow.

public class AddEntity : NativeActivity
{
     [RequiredArgument]
     public InArgument<IRepository> Repository { get; set; }
 
     [RequiredArgument]
     public InArgument<object> Entity { get; set; }
 
     protected override void Execute(NativeActivityContext context)
     {
         Repository.Get(context).Add(Entity.Get(context));
     }
}
 
public class SaveChanges : NativeActivity
{
     [RequiredArgument]
     public InArgument<IRepository> Repository { get; set; }
 
     protected override void Execute(NativeActivityContext context)
     {
         Repository.Get(context).SaveChanges();
     }
}

Maintenant l’idée est de définir l’argument Repository optionnel et de le déduire, dans ce cas, du RepositoryScope parent en utilisant la propriété Properties, comme nous avons fait avec la DisposeActivity :

public abstract class RepositoryActivity : NativeActivity
{
     public InArgument<IRepository> Repository { get; set; }
 
     protected virtual IRepository GetRepository(NativeActivityContext context)
     {
         IRepository repo = Repository.Get(context);
         if (repo == null)
             repo = ((IRepository)context.Properties.Find("Repository"));
         return repo;
     }
}
 
public class AddEntity : RepositoryActivity
{
     [RequiredArgument]
     public InArgument<object> Entity { get; set; }
 
     protected override void Execute(NativeActivityContext context)
     {
         GetRepository(context).Add(Entity.Get(context));
     }
}
 
public class SaveChanges : RepositoryActivity
{
     protected override void Execute(NativeActivityContext context)
     {
         GetRepository(context).SaveChanges();
     }
}
 
internal class DisposeActivity : RepositoryActivity
{
     protected override void Execute(NativeActivityContext context)
     {
         GetRepository(context).Dispose();
     }
}

Maintenant il va y avoir un point à prendre en compte : être capable de gérer l’encapsulation d’un RepositoryScope par un autre RepositoryScope. Pour cela, notre propriété “Repository” n’est pas suffisante.

Il va donc falloir changer notre code et nous allons utiliser une Stack<IRepository> à la place.

Dans notre code, on peut regretter la manière d’utiliser la properties “Repository”. Même s’il serait mieux d’utiliser une constante à la place de "Repository", ça reste pas terrible selon moi, et, de plus, c’est dommage de devoir faire un cast. Selon moi, on devrait utiliser des variables typés à la place.

Pour cela nous allons utiliser une nouvelle classe :

public class RepositoryContext
{
     private Stack<IRepository> _repositories;
     public Stack<IRepository> Repositories
     {
         get { return _repositories ?? (_repositories = new Stack<IRepository>()); }
     }
 
     public static RepositoryContext GetContext(NativeActivityContext context)
     {
         return (RepositoryContext)context.Properties.FirstOrDefault(kv => kv.Key == typeof(RepositoryContext).Name).Value;
     }
 
     public static RepositoryContext CreateContext(NativeActivityContext context)
     {
         RepositoryContext c = new RepositoryContext();
         context.Properties.Add(typeof(RepositoryContext).Name, c);
         return c;
     }
 
     public static RepositoryContext GetOrCreateContext(NativeActivityContext context)
     {
         return GetContext(context) ?? CreateContext(context);
     }
}

Maintenant dans la méthode Execute de notre RespositoryScope, nous allons l’initialiser comme ceci :

RepositoryContext.CreateContext(context).Repositories.Push(repo);

à la place de

context.Properties.Add("Repository", repo);

Dans les RepositoryActivity, nous allons l’utiliser comme ceci :

repo = RepositoryContext.GetContext(context).Repositories.Peek();

au lieu de

repo = ((IRepository)context.Properties.Find("Repository"));

Dans le Dispose, nous allons dépiler notre pile:

internal class DisposeActivity : RepositoryActivity
{
     protected override void Execute(NativeActivityContext context)
     {
         GetRepository(context).Dispose();
         RepositoryContext.GetContext(context).Repositories.Pop();
     }
}

Je trouve cela beaucoup mieux et je pourrais vouloir reproduire ce fonctionnement dans d’autre cas, d’où l’idée de le factoriser au maximum.

Je vais donc utiliser une classe de base :

public class WFPropertiesContext<T> 
     where T : WFPropertiesContext<T>, new()
{
     public static T GetContext(NativeActivityContext context)
     {
         return (T)context.Properties.FirstOrDefault(kv => kv.Key == typeof(T).Name).Value;
     }
 
     public static T CreateContext(NativeActivityContext context)
     {
         T c = new T();
         c.Initialize(context);
         context.Properties.Add(typeof(T).Name, c);
         return c;
     }
 
     public static T GetOrCreateContext(NativeActivityContext context)
     {
         return GetContext(context) ?? CreateContext(context);
     }
 
     protected virtual void Initialize(NativeActivityContext context)
     {
     }
}
 
public class RepositoryContext : WFPropertiesContext<RepositoryContext>
{
     private Stack<IRepository> _repositories;
     public Stack<IRepository> Repositories
     {
         get { return _repositories ?? (_repositories = new Stack<IRepository>()); }
     }
}

Posté le jeudi 1 septembre 2011 23:59 par Matthieu MEZIL | 2 commentaire(s)

EF et récursivité

A travers ce post, je vais vous présenter un cas concret de mauvaise utilisation d’EF observée récemment chez un client.

Mon modèle est le suivant :

Nous voulons simplement récupérer un arbre avec une contrainte : si le type du noeud est "G" et qu’il n’a pas d’enfant, il ne doit pas apparaître dans l’arborescence.

Comment faire ceci.

Voici le code que j’ai pu observer :

public static List<Node> GetTree()
{
     using (var context = new TreeEntities()) 
     { 
         List<Node> nodes = context.Nodes.Where(n => n.Parent == null).ToList();
         foreach (var n in nodes)
             LoadChildren(context, n);
         foreach (var n in nodes.Where(n => n.Type == "G" && n.Children.Count == 0).ToList())
             nodes.Remove(n);
         return nodes;
     }
}
 
public static void LoadChildren(TreeEntities context, Node parentNode)
{
     List<Node> nodes = context.Nodes.Where(n => n.ParentId == parentNode.Id).ToList();
     foreach (var n in nodes)
         LoadChildren(context, n);
     foreach (var n in nodes.Where(n => n.Type == "G" && n.Children.Count == 0).ToList())
         context.Nodes.Detach(n);
}

J’ai effectué un test avec le jeu d’entités suivant :

using (var context = new TreeEntities())
{
     for (int i0 = 0; i0 < 10; i0++)
     {
         Node n0 = new Node { Name = i0.ToString(), Type = i0 == 9 ? null : "G" };
         context.Nodes.AddObject(n0);
         if (i0 > 7)
             break;
         for (int i1 = 0; i1 < 10; i1++)
         {
             Node n1 = new Node { Name = n0.Name + i1.ToString(), Type = i1 == 9 ? null : "G", Parent = n0 };
             context.Nodes.AddObject(n1);
             if (i1 > 7)
                 break;
             for (int i2 = 0; i2 < 10; i2++)
             {
                 Node n2 = new Node { Name = n1.Name + i2.ToString(), Type = i2 == 9 ? null : "G", Parent = n1 };
                 context.Nodes.AddObject(n2);
                 if (i2 > 7)
                     break;
                 for (int i3 = 0; i3 < 10; i3++)
                 {
                     Node n3 = new Node { Name = n2.Name + i3.ToString(), Type = i3 == 9 ? null : "G", Parent = n2 };
                     context.Nodes.AddObject(n3);
                     if (i3 > 7)
                         break;
                     for (int i4 = 0; i4 < 10; i4++)
                         context.Nodes.AddObject(new Node { Name = n3.Name + i4.ToString(), Parent = n3 });
                 }
             }
         }
     }
     context.SaveChanges();
}

Pour cette première version, ce code s’exécute en 5 minutes 41 secondes et génère 46 226 requêtes en base !

Il n’y a pas besoin d’être DBA pour savoir que si le nombre de requêtes dépend du nombre de datarows, le code ne supporte pas la charge.

Comment améliorer les choses ?

Un des gros avantages d’EF est le fait qu’il fait tout seul les relations. C’est d’ailleurs pour cela que ce code fonctionne. A aucun moment on a affecté les enfants / parents d’un des noeuds. EF l’a fait pour nous.

On pourrait être tenter par le code suivant :

public static List<Node> GetTree()
{
    using (var context = new TreeEntities()) 
    { 

       return context.Nodes.Where(n => n.Type != "G" || n.Children.Any()).AsEnumerable().Where(n => n.ParentId == null).ToList();
    }
}

Petite remarque avant de continuer : attention à bien utiliser ParentId != null et pas Parent != null. En effet, au moment où on énumère sur les entités, rien ne nous indique que le parent a bien été chargé. Si ce n’est pas le cas, ParentId sera différent de null alors que Parent sera égal à null.

D’autre part, ce code ne fonctionne pas comme il devrait. En effet, si j’ai un noeud de type G avec un enfant de type G sans enfant, le premier noeud doit être supprimé puisque son seul enfant doit être supprimé. Or avec mon système à un seul niveau, ce ne sera pas le cas.

SQL n’est cependant pas réputé pour la récursivité.

Je vais donc tenter deux approches :

• une première dans laquelle je vais faire cette récursivité dans mon code. A noter que cela implique de charger trop d’entités (comme c’est le cas avec la première version).
• une deuxième dans laquelle c’est SQL Server qui va se charger de la récursivité

Ma première solution est la suivante :

public static IEnumerable<T> GetEntitiesInCache<T>(this ObjectContext context, EntityState entityState = EntityState.Unchanged | EntityState.Modified | EntityState.Added)
{
    return context.ObjectStateManager.GetObjectStateEntries(entityState).Select(ose => ose.Entity).OfType<T>();
}
 
public static List<Node> GetTree(TreeEntities context)
{
    using (var context = new TreeEntities()) 
    {
       foreach (var n in context.Nodes);
 
       bool continueLoop;
       do
       {
           continueLoop = false;
           foreach (var n in context.GetEntitiesInCache<Node>().Where(n => n.Type == "G" && n.Children.Count == 0).ToList())
           {
               continueLoop = true;
               context.Nodes.Detach(n);
           }
       } while (continueLoop);
 
       return context.GetEntitiesInCache<Node>().Where(n => n.ParentId == null).ToList();
   }
}

Dans ce cas, je suis passé de plus de 5 minutes 41 secondes à 1 seconde avec une seule requête exécutée en base.

A noter que je travaille avec une base locale. Dans le cas contraire l’écart de temps aurait été encore plus important.

Remarquez également le

       foreach (var n in context.Nodes);

qui permet de charger l’ensemble des noeuds.

Pour la récursivité avec SQL server, cela fera l’objet d’un post futur.

Posté le jeudi 28 juillet 2011 21:02 par Matthieu MEZIL | 3 commentaire(s)

EF nouvelle CTP

Une nouvelle CTP d’EF et de WCF Data Services est disponible.

Contrairement aux CTPs précédentes qui se concentraient essentiellement sur l’ajout d’une nouvelle approche, Code-First, celle-ci apporte des améliorations sur le moteur même d’Entity Framework.

• le support des enums
• le support des types spatial
• le support des Table Valued Functions
• le support des multi result sets dans le résultat des procédures stockées
• des améliorations dans la génération du SQL avec le TPT
• la possibilité (par défaut) de compiler et mettre en cache automatiquement les requêtes LINQ

Le designer a également eu droit à son lot de nouveautés / améliorations :

• le support des enums, types spatial et Table Valued Functions
• la possibilité d’avoir plusieurs diagrammes du même edmx avec les petites options qui vont bien pour intégrer les entités liées par exemple
• la possibilité de choisir la couleur de chaque entité
• Le report automatique du StoreGeneratedPattern du CSDL dans le SSDL
• La possibilité d’importer les procédures stockées dans le CSDL directement lors de l’import depuis la base
• L’amélioration de l’association visuelle entre association et navigation properties
• La possibilité d’externaliser dans un fichier séparé les infos relatives aux diagrammes, ce qui a le mérite de simplifier considérablement les problématiques de merge d’edmx avec un contrôleur de sources.

Mes tests m’ont amené à identifier un bug avec les Table Valued Functions : il n’est pas possible, dans la version actuelle, de placer le résultat d’une Table Valued Functions dans un let.

Plus d’info sur Announcing the Microsoft Entity Framework June 2011 CTP.

Posté le vendredi 1 juillet 2011 02:07 par Matthieu MEZIL | 4 commentaire(s)

L2E : impact sur le SQL

Comme je l’écrivais hier,

“Derrière la magie d’Entity Framework se cache la réalité du SQL. Je persiste et je signe, si vous ne connaissez pas le SQL, il sera très compliqué d’écrire des requêtes L2E optimales.

J’ai trouvé une bonne illustrations avec les fonctions de grouping.”

Hier, je vous ai montré comment exécuter un Count et un Max en une seule requête LINQ.

Maintenant imaginons que je veuille toujours récupérer le nombre de commandes et la date de la dernière commande mais par client.

Comment récupérer cela?

Si vous êtes sûr que chaque client à au moins une commande ou que vous voulez ignorer les clients sans commande, la meilleure façon d’écrire cette requête est probablement celle-ci:

from o in context.Orders
group o by o.Customer into g
select new { Customer = g.Key, OrdersCount = g.Count(), LastOrderDate = g.Max(o => o.OrderDate) };

Dans ce cas, le SQL est très proche de celui de la requête L2E :

SELECT

[GroupBy1].[K1] AS [CustomerId],

[GroupBy1].[K2] AS [LastName],

[GroupBy1].[K3] AS [FirstName],

[GroupBy1].[K4] AS [BirthDay],

[GroupBy1].[K5] AS [AddressLine],

[GroupBy1].[K6] AS [City],

[GroupBy1].[K7] AS [PostalCode],

[GroupBy1].[K8] AS [Region],

[GroupBy1].[K9] AS [Country],

[GroupBy1].[A1] AS [C1],

[GroupBy1].[A2] AS [C2]

FROM ( SELECT

[Extent2].[CustomerId] AS [K1],

[Extent2].[LastName] AS [K2],

[Extent2].[FirstName] AS [K3],

[Extent2].[BirthDay] AS [K4],

[Extent2].[AddressLine] AS [K5],

[Extent2].[City] AS [K6],

[Extent2].[PostalCode] AS [K7],

[Extent2].[Region] AS [K8],

[Extent2].[Country] AS [K9],

COUNT(1) AS [A1],

MAX([Extent1].[OrderDate]) AS [A2]

FROM [dbo].[Orders] AS [Extent1]

INNER JOIN [dbo].[Customers] AS [Extent2] ON [Extent1].[CustomerId] = [Extent2].[CustomerId]

GROUP BY [Extent2].[CustomerId], [Extent2].[LastName], [Extent2].[FirstName], [Extent2].[BirthDay], [Extent2].[AddressLine], [Extent2].[City], [Extent2].[PostalCode], [Extent2].[Region], [Extent2].[Country]

) AS [GroupBy1]

Avec un plan d’exécution assez simple :

Si vous pouvez avoir des clients sans commandes, la requêtes devient plus compliquée.

Une idée assez simple serait d’utiliser la requête précédente union les clients sans commandes :

(from o in context.Orders
 group o by o.Customer into g
 select new { Customer = g.Key, OrdersCount = g.Count(), LastOrderDate = (DateTime?)g.Max(o => o.OrderDate) }).Union(
from c in context.Customers
where !c.Orders.Any()
select new { Customer = c, OrdersCount = 0, LastOrderDate = (DateTime?)null });

Dans ce cas, la requête SQL n’est pas performante :

SELECT

[Distinct1].[C1] AS [C1],

[Distinct1].[C2] AS [C2],

[Distinct1].[C3] AS [C3],

[Distinct1].[C4] AS [C4],

[Distinct1].[C5] AS [C5],

[Distinct1].[C6] AS [C6],

[Distinct1].[C7] AS [C7],

[Distinct1].[C8] AS [C8],

[Distinct1].[C9] AS [C9],

[Distinct1].[C10] AS [C10],

[Distinct1].[C11] AS [C11],

[Distinct1].[C12] AS [C12]

FROM ( SELECT DISTINCT

[UnionAll1].[C1] AS [C1],

[UnionAll1].[CustomerId] AS [C2],

[UnionAll1].[LastName] AS [C3],

[UnionAll1].[FirstName] AS [C4],

[UnionAll1].[BirthDay] AS [C5],

[UnionAll1].[AddressLine] AS [C6],

[UnionAll1].[City] AS [C7],

[UnionAll1].[PostalCode] AS [C8],

[UnionAll1].[Region] AS [C9],

[UnionAll1].[Country] AS [C10],

[UnionAll1].[C2] AS [C11],

[UnionAll1].[C3] AS [C12]

FROM (SELECT

1 AS [C1],

[GroupBy1].[K1] AS [CustomerId],

[GroupBy1].[K2] AS [LastName],

[GroupBy1].[K3] AS [FirstName],

[GroupBy1].[K4] AS [BirthDay],

[GroupBy1].[K5] AS [AddressLine],

[GroupBy1].[K6] AS [City],

[GroupBy1].[K7] AS [PostalCode],

[GroupBy1].[K8] AS [Region],

[GroupBy1].[K9] AS [Country],

[GroupBy1].[A1] AS [C2],

CAST( [GroupBy1].[A2] AS datetime2) AS [C3]

FROM ( SELECT

[Extent2].[CustomerId] AS [K1],

[Extent2].[LastName] AS [K2],

[Extent2].[FirstName] AS [K3],

[Extent2].[BirthDay] AS [K4],

[Extent2].[AddressLine] AS [K5],

[Extent2].[City] AS [K6],

[Extent2].[PostalCode] AS [K7],

[Extent2].[Region] AS [K8],

[Extent2].[Country] AS [K9],

COUNT(1) AS [A1],

MAX([Extent1].[OrderDate]) AS [A2]

FROM [dbo].[Orders] AS [Extent1]

INNER JOIN [dbo].[Customers] AS [Extent2] ON [Extent1].[CustomerId] = [Extent2].[CustomerId]

GROUP BY [Extent2].[CustomerId], [Extent2].[LastName], [Extent2].[FirstName], [Extent2].[BirthDay], [Extent2].[AddressLine], [Extent2].[City], [Extent2].[PostalCode], [Extent2].[Region], [Extent2].[Country]

) AS [GroupBy1]

UNION ALL

SELECT

1 AS [C1],

[Extent3].[CustomerId] AS [CustomerId],

[Extent3].[LastName] AS [LastName],

[Extent3].[FirstName] AS [FirstName],

[Extent3].[BirthDay] AS [BirthDay],

[Extent3].[AddressLine] AS [AddressLine],

[Extent3].[City] AS [City],

[Extent3].[PostalCode] AS [PostalCode],

[Extent3].[Region] AS [Region],

[Extent3].[Country] AS [Country],

0 AS [C2],

CAST(NULL AS datetime2) AS [C3]

FROM [dbo].[Customers] AS [Extent3]