febrero 2010 – O bruxo mobile

Introducción

Hace ya unos cuantos dias que vengo dándole vueltas a la cabeza para escribir un post sobre especificaciones y como construirlas sobre la infraestructura de Entity Framework, aunque en realidad sería igual sobre cualquier elemento IQueryable, aunque con alguna nota de implementación. Pensando en esta entrada no sabía si comenzar con una explicación sobre este patrón o ceñirme directamente a una posible implementación, puesto que, me parece magnifica la documentación sobre el mismo que Fowler y Evans tienen en el documento de referencia. Al final, y despues de darle muchas vueltas me quedaré entre medias puesto que creo que es necesario realizar una pequeña introducción, aunque aconsejo encarecidamente desde aquí leerse el documento anterior si nunca ha visto información acerca de este patrón.

Sintetizándolo, aunque sea demasiada síntesis, podríamos decir que el patrón espeficación trata de lograr una separación entre la sentencia que unos objetos deberían de cumplir y el objeto que realiza la selección. Por ejemplo una especificación podría describir “los clientes que pertenecen a una determinada situación geográfica” pero no saber nada acerca de como realizar dicha selección. En definitiva no se trata nada más y nada menos que agregar una responsabilidad desacoplada de los objetos de dominio que la usan.

Este patrón es muy escuchado y usado en arquitecturas basadas en modelos de dominio y puesto en práctica en muchas arquitecturas para definir “criterios” de selección. Basándonos en la definición formal de este patrón, mostrada en la Figura 1, podríamos ver a primeras que una implementación de este patrón trabajando con IQueryable no tendría mucho sentido.

La razón principal de la afirmación anterior viene de la propia definición del patron, la cual implica trabajar con objetos directamente en memoria puesto que el método IsSatisfiedBy tomaría una instancia del objeto en el cual queremos comprobar si cumple un determinado criterio y devolver true o false según se cumpla o no, algo que por supuesto no deseamos por la sobrecarga que esto implicaría. Por todo esto podríamos modificar un poco nuestra definición de Specification para que en vez de devolver un booleano negando o afirmando el cumplimiento de una especificación determinada podríamos devolver una “expression” con el criterio a cumplir. En el siguiente fragmento de código tendríamos un esqueleto de nuestro contrato base con esta ligera modificación.

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Base contract for Specification pattern, for more information</span>
    <span class="rem">/// about this pattern see http://martinfowler.com/apsupp/spec.pdf</span>
    <span class="rem">/// or http://en.wikipedia.org/wiki/Specification_pattern.</span>
    <span class="rem">/// Really this is variant implementation for add feature of linq and</span>
    <span class="rem">/// lambda expression into this pattern.</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="rem">/// &lt;typeparam name="TEntity"&gt;Type of entity&lt;/typeparam&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">interface</span> ISpecification&lt;TEntity&gt;
        <span class="kwrd">where</span> TEntity : <span class="kwrd">class</span>,<span class="kwrd">new</span>()
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Check if this specification is satisfied by a </span>
        <span class="rem">/// specific expression lambda</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;/returns&gt;</span>
        Expression&lt;Func&lt;TEntity, <span class="kwrd">bool</span>&gt;&gt; SatisfiedBy();
    }

/// <summary>

/// Base contract for Specification pattern, for more information

/// about this pattern see http://martinfowler.com/apsupp/spec.pdf

/// or http://en.wikipedia.org/wiki/Specification_pattern.

/// Really this is variant implementation for add feature of linq and

/// lambda expression into this pattern.

/// </summary>

/// <typeparam name="TEntity">Type of entity</typeparam>

public interface ISpecification<TEntity>

where TEntity : class,new()

{

/// <summary>

/// Check if this specification is satisfied by a

/// specific expression lambda

/// </summary>

/// <returns></returns>

Expression<Func<TEntity, bool>> SatisfiedBy();

}

Profundizando

