Development With A Dot

Intercepting LINQ Queries

2013-05-23T09:03:11Z

A common request when working with LINQ queries (Entity Framework, NHibernate, etc) is the ability to intercept them, that is, inspect an existing query and possibly modify something in it. This is not extremely difficult to do “by hand”, but Microsoft has a nice class called ExpressionVisitor which makes the job easier. It basically has virtual methods that get called whenever the class visits each expression contained in a greater expression, which may come from a query (the IQueryable interface exposes the underlying Expression in its Expression property). The virtual methods even allow returning a replacement for each expression found, the only problem is that you must subclass ExpressionVisitor to make even the slightest change, so I wrote my own class, which exposes all node traversal as events, one event for each kind of expression, where you can return an alternative expression, thus changing the original query. Here is the code for it:

        1: public sealed class ExpressionInterceptor : ExpressionVisitor

       2: {

       3:     #region Public events

       4:     public event Func<BinaryExpression, BinaryExpression> Binary;

       5:     public event Func<BlockExpression, BlockExpression> Block;

       6:     public event Func<CatchBlock, CatchBlock> CatchBlock;

       7:     public event Func<ConditionalExpression, ConditionalExpression> Conditional;

       8:     public event Func<ConstantExpression, ConstantExpression> Constant;

       9:     public event Func<DebugInfoExpression, DebugInfoExpression> DebugInfo;

    public event Func<DefaultExpression, DefaultExpression> Default;

    public event Func<DynamicExpression, DynamicExpression> Dynamic;

    public event Func<ElementInit, ElementInit> ElementInit;

    public event Func<Expression, Expression> Expression;

    public event Func<Expression, Expression> Extension;

    public event Func<GotoExpression, GotoExpression> Goto;

    public event Func<IndexExpression, IndexExpression> Index;

    public event Func<InvocationExpression, InvocationExpression> Invocation;

    public event Func<LabelExpression, LabelExpression> Label;

    public event Func<LabelTarget, LabelTarget> LabelTarget;

    public event Func<LambdaExpression, LambdaExpression> Lambda;

    public event Func<ListInitExpression, ListInitExpression> ListInit;

    public event Func<LoopExpression, LoopExpression> Loop;

    public event Func<MemberExpression, MemberExpression> Member;

    public event Func<MemberAssignment, MemberAssignment> MemberAssignment;

    public event Func<MethodCallExpression, MethodCallExpression> MethodCall;

    public event Func<MemberInitExpression, MemberInitExpression> MemberInit;

    public event Func<NewExpression, NewExpression> New;

    public event Func<NewArrayExpression, NewArrayExpression> NewArray;

    public event Func<ParameterExpression, ParameterExpression> Parameter;

    public event Func<RuntimeVariablesExpression, RuntimeVariablesExpression> RuntimeVariables;

    public event Func<SwitchExpression, SwitchExpression> Switch;

    public event Func<TryExpression, TryExpression> Try;

    public event Func<TypeBinaryExpression, TypeBinaryExpression> TypeBinary;

    public event Func<UnaryExpression, UnaryExpression> Unary;

    #endregion

  

    #region Public methods

    public IQueryable<T> Visit<T>(IQueryable<T> query)

    {

        return (this.Visit(query as IQueryable) as IQueryable<T>);

    }

  

    public IQueryable<T> Visit<T, TExpression>(IQueryable<T> query, Func<TExpression, TExpression> action) where TExpression : Expression

    {

        EventInfo evt = this.GetType().GetEvents(BindingFlags.Public | BindingFlags.Instance).Where(x => x.EventHandlerType == typeof(Func<TExpression, TExpression>)).First();

        evt.AddEventHandler(this, action);

  

        query = this.Visit(query);

  

        evt.RemoveEventHandler(this, action);

  

        return (query);

    }

  

    public IQueryable Visit(IQueryable query)

    {

        return (query.Provider.CreateQuery(this.Visit(query.Expression)));

    }

  

    public IEnumerable<Expression> Flatten(IQueryable query)

    {

        Queue<Expression> list = new Queue<Expression>();

        Func<Expression, Expression> action = delegate(Expression expression)

        {

            if (expression != null)

            {

                list.Enqueue(expression);

            }

  

            return (expression);

        };

  

        this.Expression += action;

  

        this.Visit(query);

  

        this.Expression -= action;

  

        return (list);

    }

    #endregion

  

    #region Public override methods

    public override Expression Visit(Expression node)

    {

        if ((this.Expression != null) && (node != null))

        {

            return(base.Visit(this.Expression(base.Visit(node))));

        }

        else

        {

            return (base.Visit(node));

        }

    }

    #endregion

  

    #region Protected override methods

    protected override Expression VisitNew(NewExpression node)

    {

        if ((this.New != null) && (node != null))

        {

            return (base.VisitNew(this.New(node)));

        }

        else

        {

            return (base.VisitNew(node));

        }

    }

  

    protected override Expression VisitNewArray(NewArrayExpression node)

    {

        if ((this.NewArray != null) && (node != null))

        {

            return (base.VisitNewArray(this.NewArray(node)));

        }

        else

        {

            return (base.VisitNewArray(node));

        }

    }

  

    protected override Expression VisitParameter(ParameterExpression node)

    {

        if ((this.Parameter != null) && (node != null))

        {

            return (base.VisitParameter(this.Parameter(node)));

        }

        else

        {

            return (base.VisitParameter(node));

        }

    }

  

    protected override Expression VisitRuntimeVariables(RuntimeVariablesExpression node)

    {

        if ((this.RuntimeVariables != null) && (node != null))

        {

            return (base.VisitRuntimeVariables(this.RuntimeVariables(node)));

        }

        else

        {

            return (base.VisitRuntimeVariables(node));

        }

    }

  

    protected override Expression VisitSwitch(SwitchExpression node)

    {

        if ((this.Switch != null) && (node != null))

        {

            return (base.VisitSwitch(this.Switch(node)));

        }

        else

        {

            return (base.VisitSwitch(node));

        }

    }

  

    protected override Expression VisitTry(TryExpression node)

    {

        if ((this.Try != null) && (node != null))

        {

            return (base.VisitTry(this.Try(node)));

        }

        else

        {

            return (base.VisitTry(node));

        }

    }

  

    protected override Expression VisitTypeBinary(TypeBinaryExpression node)

    {

        if ((this.TypeBinary != null) && (node != null))

        {

            return (base.VisitTypeBinary(this.TypeBinary(node)));

        }

        else

        {

            return (base.VisitTypeBinary(node));

        }

    }

  

    protected override Expression VisitUnary(UnaryExpression node)

    {

        if ((this.Unary != null) && (node != null))

        {

            return (base.VisitUnary(this.Unary(node)));

        }

        else

        {

            return (base.VisitUnary(node));

        }

    }

  

    protected override Expression VisitMemberInit(MemberInitExpression node)

    {

        if ((this.MemberInit != null) && (node != null))

        {

            return (base.VisitMemberInit(this.MemberInit(node)));

        }

        else

        {

            return (base.VisitMemberInit(node));

        }

    }

  

    protected override Expression VisitMethodCall(MethodCallExpression node)

    {

        if ((this.MethodCall != null) && (node != null))

        {

            return (base.VisitMethodCall(this.MethodCall(node)));

        }

        else

        {

            return (base.VisitMethodCall(node));

        }

    }

  

    

    protected override Expression VisitLambda<T>(Expression<T> node)

    {

        if ((this.Lambda != null) && (node != null))

        {

            return (base.VisitLambda<T>(this.Lambda(node) as Expression<T>));

        }

        else

        {

            return (base.VisitLambda<T>(node));

        }

    }

  

    protected override Expression VisitBinary(BinaryExpression node)

    {

        if ((this.Binary != null) && (node != null))

        {

            return (base.VisitBinary(this.Binary(node)));

        }

        else

        {

            return (base.VisitBinary(node));

        }

    }

  

    protected override Expression VisitBlock(BlockExpression node)

    {

        if ((this.Block != null) && (node != null))

        {

            return (base.VisitBlock(this.Block(node)));

        }

        else

        {

            return (base.VisitBlock(node));

        }

    }

  

    protected override CatchBlock VisitCatchBlock(CatchBlock node)

    {

        if ((this.CatchBlock != null) && (node != null))

        {

            return (base.VisitCatchBlock(this.CatchBlock(node)));

        }

        else

        {

            return (base.VisitCatchBlock(node));

        }

    }

  

    protected override Expression VisitConditional(ConditionalExpression node)

    {

        if ((this.Conditional != null) && (node != null))

        {

            return (base.VisitConditional(this.Conditional(node)));

        }

        else

        {

            return (base.VisitConditional(node));

        }

    }

  

    protected override Expression VisitConstant(ConstantExpression node)

    {

        if ((this.Constant != null) && (node != null))

        {

            return (base.VisitConstant(this.Constant(node)));

        }

        else

        {

            return (base.VisitConstant(node));

        }

    }

  

    protected override Expression VisitDebugInfo(DebugInfoExpression node)

    {

        if ((this.DebugInfo != null) && (node != null))

        {

            return (base.VisitDebugInfo(this.DebugInfo(node)));

        }

        else

        {

            return (base.VisitDebugInfo(node));

        }

    }

  

    protected override Expression VisitDefault(DefaultExpression node)

    {

        if ((this.Default != null) && (node != null))

        {

            return (base.VisitDefault(this.Default(node)));

        }

        else

        {

            return (base.VisitDefault(node));

        }

    }

  

    protected override Expression VisitDynamic(DynamicExpression node)

    {

        if ((this.Dynamic != null) && (node != null))

        {

            return (base.VisitDynamic(this.Dynamic(node)));

        }

        else

        {

            return (base.VisitDynamic(node));

        }

    }

  

    protected override ElementInit VisitElementInit(ElementInit node)

    {

        if ((this.ElementInit != null) && (node != null))

        {

            return (base.VisitElementInit(this.ElementInit(node)));

        }

        else

        {

            return (base.VisitElementInit(node));

        }

    }

  

    protected override Expression VisitExtension(Expression node)

    {

        if ((this.Extension != null) && (node != null))

        {

            return (base.VisitExtension(this.Extension(node)));

        }

        else

        {

            return (base.VisitExtension(node));

        }

    }

  

    protected override Expression VisitGoto(GotoExpression node)

    {

        if ((this.Goto != null) && (node != null))

        {

            return (base.VisitGoto(this.Goto(node)));

        }

        else

        {

            return (base.VisitGoto(node));

        }

    }

  

    protected override Expression VisitIndex(IndexExpression node)

    {

        if ((this.Index != null) && (node != null))

        {

            return (base.VisitIndex(this.Index(node)));

        }

        else

        {

            return (base.VisitIndex(node));

        }

    }

  

    protected override Expression VisitInvocation(InvocationExpression node)

    {

        if ((this.Invocation != null) && (node != null))

        {

            return (base.VisitInvocation(this.Invocation(node)));

        }

        else

        {

            return (base.VisitInvocation(node));

        }

    }

  

    protected override Expression VisitLabel(LabelExpression node)

    {

        if ((this.Label != null) && (node != null))

        {

            return (base.VisitLabel(this.Label(node)));

        }

        else

        {

            return (base.VisitLabel(node));

        }

    }

  

    protected override LabelTarget VisitLabelTarget(LabelTarget node)

    {

        if ((this.LabelTarget != null) && (node != null))

        {

            return (base.VisitLabelTarget(this.LabelTarget(node)));

        }

        else

        {

            return (base.VisitLabelTarget(node));

        }

    }

  

    protected override Expression VisitListInit(ListInitExpression node)

    {

        if ((this.ListInit != null) && (node != null))

        {

            return (base.VisitListInit(this.ListInit(node)));

        }

        else

        {

            return (base.VisitListInit(node));

        }

    }

  

    protected override Expression VisitLoop(LoopExpression node)

    {

        if ((this.Loop != null) && (node != null))

        {

            return (base.VisitLoop(this.Loop(node)));

        }

        else

        {

            return (base.VisitLoop(node));

        }

    }

  

    protected override Expression VisitMember(MemberExpression node)

    {

        if ((this.Member != null) && (node != null))

        {

            return (base.VisitMember(this.Member(node)));

        }

        else

        {

            return (base.VisitMember(node));

        }

    }

  

    protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)

    {

        if ((this.MemberAssignment != null) && (node != null))

        {

            return (base.VisitMemberAssignment(this.MemberAssignment(node)));

        }

        else

        {

            return (base.VisitMemberAssignment(node));

        }

    }

    #endregion        

}

