EF 6: Ejemplos de operaciones de migracion

Tal y como hicimos en la entrega anterior vamos a ir poniendo ejemplos completos de algunos de los puntos de extensibilidad que tenemos en Entity Framework 6. En esta ocasión hablaremos de operaciones de migración, algo que ya comentamos en alguna entrada anterior, como esta. Tal y como explicamos en su momento, esto nos permite cubrir de forma personalizada con operaciones que no tengamos out of box.

Como en la entrada anterior, el código se puede descargar desde:

https://github.com/unaizorrilla/ef.contrib

Creación y borrado de vistas

A pesar de que esto suele ser habitual, estas opciones no las tenemos por defecto como operaciones de migración, por lo que son unos buenos candidatos de ejemplo. A continuación podemos ver el código de la operación CreateViewOperation.

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Represent a create view in database</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> CreateViewOperation
        :MigrationOperation
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// The view name</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> ViewName { get; <span class="kwrd">private</span> set; }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// The view body sql</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> BodySql { get; <span class="kwrd">private</span> set; }


        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new instance</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;viewName&quot;&gt;the view name to create&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;bodySql&quot;&gt;the view body sql &lt;/param&gt;</span>
        <span class="kwrd">public</span> CreateViewOperation(<span class="kwrd">string</span> viewName, <span class="kwrd">string</span> bodySql)
            :<span class="kwrd">base</span>(<span class="kwrd">null</span>)
        {
            Check.NotEmpty(viewName,<span class="str">&quot;viewName&quot;</span>);
            Check.NotEmpty(bodySql,<span class="str">&quot;bodySql&quot;</span>);

            <span class="kwrd">this</span>.ViewName = viewName;
            <span class="kwrd">this</span>.BodySql = bodySql;
        }

        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">bool</span> IsDestructiveChange
        {
            get { <span class="kwrd">return</span> <span class="kwrd">false</span>; }
        }

        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> MigrationOperation Inverse
        {
            get
            {
                <span class="kwrd">return</span> <span class="kwrd">new</span> DropViewOperation(ViewName);
            }
        }
    }

/// <summary>

/// Represent a create view in database

/// </summary>

public class CreateViewOperation

:MigrationOperation