Llegados a este punto podríamos decir que ya tenemos la base y la idea de lo que queremos construir, ahora, solamente falta seguir las propias normas y guias de este patrón empezándonos a crear nuestras especificaciones directas o “hard coded specifications” y nuestras especificaciones compuestas, al estilo And, Or …

Según avanzas en esta aproximación uno se da cuenta de que tendrá que realizar un buen esfuerzo de trabajo con árboles de expresiones, algo en el que no todo el mundo está muy puesto, y a lo que se le tiene algo de miedo, del que uno se puede curar leyendo el excelente libro de mi amigo y colega Octavio 🙂

Mi primera intentona, y fallida a mi pesar, era similar a lo siguiente:

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// A logic AND Specification</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="rem">/// &lt;typeparam name="T"&gt;Type of entity that check this specification&lt;/typeparam&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> AndSpecification&lt;T&gt;
       : CompositeSpecification&lt;T&gt;
       <span class="kwrd">where</span> T : <span class="kwrd">class</span>,<span class="kwrd">new</span>()
    {
        <span class="preproc">#region</span> Members

        <span class="kwrd">private</span> ISpecification&lt;T&gt; _RightSideSpecification = <span class="kwrd">null</span>;
        <span class="kwrd">private</span> ISpecification&lt;T&gt; _LeftSideSpecification = <span class="kwrd">null</span>;

        <span class="preproc">#endregion</span>

        <span class="preproc">#region</span> Public Constructor

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Default constructor for AndSpecification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="leftSide"&gt;Left side specification&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="rightSide"&gt;Right side specification&lt;/param&gt;</span>
        <span class="kwrd">public</span> AndSpecification(ISpecification&lt;T&gt; leftSide, ISpecification&lt;T&gt; rightSide)
        {
            <span class="kwrd">if</span> (leftSide == (ISpecification&lt;T&gt;)<span class="kwrd">null</span>)
                <span class="kwrd">throw</span> <span class="kwrd">new</span> ArgumentNullException(<span class="str">"leftSide"</span>);

            <span class="kwrd">if</span> (rightSide == (ISpecification&lt;T&gt;)<span class="kwrd">null</span>)
                <span class="kwrd">throw</span> <span class="kwrd">new</span> ArgumentNullException(<span class="str">"rightSide"</span>);

            <span class="kwrd">this</span>._LeftSideSpecification = leftSide;
            <span class="kwrd">this</span>._RightSideSpecification = rightSide;
        }

        <span class="preproc">#endregion</span>

        <span class="preproc">#region</span> Composite Specification overrides

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Left side specification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> ISpecification&lt;T&gt; LeftSideSpecification
        {
            get { <span class="kwrd">return</span> _LeftSideSpecification; }
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Right side specification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> ISpecification&lt;T&gt; RightSideSpecification
        {
            get { <span class="kwrd">return</span> _RightSideSpecification; }
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; SatisfiedBy()
        {
            Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; left = _LeftSideSpecification.SatisfiedBy();
            Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; right = _RightSideSpecification.SatisfiedBy();

            InvocationExpression invokedExpr = Expression.Invoke(right, left.Parameters.Cast&lt;Expression&gt;());
            <span class="kwrd">return</span> Expression.Lambda&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt;(Expression.AndAlso(left.Body, invokedExpr), left.Parameters);
        }

        <span class="preproc">#endregion</span>
    }

/// <summary>

/// A logic AND Specification

/// </summary>

/// <typeparam name="T">Type of entity that check this specification</typeparam>

public class AndSpecification<T>

: CompositeSpecification<T>

where T : class,new()

{

#region Members

private ISpecification<T> _RightSideSpecification = null;

private ISpecification<T> _LeftSideSpecification = null;

#endregion

#region Public Constructor

/// <summary>

/// Default constructor for AndSpecification

/// </summary>

/// <param name="leftSide">Left side specification</param>

/// <param name="rightSide">Right side specification</param>

public AndSpecification(ISpecification<T> leftSide, ISpecification<T> rightSide)

{

if (leftSide == (ISpecification<T>)null)

throw new ArgumentNullException("leftSide");

if (rightSide == (ISpecification<T>)null)

throw new ArgumentNullException("rightSide");

this._LeftSideSpecification = leftSide;

this._RightSideSpecification = rightSide;

}

#endregion

#region Composite Specification overrides

/// <summary>

/// Left side specification

/// </summary>

public override ISpecification<T> LeftSideSpecification

{

get { return _LeftSideSpecification; }

}

/// <summary>

/// Right side specification

/// </summary>

public override ISpecification<T> RightSideSpecification

{

get { return _RightSideSpecification; }

}

/// <summary>

/// <see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/>

/// </summary>

/// <returns><see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/></returns>

public override Expression<Func<T, bool>> SatisfiedBy()

{

Expression<Func<T, bool>> left = _LeftSideSpecification.SatisfiedBy();

Expression<Func<T, bool>> right = _RightSideSpecification.SatisfiedBy();

InvocationExpression invokedExpr = Expression.Invoke(right, left.Parameters.Cast<Expression>());

return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(left.Body, invokedExpr), left.Parameters);

}

#endregion

}

Os podreís imaginar que la especificacion OR era similar a esta, simplemente modificando Expression.AndAlso por Expression.Or. Todo funcionaba de maravilla en mis test contra mi mock de los ObjectSet de Entity Framework hasta que pasando las pruebas de integración me di cuenta que el QueryProvider de Entity Framework no soportaba el método Invoke, al contrario que un QueryProvider sobre objetos en memoria, y que por lo tanto esta forma no me servía :-(.

Aunque ahora mismo pondré la solución fijaros como, de una forma elegante, manteniendo el principio de separación de responsabilidades y dejando un concepto de negocio como es un tipo especial de búsqueda perfectamente explícito, se podrían declarar especificaciones como la siguiente

NOTA: Seguramente que alguna vez ha pensado como hacer consultas distintas en función de parámetros usando conjunciones o disjunciones de expressiones, pues esta es una posible solución.

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// AdHoc specification for finding orders</span>
    <span class="rem">/// by shipping values</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> OrderShippingSpecification
        :Specification&lt;Order&gt;
    {
        <span class="preproc">#region</span> Members

        <span class="kwrd">string</span> _ShippingName = <span class="kwrd">default</span>(String);
        <span class="kwrd">string</span> _ShippingAddress = <span class="kwrd">default</span>(String);
        <span class="kwrd">string</span> _ShippingCity = <span class="kwrd">default</span>(String);
        <span class="kwrd">string</span> _ShippingZip = <span class="kwrd">default</span>(String);

        <span class="preproc">#endregion</span>

        <span class="preproc">#region</span> Constructor

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Default constructor for this specification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="shippingName"&gt;Shipping Name or null for not include this value in search&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="shippingAddress"&gt;Shipping Address or null for not include this vlaue in search&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="shippingCity"&gt;Shipping City or null for not include this value in search&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="shippingZip"&gt;Shipping Zip or null for not include this value in search&lt;/param&gt;</span>
        <span class="kwrd">public</span> OrderShippingSpecification(<span class="kwrd">string</span> shippingName,<span class="kwrd">string</span> shippingAddress,<span class="kwrd">string</span> shippingCity,<span class="kwrd">string</span> shippingZip)
        {
            _ShippingName = shippingName;
            _ShippingAddress = shippingAddress;
            _ShippingCity = shippingCity;
            _ShippingZip = shippingZip;
        }

        <span class="preproc">#endregion</span>

        <span class="preproc">#region</span> Specification Overrides

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref=" Microsoft.Samples.NLayerApp.Domain.Core.Specification.Specification{TEntity}"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref=" Microsoft.Samples.NLayerApp.Domain.Core.Specification.Specification{TEntity}"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> System.Linq.Expressions.Expression&lt;Func&lt;Order, <span class="kwrd">bool</span>&gt;&gt; SatisfiedBy()
        {
            Specification&lt;Order&gt; beginSpec = <span class="kwrd">new</span> TrueSpecification&lt;Order&gt;();

            <span class="kwrd">if</span> (_ShippingName != <span class="kwrd">null</span>)
                beginSpec &amp;= <span class="kwrd">new</span> DirectSpecification&lt;Order&gt;(o =&gt;o.ShippingName!=<span class="kwrd">null</span> &amp;&amp;  o.ShippingName.Contains(_ShippingName));

            <span class="kwrd">if</span> (_ShippingAddress != <span class="kwrd">null</span>)
                beginSpec &amp;= <span class="kwrd">new</span> DirectSpecification&lt;Order&gt;(o =&gt; o.ShippingAddress !=<span class="kwrd">null</span> &amp;&amp; o.ShippingAddress.Contains(_ShippingAddress));

            <span class="kwrd">if</span> (_ShippingCity != <span class="kwrd">null</span>)
                beginSpec &amp;= <span class="kwrd">new</span> DirectSpecification&lt;Order&gt;(o =&gt; o.ShippingCity != <span class="kwrd">null</span> &amp;&amp; o.ShippingCity.Contains(_ShippingCity));

            <span class="kwrd">if</span> (_ShippingZip != <span class="kwrd">null</span>)
                beginSpec &amp;= <span class="kwrd">new</span> DirectSpecification&lt;Order&gt;(o =&gt; o.ShippingZip != <span class="kwrd">null</span> &amp;&amp; o.ShippingZip.Contains(_ShippingZip));

            <span class="kwrd">return</span> beginSpec.SatisfiedBy();

        }

        <span class="preproc">#endregion</span>
    }

/// <summary>

/// AdHoc specification for finding orders

/// by shipping values

/// </summary>

public class OrderShippingSpecification

:Specification<Order>

{

#region Members

string _ShippingName = default(String);

string _ShippingAddress = default(String);

string _ShippingCity = default(String);

string _ShippingZip = default(String);

#endregion

#region Constructor

/// <summary>

/// Default constructor for this specification

/// </summary>

/// <param name="shippingName">Shipping Name or null for not include this value in search</param>

/// <param name="shippingAddress">Shipping Address or null for not include this vlaue in search</param>

/// <param name="shippingCity">Shipping City or null for not include this value in search</param>

/// <param name="shippingZip">Shipping Zip or null for not include this value in search</param>

public OrderShippingSpecification(string shippingName,string shippingAddress,string shippingCity,string shippingZip)

{

_ShippingName = shippingName;

_ShippingAddress = shippingAddress;

_ShippingCity = shippingCity;

_ShippingZip = shippingZip;

}

#endregion

#region Specification Overrides

/// <summary>

/// <see cref=" Microsoft.Samples.NLayerApp.Domain.Core.Specification.Specification{TEntity}"/>

/// </summary>

/// <returns><see cref=" Microsoft.Samples.NLayerApp.Domain.Core.Specification.Specification{TEntity}"/></returns>

public override System.Linq.Expressions.Expression<Func<Order, bool>> SatisfiedBy()

{

Specification<Order> beginSpec = new TrueSpecification<Order>();

if (_ShippingName != null)

beginSpec &= new DirectSpecification<Order>(o =>o.ShippingName!=null && o.ShippingName.Contains(_ShippingName));

if (_ShippingAddress != null)

beginSpec &= new DirectSpecification<Order>(o => o.ShippingAddress !=null && o.ShippingAddress.Contains(_ShippingAddress));

if (_ShippingCity != null)

beginSpec &= new DirectSpecification<Order>(o => o.ShippingCity != null && o.ShippingCity.Contains(_ShippingCity));

if (_ShippingZip != null)

beginSpec &= new DirectSpecification<Order>(o => o.ShippingZip != null && o.ShippingZip.Contains(_ShippingZip));

return beginSpec.SatisfiedBy();

}

#endregion

}

Una posible solución para especificaciones And y OR

Os podreís imaginar que seguramente existe más de una aproximación para este tema y que yo probablemente me haya decantado por una aproximación algo dura, pero la verdad es que me parecía la más adecuada. Releyendo algún post sobre el tema me acorde de la serie que Matt Warren tenía sobre el tema y como hacía uso del patrón Visitor para evaluar las expresiones, ExpressionVisitor. Además, navegando, me encontré con un ejemplo aceptable que resolvía este tema en el blog de Colling Meek el cual fué la solución que adopte.

Dada la explicación, lo que necesitamos es la siguiente clase que nos haga una recomposición de las expressiones en vez de un InvocationExpression, esta clase de apoyo es la siguiente:

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Extension methods for add And and Or with parameters rebinder</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">class</span> ExpressionBuilder
    {
        <span class="kwrd">public</span> <span class="kwrd">static</span> Expression&lt;T&gt; Compose&lt;T&gt;(<span class="kwrd">this</span> Expression&lt;T&gt; first, Expression&lt;T&gt; second, Func&lt;Expression, Expression, Expression&gt; merge)
        {
            <span class="rem">// build parameter map (from parameters of second to parameters of first)</span>
            var map = first.Parameters.Select((f, i) =&gt; <span class="kwrd">new</span> { f, s = second.Parameters[i] }).ToDictionary(p =&gt; p.s, p =&gt; p.f);

            <span class="rem">// replace parameters in the second lambda expression with parameters from the first</span>
            var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
            <span class="rem">// apply composition of lambda expression bodies to parameters from the first expression </span>
            <span class="kwrd">return</span> Expression.Lambda&lt;T&gt;(merge(first.Body, secondBody), first.Parameters);
        }
        <span class="kwrd">public</span> <span class="kwrd">static</span> Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; And&lt;T&gt;(<span class="kwrd">this</span> Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; first, Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; second)
        {
            <span class="kwrd">return</span> first.Compose(second, Expression.And);
        }
        <span class="kwrd">public</span> <span class="kwrd">static</span> Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; Or&lt;T&gt;(<span class="kwrd">this</span> Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; first, Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; second)
        {
            <span class="kwrd">return</span> first.Compose(second, Expression.Or);
        }

    }

/// <summary>

/// Extension methods for add And and Or with parameters rebinder

/// </summary>

public static class ExpressionBuilder

{

public static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)

{

// build parameter map (from parameters of second to parameters of first)

var map = first.Parameters.Select((f, i) => new { f, s = second.Parameters[i] }).ToDictionary(p => p.s, p => p.f);

// replace parameters in the second lambda expression with parameters from the first

var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);

// apply composition of lambda expression bodies to parameters from the first expression

return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);

}