Yes, I know, I probably should have used properties instead of events, but that’s really not important.

A simple example might be:

       1: ExpressionInterceptor interceptor = new ExpressionInterceptor();

       2: String[] lettersArray = new String[] { "A", "B", "C" };    //a data source

       3: IQueryable<String> lettersQuery = lettersArray.AsQueryable().Where(x => x == "A").OrderByDescending(x => x).Select(x => x.ToUpper());    //a silly query

       4: IQueryable<String> lettersInterceptedQuery = interceptor.Visit<String, MethodCallExpression>(lettersQuery, x =>

       5: {

       6:     if (x.Method.Name == "ToUpper")

       7:     {

       8:         //change from uppercase to lowercase

       9:         x = Expression.Call(x.Object, typeof(String).GetMethods().Where(y => y.Name == "ToLower").First());

      10:     }

      11:  

      12:     return (x);

      13: });

      14: lettersInterceptedQuery = interceptor.Visit<String, BinaryExpression>(lettersInterceptedQuery, x =>

      15: {

      16:     //change from qual to not equal

      17:     x = Expression.MakeBinary(ExpressionType.NotEqual, x.Left, x.Right);

      18:  

      19:     return (x);

      20: });

      21: IEnumerable<Expression> lettersExpressions = interceptor.Flatten(lettersQuery);    //all expressions found

      22: IEnumerable<String> lettersList = lettersQuery.ToList();    //"A"

      23: IEnumerable<String> lettersInterceptedList = lettersInterceptedQuery.ToList();    //"c", "b"

You see, I have methods that visit both an IQueryable, an IQueryable<T> or an Expression, and there is even an inline version that takes a Func<TExpression, TExpression> for even easier usage.

As always, hope you find it useful!

Entity Framework Code First Fluent Validation

2013-05-09T18:56:09Z

Back to Entity Framework Code First (EFCF) validation. On my previous post I mentioned that EFCF did not support fluent validation. While this is true, it isn’t too hard to implement one such mechanism, which is exactly why I am writing this!

I will be using the SavingChanges event to inject the validation logic, which will be implemented by strongly typed delegates. Let’s see some code:

        1: public static class DbContextExtensions

       2: {

       3:     private static IDictionary<Type, Tuple<Delegate, String>> entityValidations = new ConcurrentDictionary<Type, Tuple<Delegate, String>>();

       4:  

       5:     public static void AddEntityValidation<TEntity>(this DbContext context, Func<TEntity, Boolean> validation, String message) where TEntity : class

       6:     {

       7:         if (context == null)

       8:         {

       9:             throw new ArgumentNullException("context");

        }

  

        if (validation == null)

        {

            throw new ArgumentNullException("validation");

        }

  

        if (String.IsNullOrWhiteSpace(message) == true)

        {

            throw new ArgumentNullException("message");

        }

  

        if (entityValidations.ContainsKey(typeof(TEntity)) == false)

        {

            (context as IObjectContextAdapter).ObjectContext.SavingChanges += delegate

            {

                if (context.Configuration.ValidateOnSaveEnabled == true)

                {

                    IEnumerable<TEntity> entities = context.ChangeTracker.Entries<TEntity>().Where(x => x.State == EntityState.Added || x.State == EntityState.Modified).Select(x => x.Entity).ToList();

  

                    foreach (TEntity entity in entities)

                    {

                        String error = ValidateEntity(entity);

  

                        if (String.IsNullOrWhiteSpace(error) == false)

                        {

                            throw (new ValidationException(error));

                        }

                    }

                }

            };

        }

  

        entityValidations[typeof(TEntity)] = new Tuple<Delegate, String>(validation, message);

    }

  

    private static String ValidateEntity<TEntity>(TEntity entity)

    {

        Type entityType = typeof(TEntity);

  

        if (entityValidations.ContainsKey(entityType) == true)

        {

            Tuple<Delegate, String> entry = entityValidations[entityType];

            Func<TEntity, Boolean> validation = entry.Item1 as Func<TEntity, Boolean>;

  

            if (validation(entity) == false)

            {

                return (entry.Item2);

            }

        }

  

        return (null);

    }

}