{

/// <summary>

/// The view name

/// </summary>

public string ViewName { get; private set; }

/// <summary>

/// The view body sql

/// </summary>

public string BodySql { get; private set; }

/// <summary>

/// Create a new instance

/// </summary>

/// <param name="viewName">the view name to create</param>

/// <param name="bodySql">the view body sql </param>

public CreateViewOperation(string viewName, string bodySql)

:base(null)

{

Check.NotEmpty(viewName,"viewName");

Check.NotEmpty(bodySql,"bodySql");

this.ViewName = viewName;

this.BodySql = bodySql;

}

/// <inheritdoc/>

public override bool IsDestructiveChange

{

get { return false; }

}

/// <inheritdoc/>

public override MigrationOperation Inverse

{

get

{

return new DropViewOperation(ViewName);

}

La operación de borrado es también bastante sencilla:

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Represent a drop view operation</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> DropViewOperation
        :MigrationOperation
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Get the view name to drop</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> ViewName { get; <span class="kwrd">private</span> set; }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new View</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;viewName&quot;&gt;the view name to drop&lt;/param&gt;</span>
        <span class="kwrd">public</span> DropViewOperation(<span class="kwrd">string</span> viewName)
            :<span class="kwrd">base</span>(<span class="kwrd">null</span>)
        {
            Check.NotEmpty(viewName, <span class="str">&quot;viewName&quot;</span>);

            ViewName = viewName;
        }

        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">bool</span> IsDestructiveChange
        {
            get { <span class="kwrd">return</span> <span class="kwrd">true</span>; }
        }
    }

/// <summary>

/// Represent a drop view operation

/// </summary>

public class DropViewOperation

:MigrationOperation

{

/// <summary>

/// Get the view name to drop

/// </summary>

public string ViewName { get; private set; }

/// <summary>

/// Create a new View

/// </summary>

/// <param name="viewName">the view name to drop</param>

public DropViewOperation(string viewName)

:base(null)

{

Check.NotEmpty(viewName, "viewName");

ViewName = viewName;

}

/// <inheritdoc/>

public override bool IsDestructiveChange

{

get { return true; }

}

Bien, ahora que ya tenemos creadas las operaciones solamente queda registrarlas en nuestro generador, que crearemos para darle soporte, tal y como se ve:

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Extented Sql Server Migrations Sql Generator with more</span>
    <span class="rem">/// operations.</span>
    <span class="rem">/// &lt;remarks&gt;</span>
    <span class="rem">/// For set  this migrations sql generator you need register it in</span>
    <span class="rem">/// your DbMigrationsConfiguration{TContext} using the method </span>
    <span class="rem">/// SetSqlGenerator</span>
    <span class="rem">/// &lt;example&gt;</span>
    <span class="rem">/// SetSqlGenerator(&quot;System.Data.SqlClient&quot;, new AdvancedSqlServerMigrationSqlGenerator());</span>
    <span class="rem">/// &lt;/example&gt;</span>
    <span class="rem">/// &lt;/remarks&gt;</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> ExtendedSqlServerMigrationSqlGenerator
        : SqlServerMigrationSqlGenerator
    {
        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Generate(MigrationOperation migrationOperation)
        {
            <span class="kwrd">this</span>.Generate((dynamic)migrationOperation);
        }
    }

/// <summary>

/// Extented Sql Server Migrations Sql Generator with more

/// operations.

/// <remarks>

/// For set this migrations sql generator you need register it in

/// your DbMigrationsConfiguration{TContext} using the method

/// SetSqlGenerator

/// <example>

/// SetSqlGenerator("System.Data.SqlClient", new AdvancedSqlServerMigrationSqlGenerator());

/// </example>

/// </remarks>

/// </summary>

public class ExtendedSqlServerMigrationSqlGenerator

: SqlServerMigrationSqlGenerator

{

/// <inheritdoc/>

protected override void Generate(MigrationOperation migrationOperation)

{

this.Generate((dynamic)migrationOperation);

}

Si observa, hay un pequeño truco para no hacer “feas” conversiones de nuestras operaciones y ejecutar código en función de la que sea, y consiste en utilizar el tipo dynamic, gracias al cual podremos redirigir al generador de la operación que necesitemos…

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Extented Sql Server Migrations Sql Generator with more</span>
    <span class="rem">/// operations.</span>
    <span class="rem">/// &lt;remarks&gt;</span>
    <span class="rem">/// For set  this migrations sql generator you need register it in</span>
    <span class="rem">/// your DbMigrationsConfiguration{TContext} using the method </span>
    <span class="rem">/// SetSqlGenerator</span>
    <span class="rem">/// &lt;example&gt;</span>
    <span class="rem">/// SetSqlGenerator(&quot;System.Data.SqlClient&quot;, new AdvancedSqlServerMigrationSqlGenerator());</span>
    <span class="rem">/// &lt;/example&gt;</span>
    <span class="rem">/// &lt;/remarks&gt;</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> ExtendedSqlServerMigrationSqlGenerator
        : SqlServerMigrationSqlGenerator
    {
        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Generate(MigrationOperation migrationOperation)
        {
            <span class="kwrd">this</span>.Generate((dynamic)migrationOperation);
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Generate a SQL to create a new view in database</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;createViewOperation&quot;&gt;The operation to produce sql for.&lt;/param&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> Generate(CreateViewOperation createViewOperation)
        {
            <span class="kwrd">using</span> (var writer = Writer())
            {
                writer.WriteLine(<span class="str">&quot;CREATE VIEW {0} AS {1};&quot;</span>,createViewOperation.ViewName,createViewOperation.BodySql);

                <span class="kwrd">this</span>.Statement(writer);
            }
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Generate a SQL to drop a existing view in database</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;dropViewOperation&quot;&gt;The operation to produce sql for.&lt;/param&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> Generate(DropViewOperation dropViewOperation)
        {
            <span class="kwrd">using</span> (var writer = Writer())
            {
                writer.WriteLine(<span class="str">&quot;DROP VIEW {0} &quot;</span>, dropViewOperation.ViewName);
              
                <span class="kwrd">this</span>.Statement(writer);
            }
        }
     }

/// <summary>

/// Extented Sql Server Migrations Sql Generator with more

/// operations.

/// <remarks>

/// For set this migrations sql generator you need register it in

/// your DbMigrationsConfiguration{TContext} using the method

/// SetSqlGenerator

/// <example>

/// SetSqlGenerator("System.Data.SqlClient", new AdvancedSqlServerMigrationSqlGenerator());

/// </example>

/// </remarks>

/// </summary>

public class ExtendedSqlServerMigrationSqlGenerator

: SqlServerMigrationSqlGenerator

{

/// <inheritdoc/>

protected override void Generate(MigrationOperation migrationOperation)

{

this.Generate((dynamic)migrationOperation);

}

/// <summary>

/// Generate a SQL to create a new view in database

/// </summary>

/// <param name="createViewOperation">The operation to produce sql for.</param>

public virtual void Generate(CreateViewOperation createViewOperation)

{

using (var writer = Writer())

{

writer.WriteLine("CREATE VIEW {0} AS {1};",createViewOperation.ViewName,createViewOperation.BodySql);

this.Statement(writer);

}

/// <summary>

/// Generate a SQL to drop a existing view in database

/// </summary>

/// <param name="dropViewOperation">The operation to produce sql for.</param>

public virtual void Generate(DropViewOperation dropViewOperation)

{

using (var writer = Writer())

{

writer.WriteLine("DROP VIEW {0} ", dropViewOperation.ViewName);

this.Statement(writer);

}

Para finalizar, ahora que tenemos nuestras operaciones y nuestro nuevo generador, solamente nos queda registrarlo…

    <span class="kwrd">public</span> <span class="kwrd">class</span> Configuration
        :DbConfiguration
    {
        <span class="kwrd">public</span> Configuration()
        {
            AddMigrationSqlGenerator(<span class="str">&quot;System.Data.SqlClient&quot;</span>, () =&gt;
            {
                <span class="kwrd">return</span> <span class="kwrd">new</span> ExtendedSqlServerMigrationSqlGenerator();
            });
        }
    }

public class Configuration

:DbConfiguration

{

public Configuration()

{

AddMigrationSqlGenerator("System.Data.SqlClient", () =>

{

return new ExtendedSqlServerMigrationSqlGenerator();

});

}

Como se imaginará hay muchas más operaciones que podríamos construir para nuestras migraciones, cosas como el manejo de permisos, collation son algunas de las otras operaciones que tiene en el código de ejemplo que se hace referencia al principio del post.

Saludos

unai

EF 6: Un ejemplo de pluralizador en castellano

Desde hace ya un tiempo vengo recibiendo bastantes correos con respecto a una de las nuevas características de EF 6 referida al sistema de pluralización. Aunque ya en este mismo blog he hablado un poco sobre esta característica la verdad es que no había enseñado un ejemplo completo. Por eso, intentaré publicar en este blog ejemplos completos sobre algunas piezas de las que hemos hablado en EF 6 pero de las que no hemos dado ejemplo completos, para este y para los siguientes posts, el código lo puede descargar desde GitHub:

https://github.com/unaizorrilla/ef.contrib.git

Para la creación del sistema de pluralización en castellano intenté no reinventar la rueda y ver como otros hacían este trabajo, como por ejemplo Andrew Peters. @anpete – developer de ADO.NET EF, con su Inflector .NET. Para las reglas de pluralización en castellano uno puede ver los diferentes documentos que hay en internet sobre esto, basta abrir Bing y hacer una pequeña búsqueda para ver cantidad de enlaces. Después de leer sobre estas reglas un posible esbozo del pluralizador podría ser el siguiente, por supuesto el código tiene sus correspondientes tests que si os interesa podríais ayudar a mejorar incluyendo nuevos casos de prueba, tanto para los elementos irregulares como para los regulares.

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">///  Pluralization service for spanish language.</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> SpanishPluralizationService
        :IPluralizationService
    {
        BidirectionalDictionary&lt;String, String&gt; _userDictionaryEntries = <span class="kwrd">new</span> BidirectionalDictionary&lt;String, String&gt;();

        StringBidirectionalDictionary _irregularWords = <span class="kwrd">new</span> StringBidirectionalDictionary(<span class="kwrd">new</span> Dictionary&lt;<span class="kwrd">string</span>, <span class="kwrd">string</span>&gt;()
        {
            {<span class="str">"faralá"</span>,<span class="str">"faralaes"</span>},
            {<span class="str">"albalá"</span>,<span class="str">"albalaes"</span>},
            {<span class="str">"no"</span>,<span class="str">"noes"</span>},
            {<span class="str">"gay"</span>,<span class="str">"gais"</span>},
            {<span class="str">"jersey"</span>,<span class="str">"jerséis"</span>},
            {<span class="str">"espray"</span>,<span class="str">"espráis"</span>},
            {<span class="str">"yóquey"</span>,<span class="str">"yoqueis"</span>},
            {<span class="str">"gachí"</span>,<span class="str">"gachís"</span>},
            {<span class="str">"pirulí"</span>,<span class="str">"pirulís"</span>},
            {<span class="str">"popurrí"</span>,<span class="str">"popurrís"</span>},
            {<span class="str">"champú"</span>,<span class="str">"champús"</span>},
            {<span class="str">"menú"</span>,<span class="str">"menús"</span>},
            {<span class="str">"tutú"</span>,<span class="str">"tutús"</span>},
            {<span class="str">"vermú"</span>,<span class="str">"vermús"</span>},
            {<span class="str">"lunes"</span>,<span class="str">"lunes"</span>},
            {<span class="str">"martes"</span>,<span class="str">"martes"</span>},
            {<span class="str">"miércoles"</span>,<span class="str">"miércoles"</span>},
            {<span class="str">"jueves"</span>,<span class="str">"jueves"</span>},
            {<span class="str">"viernes"</span>,<span class="str">"viernes"</span>},
            {<span class="str">"cienpiés"</span>,<span class="str">"cienpiés"</span>},
            {<span class="str">"buscapiés"</span>,<span class="str">"buscapiés"</span>},
            {<span class="str">"pasarurés"</span>,<span class="str">"pasapurés"</span>},
            {<span class="str">"polisíndeton"</span>,<span class="str">"polisíndeton"</span>},
            {<span class="str">"trávelin"</span>,<span class="str">"trávelin"</span>},
            {<span class="str">"cátering"</span>,<span class="str">"cátering"</span>},
            {<span class="str">"hipérbaton"</span>,<span class="str">"hipérbatos"</span>},
            {<span class="str">"imán"</span>,<span class="str">"imanes"</span>},
            {<span class="str">"imam"</span>,<span class="str">"imames"</span>},
            {<span class="str">"álbum"</span>,<span class="str">"álbumes"</span>},
            {<span class="str">"sándwich"</span>,<span class="str">"sandwiches"</span>},
            {<span class="str">"paraguas"</span>,<span class="str">"paraguas"</span>},
            {<span class="str">"tijeras"</span>,<span class="str">"tijeras"</span>},
            {<span class="str">"gafas"</span>,<span class="str">"gafas"</span>},
            {<span class="str">"víveres"</span>,<span class="str">"víveres"</span>},
            {<span class="str">"virus"</span>,<span class="str">"virus"</span>},
            {<span class="str">"atlas"</span>,<span class="str">"atlas"</span>},
            {<span class="str">"déficit"</span>,<span class="str">"déficit"</span>},
            {<span class="str">"crisis"</span>,<span class="str">"crisis"</span>},
            {<span class="str">"tórax"</span>,<span class="str">"tórax"</span>},
            {<span class="str">"fórceps"</span>,<span class="str">"fórceps"</span>},
            {<span class="str">"ratio"</span>,<span class="str">"ratios"</span>},
            {<span class="str">"plus"</span>,<span class="str">"pluses"</span>},
            {<span class="str">"tos"</span>,<span class="str">"toses"</span>},
            {<span class="str">"lapsus"</span>,<span class="str">"lapsus"</span>},
            {<span class="str">"ultimátum"</span>, <span class="str">"ultimatos"</span>},
            {<span class="str">"memorándum"</span>, <span class="str">"memorandos"</span>},
            {<span class="str">"referéndum"</span>, <span class="str">"referendos"</span>},
            {<span class="str">"vals"</span>,<span class="str">"valses"</span>}
        });

        <span class="kwrd">private</span> <span class="kwrd">readonly</span> List&lt;ReplacementRule&gt; PluralizationRules =
            <span class="kwrd">new</span> List&lt;ReplacementRule&gt;();

        <span class="kwrd">private</span> <span class="kwrd">readonly</span> List&lt;ReplacementRule&gt; SingularizationRules =
            <span class="kwrd">new</span> List&lt;ReplacementRule&gt;();

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new instance</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="userDictionaryEntries"&gt;&lt;/param&gt;</span>
        <span class="kwrd">public</span> SpanishPluralizationService(IEnumerable&lt;CustomPluralizationEntry&gt; userDictionaryEntries)
            : <span class="kwrd">this</span>()
        {
            userDictionaryEntries.Each(entry =&gt;
            {
                _userDictionaryEntries.AddValue(entry.Singular, entry.Plural);
            });
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new instance</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> SpanishPluralizationService()
        {
            <span class="rem">//Add pluralization rules</span>
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiouáéó])$"</span>, <span class="str">"$1s"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([íú])$"</span>, <span class="str">"$1es"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+y$)"</span>, <span class="str">"$1es"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([b-df-hj-np-tv-z]+)y$"</span>, <span class="str">"$1is"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ás$"</span>, <span class="str">"$1ases"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)és$"</span>, <span class="str">"$1eses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ís$"</span>, <span class="str">"$1ises"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ós$"</span>, <span class="str">"$1oses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ús$"</span>, <span class="str">"$1uses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)s$"</span>, <span class="str">"$1ses"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[l]$"</span>, <span class="str">"$1les"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[r]$"</span>, <span class="str">"$1res"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[n]$"</span>, <span class="str">"$1nes"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[d]$"</span>, <span class="str">"$1des"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[z]$"</span>, <span class="str">"$1zes"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([aeiou]+)[j]$"</span>, <span class="str">"$1jes"</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([a-z]+)ch$"</span>, <span class="kwrd">null</span>));
            PluralizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(ng|[mwckgtp])$"</span>, <span class="str">"$1s"</span>));

            <span class="rem">//Add singularization rules</span>
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([ghñpv]e)s$"</span>, <span class="str">""</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([bcdfghjklmnñprstvwxyz]{2,}e)s$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"([^e])s$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(oides)$"</span>, <span class="str">"oide"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(é)s$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(sis|tis|xis)+$"</span>, <span class="str">"$1"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"(ces)$"</span>, <span class="str">"z"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"^([bcdfghjklmnñpqrstvwxyz]*)([aeiou])([ns])es$"</span>, <span class="str">"$1$2$3"</span>));
            SingularizationRules.Add(<span class="kwrd">new</span> ReplacementRule(<span class="str">"es$"</span>, <span class="str">""</span>));
        }

       
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="word"&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> Pluralize(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">return</span> Capitalize(word, InternalPluralize);
        }
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// &lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="word"&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/&gt;&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> Singularize(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">return</span> Capitalize(word, InternalSingularize);
        }

        <span class="kwrd">string</span> InternalSingularize(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInSecond(word))
                <span class="kwrd">return</span> _userDictionaryEntries.GetFirstValue(word);

            <span class="kwrd">if</span> (_irregularWords.ExistsInSecond(word))
                <span class="kwrd">return</span> _irregularWords.GetFirstValue(word.ToLowerInvariant());

            <span class="kwrd">if</span> (IsSingular(word))
                <span class="kwrd">return</span> word;

            var rule = SingularizationRules.Where(ir =&gt; ir.IsValidFor(word.ToLowerInvariant()))
                                          .FirstOrDefault();
            <span class="kwrd">if</span> (rule != <span class="kwrd">null</span>)
                <span class="kwrd">return</span> rule.Apply(word.ToLowerInvariant());

            <span class="kwrd">return</span> word;
        }

        <span class="kwrd">string</span> InternalPluralize(<span class="kwrd">string</span> word)
        {
            DebugCheck.NotEmpty(word);

            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInFirst(word))
                <span class="kwrd">return</span> _userDictionaryEntries.GetSecondValue(word);

            <span class="kwrd">if</span> (_irregularWords.ExistsInFirst(word))
                <span class="kwrd">return</span> _irregularWords.GetSecondValue(word.ToLowerInvariant());

            <span class="kwrd">if</span> (IsPlural(word))
                <span class="kwrd">return</span> word;

            var rule = PluralizationRules.Where(ir =&gt; ir.IsValidFor(word.ToLowerInvariant()))
                                         .FirstOrDefault();

            <span class="kwrd">if</span> (rule != <span class="kwrd">null</span>)
                <span class="kwrd">return</span> rule.Apply(word.ToLowerInvariant());

            <span class="kwrd">return</span> word;
        }

        <span class="kwrd">private</span> <span class="kwrd">bool</span> IsPlural(<span class="kwrd">string</span> word)
        {
            DebugCheck.NotEmpty(word);

            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInSecond(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="kwrd">if</span> (_irregularWords.ExistsInSecond(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="rem">//return if any singularization rule exist</span>
            var rule = SingularizationRules.Where(ir =&gt; ir.IsValidFor(word.ToLowerInvariant()))
                                          .FirstOrDefault();

            <span class="kwrd">return</span> rule != <span class="kwrd">null</span>;
        }

        <span class="kwrd">private</span> <span class="kwrd">bool</span> IsSingular(<span class="kwrd">string</span> word)
        {
            DebugCheck.NotEmpty(word);

            <span class="kwrd">if</span> (_userDictionaryEntries.ExistsInFirst(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="kwrd">if</span> (_irregularWords.ExistsInFirst(word))
                <span class="kwrd">return</span> <span class="kwrd">true</span>;

            <span class="kwrd">return</span> <span class="kwrd">false</span>;
        }

        <span class="kwrd">private</span> <span class="kwrd">static</span> <span class="kwrd">bool</span> IsCapitalized(<span class="kwrd">string</span> word)
        {
            <span class="kwrd">return</span> <span class="kwrd">string</span>.IsNullOrEmpty(word) ? <span class="kwrd">false</span> : <span class="kwrd">char</span>.IsUpper(word, 0);
        }

        <span class="kwrd">private</span> <span class="kwrd">static</span> <span class="kwrd">string</span> Capitalize(<span class="kwrd">string</span> word, Func&lt;<span class="kwrd">string</span>, <span class="kwrd">string</span>&gt; action)
        {
            var result = action(word);

            <span class="kwrd">if</span> (IsCapitalized(word))
            {
                <span class="kwrd">if</span> (result.Length == 0)
                {
                    <span class="kwrd">return</span> result;
                }

                var sb = <span class="kwrd">new</span> StringBuilder(result.Length);

                sb.Append(<span class="kwrd">char</span>.ToUpperInvariant(result[0]));
                sb.Append(result.Substring(1));

                <span class="kwrd">return</span> sb.ToString();
            }
            <span class="kwrd">else</span>
            {
                <span class="kwrd">return</span> result;
            }
        }
    }

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

/// <summary>

/// Pluralization service for spanish language.

/// </summary>

public class SpanishPluralizationService

:IPluralizationService

{

BidirectionalDictionary<String, String> _userDictionaryEntries = new BidirectionalDictionary<String, String>();

StringBidirectionalDictionary _irregularWords = new StringBidirectionalDictionary(new Dictionary<string, string>()

{

{"faralá","faralaes"},

{"albalá","albalaes"},

{"no","noes"},

{"gay","gais"},

{"jersey","jerséis"},

{"espray","espráis"},

{"yóquey","yoqueis"},

{"gachí","gachís"},

{"pirulí","pirulís"},

{"popurrí","popurrís"},

{"champú","champús"},

{"menú","menús"},

{"tutú","tutús"},

{"vermú","vermús"},

{"lunes","lunes"},

{"martes","martes"},

{"miércoles","miércoles"},

{"jueves","jueves"},

{"viernes","viernes"},

{"cienpiés","cienpiés"},

{"buscapiés","buscapiés"},

{"pasarurés","pasapurés"},

{"polisíndeton","polisíndeton"},

{"trávelin","trávelin"},

{"cátering","cátering"},

{"hipérbaton","hipérbatos"},

{"imán","imanes"},

{"imam","imames"},

{"álbum","álbumes"},

{"sándwich","sandwiches"},

{"paraguas","paraguas"},

{"tijeras","tijeras"},

{"gafas","gafas"},

{"víveres","víveres"},

{"virus","virus"},

{"atlas","atlas"},

{"déficit","déficit"},

{"crisis","crisis"},

{"tórax","tórax"},

{"fórceps","fórceps"},

{"ratio","ratios"},

{"plus","pluses"},

{"tos","toses"},

{"lapsus","lapsus"},

{"ultimátum", "ultimatos"},

{"memorándum", "memorandos"},

{"referéndum", "referendos"},

{"vals","valses"}

});

private readonly List<ReplacementRule> PluralizationRules =

new List<ReplacementRule>();

private readonly List<ReplacementRule> SingularizationRules =

new List<ReplacementRule>();

/// <summary>

/// Create a new instance

/// </summary>

/// <param name="userDictionaryEntries"></param>

public SpanishPluralizationService(IEnumerable<CustomPluralizationEntry> userDictionaryEntries)

: this()

{

userDictionaryEntries.Each(entry =>

{

_userDictionaryEntries.AddValue(entry.Singular, entry.Plural);

});

}

/// <summary>

/// Create a new instance

/// </summary>

public SpanishPluralizationService()

{

//Add pluralization rules

PluralizationRules.Add(new ReplacementRule("([aeiouáéó])$", "$1s"));

PluralizationRules.Add(new ReplacementRule("([íú])$", "$1es"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+y$)", "$1es"));

PluralizationRules.Add(new ReplacementRule("([b-df-hj-np-tv-z]+)y$", "$1is"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ás$", "$1ases"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)és$", "$1eses"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ís$", "$1ises"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ós$", "$1oses"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ús$", "$1uses"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)s$", "$1ses"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[l]$", "$1les"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[r]$", "$1res"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[n]$", "$1nes"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[d]$", "$1des"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[z]$", "$1zes"));

PluralizationRules.Add(new ReplacementRule("([aeiou]+)[j]$", "$1jes"));

PluralizationRules.Add(new ReplacementRule("([a-z]+)ch$", null));

PluralizationRules.Add(new ReplacementRule("(ng|[mwckgtp])$", "$1s"));

//Add singularization rules

SingularizationRules.Add(new ReplacementRule("([ghñpv]e)s$", ""));

SingularizationRules.Add(new ReplacementRule("([bcdfghjklmnñprstvwxyz]{2,}e)s$", "$1"));

SingularizationRules.Add(new ReplacementRule("([^e])s$", "$1"));

SingularizationRules.Add(new ReplacementRule("(oides)$", "oide"));

SingularizationRules.Add(new ReplacementRule("(é)s$", "$1"));

SingularizationRules.Add(new ReplacementRule("(sis|tis|xis)+$", "$1"));

SingularizationRules.Add(new ReplacementRule("(ces)$", "z"));

SingularizationRules.Add(new ReplacementRule("^([bcdfghjklmnñpqrstvwxyz]*)([aeiou])([ns])es$", "$1$2$3"));

SingularizationRules.Add(new ReplacementRule("es$", ""));

}

/// <summary>

/// <see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/>

/// </summary>

/// <param name="word"><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></param>

/// <returns><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></returns>

public string Pluralize(string word)

{

return Capitalize(word, InternalPluralize);

}

/// <summary>

/// <see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/>

/// </summary>

/// <param name="word"><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></param>

/// <returns><see cref="System.Data.Entity.Infrastructure.Pluralization.IPluralizationService"/></returns>

public string Singularize(string word)

{

return Capitalize(word, InternalSingularize);

}

string InternalSingularize(string word)

{

if (_userDictionaryEntries.ExistsInSecond(word))

return _userDictionaryEntries.GetFirstValue(word);

if (_irregularWords.ExistsInSecond(word))

return _irregularWords.GetFirstValue(word.ToLowerInvariant());

if (IsSingular(word))

return word;

var rule = SingularizationRules.Where(ir => ir.IsValidFor(word.ToLowerInvariant()))

.FirstOrDefault();

if (rule != null)

return rule.Apply(word.ToLowerInvariant());

return word;

}

string InternalPluralize(string word)

{

DebugCheck.NotEmpty(word);

if (_userDictionaryEntries.ExistsInFirst(word))

return _userDictionaryEntries.GetSecondValue(word);

if (_irregularWords.ExistsInFirst(word))

return _irregularWords.GetSecondValue(word.ToLowerInvariant());

if (IsPlural(word))

return word;

var rule = PluralizationRules.Where(ir => ir.IsValidFor(word.ToLowerInvariant()))

.FirstOrDefault();

if (rule != null)

return rule.Apply(word.ToLowerInvariant());

return word;

}

private bool IsPlural(string word)

{

DebugCheck.NotEmpty(word);

if (_userDictionaryEntries.ExistsInSecond(word))

return true;

if (_irregularWords.ExistsInSecond(word))

return true;

//return if any singularization rule exist

var rule = SingularizationRules.Where(ir => ir.IsValidFor(word.ToLowerInvariant()))

.FirstOrDefault();

return rule != null;

}

private bool IsSingular(string word)

{

DebugCheck.NotEmpty(word);

if (_userDictionaryEntries.ExistsInFirst(word))

return true;

if (_irregularWords.ExistsInFirst(word))

return true;

return false;

}

private static bool IsCapitalized(string word)

{

return string.IsNullOrEmpty(word) ? false : char.IsUpper(word, 0);

}

private static string Capitalize(string word, Func<string, string> action)

{

var result = action(word);

if (IsCapitalized(word))

{

if (result.Length == 0)

{

return result;

}

var sb = new StringBuilder(result.Length);

sb.Append(char.ToUpperInvariant(result[0]));

sb.Append(result.Substring(1));

return sb.ToString();

}

else

{

return result;

}

Bien, ahora que ya tenemos el pluralizador creado, para establecerlo lo tenemos tan fácil como usar nuestro DbConfiguration.

    <span class="kwrd">public</span> <span class="kwrd">class</span> Configuration
        :DbConfiguration
    {
        <span class="kwrd">public</span> Configuration()
        {
            <span class="rem">//...</span>

            SetPluralizationService(<span class="kwrd">new</span> SpanishPluralizationService());

           <span class="rem">//...</span>
        }
    }

public class Configuration

:DbConfiguration

{

public Configuration()

{

//...

SetPluralizationService(new SpanishPluralizationService());

//...

}

&nbsp;

Saludos

Saludos

Unai

Unai

EF 6: Multiples contextos y migraciones para la misma base de datos

Una de las nuevas características de EF 6 es el soporte para múltiples modelos en una base de datos, creo que alguna vez lo he mencionado desde este mismo blog. Tal y como podemos ver en el feature specification del equipo de producto esta característica se basa principalmente en la nueva propiedad ContextKey de nuestra tabla MigrationHistory y la propagación del esquema de cada contexto. Aunque ya hay algunos ejemplos de esta característica por internet como por ejemplo este de Julie, me gustaría ver un pequeños trick para aprovecharnos de esta característica con diferentes contextos en un mismo proyecto.

Como todos sabéis, el primer paso para habilitar las migraciones es ejecutar el comando enable-migrations, el cual por defecto, nos crea una nueva carpeta llamada Migrations con la configuración de la migración de un contexto de trabajo. El problema es que, si tenemos varios contextos, este comando no sabrá de cual queremos hacer nuestra configuración de migración y nos mostrará un mensaje como el siguiente:

PM> enable-migrations
More than one context type was found in the assembly ‘MultipleContextDatabase’.
To enable migrations for ‘MultipleContextDatabase.ContextA.ContextA’, use Enable-Migrations -ContextTypeName MultipleContextDatabase.ContextA.ContextA.
To enable migrations for ‘MultipleContextDatabase.ContextB.ContextB’, use Enable-Migrations -ContextTypeName MultipleContextDatabase.ContextB.ContextB.

Aunque en principio, estemos tentados por probar alguna de las soluciones que el mensaje de error nos ofrece, en realidad no ganaremos nada, puesto que lo único que haríamos es tener habilitadas las migraciones para alguno de los contextos pero no para ámbos como necsitamos. La solución, para tener varias configuraciones de migración, es que las mismas estén en diferentes carpetas, para lo cual podemos aprovecharnos del flag MigrationsDirectory.

PM>enable-migrations -ContextTypeName MultipleContextDatabase.ContextA.ContextA -MigrationsDirectory:MigrationsA

PM>enable-migrations -ContextTypeName MultipleContextDatabase.ContextB.ContextB -MigrationsDirectory:MigrationsB

Con estas dos sencilla ejecuciones ya tenemos nuestras dos configuraciones de migración creadas. Por supuesto, para crear nuevas migraciones o actualizar la base de datos será necesario especificar que configuración de migración queremos usar, por ello, todos los comandos ponen a nuestra disposición el flag ConfigurationTypeName. A continuación, podemos ver un ejemplo:

PM> Add-Migration Initial -ConfigurationTypeName MultipleContextDatabase.MigrationsA.Configuration

Bien, hasta aquí este pequeño trick

Un saludo

Unai

Materiales Web Cast–Introduccion a EF 6

Bueno amigos, para todos los que no habéis podido ir al web cast o para los que lo queréis volver a ver aquí tenéis la grabación y la ppt

– Grabación del Web Cast

– PPT

Un saludo a todos

Unai

EF 6: WebCast ADO.NET Entity Framework

El próximo día 30 de Mayo, tendremos el placer de poder realizar un WebCast con Diego Vega, Developer Lead de Entity Framework, hablando de todo lo que rodea a EF 6, desde el nuevo modelo de desarrollo OSS hasta las principales características de esta nueva versión. Sinceramente, creo que es una gran oportunidad tener con nosotros a Diego y poder ver de su mano que tendremos próximamente en EF, así como tener la posiblidad de hacerle todas las preguntas que consideréis oportunas…

Aquí os dejo el enlace de registro, espero veros a todos por allí

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032553975&Culture=es-ES&community=0

Saludos

Unai

EF 6: Operaciones de migraciones personalizadas

Hace ya un tiempo, el buen amigo @iceoverflow ,hizo un pequeño pero muy interesante pull request que nos habilita la posibilidad de crear y enchufar nuevas operaciones de migración que no tengamos por defecto en Entity Framework. Aunque el proceso es un poco mecánico, abre un montón de posibilidades para hacer nuevas contribuciones, incluso aunque no sea directamente en el código de EF y si en alguna contribución ( tengo una pequeña sorpresa con esto pero ya os la contaré cuando esté más avanzada ). A continuación me gustaría enseñaros un pequeño ejemplo de lo que podemos hacer y, por supuesto, todo aquello que os gustaría tener me encantaría escucharlo e incluso hacerlo…

Bien, empezamos, trataremos de hacer una operación de migración para crear una vista, lo primero por lo tanto es definir la operación, para ello, solamente tenemos que heredar de MigrationOperation, como por ejemplo vemos a continuación:

<span class="kwrd">namespace</span> System.Data.Entity.Migrations.Model
{
    <span class="kwrd">using</span> System.Data.Entity.Utilities;

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Represent a create view in database</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> CreateViewOperation
        :MigrationOperation
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// The view name</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> ViewName { get; <span class="kwrd">private</span> set; }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// The view body sql</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> BodySql { get; <span class="kwrd">private</span> set; }


        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new instance</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;viewName&quot;&gt;the view name to create&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;bodySql&quot;&gt;the view body sql &lt;/param&gt;</span>
        <span class="kwrd">public</span> CreateViewOperation(<span class="kwrd">string</span> viewName, <span class="kwrd">string</span> bodySql)
            :<span class="kwrd">base</span>(<span class="kwrd">null</span>)
        {
            Check.NotEmpty(viewName,<span class="str">&quot;viewName&quot;</span>);
            Check.NotEmpty(bodySql,<span class="str">&quot;bodySql&quot;</span>);

            <span class="kwrd">this</span>.ViewName = viewName;
            <span class="kwrd">this</span>.BodySql = bodySql;
        }

        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">bool</span> IsDestructiveChange
        {
            get { <span class="kwrd">return</span> <span class="kwrd">false</span>; }
        }

        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">override</span> MigrationOperation Inverse
        {
            get
            {
                <span class="kwrd">return</span> <span class="kwrd">new</span> DropViewOperation(ViewName);
            }
        }
    }
}

namespace System.Data.Entity.Migrations.Model

{

using System.Data.Entity.Utilities;

/// <summary>

/// Represent a create view in database

/// </summary>

public class CreateViewOperation

:MigrationOperation

{

/// <summary>

/// The view name

/// </summary>

public string ViewName { get; private set; }

/// <summary>

/// The view body sql

/// </summary>

public string BodySql { get; private set; }

/// <summary>

/// Create a new instance

/// </summary>

/// <param name="viewName">the view name to create</param>

/// <param name="bodySql">the view body sql </param>

public CreateViewOperation(string viewName, string bodySql)

:base(null)

{

Check.NotEmpty(viewName,"viewName");

Check.NotEmpty(bodySql,"bodySql");

this.ViewName = viewName;

this.BodySql = bodySql;

}

/// <inheritdoc/>

public override bool IsDestructiveChange

{

get { return false; }

}

/// <inheritdoc/>

public override MigrationOperation Inverse

{

get

{

return new DropViewOperation(ViewName);

}

Bien, ahora que ya tenemos definida nuestra operación, ya la podemos incluir dentro de nuestras migraciones, para que quede de una forma consistente con las operaciones actuales, podríamos crear un método extensor de de DbMigration como el siguiente:

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Create a new view</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;migration&quot;&gt;The DBMigration&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;viewName&quot;&gt;The name of view to create&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;bodySql&quot;&gt;The sql body of view to create&lt;/param&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> CreateView(<span class="kwrd">this</span> DbMigration migration, <span class="kwrd">string</span> viewName, <span class="kwrd">string</span> bodySql)
        {
            ((IDbMigration)migration)
              .AddOperation(<span class="kwrd">new</span> CreateViewOperation(viewName, bodySql));
        }

/// <summary>

/// Create a new view

/// </summary>

/// <param name="migration">The DBMigration</param>

/// <param name="viewName">The name of view to create</param>

/// <param name="bodySql">The sql body of view to create</param>

public static void CreateView(this DbMigration migration, string viewName, string bodySql)

{

((IDbMigration)migration)

.AddOperation(new CreateViewOperation(viewName, bodySql));

}

Una vez hecho este trabajo, cuando una operación se ejecute, esta operación se enviará al generador sql que tengamos configurado,recuerde que puede establecerlo ahora con nuestro punto central de configuración DbConfiguration. Por lo tanto, este generador debe de estar preparado para procesar estas operaciones, por lo tanto, lo normal será partir de un generador dado como por ejemplo SqlServerMigrationSqlGenerator para extenderlo con esta nueva operación. Para nuestro ejemplo podríamos hacer algo como lo siguiente:

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">/// Extented Sql Server Migrations Sql Generator with more</span>
    <span class="rem">/// operations.</span>
    <span class="rem">/// &lt;remarks&gt;</span>
    <span class="rem">/// For set  this migrations sql generator you need register it in</span>
    <span class="rem">/// your DbMigrationsConfiguration{TContext} using the method </span>
    <span class="rem">/// SetSqlGenerator</span>
    <span class="rem">/// &lt;example&gt;</span>
    <span class="rem">/// SetSqlGenerator(&quot;System.Data.SqlClient&quot;, new AdvancedSqlServerMigrationSqlGenerator());</span>
    <span class="rem">/// &lt;/example&gt;</span>
    <span class="rem">/// &lt;/remarks&gt;</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    <span class="kwrd">public</span> <span class="kwrd">class</span> ExtendedSqlServerMigrationSqlGenerator
        : SqlServerMigrationSqlGenerator
    {
        <span class="rem">/// &lt;inheritdoc/&gt;</span>
        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Generate(MigrationOperation migrationOperation)
        {
            
        }
     }

/// <summary>

/// Extented Sql Server Migrations Sql Generator with more

/// operations.

/// <remarks>

/// For set this migrations sql generator you need register it in

/// your DbMigrationsConfiguration{TContext} using the method

/// SetSqlGenerator

/// <example>

/// SetSqlGenerator("System.Data.SqlClient", new AdvancedSqlServerMigrationSqlGenerator());

/// </example>

/// </remarks>

/// </summary>

public class ExtendedSqlServerMigrationSqlGenerator

: SqlServerMigrationSqlGenerator

{

/// <inheritdoc/>

protected override void Generate(MigrationOperation migrationOperation)

{

}

Ahora, en nuestro Generate deberíamos ver como procesar cada una de las posibles operaciones personalizadas que podamos querer incluir, para facilitar la tarea y no ver demasiada conversión o switch un truquito rápido sería este:

        /// &lt;inheritdoc/&gt;
        <span class="kwrd">protected</span> override void Generate(MigrationOperation migrationOperation)
        {
            this.Generate((dynamic)migrationOperation);
        }

        /// &lt;summary&gt;
        /// Generate a SQL <span class="kwrd">to</span> create a <span class="kwrd">new</span> view <span class="kwrd">in</span> database
        /// &lt;/summary&gt;
        /// &lt;param name=<span class="str">&quot;createViewOperation&quot;</span>&gt;The operation <span class="kwrd">to</span> produce sql <span class="kwrd">for</span>.&lt;/param&gt;
        <span class="kwrd">public</span> virtual void Generate(CreateViewOperation createViewOperation)
        {
            using (var writer = Writer())
            {
                writer.Write(<span class="str">&quot;IF object_id(N'{0}', 'V') IS NOT NULL &quot;</span>,createViewOperation.ViewName);
                writer.WriteLine(<span class="str">&quot;DROP VIEW {0} &quot;</span>,createViewOperation.ViewName);
                writer.WriteLine(<span class="str">&quot;GO &quot;</span>);
                writer.WriteLine(<span class="str">&quot;CREATE VIEW {0} AS {1}&quot;</span>,createViewOperation.ViewName,createViewOperation.BodySql);

                this.Statement(writer);
            }
        }

/// <inheritdoc/>

protected override void Generate(MigrationOperation migrationOperation)

{

this.Generate((dynamic)migrationOperation);

}

/// <summary>

/// Generate a SQL to create a new view in database

/// </summary>

/// <param name="createViewOperation">The operation to produce sql for.</param>

public virtual void Generate(CreateViewOperation createViewOperation)

{

using (var writer = Writer())

{

writer.Write("IF object_id(N'{0}', 'V') IS NOT NULL ",createViewOperation.ViewName);

writer.WriteLine("DROP VIEW {0} ",createViewOperation.ViewName);

writer.WriteLine("GO ");

writer.WriteLine("CREATE VIEW {0} AS {1}",createViewOperation.ViewName,createViewOperation.BodySql);

this.Statement(writer);

}

Al ponerlo como dynamic podemos crear un método para cada una de las operaciones personalizadas y por lo tanto simplificar tanto la lectura como el mantenimiento del código.

Espero que os haya gustado esta posibilidad, por supuesto, para los que os habéis fijado en el código esto forma parte de un proyecto que ya contiene muchas más posibles operaciones de migración que pronto compartiré con todos vosotros, de ahí que os preguntará que os gustaría tener!!, animaros…

Saludos

unai

Commands y Windows Azure ServiceBus

Bueno, un post pequeñito pequeñito, más que nada y para ser sincero, para cambiar un poco de tercio, pero que espero que os resulte interesante. Hace ya bastante tiempo, los pocos que leéis mi aburrido blog, escribí acerca de eventos de dominio y agregados. En esta ocasión me gustaría hablar de comandos y de alguna pequeña ayuda que el nuevo SDK de Azure nos trae para implementaciones de nuestros manejadores. Si bien, comandos y eventos, en realidad son cuestiones semánticas y poco más, uno en pasado, otro acción, receptores y poco más la verdad es que su implementación se parece muchísimo, puesto que en ambos tenemos un consumidor ( o N en realidad ) capaz de despachar acciones, la información del evento producido o el comando ejecutado. La implementación de estos despachadores ~~( que feo.. )~~ suele ser más o menos sencilla cuando estamos modelando nuestro sistema pero en realidad, a la hora de ir a un sistema real el tema se complica y muchas veces se acaba por utilizar algunas buenas piezas ya construidas como puede ser NServiceBus de Udi Dahan.

Nota: Para los que os interese NServiceBus y todo lo relacionado con este bloque de código os recomiendo el blog de MarÇel Serrate.

Pues bien, la nueva versión del SDK de Azure, SDK 2.0, incluye una pequeñita mejora en el procesado de mensajes de una cola, habitual para la implementación de un dispatcher de comandos y eventos, de tal forma que el patrón de recepción y vuelta a escuchar de los mensajes en nuestra cola se simplifique muchísimo introduciendo un patrón de eventos. Concrétamente veremos que el API cliente para manejar nuestras colas dispone de un nuevo método OnMessage con el que podremos especificar donde haremos el procesado de los mensajes y el establecimiento de diferentes opciones como el auto completado de los mensajes, el número máximo de llamadas concurrentes y/o el método a utilizar para manejar excepciones que se produzcan en la recepción de los mensajes. Un ejemplo trivial de esto podría ser:

            var eventDrivenMessagingOptions = <span class="kwrd">new</span> OnMessageOptions();

            eventDrivenMessagingOptions.AutoComplete = <span class="kwrd">false</span>;
            eventDrivenMessagingOptions.ExceptionReceived += OnExceptionReceived;
            eventDrivenMessagingOptions.MaxConcurrentCalls = 5;
        
            <span class="rem">// Subscribe for messages.</span>
            var queueClient = QueueClient.Create(<span class="str">&quot;commands&quot;</span>);
            queueClient.OnMessage(OnMessageArrived, eventDrivenMessagingOptions);

var eventDrivenMessagingOptions = new OnMessageOptions();

eventDrivenMessagingOptions.AutoComplete = false;

eventDrivenMessagingOptions.ExceptionReceived += OnExceptionReceived;

eventDrivenMessagingOptions.MaxConcurrentCalls = 5;

// Subscribe for messages.

var queueClient = QueueClient.Create("commands");

queueClient.OnMessage(OnMessageArrived, eventDrivenMessagingOptions);

Ahora, solamente necesitaríamos nuestro método de manejo, OnMessageArrived, dónde pondríamos la lógica de tratamiento de estos comandos/eventos para asignárselos a sus correspondientes manejadores.

        <span class="kwrd">void</span> OnMessageArrived(BrokeredMessage message)
        {
        }

void OnMessageArrived(BrokeredMessage message)

{

}

Sencillo, ¿verdad?… Bueno, ya os dije que sería una entrada cortita…

Unai

EF 6: Command rewriters – I

En las dos últimas dos entradas he hablado sobre el nuevo bloque introducido en Entity Framework 6 para la realización de intercepciones. Aunque en principio solamente hemos hablado de lo básico, como por ejemplo los diferentes tracers, más aún con la nueva propiedad Database.Log, en realidad este bloque nos permite hacer cosas mucho más interesantes como por ejemplo el re-write de consultas. Si nos fijamos un poco en nuestra nueva clase DbInterceptor esta nos expone dos interfaces fundamentales IDbCommandInterceptor y IDbCommandTreeInterceptor de las que realmente podremos partir si queremos algo mucho más “a bajo nivel” dentro de la infraestructura de Entity Framework. Con el fin de ver algo diferente a los procesos de instrumentalización de las consultas vamos a intentar crear algún ejemplo de intercepción con reescritura de consulta utilizando estas dos interfaces.

IDbCommandInterceptor, reescritura de tu SQL

Como ya hemos comentado, esta interfaz nos ofrece los procesos de pre y post para las tareas habituales con la base de datos como por ejemplo son la ejecución de consultas y comandos. La idea para nuestra reescritura es poder introducir algún mecanismo que nos permita identificar un comando y proceder a su cambio, para verlo construiremos la siguiente clase CommandRewriter, la cual esta hecha a modo de ejemplo, intentaré poner pronto a vuestra disposición una implementación más apropiada de un sistema de reescritura de consultas.

    <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">class</span> CommandRewriter
        :IDbCommandInterceptor
    {

        <span class="kwrd">int</span> IDbCommandInterceptor.NonQueryExecuted(DbCommand command, <span class="kwrd">int</span> result, DbCommandInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        DbDataReader IDbCommandInterceptor.ReaderExecuted(DbCommand command, DbDataReader result, DbCommandInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="kwrd">object</span> IDbCommandInterceptor.ScalarExecuted(DbCommand command, <span class="kwrd">object</span> result, DbCommandInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="kwrd">void</span> IDbCommandInterceptor.NonQueryExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)
        {
            <span class="kwrd">if</span> (IsCandidate(command))
            {
                Rewrite(command);
            }
        }

        <span class="kwrd">void</span> IDbCommandInterceptor.ScalarExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext) 
        {
            <span class="kwrd">if</span> (IsCandidate(command))
            {
                Rewrite(command);
            }
        }

        <span class="kwrd">void</span> IDbCommandInterceptor.ReaderExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)
        {
            <span class="kwrd">if</span> (IsCandidate(command))
            {
                Rewrite(command);
            }
        }

        <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">bool</span> IsCandidate(DbCommand command);

        <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">void</span> Rewrite(DbCommand command);
    }

public abstract class CommandRewriter

:IDbCommandInterceptor

{

int IDbCommandInterceptor.NonQueryExecuted(DbCommand command, int result, DbCommandInterceptionContext interceptionContext)

{

return result;

}

DbDataReader IDbCommandInterceptor.ReaderExecuted(DbCommand command, DbDataReader result, DbCommandInterceptionContext interceptionContext)

{

return result;

}

object IDbCommandInterceptor.ScalarExecuted(DbCommand command, object result, DbCommandInterceptionContext interceptionContext)

{

return result;

}

void IDbCommandInterceptor.NonQueryExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)

{

if (IsCandidate(command))

{

Rewrite(command);

}

void IDbCommandInterceptor.ScalarExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)

{

if (IsCandidate(command))

{

Rewrite(command);

}

void IDbCommandInterceptor.ReaderExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext)

{

if (IsCandidate(command))

{

Rewrite(command);

}

public abstract bool IsCandidate(DbCommand command);

public abstract void Rewrite(DbCommand command);

}

Si nos fijamos, en realidad, no hemos hecho absolutamente nada, simplemente hemos puesto una pequeña comprobación antes de la ejecución de los comandos que nos permita identificar si ese comando es candidato a ser reescrito. En caso afirmativo procedemos a la tarea. Un ejemplo evidente de esta reescritura se produce cuando queremos cambiar una consulta exacta por otra, por ejemplo para poder utilizar algún hint, cambiar un parámetro etc. para esto, podríamos hacer algo trivial como sigue:

    <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">class</span> MatchCommandRewriter
        :CommandRewriter
    {
        <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">string</span> MatchedQuery { get; }

        <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">string</span> NewQuery { get; }

        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">bool</span> IsCandidate(System.Data.Common.DbCommand command)
        {
            <span class="kwrd">return</span> String.Equals(command.CommandText, MatchedQuery, StringComparison.InvariantCultureIgnoreCase);
        }

        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Rewrite(System.Data.Common.DbCommand command)
        {
            command.CommandText = NewQuery;
        }
    }

public abstract class MatchCommandRewriter

:CommandRewriter

{

public abstract string MatchedQuery { get; }

public abstract string NewQuery { get; }

public override bool IsCandidate(System.Data.Common.DbCommand command)

{

return String.Equals(command.CommandText, MatchedQuery, StringComparison.InvariantCultureIgnoreCase);

}

public override void Rewrite(System.Data.Common.DbCommand command)

{

command.CommandText = NewQuery;

}

Ahora, que hemos creado estas simples bases, podríamos introducir una reescritura por ejemplo como la siguiente, que es solamente con fin ilustrativo, , en la que introducimos un hint NOLOCK en la consulta:

   <span class="kwrd">public</span> <span class="kwrd">class</span> CustomerNoLockQueryRewrite
        :MatchCommandRewriter
    {

        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">string</span> MatchedQuery
        {
            get
            {
                <span class="kwrd">return</span> <span class="str">&quot;SELECT rn[Extent1].[Id] AS [Id], rn[Extent1].[FirstName] AS [FirstName]rnFROM [dbo].[Customers] AS [Extent1]&quot;</span>;
            }
        }

        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">string</span> NewQuery
        {
            get
            {
                <span class="kwrd">return</span> <span class="str">&quot;SELECT [Extent1].[Id] AS [Id], [Extent1].[FirstName] AS [FirstName] FROM [dbo].[Customers] AS [Extent1] WITH (NOLOCK) &quot;</span>;
            }
        }
    }

public class CustomerNoLockQueryRewrite

:MatchCommandRewriter

{

public override string MatchedQuery

{

get

{

return "SELECT rn[Extent1].[Id] AS [Id], rn[Extent1].[FirstName] AS [FirstName]rnFROM [dbo].[Customers] AS [Extent1]";

}

public override string NewQuery

{

get

{

return "SELECT [Extent1].[Id] AS [Id], [Extent1].[FirstName] AS [FirstName] FROM [dbo].[Customers] AS [Extent1] WITH (NOLOCK) ";

}

Una vez creado nuestro rewriter solamente nos queda asignarlo, para lo cual, como ya sabemos de otras entradas tenemos nuestra clase Interception.

Interception.AddInterceptor(<span class="kwrd">new</span> CustomerNoLockQueryRewrite());

1	Interception.AddInterceptor(<span class="kwrd">new</span> CustomerNoLockQueryRewrite());

&#160;

A lo largo de esta entrada hemos podido ver como los interceptores sirven para mucho mas que para las trazas de nuestras consultas y podemos tener una ganancia importante con su uso dentro de nuestras aplicaciones. En esta primera edición hemos visto la intercepción de nuestras consultas SQL, para la siguiente intentaremos ver como modificar nuestros arboles de consulta antes de generar el SQL.

Saludos

Unai

EF 6: Interceptors, segunda iteración

Es lo malo de escribir posts con todo en desarrollo, que se quedan desactualizados de un día para otro, de hecho, no tengo mucha idea de cuanto os pueden aportar, a vosotros amigos lectores, estas entradas que hago sobre EF 6 y quizás seguramente estoy perdiendo el tiempo, pero me cuesta, aún así, resistirme a hacerlo.

En la anterior entrada hemos visto los primeros pasos con interception y como podíamos configurar esta, después del último commit de Arthur algunas cosas han cambiado y en mi opinión creo que han quedado mejor, mas consistentes con el diseño actual.

El primer cambio es la creación de un DbCommandLogger y un DbCommandLoggerFactory, que nos permitirán disponer de una clase para el log de los diferentes comandos con una implementación por defecto que hace la escritura en un TextWriter que podemos establecer en su constructor.

<span class="kwrd">public</span> <span class="kwrd">delegate</span> DbCommandLogger DbCommandLoggerFactory(DbContext context, TextWriter writer);

1	<span class="kwrd">public</span> <span class="kwrd">delegate</span> DbCommandLogger DbCommandLoggerFactory(DbContext context, TextWriter writer);

Para establecer este DbCommandLogger tenemos una nueva propiedad en nuestro objeto Database que nos permite establecer un TextWriter a utilizar, en realidad aunque lo que hacemos en esta propiedad es establecer el TextWriter internamente se establecer un command logger con ese text writer. Fíjese en nuestro siguiente código como podemos establecer la consola de salida como logger de los diferentes comandos ejecutados por Entity Framework.

    <span class="kwrd">public</span> <span class="kwrd">class</span> CRMContext
        :DbContext
    {
        <span class="kwrd">public</span> DbSet&lt;Customer&gt; Customers { get; set; }

        <span class="kwrd">public</span> CRMContext()
        {
            Database.Log = Console.Out;
        }
    }

public class CRMContext

:DbContext

{

public DbSet<Customer> Customers { get; set; }

public CRMContext()

{

Database.Log = Console.Out;

}

Por supuesto, si queremos cambiar nuestro DbCommandLogger por defecto podremos hacerlo, para ello, como siempre podemos acudir a nuestro DbConfiguration y establecer un Dependency Resolver o bien setearlo con el nuevo método SetCommandLogger.

   <span class="kwrd">public</span> <span class="kwrd">class</span> Configuration
        :DbConfiguration
    {
        <span class="kwrd">public</span> Configuration()
        {
            SetCommandLogger((context, writer) =&gt; <span class="kwrd">new</span> DbCommandLogger(context, writer));
        }
    }

public class Configuration

:DbConfiguration

{

public Configuration()

{

SetCommandLogger((context, writer) => new DbCommandLogger(context, writer));

}

Bueno, lo dicho, no se si estas pinceladas son interesantes para vosotros amigos lectores, pero espero que si y sobre todo que dejéis feedback de lo que necesitáis en el producto.

Saludos

Unai

EF 6: Sorpresa, interceptors

Pues si, digo bien con sorpresa, porque hasta ahora yo no era consciente de que esta fuera a ser una de las nuevas características de EF 6, de hecho si miramos el roadmap veremos que no estaba contemplada. Pero por lo que sea ya tenemos aquí los primeros commits relacionados con la posibilidad de implementar mecanismos de intercepción en la nueva versión de Entity Framework. Aunque seguramente cambiarán ciertas cosas hasta la versión final, no me puedo resistir a enseñaros alguna pincelada.

Interception

La clase estática Interception representa por ahora el punto dónde podemos agregar y quitar nuestros interceptores. En realidad, esto me ha chocado un poco porque creía que era un patrón obsoleto como el uso de Database en anteriores versiones, y creo que va a cambiar, aunque en el tablero de preguntas del proyecto hay una pregunta abierta que espero que respondan. Esta clase es tan simple como vemos a continuación.

    <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">class</span> Interception
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Registers a new &lt;see cref=&quot;IDbInterceptor&quot; /&gt; to receive notifications. Note that the interceptor</span>
        <span class="rem">///     must implement some interface that extends from &lt;see cref=&quot;IDbInterceptor&quot; /&gt; to be useful.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;interceptor&quot;&gt;The interceptor to add.&lt;/param&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> AddInterceptor(IDbInterceptor interceptor)
        {          
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Removes a registered &lt;see cref=&quot;IDbInterceptor&quot; /&gt; so that it will no longer receive notifications.</span>
        <span class="rem">///     If the given interceptor is not registered, then this is a no-op.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;interceptor&quot;&gt;The interceptor to remove.&lt;/param&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> RemoveInterceptor(IDbInterceptor interceptor)
        { 
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     This is the entry point for dispatching to interceptors. This is usually only used internally by</span>
        <span class="rem">///     Entity Framework but it is provided publicly so that other code can make sure that registered</span>
        <span class="rem">///     interceptors are called when operations are performed on behalf of EF. For example, EF providers</span>
        <span class="rem">///     a may make use of this when executing commands.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">static</span> Dispatchers Dispatch
        {
        }
    }

public static class Interception

{

/// <summary>

/// Registers a new <see cref="IDbInterceptor" /> to receive notifications. Note that the interceptor

/// must implement some interface that extends from <see cref="IDbInterceptor" /> to be useful.

/// </summary>

/// <param name="interceptor">The interceptor to add.</param>

public static void AddInterceptor(IDbInterceptor interceptor)

{

}

/// <summary>

/// Removes a registered <see cref="IDbInterceptor" /> so that it will no longer receive notifications.

/// If the given interceptor is not registered, then this is a no-op.

/// </summary>

/// <param name="interceptor">The interceptor to remove.</param>

public static void RemoveInterceptor(IDbInterceptor interceptor)

{

}

/// <summary>

/// This is the entry point for dispatching to interceptors. This is usually only used internally by

/// Entity Framework but it is provided publicly so that other code can make sure that registered

/// interceptors are called when operations are performed on behalf of EF. For example, EF providers

/// a may make use of this when executing commands.

/// </summary>

public static Dispatchers Dispatch

{

}

Como se puede ver, en realidad, lo que nos ofrece es un mecanismo para agregar y quitar interceptores, pensado en enchufar los mismos solamente en ciertas partes del trabajo o momentos determinados. De hecho la nueva característica de scaffolding de los procedimientos almacenados se basa en esta infraestructura. A mayores de esto, vemos como un interceptor no es más que cualquier clase que implemente IDbInterceptor, por suerte, a nosotros ya nos ofrecen una clase base de la que partir llamada DbInterceptor, que será la que usemos por norma general.

    <span class="kwrd">public</span> <span class="kwrd">class</span> DbInterceptor : IDbCommandInterceptor, IDbCommandTreeInterceptor
    {
        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> DbCommandTree TreeCreated(DbCommandTree commandTree, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> commandTree;
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> NonQueryExecuting(DbCommand command, DbInterceptionContext interceptionContext)
        {
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">int</span> NonQueryExecuted(DbCommand command, <span class="kwrd">int</span> result, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> ReaderExecuting(DbCommand command, CommandBehavior behavior, DbInterceptionContext interceptionContext)
        {
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> DbDataReader ReaderExecuted(
            DbCommand command, CommandBehavior behavior, DbDataReader result, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> ScalarExecuting(DbCommand command, DbInterceptionContext interceptionContext)
        {
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">object</span> ScalarExecuted(DbCommand command, <span class="kwrd">object</span> result, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> AsyncNonQueryExecuting(DbCommand command, DbInterceptionContext interceptionContext)
        {
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> Task&lt;<span class="kwrd">int</span>&gt; AsyncNonQueryExecuted(DbCommand command, Task&lt;<span class="kwrd">int</span>&gt; result, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> AsyncReaderExecuting(DbCommand command, CommandBehavior behavior, DbInterceptionContext interceptionContext)
        {
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> Task&lt;DbDataReader&gt; AsyncReaderExecuted(
            DbCommand command, CommandBehavior behavior, Task&lt;DbDataReader&gt; result, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> AsyncScalarExecuting(DbCommand command, DbInterceptionContext interceptionContext)
        {
        }

        <span class="rem">/// &lt;inheritdoc /&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> Task&lt;<span class="kwrd">object</span>&gt; AsyncScalarExecuted(DbCommand command, Task&lt;<span class="kwrd">object</span>&gt; result, DbInterceptionContext interceptionContext)
        {
            <span class="kwrd">return</span> result;
        }
    }

public class DbInterceptor : IDbCommandInterceptor, IDbCommandTreeInterceptor

{

/// <inheritdoc />

public virtual DbCommandTree TreeCreated(DbCommandTree commandTree, DbInterceptionContext interceptionContext)

{

return commandTree;

}

/// <inheritdoc />

public virtual void NonQueryExecuting(DbCommand command, DbInterceptionContext interceptionContext)

{

}

/// <inheritdoc />

public virtual int NonQueryExecuted(DbCommand command, int result, DbInterceptionContext interceptionContext)

{

return result;

}

/// <inheritdoc />

public virtual void ReaderExecuting(DbCommand command, CommandBehavior behavior, DbInterceptionContext interceptionContext)

{

}

/// <inheritdoc />

public virtual DbDataReader ReaderExecuted(

DbCommand command, CommandBehavior behavior, DbDataReader result, DbInterceptionContext interceptionContext)

{

return result;

}

/// <inheritdoc />

public virtual void ScalarExecuting(DbCommand command, DbInterceptionContext interceptionContext)

{

}

/// <inheritdoc />

public virtual object ScalarExecuted(DbCommand command, object result, DbInterceptionContext interceptionContext)

{

return result;

}

/// <inheritdoc />

public virtual void AsyncNonQueryExecuting(DbCommand command, DbInterceptionContext interceptionContext)

{

}

/// <inheritdoc />

public virtual Task<int> AsyncNonQueryExecuted(DbCommand command, Task<int> result, DbInterceptionContext interceptionContext)

{

return result;

}

/// <inheritdoc />

public virtual void AsyncReaderExecuting(DbCommand command, CommandBehavior behavior, DbInterceptionContext interceptionContext)

{

}

/// <inheritdoc />

public virtual Task<DbDataReader> AsyncReaderExecuted(

DbCommand command, CommandBehavior behavior, Task<DbDataReader> result, DbInterceptionContext interceptionContext)

{

return result;

}

/// <inheritdoc />

public virtual void AsyncScalarExecuting(DbCommand command, DbInterceptionContext interceptionContext)

{

}

/// <inheritdoc />

public virtual Task<object> AsyncScalarExecuted(DbCommand command, Task<object> result, DbInterceptionContext interceptionContext)

{

return result;

}

Como podéis ver, hay muchos métodos en los que nos podemos enganchar, tanto para llamadas síncronas como asíncronas, así como a ciertores pre-post procesos, como por ejemplo en la ejecución de comandos. Un hola mundo, podría ser el siguiente, donde sacamos por la consola las consultas de lectura ejecutadas por EF:

    <span class="kwrd">public</span> <span class="kwrd">class</span> TracerInterceptor
        :DbInterceptor
    {
        <span class="kwrd">public</span> <span class="kwrd">override</span> DbDataReader ReaderExecuted(DbCommand command, System.Data.CommandBehavior behavior, DbDataReader result, DbInterceptionContext interceptionContext)
        {
            Console.WriteLine(<span class="str">&quot;CommandText:{0}&quot;</span>,command.CommandText);

            <span class="kwrd">return</span> result;
        }
    }

public class TracerInterceptor

:DbInterceptor

{

public override DbDataReader ReaderExecuted(DbCommand command, System.Data.CommandBehavior behavior, DbDataReader result, DbInterceptionContext interceptionContext)

{

Console.WriteLine("CommandText:{0}",command.CommandText);

return result;

}

Feedback

Estoy seguro que todo el equipo va a necesitar feedback de esta nueva característica, que os gusta, que no, que necesitáis que no tengáis etc. por eso me gustaría pediros a todos que os animéis a pasar por el portal del producto y dejar vuestras necesidades / recomendaciones etc…

Saludos

Unai