public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)

{

return first.Compose(second, Expression.And);

}

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)

{

return first.Compose(second, Expression.Or);

}

&nbsp;

La definición completa por lo tanto de una especificación And queda como sigue:

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// A logic AND Specification</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="rem">/// &lt;typeparam name="T"&gt;Type of entity that check this specification&lt;/typeparam&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> AndSpecification&lt;T&gt;
       : CompositeSpecification&lt;T&gt;
       <span class="kwrd">where</span> T : <span class="kwrd">class</span>,<span class="kwrd">new</span>()
    {
        <span class="preproc">#region</span> Members

        <span class="kwrd">private</span> ISpecification&lt;T&gt; _RightSideSpecification = <span class="kwrd">null</span>;
        <span class="kwrd">private</span> ISpecification&lt;T&gt; _LeftSideSpecification = <span class="kwrd">null</span>;

        <span class="preproc">#endregion</span>

        <span class="preproc">#region</span> Public Constructor

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Default constructor for AndSpecification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="leftSide"&gt;Left side specification&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name="rightSide"&gt;Right side specification&lt;/param&gt;</span>
        <span class="kwrd">public</span> AndSpecification(ISpecification&lt;T&gt; leftSide, ISpecification&lt;T&gt; rightSide)
        {
            <span class="kwrd">if</span> (leftSide == (ISpecification&lt;T&gt;)<span class="kwrd">null</span>)
                <span class="kwrd">throw</span> <span class="kwrd">new</span> ArgumentNullException(<span class="str">"leftSide"</span>);

            <span class="kwrd">if</span> (rightSide == (ISpecification&lt;T&gt;)<span class="kwrd">null</span>)
                <span class="kwrd">throw</span> <span class="kwrd">new</span> ArgumentNullException(<span class="str">"rightSide"</span>);

            <span class="kwrd">this</span>._LeftSideSpecification = leftSide;
            <span class="kwrd">this</span>._RightSideSpecification = rightSide;
        }

        <span class="preproc">#endregion</span>

        <span class="preproc">#region</span> Composite Specification overrides

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Left side specification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> ISpecification&lt;T&gt; LeftSideSpecification
        {
            get { <span class="kwrd">return</span> _LeftSideSpecification; }
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Right side specification</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> ISpecification&lt;T&gt; RightSideSpecification
        {
            get { <span class="kwrd">return</span> _RightSideSpecification; }
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; SatisfiedBy()
        {
            Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; left = _LeftSideSpecification.SatisfiedBy();
            Expression&lt;Func&lt;T, <span class="kwrd">bool</span>&gt;&gt; right = _RightSideSpecification.SatisfiedBy();

            <span class="kwrd">return</span> (left.And(right));
         }

        <span class="preproc">#endregion</span>
    }

/// <summary>

/// A logic AND Specification

/// </summary>

/// <typeparam name="T">Type of entity that check this specification</typeparam>

public class AndSpecification<T>

: CompositeSpecification<T>

where T : class,new()

{

#region Members

private ISpecification<T> _RightSideSpecification = null;

private ISpecification<T> _LeftSideSpecification = null;

#endregion

#region Public Constructor

/// <summary>

/// Default constructor for AndSpecification

/// </summary>

/// <param name="leftSide">Left side specification</param>

/// <param name="rightSide">Right side specification</param>

public AndSpecification(ISpecification<T> leftSide, ISpecification<T> rightSide)

{

if (leftSide == (ISpecification<T>)null)

throw new ArgumentNullException("leftSide");

if (rightSide == (ISpecification<T>)null)

throw new ArgumentNullException("rightSide");

this._LeftSideSpecification = leftSide;

this._RightSideSpecification = rightSide;

}

#endregion

#region Composite Specification overrides

/// <summary>

/// Left side specification

/// </summary>

public override ISpecification<T> LeftSideSpecification

{

get { return _LeftSideSpecification; }

}

/// <summary>

/// Right side specification

/// </summary>

public override ISpecification<T> RightSideSpecification

{

get { return _RightSideSpecification; }

}

/// <summary>

/// <see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/>

/// </summary>

/// <returns><see cref="Microsoft.Samples.NLayerApp.Domain.Core.Specification.ISpecification"/></returns>

public override Expression<Func<T, bool>> SatisfiedBy()

{

Expression<Func<T, bool>> left = _LeftSideSpecification.SatisfiedBy();

Expression<Func<T, bool>> right = _RightSideSpecification.SatisfiedBy();

return (left.And(right));

}

#endregion

}

&nbsp;

¿Por dónde continuamos?

Dentro de la jerarquía de especificaciones que se propone en el documento de Eric y Fowler podemos encontrar desde la especificación Not hasta una base para LeafSpecifications que tendríamos que construir… es decir, un poquito más de curro para poder disfrutar…

Un resumen

La verdad espero que le encontréis utilidad a esta forma de implementar el patrón Specification, y por supuesto, si no lo conociais espero que os levante un poco la curiosidad y veais las bondades que este puede tener dentro de vuestros desarrollos, por supuesto me encantaría ver vuestras opiniones al respecto y si realmente esta forma de encajar criterios es adecuado para vuestras soluciones…

Saludos

Unai Zorrilla

Mes: febrero 2010

EF 4 – Features CTP 2 y VS2010 RC

Entity Framework y Specification Pattern

Introducción

Profundizando

Una posible solución para especificaciones And y OR

¿Por dónde continuamos?

Un resumen