We have an extension method that allows declaring, for an entity type, a validation expression, such as this:

       1: ctx.AddEntityValidation<SomeEntity>(x => x.SomeProperty != null, "SomeProperty is required");

The validation will be fired when the SaveChanges method is called and the errors will be encapsulated in a ValidationException:

       1: try

       2: {

       3:     ctx.SaveChanges();

       4: }

       5: catch (ValidationException ex)

       6: {

       7:     //see content of ex.ValidationResult.ErrorMessage

       8: }

This code can certainly be improved – multiple validations per entity, property-based validations, etc – but I think it is good enough to illustrate my technique.

One final note: the fluent validation will only be fired if the ValidateOnSaveEnabled property is set to true, which is the default.

Entity Framework Code First Validation

2013-05-09T11:40:54Z

Introduction

Most persistence frameworks implement some kind of custom validation of entities before they are sent to the database. By custom I mean something more than just “is not null”, “has XX characters”, etc. This typically includes individual properties as well as validation of the entity as a whole – for example, checking that a property’s value is valid when used together with another property’s value.

Entity Framework Code First is no exception. Out of the box it already offers a number of possibilities for validating entities that cover typical scenarios: validation by attributes or by a validation method. One validation left out is one based on XML, but since Code First doesn’t really use XML, it should be no surprise, and the other is fluent validation, something that really should be supported.

Let’s explore each of these possibilities.

Overriding ValidateEntity

The DbContext class has a virtual method called ShouldValidateEntity that is called for each entity about to be persisted – meaning, inserted or updated –, and, when it returns true – which it does by default – will trigger a call to ValidateEntity, another virtual method. In this method, we have a chance to validate our entities any way we like. An example might be, for instance, checking if the entity to be saved implements IDataErrorInfo and extract validation information from this implementation:

        1: protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<Object, Object> items)

       2: {

       3:     DbEntityValidationResult result = base.ValidateEntity(entityEntry, items);

       4:     IDataErrorInfo dei = entityEntry.Entity as IDataErrorInfo;

       5:     

       6:     foreach (String propertyName in entityEntry.CurrentValues.PropertyNames)

       7:     {

       8:         String errorMessage = dei[propertyName];

       9:  

      10:         if (String.IsNullOrWhiteSpace(errorMessage) == false)

      11:         {

      12:             result.ValidationErrors.Add(new DbValidationError(propertyName, errorMessage));

      13:         }

      14:     }

      15:  

      16:     return (result);

      17: }

For the validation to occur, the ValidateOnSave property must be true, which it is by default.
Don’t forget to always call the base implementation!

Applying Validation Attributes

Another option, which also applies to ASP.NET MVC validation (see http://weblogs.asp.net/ricardoperes/archive/2012/06/03/asp-net-mvc-validation-complete.aspx) is using validation attributes, that is, attributes that inherit from ValidationAttribute. The base ValidateEntity method of DbContext also checks for these attributes, another reason why you should always call it. Let’s see an example:

       1: [Serializable]

       2: [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]

       3: public sealed class PositiveAttribute : ValidationAttribute

       4: {

       5:     protected override ValidationResult IsValid(Object value, ValidationContext validationContext)

       6:     {

       7:         Int64 longValue = Convert.ToInt64(value);

       8:  

       9:         if (longValue <= 0)

      10:         {

      11:             return (new ValidationResult("Value cannot be negative or zero"));

      12:         }

      13:  

      14:         return (ValidationResult.Success);

      15:     }

      16: }

You would then apply this to some property in your entity:

       1: public class MyEntity

       2: {

       3:     [Positive]

       4:     public Int64 MyAlwaysPositiveNumber { get; set; }

       5: }

The “problem” with this approach is that you must include any assemblies containing these custom validation attributes together with your model. If they are on the same assembly, there’s no problem.

By the way, you can specify multiple validation attributes and you can even apply them to the whole class, not just a property.

Implementing IValidatableObject

Another option, also common to MVC, is having your entities implement IValidatableObject. This interface defines a contract for returning a collection of validation errors for an entity. Here’s a sample implementation:

       1: public class Contract : IValidatableObject

       2: {

       3:     public String Name { get; set; }

       4:     public DateTime StartDate { get; set; }

       5:     public DateTime EndDate { get; set; }

       6:  

       7:     public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)

       8:     {

       9:         if (this.StartDate >= this.EndDate)

      10:         {

      11:             yield return (new ValidationResult("The end date is before or the same as the start date", new String[] { "StartDate", "EndDate" }));

      12:         }

      13:     }

      14: }

Handling SavingChanges Event

The “underlying” ObjectContext – which, in fact, is only created if requested – exposes a SavingChanges event which is triggered whenever Entity Framework is about to send changes to the database, typically whenever the SaveChanges method is called. If we handle this event, we can perform our custom validation before our entities are saved, and in case something is wrong we can throw an exception to cancel the saving process:

       1: (ctx as IObjectContextAdapter).ObjectContext.SavingChanges += ObjectContext_SavingChanges;

       2:  

       3: void ObjectContext_SavingChanges(Object sender, EventArgs e)

       4: {

       5:     ObjectContext octx = sender as ObjectContext;

       6:     IEnumerable<Object> entities = octx.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified).Select(x => x.Entity);

       7:  

       8:     //do custom validation and throw an exception if something wrong is found

       9:  

      10: }

This has the arguable advantage that it decouples the validation process from the entities and the context themselves.

Conclusion

In case you are using any of these validation techniques, always surround calls to SaveChanges inside a try…catch block and look out for a DbEntityValidationException or your own exception, if you followed the SavingChanges approach. Inside DbEntityValidationException you have an EntityValidationErrors that contains all the details:

       1: try

       2: {

       3:     ctx.SaveChanges();

       4: }

       5: catch (DbEntityValidationException ex)

       6: {

       7:     foreach (DbEntityValidationResult result in ex.EntityValidationErrors)

       8:     {

       9:         //..

      10:     }

      11: }

Alternatively, you can explicitly call GetValidationErrors and see the collection of errors from all sources, except, of course, SavingChanges, because the context is not actually in the process of saving changes, for all entities currently being tracked by the context.

The order by which these validation processes are applied is:

ValidateEntity
ValidationAttribute (from base ValidateEntity)
IValidatableObject (from base ValidateEntity
SavingChanges (only if no errors are found)

Pick the one that better suits your needs!

Blogs Portugueses Sobre SharePoint

2013-05-09T10:26:00Z

This post is in portuguese only, sorry!

A partir de um comentário no LinkedIn, no grupo da Comunidade Portuguesa de SharePoint (http://www.linkedin.com/groups?home=&gid=996587&trk=anet_ug_hm) foi começada uma lista dos blogs de autores portugueses e brasileiros sobre SharePoint, ainda que não exclusivamente. Vou publicar essa lista aqui, e tentarei mantê-la actualizada.

Comunidade Portuguesa de SharePoint - http://www.sharepointpt.org/
Tech Talk PT - http://techtalkpt.wordpress.com/
My time break for SharePoint - http://aaclage.blogspot.pt/
Stepping stones for crossing technological ponds - http://mystepstones.wordpress.com/
Raquel Aline kb - http://raquelalineblog.wordpress.com/
EPM+ - http://blogs.technet.com/b/epmmais/
Demétrio Silva – Sql Server - http://demetriosilva.wordpress.com/
Ricardo Calejo - http://ricardocalejo.livethoughts.net/
Development With A Dot - http://weblogs.asp.net/ricardoperes/
ponto de partilha - http://pontodepartilha.blogspot.pt/
ShareMídia - http://crimac.net/sharemidia/
ftduarte.blogspot.com - http://ftduarte.blogspot.pt/
André Vala - http://blogit.create.pt/blogs/andrevala/
Miguel Isidoro - http://blogit.create.pt/blogs/miguelisidoro/

Se conhecerem mais, por favor, comuniquem-mos!

Using the Enterprise Library 6 Configuration Console with Visual Studio 2012

2013-05-07T16:36:06Z

You will have to download and run the Configuration Console from http://www.microsoft.com/en-us/download/details.aspx?id=38789, there is no NuGet package for it. After that, you will get a context menu for each project on the solution for editing the configuration:

Filter Collections Automatically With Entity Framework Code First

2013-05-04T21:41:55Z

Introduction

In some O/RMs, it is possible to specify automatic filters for entity collections such as one-to-many or many-to-many. These are applied automatically whenever these collections are being populated. Entity Framework does not offer one such mechanism, however, it is possible to implement it.

Context Collections

In Entity Framework Code First, entities are exposed as IDbSet<T> or DbSet<T> collections on a context, a DbContext-derived class. There is no way to automatically set a filter that will apply to all queries coming from these collections, unless we create our own IDbSet<T> class. Let’s call it FilteredDbSet<T> and have it implement the same interfaces as DbSet<T> so that it can be used instead of it transparently:

        1: public class FilteredDbSet<TEntity> : IDbSet<TEntity>, IOrderedQueryable<TEntity> where TEntity : class

       2: {

       3:     #region Private readonly fields

       4:     private readonly DbSet<TEntity> set;

       5:     private readonly Func<TEntity, Boolean> matchesFilter;

       6:     #endregion

       7:  

       8:     #region Public constructors

       9:     public FilteredDbSet(DbContext context, Expression<Func<TEntity, Boolean>> filter)

    {

        this.set = set;

        this.Filter = filter;

        this.matchesFilter = filter.Compile();

    }

  

    #endregion

  

    #region Public properties

    public Expression<Func<TEntity, Boolean>> Filter

    {

        get;

        protected set;

    }

  

    public IQueryable<TEntity> Unfiltered

    {

        get

        {

            return (this.set);

        }

    }

    #endregion

  

    #region Public methods

    public IQueryable<TEntity> Include(String path)

    {

        return (this.set.Include(path).Where(this.Filter));

    }

  

    public DbSqlQuery<TEntity> SqlQuery(String sql, params Object[] parameters)

    {

        return (this.set.SqlQuery(sql, parameters));

    }

    #endregion

  

    #region IDbSet<TEntity> Members

    TEntity IDbSet<TEntity>.Add(TEntity entity)

    {

        this.ThrowIfEntityDoesNotMatchFilter(entity);

        return (this.set.Add(entity));

    }

  

    TEntity IDbSet<TEntity>.Attach(TEntity entity)

    {

        this.ThrowIfEntityDoesNotMatchFilter(entity);

        return (this.set.Attach(entity));

    }

  

    TDerivedEntity IDbSet<TEntity>.Create<TDerivedEntity>()

    {

        var entity = this.set.Create<TDerivedEntity>();

        return (entity as TDerivedEntity);

    }

  

    TEntity IDbSet<TEntity>.Create()

    {

        var entity = this.set.Create();

        return (entity);

    }

  

    TEntity IDbSet<TEntity>.Find(params Object[] keyValues)

    {

        var entity = this.set.Find(keyValues);

        ThrowIfEntityDoesNotMatchFilter(entity);

        return (entity);

    }

  

    TEntity IDbSet<TEntity>.Remove(TEntity entity)

    {

        ThrowIfEntityDoesNotMatchFilter(entity);

        return (this.set.Remove(entity));

    }

  

    ObservableCollection<TEntity> IDbSet<TEntity>.Local

    {

        get { return (this.set.Local); }

    }

    #endregion

  

    #region IEnumerable<TEntity> Members

    IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()

    {

        return (this.set.Where(this.Filter).GetEnumerator());

    }

    #endregion

  

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()

    {

        return ((this as IEnumerable<TEntity>).GetEnumerator());

    }

    #endregion

  

    #region IQueryable Members

    Type IQueryable.ElementType

    {

        get { return ((this.set as IQueryable).ElementType); }

    }

  

    Expression IQueryable.Expression

    {

        get

        {

            return (this.set.Where(this.Filter).Expression);

        }

    }

  

    IQueryProvider IQueryable.Provider

    {

        get

        {

            return ((this.set as IQueryable).Provider);

        }

    }

    #endregion

  

    #region Private methods

    private void ThrowIfEntityDoesNotMatchFilter(TEntity entity)

    {

        if ((entity != null) && (this.matchesFilter(entity) == false))

        {

            throw (new ArgumentException("Entity does not match filter", "entity"));

        }

    }

  

    #endregion

}

In the constructor of our DbContext, we create instances of this class, and pass a LINQ restriction query on its constructor:

       1: public MyContext : DbContext

       2: {

       3:     public MyContext()

       4:     {

       5:         this.Bases = new FilteredDbSet<Base>(this, x => x.SomeProperty == 1);

       6:     }

       7:  

       8:     public IDbSet<Base> Bases { get; protected set; }

       9: }

From now on, all queries over the Bases collection will be restricted.

Entity Collections

A different matter is collections on entities. For these, we usually declare a property of ICollection<T> and let Entity Framework create an instance for us, when it is loading the entity. The class responsible for creating this instance is DbCollectionEntry, which unfortunately does not allow subclassing, because it doesn’t have any public or protected constructors or virtual methods. Let’s take a different path and create our own collection class instead:

       1: [Serializable]

       2: public class FilteredCollection<T> : ICollection<T>

       3: {

       4:     private readonly DbCollectionEntry collectionEntry;

       5:     private readonly Func<T, Boolean> compiledFilter;

       6:     private ICollection<T> collection;

       7:  

       8:     public FilteredCollection(ICollection<T> collection, DbCollectionEntry collectionEntry, Expression<Func<T, Boolean>> filter)

       9:     {

        this.Filter = filter;

        this.collection = collection ?? new HashSet<T>();

        this.collectionEntry = collectionEntry;

        this.compiledFilter = filter.Compile();

  

        if (collection != null)

        {

            foreach (T entity in collection)

            {

                this.collection.Add(entity);

            }

  

            this.collectionEntry.CurrentValue = this;

        }

        else

        {

            this.LoadIfNecessary();

        }

    }

  

    public Expression<Func<T, Boolean>> Filter

    {

        get;

        private set;

    }

  

    protected void ThrowIfInvalid(T entity)

    {

        if (this.compiledFilter(entity) == false)

        {

            throw (new ArgumentException("entity"));

        }

    }

  

    protected void LoadIfNecessary()

    {

        if (this.collectionEntry.IsLoaded == false)

        {

            IQueryable<T> query = this.collectionEntry.Query().Cast<T>().Where(this.Filter);

  

            this.collection = query.ToList();

  

            this.collectionEntry.CurrentValue = this;

  

            var _internalCollectionEntry = this.collectionEntry.GetType().GetField("_internalCollectionEntry", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(this.collectionEntry);

            var _relatedEnd = _internalCollectionEntry.GetType().BaseType.GetField("_relatedEnd", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(_internalCollectionEntry);

            _relatedEnd.GetType().GetField("_isLoaded", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(_relatedEnd, true);

        }

    }

  

    #region ICollection<T> Members

  

    void ICollection<T>.Add(T item)

    {

        this.LoadIfNecessary();

        this.ThrowIfInvalid(item);

        this.collection.Add(item);

    }

  

    void ICollection<T>.Clear()

    {

        this.LoadIfNecessary();

        this.collection.Clear();

    }

  

    Boolean ICollection<T>.Contains(T item)

    {

        this.LoadIfNecessary();

        return (this.collection.Contains(item));

    }

  

    void ICollection<T>.CopyTo(T[] array, Int32 arrayIndex)

    {

        this.LoadIfNecessary();

        this.collection.CopyTo(array, arrayIndex);

    }

  

    Int32 ICollection<T>.Count

    {

        get

        {

            this.LoadIfNecessary();

            return (this.collection.Count);

        }

    }

  

    Boolean ICollection<T>.IsReadOnly

    {

        get

        {

            this.LoadIfNecessary();

            return (this.collection.IsReadOnly);

        }

    }

  

    Boolean ICollection<T>.Remove(T item)

    {

        this.LoadIfNecessary();

        return (this.collection.Remove(item));

    }

  

    #endregion

  

    #region IEnumerable<T> Members

  

    IEnumerator<T> IEnumerable<T>.GetEnumerator()

    {

        this.LoadIfNecessary();

        return (this.collection.GetEnumerator());

    }

  

    #endregion

  

    #region IEnumerable Members

  

    IEnumerator IEnumerable.GetEnumerator()

    {

        return ((this as IEnumerable<T>).GetEnumerator());

    }

  

    #endregion

}

This collection receives a pointer to a possibly existing collection and a DbCollectionEntry responsible for loading this collection. We must use a bit of reflection magic to let DbCollectionEntry think that the collection was already loaded (IsLoaded), and instead load it ourselves, by applying our custom restriction to the expression returned by its Query method.

Now, in order to use this collection, we must intercept the ObjectMaterialized event of the underlying ObjectContext. We set up the filter through an extension method over DbContext:

       1: public static class DbContextExtensions

       2: {

       3:      public static void Filter<TContext, TParentEntity, TCollectionEntity>(this TContext context, Expression<Func<TContext, IDbSet<TParentEntity>>> path, Expression<Func<TParentEntity, ICollection<TCollectionEntity>>> collection, Expression<Func<TCollectionEntity, Boolean>> filter)

       4:         where TContext : DbContext

       5:         where TParentEntity : class, new()

       6:         where TCollectionEntity : class

       7:     {

       8:          (context as IObjectContextAdapter).ObjectContext.ObjectMaterialized += delegate(Object sender, ObjectMaterializedEventArgs e)

       9:         {

      10:             if (e.Entity is TParentEntity)

      11:             {

      12:                 String navigationProperty = collection.ToString().Split('.')[1];

      13:                 DbCollectionEntry col = context.Entry(e.Entity).Collection(navigationProperty);

      14:                 col.CurrentValue = new FilteredCollection<TCollectionEntity>(null, col, filter);

      15:             }

      16:         };

      17:     }

      18: }

The actual ICollection<T> is returned by setting a value to the DbCollectionEntry.CurrentValue property, and we set it to our collection

We use this extension method like this:

       1: ctx.Filter(p => p.Products, p => p.Details, p => p.SomeProperty == 0);

This will pick the Product entity from the Products context collection and filter its Details collection.

Conclusion

As you can see, even though Entity Framework does not have all functionality that we might be used to, it still offers enough extensibility points that allow us to built it ourselves. The same technique that I presented here can be used for building lazy loaded or even IQueryable<T> collections, both interesting ideas that I leave as an exercise to you!

Querying Entity Framework Code First Inheritance

2013-04-30T17:02:19Z

This is a short post to complement my previous one on Entity Framework Code First Inheritance: how to query for a specific class. The options are:

From the DbContext collection:

            1: IEnumerable<DerivedA> derived = ctx.Bases.OfType<DerivedA>().ToList();

From the inner ObjectContext, using Entity SQL and the OFTYPE operator:

           1: IEnumerable<DerivedA> derived = (ctx as IObjectContextAdapter).ObjectContext.CreateQuery<DerivedA>("SELECT VAlUE b FROM OFTYPE(Bases, MyNamespace.DerivedA) AS b").OfType<DerivedA>().ToList();

Also in Entity SQL, using TREAT and IS OF:

           1: IEnumerable<DerivedA> derived = (ctx as IObjectContextAdapter).ObjectContext.CreateQuery<DerivedA>("SELECT VAlUE TREAT(b AS MyNamespace.DerivedA) FROM Bases AS b WHERE b IS OF (ConsoleApplication1.DerivedA)").OfType<DerivedA>().ToList();

Using LINQ to Entities:

           1: IEnumerable<DerivedA> derived = (from d in ctx.Bases where d is DerivedA select d as DerivedA).ToList();

Using pure SQL:

           1: IEnumerable<DerivedA> derived = ctx.Database.SqlQuery<DerivedA>("SELECT * FROM Bases AS b WHERE b.Discriminator = 'DerivedA'").ToList();

Visual Studio 2012 and .NET 4.5 Expert Development Cookbook Review

2013-04-30T12:07:29Z

Visual Studio 2012 and .NET 4.5 Expert Development Cookbook

I recently started reading Packt Publishing’s Visual Studio 2012 and .NET 4.5 Expert Development Cookbook. It is a book focused primarily on the new features of .NET 4.5 and Visual Studio 2012. Although some concepts already existed in previous versions (some Visual Studio IDE elements, for example), others are quit new (take Windows 8 programming APIs and the new asynchronous syntax). It follows the now classic recipes or cookbook approach, where for each category, a number of recipes are presented with a brief description of their purpose and some code to illustrate the solution. It is a very focused book, it doesn’t cover anything that shouldn’t be there.

The first chapter is about the IDE, how to use it effectively and how to extend it without using code. It walks us through creating templates and code snippets and in the process we get to know smart tags, refactoring options, UML diagrams and other nice functionality.

On second chapter, the focus is .NET application and memory management. We learn about the internal structure of a .NET assembly (actually, its various types), garbage collection and memory management and even how to disassemble it with ILMerge or Reflector. Talking about disassembling, some tips for protecting an assembly against it are also presented by means of Dotfuscator. Also includes an interesting tip on detecting memory leaks. This is the one chapter that mostly deals with pre-.NET 4.5 concepts.

Next comes asynchronous programming, something that most people (including myself) are looking with increased interest since the arrival of .NET 4.5. The chapter presents all programming models currently available for .NET developers and talks about some not well known thread synchronization objects and techniques of the .NET world, including guidelines on choosing the appropriate mechanisms. Finally it covers the new async and await pattern.

Following is a chapter on the new enhancements to ASP.NET, which go from HTML5 editor and syntax support to working with strongly-typed models in data-bound controls. In the middle, it also covers using asynchronous programming techniques in pages, modules and handlers and effectively using jQuery. There’s also a recipe on actually using some of HTML5’s new features, which is not strictly on ASP.NET, but is useful nevertheless.

WPF is next. The very popular MVVM patter is presented together with the new improvements like Ribbon support, a feature which seems to be becoming ubiquitous in Microsoft products.

The final chapters are all about Windows 8 applications. The first focuses on building touch-sensitive applications. It was a fun read, because I knew absolutely nothing on the subject. It actually covers more than just touch-sensitive applications, and covers WinRT, JavaScript and XAML.

The last chapter talks about the various options for communicating and sharing contained within Windows 8. Also a very interesting one, of which I knew nothing about. It covers the ways by which we can share data between Windows 8 applications, writing notification services in WCF and displaying notifications in tiles or toasts.

It was a very pleasant read, I am sure to return to it very often, for some of the topics are very wide.

Entity Framework Code First Inheritance

2013-04-29T21:59:00Z

Introduction

Another post for self reference, this time, how to map inheritance strategies with Entity Framework Code First.

Single Table Inheritance / Table Per Class Hierarchy

First, the default strategy: one table for all classes in the hierarchy. Will store all columns on the same table, so all properties on derived classes must be nullable, and there will be lots of nulls. An additional column will be created, which will contain a discriminator value for deciding which type corresponds to each row.

        1: [Table("Base")]

       2: public abstract class Base

       3: {

       4:     public Int32 BaseId { get; set; }

       5:  

       6:     public String InheritedColumn { get; set; }

       7: }

         1: public class DerivedA : Base

         2: {

         3:     public String A { get; set; }

         4: }

         1: public class DerivedB : Base

         2: {

         3:     public String B { get; set; }

         4: }

Class Table Inheritance / Table Per Type

This will map all properties of the base class into a table of its own and each derived class in its own table, connected to the base table by a foreign key. No duplication will occur and properties on derived classes can be mapped as not nullable.

         1: [Table("Base")]

         2: public abstract class Base

         3: {

         4:     public Int32 BaseId { get; set; }

         5:  

         6:     public String InheritedColumn { get; set; }

         7: }

         1: [Table("DerivedA")]

         2: public class DerivedA : Base

         3: {

         4:     public String ColumnA { get; set; }

         5: }

         1: [Table("DerivedB")]

         2: public class DerivedB : Base

         3: {

         4:     public String ColumnB { get; set; }

         5: }

Concrete Table Inheritance / Table Per Concrete Type

No table for the base class, each concrete class will have its own table, which will contain columns for all of the class’ properties, including inherited ones. One record will only exist in one of the tables, so usage of IDENTITY columns as primary keys is not possible, because there will be records with the same ID on all of the tables, unless different seeds and/or increments are used.

         1: public abstract class Base

         2: {

         3:     public Int32 BaseId { get; set; }

         4:  

         5:     public String InheritedColumn { get; set; }

         6: }

         1: [Table("DerivedA")]

         2: public class DerivedA : Base

         3: {

         4:     public String ColumnA { get; set; }

         5: }

         1: [Table("DerivedB")]

         2: public class DerivedB : Base

         3: {

         4:     public String ColumnB { get; set; }

         5: }

This will require additional configuration at the context level, this strategy is not possible just with attributes:

         1: public class Context : DbContext

         2: {

         3:     protected override void OnModelCreating(DbModelBuilder modelBuilder)

         4:     {

         5:         modelBuilder.Entity<DerivedA>().Map(m =>

         6:         {

         7:             m.MapInheritedProperties();

         8:         });

         9:         modelBuilder.Entity<DerivedB>().Map(m =>

        10:         {

        11:             m.MapInheritedProperties();

        12:         });

        13:     }

        14:  

        15:     public DbSet<Base> Bases { get; set; }

        16: }

Entity Framework Code First Relations

2013-04-29T17:24:24Z

Introduction

This post is more for self-reference than anything else. Basically, I tend to forget some options for mapping relations with Entity Framework Code First, so I wrote this. If in doing so it helps someone, even better!

One-to-Many

First, the most basic: one-to-many/many-to-one: an instance of the Master class has lots of Details.

        1: public class Master

       2: {

       3:     public Int32 MasterId { get; set; }

       4:  

       5:     public virtual ICollection<Detail> Details { get; protected set; }

       6: }

       1: public class Detail

       2: {

       3:     public Int32 DetailId { get; set; }

       4:  

       5:     public virtual Master Master { get; set; }

       6: }

One-to-One

The stepchild of database relations. Sometimes it is useful, though: a single Master has an optional Detail, which always refers to an existing Master.

       1: public class Master

       2: {

       3:     public Int32 MasterId { get; set; }

       4:  

       5:     public virtual Detail Detail { get; set; }

       6: }

       1: public class Detail

       2: {

       3:     [Key]

       4:     [ForeignKey("Master")]

       5:     public Int32 MasterId { get; set; }

       6:  

       7:     [Required]

       8:     public virtual Master Master { get; set; }

       9: }

Many-to-Many

A single Master can have many Details; each Detail can itself be connected to multiple Masters.

       1: public class Master

       2: {

       3:     public Master()

       4:     {

       5:         this.Details = new List<Detail>();

       6:     }

       7:  

       8:     public Int32 MasterId { get; set; }

       9:  

      10:     public virtual ICollection<Detail> Details { get; protected set; }

      11: }

       1: public class Detail

       2: {

       3:     public Detail()

       4:     {

       5:         this.Masters = new List<Master>();

       6:     }

       7:  

       8:     public Int32 DetailId { get; set; }

       9:  

      10:     public virtual ICollection<Master> Masters { get; protected set; }

      11: }

One-to-Many With Composite Key

In this case we have a composite primary key constituted by a foreign key and a scalar column: a Master instance is related with many Details and each Detail is identified by both a single Master and a timestamp.

       1: public class Master

       2: {

       3:     public Master()

       4:     {

       5:         this.Details = new List<Detail>();

       6:     }

       7:  

       8:     public Int32 MasterId { get; set; }

       9:  

      10:     public virtual ICollection<Detail> Details { get; protected set; }

      11: }

       1: public class Detail

       2: {

       3:     [Key]

       4:     [ForeignKey("Master")]

       5:     [Column(Order = 0)]

       6:     public Int32 MasterId { get; set; }

       7:  

       8:     [Required]

       9:     public virtual Master Master { get; set; }

      10:  

      11:     [Key]

      12:     [Column(Order = 1)]

      13:     public DateTime Timestamp { get; set; }

      14: }

Have I forgotten something? Let me know!

Unity – Part 3: Aspect Oriented Programming

2013-04-28T12:15:51Z

AOP

This is my third post on Unity. See the first here for an introduction and the second here for how to apply dependency injection.

Aspect Oriented Programming (AOP) is a technique for applying cross-cutting concerns to existing implementations, without modifying them. Some examples of it are:

Wrapping method calls that go to the database in transactions automatically;
Logging all calls to some method, including the input parameters and return value;
Catching exceptions thrown in a method automatically and doing something with them.

AOP is supported in the Enterprise Library (of which Unity is part) by the Policy Injection application block, and it can be integrated with Unity. You must install this application block, perhaps by using NuGet:

We need to add the interception behavior – which is the one that actually applies aspects – to Unity, either by code:

        1: unity.AddNewExtension<Interception>();

Or by XML configuration:

       1: <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">

       2:     <sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration"/>

       3: </unity>

Having said that, the first concept we need to know is that of an interceptor. An interceptor in the Policy Injection block is an implementation of Microsoft.Practices.Unity.InterceptionExtension.IInterceptor interface, and there are three implementations:

Microsoft.Practices.Unity.InterceptionExtension.InterfaceInterceptor: for intercepting calls to a type that is exposed by an interface;
Microsoft.Practices.Unity.InterceptionExtension.TransparentProxyInterceptor: for intercepting calls to a type that inherits from MarshalByRefObject;
Microsoft.Practices.Unity.InterceptionExtension.VirtualMethodInterceptor: for intercepting virtual method calls.

It is required that, when you are going to apply an aspect to a registration, you choose an interceptor suitable for that registration, based on what type we are registering.

An aspect itself is an implementation of Microsoft.Practices.Unity.InterceptionExtension.ICallHandler, Unity includes five out of the box such handlers:

Authorization handler (Microsoft.Practices.EnterpriseLibrary.Security.PolicyInjection.AuthorizationCallHandler): for implementing authorization rules;
Exception handling handler (Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.PolicyInjection.ExceptionCallHandler): for applying the rules of the Exception Handling application block;
Logging handler (Microsoft.Practices.EnterpriseLibrary.Logging.PolicyInjection.LogCallHandler): for logging calls before and after a method call using the Logging application block;
Validation handler (Microsoft.Practices.EnterpriseLibrary.Validation.ValidationCallHandler): for validating arguments of a method with the Validation application block;
Performance counter handler (Microsoft.Practices.EnterpriseLibrary.PolicyInjection.CallHandlers.PerformanceCounterCallHandler): for updating a performance counter upon calling a method.

The ICallHandler interface only defines a single method, Invoke, which wraps a method’s arguments and allows having code run before, after or even instead of the target method, and an Order property, for specifying the order by which the aspect should be applied, in case there are many.

A simple call handler, for outputting some string before or after a method call, might be:

       1: public class OutputCallHandler : ICallHandler

       2: {

       3:     public Boolean Before

       4:     {

       5:         get;

       6:         set;

       7:     }

       8:  

       9:     public Boolean After

    {

        get;

        set;

    }

  

    public String Message

    {

        get;

        set;

    }

  

    Int32 ICallHandler.Order

    {

        get;

        set;

    }

  

    IMethodReturn ICallHandler.Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)

    {

        if (this.Before == true)

        {

            Console.WriteLine(this.Message);

        }

  

        IMethodReturn result = getNext()(input, getNext);

  

        if (result.Exception != null)

        {

            Console.Error.WriteLine(result.Exception.Message);

        }

        else

        {

            if (this.After == true)

            {

                Console.WriteLine(this.Message);

            }

        }

  

        return (result);

    }

}

Another option is to have interception for all methods of the target registration, which can be achieved by implementing Microsoft.Practices.Unity.InterceptionExtension.IInterceptionBehavior in a concrete class, such as this:

       1: public class MyInterceptionBehavior : IInterceptionBehavior

       2: {

       3:     IEnumerable<Type> IInterceptionBehavior.GetRequiredInterfaces()

       4:     {

       5:         return (Type.EmptyTypes);

       6:     }

       7:  

       8:     IMethodReturn IInterceptionBehavior.Invoke(IMethodInvocation input, GetNextInterceptionBehaviorDelegate getNext)

       9:     {

        //before target method call

  

        if (input.MethodBase == typeof(MyService).GetMethod("DoSomething"))

        {

            //do something

        }

  

        IMethodReturn methodReturn = getNext().Invoke(input, getNext);

  

        //after target method call

  

        return (methodReturn);

    }

  

    Boolean IInterceptionBehavior.WillExecute

    {

        get

        {

            return (true);

        }

    }

}

If we want to cancel the default method call, if it is non void, we must return an appropriate value:

       1: IMethodReturn methodReturn = input.CreateMethodReturn(someValue, input.Arguments);

Or if we want to return an exception:

       1: IMethodReturn methodReturn = input.CreateExceptionMethodReturn(new SomeException());

There are three ways by which we can apply an aspect to a registration:

By applying an attribute to a method on the declaring or target type;
By code configuration;
By XML configuration.

Interception By Attributes

We need to create an attribute that derives from Microsoft.Practices.Unity.InterceptionExtension.HandlerAttribute and which instantiates our call handler:

       1: [Serializable]

       2: [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)]

       3: public sealed class OutputCallHandlerAttribute : HandlerAttribute

       4: {

       5:     public Boolean Before

       6:     {

       7:         get;

       8:         set;

       9:     }

  

    public Boolean After

    {

        get;

        set;

    }

  

    public String Message

    {

        get;

        private set;

    }

  

    public OutputCallHandlerAttribute(String message)

    {

        this.Message = message;

    }

  

    public override ICallHandler CreateHandler(IUnityContainer container)

    {

        return (new OutputCallHandler() { After = this.After, Before = this.Before, Message = this.Message });

    }        

}

And we apply it to any method declaration:

       1: public interface IMyService

       2: {

       3:     [OutputCallHandler("Before", Before = true)]

       4:     [OutputCallHandler("After", After = true)]

       5:     void DoSomething();

       6: }

But before this works, we need to tell Unity to use interface interception for our type:

       1: unity.Configure<Interception>().SetDefaultInterceptorFor<IMyService>(new InterfaceInterceptor());

Interception By Code

For intercepting by code, whenever we register something with Unity, we also tell it to use interface interception and to include a behavior instance – it is not possible to specify a call handler for a specific method:

       1: unity.RegisterType<IMyService, MyService>(new ContainerControlledLifetimeManager(), new Interceptor<InterfaceInterceptor>(), new InterceptionBehavior<OutputInterceptionBehavior>());

Interception By Configuration

When applying interception by configuration we also cannot target a specific method, but instead specify an interception behavior, which will apply to all method – of course, inside of it we can do our own filtering, by looking at the IMethodInvocation.MethodBase property:

       1: <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">

       2:     <sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension, Microsoft.Practices.Unity.Interception.Configuration"/>

       3:     <container>

       4:         <extension type="Microsoft.Practices.Unity.InterceptionExtension.Interception, Microsoft.Practices.Unity.Interception"/>

       5:         <interceptors>

       6:             <interceptor type="InterfaceInterceptor">

       7:                 <default type="MyNamespace.IMyService, MyAssembly"/>

       8:             </interceptor>

       9:         </interceptors>

      10:         <register type="MyNamespace.IMyService, MyAssembly" mapTo="MyNamespace.MyService, MyAssembly">

      11:             <lifetime type="singleton"/>

      12:             <interceptionBehavior type="MyNamespace.OutputInterceptionBehavior, MyAssembly"/>

      13:         </register>

      14:         </register>

      15:     </container>

      16: </unity>

Executing

You must Unity to retrieve an instance, which will be properly wrapped in a proxy, and from there all of your configured interceptors will be called:

       1: IMyService svc = ServiceLocator.Current.GetInstance<IMyService>();

       2: svc.DoSomething();

Next in line: extending Unity.

Unity – Part 2: Dependency Injection

2013-04-18T15:57:38Z

Dependency Injection

Second part of my series on Unity. For an introduction, read the first post.

OK, now we know how to get Inversion of Control (IoC): instead of referencing a particular concrete implementation, we instead reference an interface or an abstract base class, which creates a level of abstraction and allows us to change things at a later time.

Now let’s see what Unity has to offer in terms of Dependency Injection (DI). DI is the process by which objects are populated (injected) with values, called dependencies, usually coming from the IoC container itself. Basically, we have three options for that:

Constructor injection;
Property injection;
Method injection.

What this means is, when asked for a particular instance, Unity will call a constructor, set a property’s value or invoke a method with a parameter coming from its registration. Say you have a class like this:

        1: public class MyService : IMyService

       2: {

       3:     public ILogger Logger

       4:     {

       5:         get;

       6:         private set;

       7:     }

       8:  

       9:     public MyService(ILogger logger)

      10:     {

      11:         this.Logger = logger;

      12:     }

      13:  

      14:     public void SetLogger(ILogger logger)

      15:     {

      16:         this.Logger = logger;

      17:     }

      18: }

Unity can inject the Logger instance by either passing a parameter on the constructor when building an instance of the MyService class, directly setting the Logger property (even with a private setter) or by invoking the SetLogger method.

Injection By Configuration

As we have seen, most things in Unity can be configured by XML configuration:

       1: <register type="MyNamespace.IMyService, MyAssembly" mapTo="MyNamespace.MyService, MyAssembly">

       2:     <constructor>

       3:         <param name="logger" dependencyType="MyNamespace.ILogger, MyAssembly" dependencyName="File"/>

       4:     </constructor>

       5:     <property name="Logger" dependencyType="MyNamespace.ILogger, MyAssembly" dependencyName="File"/>

       6:     <method name="SetLogger">

       7:         <param name="logger" dependencyType="MyNamespace.ILogger, MyAssembly" dependencyName="File"/>

       8:     </method>

       9: </register>

Did you notice the dependencyName attribute? That is the name under which the dependencyType was registered, if not set, it defaults to the empty string.

I have included both constructor, property and method injection, you usually will only need one of them.

Injection By Code

Another option is by code. When registering a type, you must add some additional code:

       1: unity.RegisterType<IMyService, MyService>(new InjectionConstructor(unity.Resolve<ILogger>("File")), new InjectionMethod("SetLogger", unity.Resolve<ILogger>("File")), new InjectionProperty("Logger", unity.Resolve<ILogger>("File")));

If you don’t want to resolve an instance yourself in InjectionMethod, InjectionConstructor or InjectionProperty, you can pass a Type and Unity will look up the actual instance for you.

Injection By Attributes

Another option is by applying attributes:

       1: public class MyService : IMyService

       2: {

       3:     [Dependency("File")]

       4:     public ILogger Logger

       5:     {

       6:         get;

       7:         private set;

       8:     }

       9:  

      10:     [InjectionConstructor]

      11:     public MyService([Dependency("File")] ILogger logger)

      12:     {

      13:         this.Logger = logger;

      14:     }

      15:  

      16:     [InjectionMethod]

      17:     public void SetLogger([Dependency("File")] ILogger logger)

      18:     {

      19:         this.Logger = logger;

      20:     }

      21: }

The File string is the name of the registered type.

Like previously mentioned, although I depicted all three, you will pick only one injection method. When you call Resolve or GetInstance, the instance you get will have its dependencies assigned.

Injecting Dependencies On Existing Entities

If you have some object instance that was obtained elsewhere, you can still ask Unity to inject whatever dependencies this object has. This is achieved by the BuildUp family of methods:

       1: IMyService svc = new MyService();

       2:  

       3: unity.BuildUp(svc);    //Logger property is set and SetLogger method is called

Next in line: applying aspects. Stay tuned!

Unity - Part 1: Introduction

2013-04-17T21:19:00Z

Updated: ContainerControlled instead of ExternallyControlled in the bullet list of lifetime managers. Thanks, Ross Smith!

Introduction

Unity is Microsoft’s Inversion of Control (IoC) and Dependency Injection (DI) container. It is part of the Enterprise Library family of Application Blocks.

I have been using it for years. Yes, I am aware that there are lots of other tools for the same purpose and with more or less functionality, but I actually like Unity. It has a good combination of out of the box features, performance and extensibility options. Some of its aspects, I believe, are not well know, so I set out to write a couple of posts on it, this being the first. This will not be an introduction to IoC and DI, I am assuming you already know that.

First things first: the best way to install Unity is by using Nuget:

It will install both Unity and the Common Service Locator, and all .NET versions from 2.0 are supported.

The Common Service Locator is an attempt to define a common interface for a IoC functionality; different IoC libraries implement adapters for the Common Service Locator, so that they can be used through the common interface, without tying the implementation to a particular one. Most IoC containers already implement one such adapter.

We create a Unity container like this:

        1: private static readonly IUnityContainer unity = new UnityContainer();

And we set up the Common Service Locator from it:

       1: ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(unity));

An IoC container is no good without registrations. You can register entries on the configuration file or through code. An IoC container is particularly good for minimizing coupling, by having dependencies on interfaces and abstract base classes instead of actual implementations, so these registrations basically consist of an interface of abstract base class as the key and a concrete type or instance as the value. Let’s consider a simple interface, ILogger, and two concrete implementations, ConsoleLogger and FileLogger:

The implementation is not very important, but lets consider the following ILogger interface:

       1: public interface ILogger

       2: {

       3:     void Log(String message);

       4: }

Registration By Configuration File

If you want to register by configuration, place the following content on the Web.config or App.config file:

       1: <configuration>

       2:     <configSections>

       3:         <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>

       4:     </configSections>

       5:     <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">

       6:         <container>

       7:             <register type="MyNamespace.ILogger, MyAssembly" mapTo="MyNamespace.ConsoleLogger, MyAssembly"/>

       8:             <register type="MyNamespace.ILogger, MyAssembly" mapTo="MyNamespace.FileLogger, MyAssembly" name="File"/>

       9:         </container>

      10:     </unity>

      11: </configuration>

Notice the two registrations, both for the interface ILogger, one mapping to ConsoleLogger, without a name, and another mapping to FileLogger, with a name of File. This is perfectly valid, there can be multiple declarations for the same interface (or abstract base class), provided they have different names. If no name is specified, it will default to the empty string (“”).

We have to tell Unity to load the configuration from the .config file, and we do it like this (do reference the Microsoft.Practices.Unity.Configuration namespace for the LoadConfiguration extension method):

       1: unity.LoadConfiguration();

Registration By Code

Alternatively, if you want to register entries by code, do so as:

       1: unity.RegisterType<ILogger, ConsoleLogger>();

       2: unity.RegisterType<ILogger, FileLogger>("File");

With registration by code, you can do something that is not available with the configuration file approach: registering a concrete instance as the value. Here’s how:

       1: unity.RegisterType<ILogger, ConsoleLogger>();

       2: unity.RegisterInstance<ILogger>("File", new FileLogger());

This has the advantage that you can create an instance anyway you like, with any specific configuration, and make it available to Unity.

Pay attention to this: the Common Service Locator has no methods for adding entries to the registration, just for resolving them.

Getting Instances

After you have some entries registered, you can ask for them, either by calling Unity directly (not recommended) or through the Common Service Locator (better):

       1: ILogger loggerFromUnity = unity.Resolve<ILogger>();

       2: ILogger loggerFromCommonServiceLocator = ServiceLocator.Current.GetInstance<ILogger>();

Or, if you want to obtain a particular named registration:

       1: ILogger fileLoggerFromUnity = unity.Resolve<ILogger>("File");

       2: ILogger fileLoggerFromCommonServiceLocator = ServiceLocator.Current.GetInstance<ILogger>("File");

For dynamic invocation, when you don’t have at compile time the desired Type, and thus no strong typing:

       1: ILogger loggerFromUnity = unity.Resolve(typeof(ILogger)) as ILogger;

       2: ILogger loggerFromCommonServiceLocator = ServiceLocator.Current.GetInstance(typeof(ILogger)) as ILogger;

It is possible to get all registered values for a given type:

       1: IEnumerable<ILogger> loggersFromUnity = unity.ResolveAll<ILogger>();

       2: IEnumerable<ILogger> loggersFromCommonServiceLocator = ServiceLocator.Current.GetAllInstances<ILogger>();

       3:

And, if there is the need, you can also resolve instances for a Type, that is, not using generics:

       1: IEnumerable<ILogger> loggersFromUnity = unity.ResolveAll(typeof(ILogger)).OfType<ILogger>();

       2: IEnumerable<ILogger> loggersFromCommonServiceLocator = ServiceLocator.Current.GetAllInstances(typeof(ILogger)).OfType<ILogger>();

For the single instance methods, if no such registration exists (for the type or the name), an exception will be thrown. For the enumeration ones, an empty list will be returned.

Lifetime Managers

By now, you might ask yourself: OK, but what if we ask Unity for some registered interface two or more times, will it give me the same instance or different instances? If we have registered an instance, by calling RegisterInstance instead of RegisterType, Unity will indeed return the same instance all the time. Otherwise, Unity will do what the Lifetime Manager tells it to do. For a good discussion, see Understanding Lifetime Managers.

A Lifetime Manager is an instance of a class that inherits from LifetimeManager and is responsible for creating or retrieving stored instances of mapped classes. Unity comes with the following out of the box implementations, but you are free to implement others:

ContainerControlledLifetimeManager (aka, singleton): Unity will only create an instance of the concrete type, and will return it every time, effectively treating it as a singleton;
PerThreadLifetimeManager (perthread): a different instance will be created once for each thread that the method it is called on, and the same instance will be returned on all subsequent calls for the same thread;
TransientLifetimeManager (transient): a new instance will be created and returned every time.
HierarchicalLifetimeManager (hierarchical): a new instance will be created and the same one will be returned for each Unity container, and another one for each child container (more on this later).
PerResolveLifetimeManager (perresolve): a new instance will be created every time, but it will be reused in the same build process if it is needed as a dependency somewhere in the list of dependencies of the current resolve process.
ExternallyControlledLifetimeManager (external): the actual instance was created and is managed elsewhere, like when you supply your own instance.

If we don’t specify a particular Lifetime Manager instance, or if we use null, the default is TransientLifetimeManager. The RegisterType method has overloads that take a LifetimeManager instance:

       1: unity.RegisterType<ILogger, FileLogger>("File", new ContainerControlledLifetimeManager());

If you want to do it by configuration:

       1: <register type="MyNamespace.ILogger, MyAssembly" mapTo="MyNamespace.FileLogger, MyAssembly" name="File">

       2:     <lifetime type="singleton"/>

       3: </register>

Conclusion

That’s it for now. In the next post: dependency injection.

NHibernate Pitfalls: Collections of Elements and Inverse

2013-04-16T11:15:18Z

This is part of a series of posts about NHibernate Pitfalls. See the entire collection here.

When mapping a collection of elements, this collection should not be marked as inverse. This is a different behavior from many to many or one to many, and it is because on the other endpoint of the relation, there is no entity to have the ownership of the relation, which is what the inverse attribute is for.

A simple example, in HBM.XML, just to remember:

        1: <class name="Post" lazy="true" table="`POST`">

       2:     <!-- ... -->

       3:     <set cascade="all" lazy="false" name="Tags" table="`TAG`" order-by="`TAG`">

       4:         <key column="`POST_ID`" />

       5:         <element column="`TAG`" type="String" length="20" not-null="true" unique="true" />

       6:     </set>

       7:     </class>

       8: </hibernate-mapping>