EF6 Contrib: Operaciones de migración

Otra de las características que tenemos dentro de EF6 Contrib es la de agregar operaciones personalizadas de migración, por ahora ya hay unas cuantas que seguro serán de utilidad para algunas de vosotros y aquellas que no están seguro que pronto estarán o bien os animo a escribirlas. La ultima ha venido de un pull request de Quique ( @quiu3 ) en el que ha incluido la posibilidad de agregar computed columns, os animo a ver el pull request para ver lo sencillo que es incluir nuevas migraciones.

    <span class="kwrd">public</span> <span class="kwrd">class</span> AddComputedColumnOperation : MigrationOperation
    {
        <span class="kwrd">public</span> <span class="kwrd">string</span> TableName { get; <span class="kwrd">private</span> set; }

        <span class="kwrd">public</span> <span class="kwrd">string</span> ColumnName { get; <span class="kwrd">private</span> set; }

public class AddComputedColumnOperation : MigrationOperation

{

public string TableName { get; private set; }

public string ColumnName { get; private set; }

        <span class="kwrd">public</span> AddComputedColumnOperation(<span class="kwrd">string</span> tableName, <span class="kwrd">string</span> columnName, <span class="kwrd">object</span> anonymousArguments)
            : <span class="kwrd">base</span>(anonymousArguments)
        {
            Check.NotEmpty(tableName, <span class="str">"tableName"</span>);
            Check.NotEmpty(columnName, <span class="str">"columnName"</span>);            

            <span class="kwrd">this</span>.TableName = tableName;
            <span class="kwrd">this</span>.ColumnName = columnName;            
        }

        <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="kwrd">public</span> <span class="kwrd">override</span> MigrationOperation Inverse
        {
            get
            {
                <span class="kwrd">return</span> <span class="kwrd">new</span> DropComputedColumnOperation(TableName,ColumnName);
            }
        }
    }

public AddComputedColumnOperation(string tableName, string columnName, object anonymousArguments)

: base(anonymousArguments)

{

Check.NotEmpty(tableName, "tableName");

Check.NotEmpty(columnName, "columnName");

this.TableName = tableName;

this.ColumnName = columnName;

}

public override bool IsDestructiveChange

{

get { return false; }

}

public override MigrationOperation Inverse

{

get

{

return new DropComputedColumnOperation(TableName,ColumnName);

}

Para hacer uso de estos elementos solamente tenemos que cambiar el generador a utilizar, por defecto en EF 6 Contrib solamente tenemos un generador para Sql Server. Establecer este generador es tan sencillo como se ve a continuación:

    <span class="kwrd">internal</span> <span class="kwrd">sealed</span> <span class="kwrd">class</span> Configuration : DbMigrationsConfiguration&lt;ConsoleApplication1.CRMContext&gt; 
    {
        <span class="kwrd">public</span> Configuration()
        {
            AutomaticMigrationsEnabled = <span class="kwrd">false</span>;
            SetSqlGenerator(<span class="str">"System.Data.SqlClient"</span>, <span class="kwrd">new</span> ExtendedSqlServerMigrationSqlGenerator());
        }

        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Seed(ConsoleApplication1.CRMContext context)
        {
          
        }
    }

internal sealed class Configuration : DbMigrationsConfiguration<ConsoleApplication1.CRMContext>

{

public Configuration()

{

AutomaticMigrationsEnabled = false;

SetSqlGenerator("System.Data.SqlClient", new ExtendedSqlServerMigrationSqlGenerator());

}

protected override void Seed(ConsoleApplication1.CRMContext context)

{

}

Por supuesto también se podría hacer utilizando un DbConfiguration, cualquier opción sería válida, a elegir. Hasta aquí esta pequeña entrada, espero que os sea de utilidad….

Saludos

Unai

&nbsp;

Preview EF 6.1 Features: Transaction Handler

Una de las principales novedades en EF 6 y de la que hablamos aquí, en este mismo blog, unas cuantas veces hace referencia a la característica de “connection resiliency” gracias a la cual tenemos una forma simple de tener aplicaciones capaces de manejar los errores temporales que un cluster de sql server podría producir, sin tener para ello que escribir ningún tipo de código de reintentos. Sin embargo, había algún escenario que esta nueva característica no cubría como el escenario conocido por “Idempotent Issue” producido cuando después de una ejecución de un IUD( Insert, Update, Delete ) obtenemos un connection failure ya que no tenemos una forma segura de saber si en realidad esta escritura se ha realizado en la base de datos. La única forma de poder hacer algo es llevar un seguimiento del comando para garantizar la “idempotencia”. Por desgracia Sql Server no ofrece/dispone de ningún mecanismo por lo que la tarea de realizar este seguimiento nos la tenemos que hacer nosotros. Aquí es dónde entra el trabajo del equipo de Entity Framwork, puesto que ha realizado esta tarea por nosotros, gracias a la cual cuando tenemos un connection failure en un IUD el sabrá si realizar un reintento del comando o bien si lo que ha pasado es que la notificación del commit no ha llegado correctamente.

¿Como activamos esta característica?

Nota: Durante la escritura de este post se ha usado la versión 6.1.0-alpha1-30121

Para activarla como hacemos desde la llegada de nuestra configuración en código es usar nuestras clases DbConfiguration para registrar este nuevo servicio, como podéis ver a continuación:

   <span class="kwrd">public</span> <span class="kwrd">class</span> Configuration
        : DbConfiguration
    {
        <span class="kwrd">public</span> Configuration()
        {
            SetTransactionHandler(<span class="str">&quot;System.Data.SqlClient&quot;</span>, () =&gt; <span class="kwrd">new</span> CommitFailureHandler());
            SetExecutionStrategy(<span class="str">&quot;System.Data.SqlClient&quot;</span>, () =&gt; <span class="kwrd">new</span> SqlAzureExecutionStrategy());
        }
    }

public class Configuration

: DbConfiguration

{

public Configuration()

{

SetTransactionHandler("System.Data.SqlClient", () => new CommitFailureHandler());

SetExecutionStrategy("System.Data.SqlClient", () => new SqlAzureExecutionStrategy());

}

¿Cómo se hace el seguimiento?

Si nos fijamos un poco, cuando vemos la base de datos creada o usada por un contexto que tiene habilitada esta característica veremos una nueva tabla que nada tiene que ver con nuestro modelo, y al igual que la tabla de migraciones, empieza con un “_” para identificarla como una tabla de “fontanería”. Esta tabla es _TransactionHistory y contiene este seguimiento de comandos del que hablamos. Por supuesto, al igual que podemos customizar la tabla de migraciones también podremos hacer lo mismo con esta, fijaros que tenemos un TransactionContext del que podemos heredar.

En esta tabla, irán apareciendo y desapareciendo entradas que permitirán identificar a los comandos que se están ejecutando en un determinado contexto, una vez que este contexto se destruye, sus entradas correspondientes desaparecerán. Este log de transacciones también contiene otro elemento que hace que se limpie y consiste en un límite hardcoded establecido en CommitFailureHandler cuyo valor es 20, lo que quiere decir que cuando aparezcan 20 entradas de log para un mismo contexto estas entradas de log se limpiarán.

         <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Gets the number of transactions to be executed on the context before the transaction log will be cleaned.</span>
        <span class="rem">/// The default value is 20.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">protected</span> <span class="kwrd">virtual</span> <span class="kwrd">int</span> PruningLimit
        {
            get { <span class="kwrd">return</span> 20; }
        }

/// <summary>

/// Gets the number of transactions to be executed on the context before the transaction log will be cleaned.

/// The default value is 20.

/// </summary>

protected virtual int PruningLimit

{

get { return 20; }

}

Internals

Creo que más o menos ha quedado clara la problemática y como necesitamos un sistema de tracking de nuestras transacciones para posteriormente poder actuar ante los problemas de idempotencia. ¿ Pero como ha sido posible esto internamente? Ya en EF 6 se introdujeron unos pocos interceptores para mediar en la ejecución de consultas y comandos para la base de datos, pero estos no eran suficientes puesto que para este nivel necesitábamos más interceptores a nivel de transacción y conexión, por ello, ahora mismo disponemos de los siguientes elementos nuevos.

IDbTransactionInterceptor: Interceptor que nos permite interceptar diferentes operaciones relativas a las transacciones y a la solicitud de conexiones, etc.
IDbConnectionInterceptor: Interceptor que nos permite saber e interceptar diferentes elementos relativos a las conexiones, cuando se abren, se cierran, empiezan una transacción etc.

Gracias a estos nuevos interceptores, que podrían ser registrados igualmente en nuestro DbInterception, se puede realizar esta característica. Seguro que otras muchas cosas saldrán gracias a estos nuevos interceptores y seguro que a muchos de vosotros ya se os han ocurrido ideas.

saludos

unai

EF 6 Contrib: Performance Interceptors

Como ya hemos dicho, tantas y tantas veces, desde este mismo blog, sin duda, una de las mejores cosas con la llegada de EF6 es la cantidad de puntos de extensibilidad de los que disponemos y que nos permiten jugar con ciertas cosas bastante interesantes. La nueva característica para subscribir código antes y después de cada ejecución, que Entity Framework hace contra la base de datos, es una de estas sobre la que siempre estamos pensando cosas que podemos hacer, en realidad hay muchas cosas que a la mayoría se nos ocurren como por ejemplo auditoria, cache, re-escritura de comandos etc etc etc. En el proyecto de EF 6 Contrib se hace uso de esta característica para darnos cierta información del rendimiento de nuestras aplicaciones haciendo uso de estos interceptores, gracias a los cuales se puede examinar la consulta y/o el plan de ejecución contra el motor de base de datos, por ahora solamente para Sql Server.

Para hacer uso de estos analizadores lo primero será incluir ef6.contrib desde nuestra consola de NuGet

PM&gt; install-package ef6.contrib
Attempting to resolve dependency <span class="str">'EntityFramework (≥ 6.0.2)'</span>.
Attempting to resolve dependency <span class="str">'Common.Logging (≥ 2.1.2)'</span>.
Installing <span class="str">'Common.Logging 2.1.2'</span>.
Successfully installed <span class="str">'Common.Logging 2.1.2'</span>.
Installing <span class="str">'EF6.Contrib 1.0.3'</span>.

PM> install-package ef6.contrib

Attempting to resolve dependency 'EntityFramework (≥ 6.0.2)'.

Attempting to resolve dependency 'Common.Logging (≥ 2.1.2)'.

Installing 'Common.Logging 2.1.2'.

Successfully installed 'Common.Logging 2.1.2'.

Installing 'EF6.Contrib 1.0.3'.

Una vez instalado, este pone a nuestra disposición el interceptor PerformanceInterceptor, que podemos registrar en nuestro archivo de configuración como sigue:

    <span class="kwrd">public</span> <span class="kwrd">class</span> Configuration
        : DbConfiguration
    {
        <span class="kwrd">public</span> Configuration()
        {
            <span class="kwrd">this</span>.AddInterceptor(<span class="kwrd">new</span> PerformanceInterceptor(msg =&gt;
            {
                Console.WriteLine(<span class="str">&quot;{0}-{1}&quot;</span>, msg.Message, msg.Command);
            }));
        }
    }

public class Configuration

: DbConfiguration

{

public Configuration()

{

this.AddInterceptor(new PerformanceInterceptor(msg =>

{

Console.WriteLine("{0}-{1}", msg.Message, msg.Command);

}));

}

El delegado Action<PerformanceReport> nos permite decidir dónde queremos llevar la información generada, a un fichero, base de datos o como en nuestro caso, simplemente a la consola de salida. Amén de este parámetro en el constructor, esta clase nos permite incluir el conjunto de analizadores a usar. PerformanceInterceptor se basa en un conjunto de analizadores, IPerformanceAnalyzer, que podemos ampliar con los nuestros, para realizar el trabajo de revisión de las consultas. Si, como en este caso, no se hace uso de este parámetro el interceptor utilizará solamente el contenedor de dependencias para resolver los analizadores que se desean usar. Con el fin de ver un ejemplo nos crearemos un pequeño resolver que se encargará de registrar un analizador.

    <span class="kwrd">class</span> DummyResolver
            : IDbDependencyResolver
    {
        <span class="kwrd">public</span> <span class="kwrd">object</span> GetService(Type type, <span class="kwrd">object</span> key)
        {
            <span class="kwrd">return</span> <span class="kwrd">null</span>;
        }

        <span class="kwrd">public</span> IEnumerable&lt;<span class="kwrd">object</span>&gt; GetServices(Type type, <span class="kwrd">object</span> key)
        {
            <span class="kwrd">if</span> (<span class="kwrd">typeof</span>(IPerformanceAnalyzer).IsAssignableFrom(type))
            {
                <span class="kwrd">return</span> <span class="kwrd">new</span> List&lt;IPerformanceAnalyzer&gt;()
                {
                    <span class="kwrd">new</span> ExecutionTimePerformanceAnalyzer(TimeSpan.FromSeconds(3)),
                };
            }

            <span class="kwrd">return</span> Enumerable.Empty&lt;<span class="kwrd">object</span>&gt;();
        }
    }

class DummyResolver

: IDbDependencyResolver

{

public object GetService(Type type, object key)

{

return null;

}

public IEnumerable<object> GetServices(Type type, object key)

{

if (typeof(IPerformanceAnalyzer).IsAssignableFrom(type))

{

return new List<IPerformanceAnalyzer>()

{

new ExecutionTimePerformanceAnalyzer(TimeSpan.FromSeconds(3)),

};

}

return Enumerable.Empty<object>();

}

Como podéis ver en en este código, se está registrando en este caso, un único analizador llamada ExecutionTimePerformanceAnalyzer, que como os imaginaréis, se encarga de analizar los tiempos de ejecución de cada consulta y para aquellas cuyo tiempo sea superior a 3 segundos enviará un “informe”. Crearse nuevos analizadores es sencillo, solamente tenemos que implementar la interfaz IPerformanceAnalyzer que es tan sencilla como sigue, por lo que os animo a crear y contribuir nuevos analizadores.

    <span class="kwrd">public</span> <span class="kwrd">interface</span> IPerformanceAnalyzer
    {
        PerformanceCommandReport Analyze(DbCommand command, TimeSpan executionTime);
    }

public interface IPerformanceAnalyzer

{

PerformanceCommandReport Analyze(DbCommand command, TimeSpan executionTime);

}

Si utilizas SqlServer, EF6 Contrib dispone de otro paquete, EF6.Contrib.SqlServerPerformanceAnalyzers, que contiene analizadores especiales para Sql Server, podríamos por ejemplo ampliar nuestro registro de analizadores como sigue, los nombres son representativos de sus funciones.

    <span class="kwrd">class</span> DummyResolver
            : IDbDependencyResolver
    {
        <span class="kwrd">public</span> <span class="kwrd">object</span> GetService(Type type, <span class="kwrd">object</span> key)
        {
            <span class="kwrd">return</span> <span class="kwrd">null</span>;
        }

        <span class="kwrd">public</span> IEnumerable&lt;<span class="kwrd">object</span>&gt; GetServices(Type type, <span class="kwrd">object</span> key)
        {
            <span class="kwrd">if</span> (<span class="kwrd">typeof</span>(IPerformanceAnalyzer).IsAssignableFrom(type))
            {
                <span class="kwrd">return</span> <span class="kwrd">new</span> List&lt;IPerformanceAnalyzer&gt;()
                {
                    <span class="kwrd">new</span> ExecutionTimePerformanceAnalyzer(TimeSpan.FromSeconds(3)),
                    <span class="kwrd">new</span> UnparametrizedWhereClausesPerformanceAnalyzer(),
                    <span class="kwrd">new</span> TopSlowQueriesPerformanceAnalyzer(topQueries:10)
                };
            }

            <span class="kwrd">return</span> Enumerable.Empty&lt;<span class="kwrd">object</span>&gt;();
        }

class DummyResolver

: IDbDependencyResolver

{

public object GetService(Type type, object key)

{

return null;

}

public IEnumerable<object> GetServices(Type type, object key)

{

if (typeof(IPerformanceAnalyzer).IsAssignableFrom(type))

{

return new List<IPerformanceAnalyzer>()

{

new ExecutionTimePerformanceAnalyzer(TimeSpan.FromSeconds(3)),

new UnparametrizedWhereClausesPerformanceAnalyzer(),

new TopSlowQueriesPerformanceAnalyzer(topQueries:10)

};

}

return Enumerable.Empty<object>();

}

Estos son solo algunos ejemplos de analizadores, hay otros como la revisión de consultas de paginación etc etc etc. pero hay varios puntos de mejora como comentamos que se podrían utilizar, XEvents y el análisis de planes de ejecución, para ello EF6 Contrib está comenzando el trabajo con la clase SqlExecutionPlanPerformanceAnalyzer que servirá de base para todos los analizadores que deseen inspeccionar el plan de ejecución de un determinado comando:

    <span class="kwrd">public</span> <span class="kwrd">abstract</span> <span class="kwrd">class</span> SqlExecutionPlanPerformanceAnalyzer
        : IPerformanceAnalyzer
    {
        <span class="rem">///&lt;inheritdoc/&gt;</span>
        <span class="kwrd">public</span> PerformanceCommandReport Analyze(DbCommand command, TimeSpan executionTime)
        {
            var plan = GetQueryPlan(command.Connection.ConnectionString, command.CommandText);

            <span class="kwrd">if</span> (plan != <span class="kwrd">null</span>)
            {
                <span class="kwrd">return</span> EvaluatePlan(plan);
            }

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

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Get the &lt;see cref=&quot;PerformanceCommandReport&quot;/&gt; from Sql Plan</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;sqlPlan&quot;&gt;The sql plan to evaluate&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;The performance command report or null if no issues is present in plan&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">abstract</span> PerformanceCommandReport EvaluatePlan(XDocument sqlPlan);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Get query plan from specified command using database information</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;connectionstring&quot;&gt;The connection string to use&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;commandText&quot;&gt;The command text&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;The query plan in XML format or null&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">virtual</span> XDocument GetQueryPlan(<span class="kwrd">string</span> connectionstring, <span class="kwrd">string</span> commandText)
        {
            <span class="kwrd">using</span> (var connection = <span class="kwrd">new</span> SqlConnection(connectionstring))
            {
                var queryPlanCommand = connection.CreateCommand();

                queryPlanCommand.CommandText = <span class="str">&quot;SELECT qp&quot;</span>
                    + <span class="str">&quot; FROM sys.dm_exec_cached_plans as cp CROSS APPLY sys.dm_exec_query_plan(plan_handle) as qp&quot;</span>
                    + <span class="str">&quot; CROSS APPLY sys.dm_exec_sql_text(plan_handle) as qt WHERE qt=@qt&quot;</span>;

                queryPlanCommand.Parameters.AddWithValue(<span class="str">&quot;@qt&quot;</span>, commandText);

                var plan = queryPlanCommand.ExecuteScalar();

                <span class="kwrd">if</span> (plan != DBNull.Value)
                {
                    <span class="kwrd">return</span> XDocument.Parse(plan.ToString());
                }

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

public abstract class SqlExecutionPlanPerformanceAnalyzer

: IPerformanceAnalyzer

{

///<inheritdoc/>

public PerformanceCommandReport Analyze(DbCommand command, TimeSpan executionTime)

{

var plan = GetQueryPlan(command.Connection.ConnectionString, command.CommandText);

if (plan != null)

{

return EvaluatePlan(plan);

}

return null;

}

/// <summary>

/// Get the <see cref="PerformanceCommandReport"/> from Sql Plan

/// </summary>

/// <param name="sqlPlan">The sql plan to evaluate</param>

/// <returns>The performance command report or null if no issues is present in plan</returns>

public abstract PerformanceCommandReport EvaluatePlan(XDocument sqlPlan);

/// <summary>

/// Get query plan from specified command using database information

/// </summary>

/// <param name="connectionstring">The connection string to use</param>

/// <param name="commandText">The command text</param>

/// <returns>The query plan in XML format or null</returns>

public virtual XDocument GetQueryPlan(string connectionstring, string commandText)

{

using (var connection = new SqlConnection(connectionstring))

{

var queryPlanCommand = connection.CreateCommand();

queryPlanCommand.CommandText = "SELECT qp"

+ " FROM sys.dm_exec_cached_plans as cp CROSS APPLY sys.dm_exec_query_plan(plan_handle) as qp"

+ " CROSS APPLY sys.dm_exec_sql_text(plan_handle) as qt WHERE qt=@qt";

queryPlanCommand.Parameters.AddWithValue("@qt", commandText);

var plan = queryPlanCommand.ExecuteScalar();

if (plan != DBNull.Value)

{

return XDocument.Parse(plan.ToString());

}

return null;

}

Si os ha gustado, me gustaría animaros a contribuir de las múltiples formas que se puede hacer…

Saludos

Unai

Evento: ¿Quieres conocer todo sobre VS 2013, ALM y desarrollo de aplicaciones web?

Los dias 3-5 de Diciembre tendré el placer de participar con mis compañeros de Plain Concepts en el evento ALM, arquitectura y desarrollo de aplicaciones web con VS 2013, evento en el que trataremos de enseñaros muchas de las novedades, sino todas, de los stack Microsoft en ALM, Acceso a Datos y desarrollo de aplicaciones Web. Usaremos para ello el conjunto de demos de My Company, demos desarrolladas por Plain Concepts para el lanzamiento de VS 2013 sobre las que discutiremos diferentes opciones tecnológicas.

Aquí os pego la agenda y aquí podéis registraros en Barcelona y Madrid.. Por cierto, para el evento de Madrid contaremos con el inestimable de David Carmona, si, ese mismo con el que tantos y tantos hemos aprendido sobre el mundo del desarrollo de Software, no te lo pierdas!!!!!

// Capa de acceso a datos; Entity Framework 6

Durante esta primera sesión intentaremos realizar un resumen de todas aquellas novedades que acompañan a la versión de Entity Framework 6, cuya versión reléase ha sido incluida dentro de Visual Studio 2013.

Operaciones de migraciones personalizadas.
Convenciones personalizadas.
Mapeo a procedimientos almacenados.
Operaciones asíncronas.
Interceptores.
y mucho más…

// Capa de servicios; OWIN, Web API 2, OData

Hablando de la capa de servicios nos podemos encontrar con diferentes tecnologías que podemos emplear, cuyo uso dependerá de muchos factores que hay que ser capaz de analizar al iniciar la aplicación.

OWIN-Katana.
ASP.NET WebAPI 2; o Attribute Routing, CORS, OWIN…
ASP.NET Web API OData.
SignalR.

// Capa de presentación; HTML, JavaScript, CSS

Esta tercera sesión está centrada en todas aquellas novedades, trucos o herramientas que nos ayudarán a trabajar con HTML, JavaScript o CSS. Algunas de las cosas que trataremos son:

ASP.NET Scaffolding
BootStrap
Angular.js
Browser Link
Web Essentials

// Gestión del ciclo de vida de aplicaciones web

Tan importante es conocer la tecnología como ser capaces de desarrollar software de la manera más eficiente posible. Durante esta sesión veremos las principales novedades de Visual Studio 2013 para la gestión de ciclo de vida de aplicaciones.

Visual Studio Online.
Monaco
InRelease
App Insights

// Despliegue de aplicaciones web en Windows Azure

La última sesión del día estará centrada en el despliegue de aplicaciones en Windows Azure y cómo es posible trabajar sencilla con Windows Azure desde Visual Studio.

Montar un escenario de desarrollo con Windows Azure.
Depuración remota.
Novedades del Sdk 2.2
Despliegue de aplicaciones a Azure Web Sites

Unai

EF 6 Contrib.. empezamos!!

Bueno, ya hace unos cuantos días que se liberó EF 6.0.1 en la que tuve el inmenso placer de participar con unos cuantos pull request con features y fixes. Puesto que todo no puede entrar dentro de la rama del producto, por diversas y variadas razones que creo que no vienen al caso comentar aquí, amén de seguir colaborando con otros nuevos pull request he decidido crear un pequeño proyecto de contribuciones dónde poder incluir aquellas otras cosas que como desarrollador me gustaría tener.

EF6 Contrib Site

Este es el sitio de Codeplex dónde está el proyecto de contribuciones y donde además del código estará la documentacion, backlog, issues etc.. Por supuesto, estás invitado a colaborar, de la forma que consideres adecuada, señalando bugs, creando nuevo código de contribución etc. En el caso de querer contribuir con código, las reglas y normas son las mismas que el equipo de EF tiene puesto para contribuir en la rama principal, podéis revisar las mismas en http://entityframework.codeplex.com

Try it

Actualmente ya hay una versión publicada en NuGet, para acceder a ella solamente tenemos que instalar el paquete ef6contrib como sigue:

install-package ef6contrib

Saludos

Unai

[Eventos] Plain Concepts Architecture Day

El dia 29 de Octubre tendré el placer junto a mis compañeros de Plain Concepts de participar en un nuevo Architecture Day, muy dedicado a puntos fundamentales hoy en día como son los siguientes:

Estado del arte en tecnologías y estilos arquitectónicos en tecnologías Microsoft.
El stack de desarrollo de aplicaciones web.
Arquitecturas en la nube.
Gestión de la identidad.

Como siempre, en este tipo de eventos, intentaremos que sea lo más ágil posible, así como involucrar a todos los asistentes para establecer un debate y así poder resolver todas las dudas o poner de manifiesto diferentes pensamientos.

Aquí tenéis el enlace del evento dónde podéis ver más información y registraros en el mismo..

http://www.plainconcepts.com/ArchitectureDay/

Saludos

unai

[WebCast]–Siéntete seguro con tu KATANA!!!

Hace ya tiempo del último WebCast en el que tuve el placer de intervenir, novedades de EF 6 con Diego Vega, en el que participamos mas de 100 personas, lo cual no está nada, pero que nada mal. En esta ocasión me juntaré con mi compañero Ibon para hablar de seguridad con Katana. Seguro que ya sois muchos los que sabéis y habéis oído hablar acerca de Owin y Katana y que os podéis preguntar como trabajar los mecanismos de autenticación y autorización con este nuevo framework, pues bien, este es el sitio indicado, no os lo perdáis….

NOTA: el web cast no tratará sobre introducción a Katana, para ello, podéis ver/leer el blog del amigo Jose Maria Aguilar, el cual contiene una excelente serie sobre el tema, serie que va por la cuarta entrega ya.

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

Siéntete seguro con tu Katana!

Id. de evento:
1032567495

Idiomas:
Español.

Productos:
Microsoft ASP.NET y Windows Azure.

Público:
Generalista desarrollador.

Seguramente muchos ya habréis oído algo sobre Katana, quizás algunos hasta habéis hecho vuestras primeras líneas de este proyecto de Microsoft para flexibilizar nuestras aplicaciones ASP.NET. Pues bien, a lo largo de este Web Cast veremos cómo autenticar y autorizar nuestras aplicaciones ASP.NET MVC y nuestros HTTP API construídas sobre Katana, tanto de forma personalizada como utilizando Windows Azure Active Directory, WADD, para entornos empresariales.

PONENTES:

Unai Zorrilla lleva de cerca de 12 años desarrollando software como consultor independiente y en diferentes empresas privadas, realizando las tareas de arquitectura de software bajo plataforma .NET y tocando distintas ramas tecnológicas.

Ha sido reconocido con el galardón de MVP, colabora activamente con la comunidad en evento de formación, talleres de arquitectura y giras de producto

http://geeks.ms/blogs/unai/

Ibon Landa lleva más de 12 años dedicado al desarrollo de software dónde ha tenido la oportunidad de trabajar en diferentes entornos y tecnologías. Participa de forma activa en la comunidad, escribiendo su blog, manteniendo un portal sobre Cloud Computing y colaborando grupos de usuarios en eventos de formación, talleres y giras de producto. Ha sido reconocido con el galardón de Microsoft MVP en la categoría de Windows Azure.

http://geeks.ms/blogs/ilanda

@ibonilm

Saludos

unai

Migraciones e inicializadores en EF 6

Bueno, creo que esta entrada es de esas que a alguno les quitará alguna hora de encima de volverse loco…. Con EF 6 el equipo de trabajo ha hecho un pequeño cambio de comportamiento en los inicializadores dependiendo de si Migrations está activa o no. Concretamente, inicializadores como DropCreateDatabaseAlways y DropCreateDatabaseIfModelChanges no funcionan como esperamos si la base de datos no existe, de hecho, si intentamos ejecutar nuestro código con uno de estos inicializadores el sistema nos dará una bonita excepción con un mensaje parecido al siguiente:

Additional information: Migrations is enabled for context ‘XXXXX’ but the database does not exist or contains no mapped tables. Use Migrations to create the database and its tables, for example by running the ‘Update-Database’ command from the Package Manager Console.

El error es claro, pero.. ¿Porqué?. Personalmente a mi este comportamiento no me gusta nada, de hecho hay escenarios dónde quiero tener estos inicializadores con sus Seed, como por ejemplo para mis tests integrados contra la BD. Usar MigrateToLatestVersionDatabase tampoco es una solución por dos motivos, esta no borra la base de datos anterior, y yo es algo que puedo necesitar y además tampoco tiene un seed a usar, se supone que para eso tenemos nuestra configuración de migraciones, pero, no es lo que quiero.

Para todos aquellos que como yo, queráis tener un inicializador que borre y cree la base de datos en la ultima migración conocida podéis utilizar el siguiente código, que espero pronto lo suba a mi proyecto de contrib.

<span class="kwrd">class</span> DropAndMigrateDatabaseToLatestVersion&lt;TContext, TMigrationsConfiguration&gt;
        : IDatabaseInitializer&lt;TContext&gt;
        <span class="kwrd">where</span> TContext : DbContext, <span class="kwrd">new</span>()
        <span class="kwrd">where</span> TMigrationsConfiguration : DbMigrationsConfiguration&lt;TContext&gt;, <span class="kwrd">new</span>()
    {
        TMigrationsConfiguration _config;

        <span class="kwrd">public</span> DropAndMigrateDatabaseToLatestVersion()
        {
            _config = <span class="kwrd">new</span> TMigrationsConfiguration();
        }

        <span class="kwrd">public</span> <span class="kwrd">void</span> InitializeDatabase(TContext context)
        {
            context.Database.Delete();

            var migrator = <span class="kwrd">new</span> DbMigrator(_config);
            migrator.Update();

            Seed(context);
        }

        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> Seed(TContext context) { }
    }

class DropAndMigrateDatabaseToLatestVersion<TContext, TMigrationsConfiguration>

: IDatabaseInitializer<TContext>

where TContext : DbContext, new()

where TMigrationsConfiguration : DbMigrationsConfiguration<TContext>, new()

{

TMigrationsConfiguration _config;

public DropAndMigrateDatabaseToLatestVersion()

{

_config = new TMigrationsConfiguration();

}

public void InitializeDatabase(TContext context)

{

context.Database.Delete();

var migrator = new DbMigrator(_config);

migrator.Update();

Seed(context);

}

public virtual void Seed(TContext context) { }

}

EDITADO: Parece que para EF 6.1 volveremos a tener el comportamiento correcto

Un saludo

Unai

Algunas notas sobre las configuraciones por código en EF 6

Bien, por suerte, ya estoy empezando a ver bastante código con EF 6 y también, como es lógico, estoy viendo como se usan, bien o mal, ciertas piezas que son nuevas en esta versión. Una de las cosas que me llama la atención tiene que ver con DbConfiguration, el nuevo componente que nos permitirá establecer la configuración para todos los contextos de trabajo, y esto es importante hacerlo notar, porque mucha gente entiende esta configuración para una unidad de trabajo en concreto y no como una configuración global.

Entity Framework 6 hace una búsqueda en todos los ensamblados del App Domain en busca de una clase que implemente DbConfiguration y entiende que solamente una de estas clases debería existir, avisándonos en caso contrario con una bonita excepción… Por eso, en mi opinión, no es buena práctica que como creadores de una unidad de trabajo establezcamos cual será el DbConfiguration, deberíamos dejar este trabajo para un último término, en nuestro frontal Web, Web API etc… El riesgo que corremos sino seguimos esta práctica es la de caer en la existencia de múltiples objetos de configuración, además, esto que acabamos de proponer tiene más sentido aún sinos damos cuenta de que DbConfiguration es el mecanismo para proporcionar servicios a la infraestructura de EF 6 y por lo tanto si queremos juntarlo con nuestro contenedor de DI deberemos hacerlo lo más cerca de nuestro composition root.

Para los escenarios en los que hay múltiples ensamblados con múltiples tipos, la búsqueda de nuestra configuración, lógicamente, puede llevar más tiempo del deseado. Para evitar esto, EF 6 nos permite establecer en nuestra sección del archivo de configuración que elemento en concreto queremos usar:

Otro de los escenarios posibles con el trabajo de DbConfiguration, aunque no es demasiado habitual, consiste en aquel en el que no somos dueños de esta clase de configuración pero queremos establecer nuevas implementaciones de servicios o incluso cambiar algunas de las implementaciones establecidas. Para ello, DbConfiguration nos ofrece un evento, Loaded, en el que nos podemos subscribir y tener acceso a este objeto de configuración como podemos ver a continuación gracias a la clase DbConfigurationEventArgs.

<span class="kwrd">public</span> <span class="kwrd">class</span> DbConfigurationLoadedEventArgs : EventArgs
{
        
        <span class="kwrd">public</span> IDbDependencyResolver DependencyResolver { get; }

        <span class="kwrd">public</span> <span class="kwrd">void</span> AddDefaultResolver(IDbDependencyResolver resolver);
        
        <span class="kwrd">public</span> <span class="kwrd">void</span> AddDependencyResolver(IDbDependencyResolver resolver, <span class="kwrd">bool</span> overrideConfigFile);
        
        <span class="kwrd">public</span> <span class="kwrd">void</span> ReplaceService&lt;TService&gt;(Func&lt;TService, <span class="kwrd">object</span>, TService&gt; serviceInterceptor);
        
 }

public class DbConfigurationLoadedEventArgs : EventArgs

{

public IDbDependencyResolver DependencyResolver { get; }

public void AddDefaultResolver(IDbDependencyResolver resolver);

public void AddDependencyResolver(IDbDependencyResolver resolver, bool overrideConfigFile);

public void ReplaceService<TService>(Func<TService, object, TService> serviceInterceptor);

}

Bueno, hasta aquí esta pequeña entrada, espero tener tiempo para escribir de forma más profunda….

saludos

Unai

Entity Framework 6 en MsCoders Madrid

Mañana tendré la oportunidad de juntarme otra vez con los amigos de MsCoders Madrid para hablar un poco de Entity Framework, tal y como dicen el extracto de la charla – mesa redonda, la idea es :

“En esta mesa redonda abordaremos el tema de los ORMs y hablaremos acerca de Entity Framework. Comparte con nosotros tu experiencia, dudas, problemas, trucos… que hayas tenido en proyectos reales y recibe consejo de una de los programadores del equipo de EF que cuenta con unos cuantos pull requests a sus espaldas. Te invitamos a formar parte de esta reunión técnica.”

Espero veros por alli mañana 3 de Octubre en :

Centro de Innovación Vaguada
Avda. Monforte de Lemos, 38
Teléfono: 913782508
Autobús: Líneas 49, 83, 128, 132, 137
Metro: Línea 9, Barrio del Pilar

Por cierto, para los asistentes, gracias a www.campusmvp.com daremos un cupón para el libro de EF y el curso de Entity Framework que os animo desde aquí a hacer

Un saludo

Unai