EF 6:Nuevas pequeñas grandes cosas..

Creo que son ya unas cuantas entradas las que llevo con EF 6 en este blog, y eso que aún no tenemos ni la primera CTP, pero a cada nueva build que hacen podemos ver nuevas e interesantes cosas que me gusta adelantarme a escribir.

De entre estas nuevas cosillas me gustaría destacar estos tres nuevos métodos que he podido contribuir en sus correspondientes pull request ( addrange, removerange, haschanges )

AddRange

Como seguramente os imaginaréis, este pequeño método nos permite agregar dentro de nuestros DbSet<T> y DbSet un conjunto de elementos de una única pasada, evitando así tener que hacer las n repetitivas llamadas al método Add. Aunque esto parezca trivial, y en realidad, fuera fácil de construir con un método extensor, la verdad es que tiene un pelín más de miga, puesto que algo que podíamos hacer era aprovechar este nuevo método para evitar la detección de cambios para cada uno de los elementos de la colección a incluir.

Nota:

Como seguramente sabréis, EF realiza un proceso de detección de cambios de forma automática ( si no hemos configurado lo contrario ) en ciertos procesos, como por ejemplo en el de agregar elementos al DbSet, por lo tanto, esto podría suponer una sobrecarga en ciertos escenarios con muchas entradas en el ObjectStateManager. Si quieres saber más sobre la detección de cambios en EF, entonces nada mejor que leer del mejor, en concreto, esta serie de Arthur Vickers.

Al final, una vez valorado esto y agregado este nuevo método en la superficie publica de DbSet<T> y DbSet, el código queda tan liviano como vemos a continuación en el método AddRange de nuestro InternalSet.

        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> AddRange(IEnumerable entities)
        {
            DebugCheck.NotNull(entities);

            InternalContext.DetectChanges();

            ActOnSet(
                entity =&gt; InternalContext.ObjectContext.AddObject(EntitySetName, entity), EntityState.Added, entities, <span class="str">&quot;Add&quot;</span>);
        }

public virtual void AddRange(IEnumerable entities)

{

DebugCheck.NotNull(entities);

InternalContext.DetectChanges();

ActOnSet(

entity => InternalContext.ObjectContext.AddObject(EntitySetName, entity), EntityState.Added, entities, "Add");

}

RemoveRange

Bien, después de explicado lo anterior, este es de cajón, en realidad aplican los mimos argumentos con respecto a relajar la detección de cambios, por lo tanto, la implementación en nuestro InternalSet es similar a lo siguiente:

        <span class="kwrd">public</span> <span class="kwrd">virtual</span> <span class="kwrd">void</span> RemoveRange(IEnumerable entities)
        {
            DebugCheck.NotNull(entities);

            <span class="rem">// prevent &quot;enumerator was changed&quot; exception</span>
            <span class="rem">// if entities is syncronized with other elements</span>
            <span class="rem">// (e.g: local view from DbSet.Local.)</span>
            var copyOfEntities = entities
                .Cast&lt;<span class="kwrd">object</span>&gt;().ToList();

            InternalContext.DetectChanges();

            ActOnSet(
                entity =&gt; InternalContext.ObjectContext.DeleteObject(entity), EntityState.Deleted, copyOfEntities, <span class="str">&quot;Delete&quot;</span>);
        }

public virtual void RemoveRange(IEnumerable entities)

{

DebugCheck.NotNull(entities);

// prevent "enumerator was changed" exception

// if entities is syncronized with other elements

// (e.g: local view from DbSet.Local.)

var copyOfEntities = entities

.Cast<object>().ToList();

InternalContext.DetectChanges();

ActOnSet(

entity => InternalContext.ObjectContext.DeleteObject(entity), EntityState.Deleted, copyOfEntities, "Delete");

}

&#160;

HasChanges

Este método es una pequeña ayuda para comprobar si nuestra unidad de trabajo tiene cambios pendientes, elementos agregados, borrados o modificados en la misma y no llevados aún a la base de datos. El mismo está situado en la clase DbChangeTracker y como podemos ver en el siguiente tests funcional lo tendremos accesible mediante la propiedad ChangeTracker de nuestros DbContext.

        [Fact]
        <span class="kwrd">public</span> <span class="kwrd">void</span> HasChanges_return_true_if_context_have_entities_in_deleted_state()
        {
            <span class="kwrd">using</span> (var context = <span class="kwrd">new</span> SomeContext())
            {
                var foo = <span class="kwrd">new</span> Foo() { Bar = <span class="str">&quot;the foo&quot;</span> };

                context.Foos.Attach(foo);
                context.Entry(foo).State = EntityState.Deleted;

                Assert.True(context.ChangeTracker.HasChanges());
            }
        }

[Fact]

public void HasChanges_return_true_if_context_have_entities_in_deleted_state()

{

using (var context = new SomeContext())

{

var foo = new Foo() { Bar = "the foo" };

context.Foos.Attach(foo);

context.Entry(foo).State = EntityState.Deleted;

Assert.True(context.ChangeTracker.HasChanges());

}

La implementación es realmente sencilla puesto que internamente ya se dispone de un método para comprobar el número de entradas en el ObjectStateManager.

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Check if the &lt;see cref=&quot;DbContext&quot; /&gt; contain changes, added, modified or deleted entities and relationships of POCO entities. </span>
        <span class="rem">///     This method call first to detect changes on the underlying &lt;see cref=&quot;DbContext&quot; /&gt;.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;returns&gt;True if underlying &lt;see cref=&quot;DbContext&quot; /&gt; have changes, else false.&lt;/returns&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">bool</span> HasChanges()
        {
            _internalContext.DetectChanges();

            var objectStateManager = _internalContext
               .ObjectContext.ObjectStateManager;

            DebugCheck.NotNull(objectStateManager);

            var entriesAffected =
              objectStateManager.GetObjectStateEntriesCount(EntityState.Added | EntityState.Deleted | EntityState.Modified);


            <span class="kwrd">return</span> entriesAffected &gt; 0;
        }

/// <summary>

/// Check if the <see cref="DbContext" /> contain changes, added, modified or deleted entities and relationships of POCO entities.

/// This method call first to detect changes on the underlying <see cref="DbContext" />.

/// </summary>

/// <returns>True if underlying <see cref="DbContext" /> have changes, else false.</returns>

public bool HasChanges()

{

_internalContext.DetectChanges();

var objectStateManager = _internalContext

.ObjectContext.ObjectStateManager;

DebugCheck.NotNull(objectStateManager);

var entriesAffected =

objectStateManager.GetObjectStateEntriesCount(EntityState.Added | EntityState.Deleted | EntityState.Modified);

return entriesAffected > 0;

}

Para terminar esta pequeña entrada me gustaría hablar de otra “gran” novedad que tenemos en las últimas builds de EF, novedad introducida por el propio equipo, en concreto por Andrew Peters (@anpete), que consiste en la posibilidad de hacer el scaffolding de las entidades mapeadas con procedimientos almacenados de forma automática. Lo mejor para explicarlo es ver un pequeño ejemplo, para ello partiremos del siguiente modelo y su correspondiente configuración:

    <span class="kwrd">public</span> <span class="kwrd">class</span> Blog
    {
        <span class="kwrd">public</span> <span class="kwrd">int</span> Id { get; set; }
        <span class="kwrd">public</span> <span class="kwrd">string</span> FirstName { get; set; }
        <span class="kwrd">public</span> <span class="kwrd">string</span> LastName { get; set; }
    }

    <span class="kwrd">public</span> <span class="kwrd">class</span> BlogContext
        :DbContext
    {
        <span class="kwrd">public</span> DbSet&lt;Blog&gt; Blogs { get; set; }

        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.AddFromAssembly(<span class="kwrd">typeof</span>(BlogContext).Assembly);
        }
    }

    <span class="kwrd">internal</span> <span class="kwrd">class</span> BlogConfiguration
        :EntityTypeConfiguration&lt;Blog&gt;
    {
        <span class="kwrd">private</span> BlogConfiguration()
        {
            <span class="kwrd">this</span>.MapToStoredProcedures();
        }
    }

public class Blog

{

public int Id { get; set; }

public string FirstName { get; set; }

public string LastName { get; set; }

}

public class BlogContext

:DbContext

{

public DbSet<Blog> Blogs { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Configurations.AddFromAssembly(typeof(BlogContext).Assembly);

}

internal class BlogConfiguration

:EntityTypeConfiguration<Blog>

{

private BlogConfiguration()

{

this.MapToStoredProcedures();

}

Nada nuevo, o por lo menos de lo que no hayamos hablado ya, una entidad mapeada con procedimientos almacenados por medió del método MapToStoreProcedures, aplicando convenciones al no estar “configurado”. Lo nuevo en las últimas builds, le recomiendo usar los paquetes de NuGet del feed de ASP.NET Stack nightly builds, está en que las migraciones son capaces de hacer el scaffolding de estos procedimientos almacenados, por lo tanto, si ejecutaramos la creación de una migración, tal cual sigue:

PM&gt; enable-migrations
Checking <span class="kwrd">if</span> the context targets an existing database...
Code First Migrations enabled <span class="kwrd">for</span> project MapToStoreProcedures.

PM> enable-migrations

Checking if the context targets an existing database...

Code First Migrations enabled for project MapToStoreProcedures.

PM&gt; Add-Migration InitialScaffolding
Scaffolding migration <span class="str">'InitialScaffolding'</span>.
The Designer Code <span class="kwrd">for</span> <span class="kwrd">this</span> migration file includes a snapshot of your current Code First model. This snapshot <span class="kwrd">is</span> used to calculate the changes to your model when you scaffold the next migration. If you make additional changes to your model that you want to include <span class="kwrd">in</span> <span class="kwrd">this</span> migration, then you can re-scaffold it by running <span class="str">'Add-Migration InitialScaffolding'</span> again.

PM> Add-Migration InitialScaffolding

Scaffolding migration 'InitialScaffolding'.

The Designer Code for this migration file includes a snapshot of your current Code First model. This snapshot is used to calculate the changes to your model when you scaffold the next migration. If you make additional changes to your model that you want to include in this migration, then you can re-scaffold it by running 'Add-Migration InitialScaffolding' again.

Veríamos un resultado similar a lo siguiente:

<span class="kwrd">namespace</span> MapToStoreProcedures.Migrations
{
    <span class="kwrd">using</span> System;
    <span class="kwrd">using</span> System.Data.Entity.Migrations;
    
    <span class="kwrd">public</span> <span class="kwrd">partial</span> <span class="kwrd">class</span> InitialScaffolding : DbMigration
    {
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Up()
        {
            CreateTable(
                <span class="str">&quot;dbo.Blogs&quot;</span>,
                c =&gt; <span class="kwrd">new</span>
                    {
                        Id = c.Int(nullable: <span class="kwrd">false</span>, identity: <span class="kwrd">true</span>),
                        FirstName = c.String(),
                        LastName = c.String(),
                    })
                .PrimaryKey(t =&gt; t.Id);
            
            CreateStoredProcedure(
                <span class="str">&quot;Blog_Insert&quot;</span>,
                p =&gt; <span class="kwrd">new</span>
                    {
                        FirstName = p.String(),
                        LastName = p.String(),
                    },
                body:
                    <span class="str">@&quot;INSERT [dbo].[Blogs]([FirstName], [LastName])
                      VALUES (@FirstName, @LastName)
                      
                      DECLARE @Id int
                      SELECT @Id = [Id]
                      FROM [dbo].[Blogs]
                      WHERE @@ROWCOUNT &gt; 0 and [Id] = scope_identity()
                      
                      SELECT t0.[Id]
                      FROM [dbo].[Blogs] as t0
                      WHERE @@ROWCOUNT &gt; 0 and t0.[Id] = @Id&quot;</span>
            );
            
            CreateStoredProcedure(
                <span class="str">&quot;Blog_Update&quot;</span>,
                p =&gt; <span class="kwrd">new</span>
                    {
                        Id = p.Int(),
                        FirstName = p.String(),
                        LastName = p.String(),
                    },
                body:
                    <span class="str">@&quot;UPDATE [dbo].[Blogs]
                      SET [FirstName] = @FirstName, [LastName] = @LastName
                      WHERE ([Id] = @Id)&quot;</span>
            );
            
            CreateStoredProcedure(
                <span class="str">&quot;Blog_Delete&quot;</span>,
                p =&gt; <span class="kwrd">new</span>
                    {
                        Id = p.Int(),
                    },
                body:
                    <span class="str">@&quot;DELETE [dbo].[Blogs]
                      WHERE ([Id] = @Id)&quot;</span>
            );
            
        }
        
        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Down()
        {
            DropStoredProcedure(<span class="str">&quot;Blog_Delete&quot;</span>);
            DropStoredProcedure(<span class="str">&quot;Blog_Update&quot;</span>);
            DropStoredProcedure(<span class="str">&quot;Blog_Insert&quot;</span>);
            DropTable(<span class="str">&quot;dbo.Blogs&quot;</span>);
        }
    }
}

namespace MapToStoreProcedures.Migrations

{

using System;

using System.Data.Entity.Migrations;

public partial class InitialScaffolding : DbMigration

{

public override void Up()

{

CreateTable(

"dbo.Blogs",

c => new

{

Id = c.Int(nullable: false, identity: true),

FirstName = c.String(),

LastName = c.String(),

})

.PrimaryKey(t => t.Id);

CreateStoredProcedure(

"Blog_Insert",

p => new

{

FirstName = p.String(),

LastName = p.String(),

body:

@"INSERT [dbo].[Blogs]([FirstName], [LastName])

VALUES (@FirstName, @LastName)

DECLARE @Id int

SELECT @Id = [Id]

FROM [dbo].[Blogs]

WHERE @@ROWCOUNT > 0 and [Id] = scope_identity()

SELECT t0.[Id]

FROM [dbo].[Blogs] as t0

WHERE @@ROWCOUNT > 0 and t0.[Id] = @Id"

);

CreateStoredProcedure(

"Blog_Update",

p => new

{

Id = p.Int(),

FirstName = p.String(),

LastName = p.String(),

body:

@"UPDATE [dbo].[Blogs]

SET [FirstName] = @FirstName, [LastName] = @LastName

WHERE ([Id] = @Id)"

);

CreateStoredProcedure(

"Blog_Delete",

p => new

{

Id = p.Int(),

body:

@"DELETE [dbo].[Blogs]

WHERE ([Id] = @Id)"

);

}

public override void Down()

{

DropStoredProcedure("Blog_Delete");

DropStoredProcedure("Blog_Update");

DropStoredProcedure("Blog_Insert");

DropTable("dbo.Blogs");

}

&#160;

¿Qué os parece?

Saludos

Unai

&#160;

EF 6: Connection resiliency y azure

Seguro que de muchos es sabido que cuando trabajamos con Sql Database es posible que alguna de nuestras operaciones pueda fallar, independientemente de si usamos EF, NH o directamente con nuestro SqlClient, debido a inestabilidades de la red o problemas de back-end [si desea explorar el porque de la realidad de estos problemas le recomiendo este enlace]. Aunque en la realidad esto no es algo ni mucho menos habitual, puede pasar, y, por lo general, sino somos conscientes de ello suele dar bastantes dolores de cabeza, por lo aleatorio de los fallos. Por supuesto, hay muchos workaround para este problema, y como no, también para los que usamos actualmente EF, en cualquier de sus versiones como por ejemplo este que comenta mi buen amigo Cesar de La Torre. en un post de hace una eternidad. Con el fin de hacer esto más sencillo para nosotros y en realidad para resolver otros posibles problema similares para este u otros motores relacionales el equipo de EF ya tiene en la rama de EF 6 nuevas funcionalidades.

Estas nuevas características se pueden concretar en los siguientes elementos:

IExecutionStrategy

Esta interfaz define el contrato para la pieza que tendrá como responsabilidad la ejecución de operaciones que potencialmente necesiten reintentarse, por ejemplo las operaciones sobre Sql Database. El contrato de esta interfaz no es nada complicado como podemos ver a continuación:

<span class="kwrd">namespace</span> System.Data.Entity.Infrastructure
{
    <span class="kwrd">using</span> System.Diagnostics.CodeAnalysis;
    <span class="kwrd">using</span> System.Threading;
    <span class="kwrd">using</span> System.Threading.Tasks;

    <span class="kwrd">public</span> <span class="kwrd">interface</span> IExecutionStrategy
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Indicates whether this &lt;see cref=&quot;IExecutionStrategy&quot;/&gt; might retry the execution after a failure.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">bool</span> RetriesOnFailure { get; }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Executes the specified action.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;action&quot;&gt;A delegate representing an executable action that doesn't return any results.&lt;/param&gt;</span>
        <span class="kwrd">void</span> Execute(Action action);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Executes the specified function and returns the result.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;typeparam name=&quot;TResult&quot;&gt;The return type of &lt;paramref name=&quot;func&quot;/&gt;.&lt;/typeparam&gt;</span>
        <span class="rem">/// &lt;param name=&quot;func&quot;&gt;A delegate representing an executable action that returns the result of type &lt;typeparamref name=&quot;TResult&quot;/&gt;.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;The result from the action.&lt;/returns&gt;</span>
        TResult Execute&lt;TResult&gt;(Func&lt;TResult&gt; func);
        
<span class="preproc">#if</span> !NET40

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Executes the specified asynchronous action.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;taskAction&quot;&gt;A function that returns a started task.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">///     A task that will run to completion if the original task completes successfully (either the</span>
        <span class="rem">///     first time or after retrying transient failures). If the task fails with a non-transient error or</span>
        <span class="rem">///     the retry limit is reached, the returned task will become faulted and the exception must be observed.</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        Task ExecuteAsync(Func&lt;Task&gt; taskFunc);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Executes the specified asynchronous action.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;taskAction&quot;&gt;A function that returns a started task.&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;cancellationToken&quot;&gt;</span>
        <span class="rem">///     A cancellation token used to cancel the retry operation, but not operations that are already in flight</span>
        <span class="rem">///     or that already completed successfully.</span>
        <span class="rem">/// &lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">///     A task that will run to completion if the original task completes successfully (either the</span>
        <span class="rem">///     first time or after retrying transient failures). If the task fails with a non-transient error or</span>
        <span class="rem">///     the retry limit is reached, the returned task will become faulted and the exception must be observed.</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        Task ExecuteAsync(Func&lt;Task&gt; taskFunc, CancellationToken cancellationToken);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Executes the specified asynchronous function and returns the result.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;typeparam name=&quot;TResult&quot;&gt;</span>
        <span class="rem">///     The type parameter of the &lt;see cref=&quot;Task{T}&quot;/&gt; returned by &lt;paramref name=&quot;taskFunc&quot;/&gt;.</span>
        <span class="rem">/// &lt;/typeparam&gt;</span>
        <span class="rem">/// &lt;param name=&quot;taskFunc&quot;&gt;A function that returns a started task of type &lt;typeparamref name=&quot;TResult&quot;/&gt;.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">///     A task that will run to completion if the original task completes successfully (either the</span>
        <span class="rem">///     first time or after retrying transient failures). If the task fails with a non-transient error or</span>
        <span class="rem">///     the retry limit is reached, the returned task will become faulted and the exception must be observed.</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        [SuppressMessage(<span class="str">&quot;Microsoft.Design&quot;</span>, <span class="str">&quot;CA1006:DoNotNestGenericTypesInMemberSignatures&quot;</span>)]
        Task&lt;TResult&gt; ExecuteAsync&lt;TResult&gt;(Func&lt;Task&lt;TResult&gt;&gt; taskFunc);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Executes the specified asynchronous function and returns the result.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;typeparam name=&quot;TResult&quot;&gt;</span>
        <span class="rem">///     The type parameter of the &lt;see cref=&quot;Task{T}&quot;/&gt; returned by &lt;paramref name=&quot;taskFunc&quot;/&gt;.</span>
        <span class="rem">/// &lt;/typeparam&gt;</span>
        <span class="rem">/// &lt;param name=&quot;taskFunc&quot;&gt;A function that returns a started task of type &lt;typeparamref name=&quot;TResult&quot;/&gt;.&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;cancellationToken&quot;&gt;</span>
        <span class="rem">///     A cancellation token used to cancel the retry operation, but not operations that are already in flight</span>
        <span class="rem">///     or that already completed successfully.</span>
        <span class="rem">/// &lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">///     A task that will run to completion if the original task completes successfully (either the</span>
        <span class="rem">///     first time or after retrying transient failures). If the task fails with a non-transient error or</span>
        <span class="rem">///     the retry limit is reached, the returned task will become faulted and the exception must be observed.</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        [SuppressMessage(<span class="str">&quot;Microsoft.Design&quot;</span>, <span class="str">&quot;CA1006:DoNotNestGenericTypesInMemberSignatures&quot;</span>)]
        Task&lt;TResult&gt; ExecuteAsync&lt;TResult&gt;(Func&lt;Task&lt;TResult&gt;&gt; taskFunc, CancellationToken cancellationToken);

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

    }
}

namespace System.Data.Entity.Infrastructure

{

using System.Diagnostics.CodeAnalysis;

using System.Threading;

using System.Threading.Tasks;

public interface IExecutionStrategy

{

/// <summary>

/// Indicates whether this <see cref="IExecutionStrategy"/> might retry the execution after a failure.

/// </summary>

bool RetriesOnFailure { get; }

/// <summary>

/// Executes the specified action.

/// </summary>

/// <param name="action">A delegate representing an executable action that doesn't return any results.</param>

void Execute(Action action);

/// <summary>

/// Executes the specified function and returns the result.

/// </summary>

/// <typeparam name="TResult">The return type of <paramref name="func"/>.</typeparam>

/// <param name="func">A delegate representing an executable action that returns the result of type <typeparamref name="TResult"/>.</param>

/// <returns>The result from the action.</returns>

TResult Execute<TResult>(Func<TResult> func);

#if !NET40

/// <summary>

/// Executes the specified asynchronous action.

/// </summary>

/// <param name="taskAction">A function that returns a started task.</param>

/// <returns>

/// A task that will run to completion if the original task completes successfully (either the

/// first time or after retrying transient failures). If the task fails with a non-transient error or

/// the retry limit is reached, the returned task will become faulted and the exception must be observed.

/// </returns>

Task ExecuteAsync(Func<Task> taskFunc);

/// <summary>

/// Executes the specified asynchronous action.

/// </summary>

/// <param name="taskAction">A function that returns a started task.</param>

/// <param name="cancellationToken">

/// A cancellation token used to cancel the retry operation, but not operations that are already in flight

/// or that already completed successfully.

/// </param>

/// <returns>

/// A task that will run to completion if the original task completes successfully (either the

/// first time or after retrying transient failures). If the task fails with a non-transient error or

/// the retry limit is reached, the returned task will become faulted and the exception must be observed.

/// </returns>

Task ExecuteAsync(Func<Task> taskFunc, CancellationToken cancellationToken);

/// <summary>

/// Executes the specified asynchronous function and returns the result.

/// </summary>

/// <typeparam name="TResult">

/// The type parameter of the <see cref="Task{T}"/> returned by <paramref name="taskFunc"/>.

/// </typeparam>

/// <param name="taskFunc">A function that returns a started task of type <typeparamref name="TResult"/>.</param>

/// <returns>

/// A task that will run to completion if the original task completes successfully (either the

/// first time or after retrying transient failures). If the task fails with a non-transient error or

/// the retry limit is reached, the returned task will become faulted and the exception must be observed.

/// </returns>

[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]

Task<TResult> ExecuteAsync<TResult>(Func<Task<TResult>> taskFunc);

/// <summary>

/// Executes the specified asynchronous function and returns the result.

/// </summary>

/// <typeparam name="TResult">

/// The type parameter of the <see cref="Task{T}"/> returned by <paramref name="taskFunc"/>.

/// </typeparam>

/// <param name="taskFunc">A function that returns a started task of type <typeparamref name="TResult"/>.</param>

/// <param name="cancellationToken">

/// A cancellation token used to cancel the retry operation, but not operations that are already in flight

/// or that already completed successfully.

/// </param>

/// <returns>

/// A task that will run to completion if the original task completes successfully (either the

/// first time or after retrying transient failures). If the task fails with a non-transient error or

/// the retry limit is reached, the returned task will become faulted and the exception must be observed.

/// </returns>

[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]

Task<TResult> ExecuteAsync<TResult>(Func<Task<TResult>> taskFunc, CancellationToken cancellationToken);

#endif

}

La idea básica que hay detrás de esta interfaz es poder envolver una acción en un determinado ámbito capaz de decidir si las excepciones que se produzcan son o no candidatas para reintentarse, por ejemplo porque entendemos que es un fallo de Sql Database y no relacionado con el mapeo, consulta etc…, cada cierto tiempo. Por supuesto, decidir si una excepción de una operación implica que la operación debe repetirse es algo configurable y no fijo, cuya implementación esta marcada por una nueva interfaz, que vemos a continuación.

IRetriableExceptionDetector

Mediante este contrato tendremos la posibilidad de especificar que excepciones son candidatas a “resolver” por medio de reintentos, el siguiente código representa este contrato

<span class="rem">// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.</span>

<span class="kwrd">namespace</span> System.Data.Entity.Infrastructure
{
    <span class="kwrd">public</span> <span class="kwrd">interface</span> IRetriableExceptionDetector
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Determines whether the specified exception represents a transient failure that can be compensated by a retry.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;ex&quot;&gt;The exception object to be verified.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;&lt;c&gt;true&lt;/c&gt; if the specified exception is considered as transient, otherwise &lt;c&gt;false&lt;/c&gt;.&lt;/returns&gt;</span>
        <span class="kwrd">bool</span> ShouldRetryOn(Exception ex);
    }
}

namespace System.Data.Entity.Infrastructure

{

public interface IRetriableExceptionDetector

{

/// <summary>

/// Determines whether the specified exception represents a transient failure that can be compensated by a retry.

/// </summary>

/// <param name="ex">The exception object to be verified.</param>

/// <returns><c>true</c> if the specified exception is considered as transient, otherwise <c>false</c>.</returns>

bool ShouldRetryOn(Exception ex);

}

IRetryDelayStrategy

Este es el último elemento que necesitamos, y probablemente el más sencillo puesto que tiene como única finalidad marcar el tiempo entre reintentos de operaciones fallidas.

<span class="rem">// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.</span>

<span class="kwrd">namespace</span> System.Data.Entity.Infrastructure
{
    <span class="kwrd">public</span> <span class="kwrd">interface</span> IRetryDelayStrategy
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Determines whether the action should be retried and the delay before the next attempt.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;lastException&quot;&gt;The exception thrown during the last execution attempt.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">///     Returns the delay indicating how long to wait for before the next execution attempt if the action should be retried;</span>
        <span class="rem">///     &lt;c&gt;null&lt;/c&gt; otherwise</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        TimeSpan? GetNextDelay(Exception lastException);
    }
}

namespace System.Data.Entity.Infrastructure

{

public interface IRetryDelayStrategy

{

/// <summary>

/// Determines whether the action should be retried and the delay before the next attempt.

/// </summary>

/// <param name="lastException">The exception thrown during the last execution attempt.</param>

/// <returns>

/// Returns the delay indicating how long to wait for before the next execution attempt if the action should be retried;

/// <c>null</c> otherwise

/// </returns>

TimeSpan? GetNextDelay(Exception lastException);

}

Bien, ahora que ya conocemos las piezas, ya podemos entender que tenemos para Sql Database, y esto, no es más que implementaciones concretas para estos contratos que podemos “inyectar” dentro de EF .

La implementación para el trabajo de Azure, Sql Database, se basa principalmente en la clase SqlAzureExecutionStrategy, que tendremos por defecto en el proveedor de Sql Server por defecto.

<span class="rem">// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.</span>

<span class="kwrd">namespace</span> System.Data.Entity.SqlServer
{
    <span class="kwrd">using</span> System.Data.Entity.Infrastructure;

    <span class="rem">/// &lt;summary&gt;</span>
    <span class="rem">///     An &lt;see cref=&quot;ExecutionStrategy&quot;/&gt; that uses the &lt;see cref=&quot;ExponentialRetryDelayStrategy&quot;/&gt; and</span>
    <span class="rem">///     &lt;see cref=&quot;SqlAzureRetriableExceptionDetector&quot;/&gt;.</span>
    <span class="rem">/// &lt;/summary&gt;</span>
    [DbProviderName(<span class="str">&quot;System.Data.SqlClient&quot;</span>)]
    <span class="kwrd">public</span> <span class="kwrd">class</span> SqlAzureExecutionStrategy : ExecutionStrategy
    {
        <span class="kwrd">public</span> SqlAzureExecutionStrategy()
            : <span class="kwrd">base</span>(<span class="kwrd">new</span> ExponentialRetryDelayStrategy(), <span class="kwrd">new</span> SqlAzureRetriableExceptionDetector())
        {
        }
    }
}

namespace System.Data.Entity.SqlServer

{

using System.Data.Entity.Infrastructure;

/// <summary>

/// An <see cref="ExecutionStrategy"/> that uses the <see cref="ExponentialRetryDelayStrategy"/> and

/// <see cref="SqlAzureRetriableExceptionDetector"/>.

/// </summary>

[DbProviderName("System.Data.SqlClient")]

public class SqlAzureExecutionStrategy : ExecutionStrategy

{

public SqlAzureExecutionStrategy()

: base(new ExponentialRetryDelayStrategy(), new SqlAzureRetriableExceptionDetector())

{

}

Como observará, en realidad esto no tiene nada más que el marcador de tiempos, ExponentialRetryDelayStrategy, que cuyo nombre indica hace un incremento exponencial basado en la siguiente fórmula:min (minDelay + coefficient * random(1, maxRandomFactor) * (exponentialBase ^ retryCount – 1), maxDelay), y un detector de excepciones personalizado que permitirá reintentar las siguientes excepciones.

SqlException con diferentes numberos de error, revisar el código siguiente para ver los casos concretos.
Un TimeoutException.

Como se establece la estrategia que queremos usar? por ejemplo esta para Sql Database?, pues bien, tan simple como hacemos otras inyecciones, por medio de nuestro DbConfiguration y el método AddExecutionStrategy.

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Call this method from the constructor of a class derived from &lt;see cref=&quot;DbConfiguration&quot; /&gt; to add an</span>
        <span class="rem">///     &lt;see cref=&quot;IExecutionStrategy&quot;/&gt; for use with the associated provider.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;remarks&gt;</span>
        <span class="rem">///     The &lt;typeparamref name=&quot;T&quot;/&gt; type should have a &lt;see cref=&quot;DbProviderNameAttribute&quot;/&gt; applied to it.</span>
        <span class="rem">///     This method is provided as a convenient and discoverable way to add configuration to the Entity Framework.</span>
        <span class="rem">///     Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for</span>
        <span class="rem">///     &lt;see cref=&quot;IExecutionStrategy&quot; /&gt;. This means that, if desired, the same functionality can be achieved using</span>
        <span class="rem">///     a custom resolver or a resolver backed by an Inversion-of-Control container.</span>
        <span class="rem">/// &lt;/remarks&gt;</span>
        <span class="rem">/// &lt;typeparam name=&quot;T&quot;&gt; The type that implements &lt;see cref=&quot;IExecutionStrategy&quot;/&gt;. &lt;/typeparam&gt;</span>
        <span class="rem">/// &lt;param name=&quot;getExecutionStrategy&quot;&gt; A function that returns a new instance of an execution strategy. &lt;/param&gt;</span>
        <span class="kwrd">protected</span> <span class="kwrd">internal</span> <span class="kwrd">void</span> AddExecutionStrategy&lt;T&gt;(Func&lt;T&gt; getExecutionStrategy)
            <span class="kwrd">where</span> T : IExecutionStrategy
        {
            Check.NotNull(getExecutionStrategy, <span class="str">&quot;getExecutionStrategy&quot;</span>);

            _internalConfiguration.CheckNotLocked(<span class="str">&quot;AddExecutionStrategy&quot;</span>);

            <span class="kwrd">foreach</span> (var providerInvariantNameAttribute <span class="kwrd">in</span> DbProviderNameAttribute.GetFromType(<span class="kwrd">typeof</span>(T)))
            {
                _internalConfiguration.AddDependencyResolver(
                    <span class="kwrd">new</span> ExecutionStrategyResolver&lt;T&gt;(providerInvariantNameAttribute.Name, <span class="rem">/*serverName:*/</span> <span class="kwrd">null</span>, getExecutionStrategy));
            }
        }

/// <summary>

/// Call this method from the constructor of a class derived from <see cref="DbConfiguration" /> to add an

/// <see cref="IExecutionStrategy"/> for use with the associated provider.

/// </summary>

/// <remarks>

/// The <typeparamref name="T"/> type should have a <see cref="DbProviderNameAttribute"/> applied to it.

/// This method is provided as a convenient and discoverable way to add configuration to the Entity Framework.

/// Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for

/// <see cref="IExecutionStrategy" />. This means that, if desired, the same functionality can be achieved using

/// a custom resolver or a resolver backed by an Inversion-of-Control container.

/// </remarks>

/// <typeparam name="T"> The type that implements <see cref="IExecutionStrategy"/>. </typeparam>

/// <param name="getExecutionStrategy"> A function that returns a new instance of an execution strategy. </param>

protected internal void AddExecutionStrategy<T>(Func<T> getExecutionStrategy)

where T : IExecutionStrategy

{

Check.NotNull(getExecutionStrategy, "getExecutionStrategy");

_internalConfiguration.CheckNotLocked("AddExecutionStrategy");

foreach (var providerInvariantNameAttribute in DbProviderNameAttribute.GetFromType(typeof(T)))

{

_internalConfiguration.AddDependencyResolver(

new ExecutionStrategyResolver<T>(providerInvariantNameAttribute.Name, /*serverName:*/ null, getExecutionStrategy));

}

Si nos fijamos un poco veremos como lo primero que hace este método es recuperar el proveedor para el que aplica esta estrategia, buscando un atributo, DbProviderName. Una vez localizado este atributo se establece el dependency resolver con la estrategia indicada. A partir de ese momento, ya tendremos disponible nuestra estrategia de reintentos..

Bueno, esto ha sido todo, espero que os sigan gustando las novedades de EF 6 y que sigáis viendo todo lo nuevo que poco a poco vamos teniendo…

Unai

EF 6: Snack Preview de MapToStoreProcedures en EF 6

Por diversas razones, que no son objetivo de este post, el mapeo a procedimientos almacenados ha sido una de los issues más votados dentro del proyecto de EF 6, y por eso, tal como estaba en el roadmap inicial, el equipo ya ha empezado a trabajar en esta característica, de la cual ya tenemos algo hecho con lo que podemos jugar. Aunque aún tengo unas cuantas preguntas sin responder del equipo, con las fuentes actuales vemos como se ha incluído un nuevo método MapToStoreProcedures dentro de nuestra bien conocida clase EntityTypeConfiguration<T>.

        [SuppressMessage(<span class="str">&quot;Microsoft.Design&quot;</span>, <span class="str">&quot;CA1006:DoNotNestGenericTypesInMemberSignatures&quot;</span>)]
        <span class="kwrd">public</span> EntityTypeConfiguration&lt;TEntityType&gt; MapToStoredProcedures(
            Action&lt;ModificationFunctionsConfiguration&lt;TEntityType&gt;&gt; modificationFunctionMappingConfigurationAction)
        {
            Check.NotNull(modificationFunctionMappingConfigurationAction, <span class="str">&quot;modificationFunctionMappingConfigurationAction&quot;</span>);

            var modificationFunctionMappingConfiguration
                = <span class="kwrd">new</span> ModificationFunctionsConfiguration&lt;TEntityType&gt;();

            modificationFunctionMappingConfigurationAction(modificationFunctionMappingConfiguration);

            _entityTypeConfiguration.MapToStoredProcedures(modificationFunctionMappingConfiguration.Configuration);

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

[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]

public EntityTypeConfiguration<TEntityType> MapToStoredProcedures(

Action<ModificationFunctionsConfiguration<TEntityType>> modificationFunctionMappingConfigurationAction)

{

Check.NotNull(modificationFunctionMappingConfigurationAction, "modificationFunctionMappingConfigurationAction");

var modificationFunctionMappingConfiguration

= new ModificationFunctionsConfiguration<TEntityType>();

modificationFunctionMappingConfigurationAction(modificationFunctionMappingConfiguration);

_entityTypeConfiguration.MapToStoredProcedures(modificationFunctionMappingConfiguration.Configuration);

return this;

}

Como se puede ver en este pequeño fragmento, gracias a este nuevo método, tendremos la posibilidad de configurar el mapeo contra los procedimientos de inserción, borrado y actualización utilizando esta configuración. Como siempre se aprende mejor de los ejemplo, a continuación ponemos el ejemplo trivial de mapeo, que nos va a permitir ver algunas cosas interesantes.

        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity&lt;Customer&gt;()
                .MapToStoredProcedures((mfc) =&gt;
                {
                    mfc.Update(umfc =&gt; umfc.HasName(<span class="str">&quot;uspCustomer&quot;</span>)
                                            .Parameter(c =&gt; c.FirstName, <span class="str">&quot;fname&quot;</span>));

                    mfc.Insert(imfc =&gt; imfc.HasName(<span class="str">&quot;ispCustomer&quot;</span>)
                                        .Parameter(c =&gt; c.FirstName, <span class="str">&quot;fname&quot;</span>)
                                        .Parameter(c =&gt; c.LastName, <span class="str">&quot;lname&quot;</span>)
                                        .Result(c=&gt;c.Id,<span class="str">&quot;Id&quot;</span>));

                    mfc.Delete(dmfc =&gt; dmfc.HasName(<span class="str">&quot;dspCustomer&quot;</span>)
                                        .Parameter(c =&gt; c.Id, <span class="str">&quot;id&quot;</span>));
                });
        }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Entity<Customer>()

.MapToStoredProcedures((mfc) =>

{

mfc.Update(umfc => umfc.HasName("uspCustomer")

.Parameter(c => c.FirstName, "fname"));

mfc.Insert(imfc => imfc.HasName("ispCustomer")

.Parameter(c => c.FirstName, "fname")

.Parameter(c => c.LastName, "lname")

.Result(c=>c.Id,"Id"));

mfc.Delete(dmfc => dmfc.HasName("dspCustomer")

.Parameter(c => c.Id, "id"));

});

}

Como observará, con el método anterior podremos especificar los mapeos de los diferentes procedimientos, pudiendo personalizar desde el nombre de los mismos hasta el nombre de los parámetros, tanto de entrada como de salida. Bueno, hasta aquí esta pequeñita entrega, como rezaba el título era solamente un sneak… espero que los que conozcáis EF os animéis a hacer más clones y si encontráis mejoras no dudéis en contribuir…

Update 1: Parece que me he adelantado un pelin y la gente de ADO.NET ha liberado una especificación de esta característica mucho más completa, que complementa lo comentado aquí con tras de las estupendas características de esta nueva novedad como son:

Convenciones por defecto para los nombres de los SP. Es decir, si como anteriormente no especificamos alguna de las funciones, por defecto se buscarán los siguientes nombres de SP, type_Insert,type_Update y type_Delete. En nuestro caso Customer_Update, Customer_Insert y Customer_Delete.

Para las relaciones Many To Many hay soporte con SP para el trabajo de inserciones y borrados, revisar la especificación para más información.

Saludos

Unai

Cloud Tour

Ya estamos otra vez de gira, en esta ocasión hablando sobre la plataforma de cloud computing de Microsoft, Windows Azure. Aunque, desde un punto de vista especial y fuera de los convencionalismos típicos de esta plataforma. La idea es ver si Windows Azure también es una estupenda plataforma para aquellos que no trabajan en entornos Microsoft. La agenda y los detalles de las sesiones los podéis ver a continuación:

En mi caso, yo me encargaré de la plataforma de acceso a datos, dónde veremos las posibilidades que Windows Azure nos da. Espero que os guste, para los que no estéis registrados, aquí tenéis fechas y más información…. nos vemos..

AGENDA

9:30 – 10:30 Introducción a la plataforma
10:30 – 11:30 IaaS – Linux, máquinas y redes virtuales
11:30 Café
11:45 – 12:30 PaaS – Trabajando con Java y Eclipse
12:30 – 13:30 PHP y Azure Web Sites
13:30 Comida
14:30 – 15:30 Almacenamiento en la nube: SQL, NoSQL
15:30 – 16:30 Big Data y Apache Hadoop
16:30 – 17:30 Desarrollo de backends para dispositivos móviles

Organización: Plain Concepts

Introducción a la plataforma

El objetivo de esta primera sesión será describir los principales servicios de la plataforma; Por qué puede interesar para mi empresa usar Cloud Computing, qué nivel de servicio, que opciones tengo si no trabajo con tecnologías Microsoft etc… Durante la sesión se hará especial hincapié en las diferentes opciones de interoperabilidad que existen y cómo es posible trabajar con otros lenguajes de programación como Java, Node.js o PHP e incluso desde otros sistema operativos, Linux y MAC.

IaaS – Linux, Máquinas y Redes Virtuales

La plataforma Windows Azure dispone de un servicio de infraestructura que permite de forma rápida y sencilla crear máquinas virtuales Windows y Linux. Durante esta sesión se mostrará las principales características de la misma y cómo es posible trabajar desde un ecosistema Linux, tanto a nivel de cliente como de servidor.

Cómo desplegar una máquina virtual Linux.
Cómo montar tu propia red virtual.
Cómo trabajar desde un ecosistema completamente Linux, tanto en desktop como en servidor.

PaaS, trabajando con Java y Eclipse

El servicio de “Plataforma como Servicio” es otro de los pilaras básicos de Windows Azure, el cual permite abstraernos de gran parte del trabajo de infraestructura y centrarnos únicamente en la aplicación que queremos desarrollar, posibilitando escenario de escalabilidad y disponibilidad difíciles de conseguir en otro tipo de soluciones. Durante esta sesión veremos de forma práctica cómo podemos desplegar aplicaciones Java con Eclipse en Windows Azure.

PHP y Azure Web Sites

Durante esta sesión se mostrará de forma prácticas las opciones disponibles para desplegar aplicaciones PHP en Windows Azure.

Durante esta sesión se empleará Windows Azure Web Sites para desplegar este tipo de aplicaciones, sirviendo a su vez para explicar con más detalle cómo es posible disponer de un escenario de integración continua con PHP, Azure Web Sites y GitHub.

Así mismo se verá cómo es posible trabajar de forma rápida y sencilla con WordPress, Drupal o Joomla.

Almacenamiento en la nube – SQL, NoSQL

Durante esta sesión se describirán las diferentes opciones de almacenamiento que están disponible en la nube, tanto base de datos relaciones, SQL Database y MySQL, como base de datos NOSQL como Windows Azure Table Storage, MongoDB o Cassandra.

De forma práctica podrá verse un ejemplo de cómo es posible trabajar con MongoDB, desplegado en una máquina virtual o haciendo uso de MongoDB como servicio.

Big Data y Hadoop

No se puede negar que Big Data y Hadoop son términos de moda en el mundo de IT, pero ¿sabes lo que realmente pueden aportar a tu organización? Y, aún más importante, ¿cómo podrías implementarlo dentro de tu ecosistema?

Durante esta sesión realizará una introducción a Big Data y Hadoop y de cómo es posible sacarle el máximo rendimiento a estas dos tecnologías dentro de nuestra organización.

Desarrollo de backends para el desarrollo de aplicaciones móviles

Aplicaciones para Android, Windows Phone, iPhone, iPad, Windows 8… casi todas tienen en común que generalmente necesitan de servicios de backend para ciertas funcionalidades; almacenamiento, notificaciones push, envíos de SMS, seguridad con diferentes proveedores de identidad etc… Durante esta sesión hablaremos de Mobile Services, una tecnología que permite disponer de forma rápida y sencilla de servicios de backend que pueden ser utilizados desde cualquiera de los dispositivos mencionando anteriormente, ya que además de ofrecer un API REST de uso dispone de SDKs propios de cada plataforma que simplifica su utilización.

Saludos

Unai

EF 6: Pluralization Service ahora es un servicio público

Esta ‘pequeña feature’ era algo que tenía en mente hacer desde hace tiempo, después de otros pull request con features y pequeños arreglos, he podido sacar un rato y realizar la implementación del mismo como podéis ver en este change set. La idea es básicamente poder tunear el servicio que se encarga de realizar la singularización y pluralización de nuestras entidades, por ejemplo para decidir por convención el nombre de una tabla. En realidad, este servicio es utilizado principalmente por PluralizingTableNameConvention y PluralizingEntitySetNameConvention para realizar su trabajo. Hasta ahora, es clase no era pública y su uso estaba fijado por las convenciones anteriores, no teniendo ninguna forma de cambiar la implementación del mismo. A lo largo de las siguientes líneas os contaré los cambios realizados y lo que podremos hacer en la siguiente versión de EF.

Haciendo el servicio público

Lo primero es crear el contrato para este servicio, que como podéis ver a continuación es tan sencillo como lo siguiente:

    <span class="kwrd">public</span> <span class="kwrd">interface</span> IPluralizationService
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Check if a word is plural.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;word&quot;&gt;The word to check.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;True if word is plural; false otherwise..&lt;/returns&gt;</span>
        <span class="kwrd">bool</span> IsPlural(<span class="kwrd">string</span> word);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Check if a word is singular.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;word&quot;&gt;The word to check.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;True if word is singular; false otherwise.&lt;/returns&gt;</span>
        <span class="kwrd">bool</span> IsSingular(<span class="kwrd">string</span> word);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Pluralize a word using the service.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;word&quot;&gt;The word to pluralize.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;The pluralized word &lt;/returns&gt;</span>
        <span class="kwrd">string</span> Pluralize(<span class="kwrd">string</span> word);

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Singularize a word using the service.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name=&quot;word&quot;&gt;The word to singularize.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;The singularized word.&lt;/returns&gt;</span>
        <span class="kwrd">string</span> Singularize(<span class="kwrd">string</span> word);
    }

public interface IPluralizationService

{

/// <summary>

/// Check if a word is plural.

/// </summary>

/// <param name="word">The word to check.</param>

/// <returns>True if word is plural; false otherwise..</returns>

bool IsPlural(string word);

/// <summary>

/// Check if a word is singular.

/// </summary>

/// <param name="word">The word to check.</param>

/// <returns>True if word is singular; false otherwise.</returns>

bool IsSingular(string word);

/// <summary>

/// Pluralize a word using the service.

/// </summary>

/// <param name="word">The word to pluralize.</param>

/// <returns>The pluralized word </returns>

string Pluralize(string word);

/// <summary>

/// Singularize a word using the service.

/// </summary>

/// <param name="word">The word to singularize.</param>

/// <returns>The singularized word.</returns>

string Singularize(string word);

}

Este servicio, por defecto, tendrá una implementación basada en lengua inglesa, llamado EnglishPluralizationService, que no es más que la adaptación a este contrato del servicio anterior, por compatibilidad. Para registrar la implementación que queramos usar se ha incluido un nuevo método en DbConfiguration llamado SetPluralizationService, gracias al cuál podremos establecer esta implementación, si es que queremos cambiar la existente. A continuación podemos ver un ejemplo de esto:

    <span class="kwrd">public</span> <span class="kwrd">class</span> OrderContextDbConfiguration
        : DbConfiguration
    {
        <span class="kwrd">public</span> OrderContextDbConfiguration()
        {
            SetPluralizationService(<span class="kwrd">new</span> SpanishPluralizationService());
        }
    }

public class OrderContextDbConfiguration

: DbConfiguration

{

public OrderContextDbConfiguration()

{

SetPluralizationService(new SpanishPluralizationService());

}

Un pequeño añadido aprovechando la coyuntura..

Ya metidos en faena, hay una pequeña cosa que podíamos hacer para no obligar a nadie a crear un servicio de pluralización si alguna de las reglas del existente no le convenía o quisiera ‘customizar’ este trabajo. La idea es básicamente permitir al usuario incluir en el servicio de pluralización la definición de una entrada de diccionario, con los correspondientes Singular y Plural, como podemos ver en el siguiente fragmento.

    <span class="kwrd">public</span> <span class="kwrd">class</span> CustomPluralizationEntry
    {
        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Get the singular.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> Singular { get; <span class="kwrd">private</span> set; }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">///     Get the plural.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">string</span> Plural { 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;singular&quot;&gt;A non null or empty string representing the singular.&lt;/param&gt;</span>
        <span class="rem">/// &lt;param name=&quot;plural&quot;&gt;A non null or empty string representing the plural.&lt;/param&gt;</span>
        <span class="kwrd">public</span> CustomPluralizationEntry(<span class="kwrd">string</span> singular, <span class="kwrd">string</span> plural)
        {
            Check.NotEmpty(singular, <span class="str">&quot;singular&quot;</span>);
            Check.NotEmpty(plural, <span class="str">&quot;plural&quot;</span>);

            Singular = singular;
            Plural = plural;
        }
    }

public class CustomPluralizationEntry

{

/// <summary>

/// Get the singular.

/// </summary>

public string Singular { get; private set; }

/// <summary>

/// Get the plural.

/// </summary>

public string Plural { get; private set; }

/// <summary>

/// Create a new instance

/// </summary>

/// <param name="singular">A non null or empty string representing the singular.</param>

/// <param name="plural">A non null or empty string representing the plural.</param>

public CustomPluralizationEntry(string singular, string plural)

{

Check.NotEmpty(singular, "singular");

Check.NotEmpty(plural, "plural");

Singular = singular;

Plural = plural;

}

Estas entradas de diccionario se pueden establecer en el constructor del servicio de pluralización antes de registrarlo, por ejemplo, ahora utilizando un IDbDependencyResolver, como vemos:

    <span class="kwrd">public</span> <span class="kwrd">class</span> UnityDependencyResolver
        : IDbDependencyResolver
    {
        IUnityContainer _container;

        <span class="kwrd">public</span> UnityDependencyResolver()
        {
            _container = <span class="kwrd">new</span> UnityContainer();

            _container.RegisterType&lt;IPluralizationService&gt;(<span class="kwrd">new</span> InjectionFactory((c) =&gt;
            {
                var pluralizationService = <span class="kwrd">new</span> EnglishPluralizationService(<span class="kwrd">new</span> CustomPluralizationEntry[]
                {
                    <span class="kwrd">new</span> CustomPluralizationEntry(<span class="str">&quot;Producto&quot;</span>,<span class="str">&quot;Productos&quot;</span>)
                });

                <span class="kwrd">return</span> pluralizationService;
            }));
        }

        <span class="kwrd">public</span> <span class="kwrd">object</span> GetService(Type type, <span class="kwrd">object</span> key)
        {
            <span class="kwrd">if</span> (_container.IsRegistered(type))
                <span class="kwrd">return</span> _container.Resolve(type, (<span class="kwrd">string</span>)key);

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

public class UnityDependencyResolver

: IDbDependencyResolver

{

IUnityContainer _container;

public UnityDependencyResolver()

{

_container = new UnityContainer();

_container.RegisterType<IPluralizationService>(new InjectionFactory((c) =>

{

var pluralizationService = new EnglishPluralizationService(new CustomPluralizationEntry[]

{

new CustomPluralizationEntry("Producto","Productos")

});

return pluralizationService;

}));

}

public object GetService(Type type, object key)

{

if (_container.IsRegistered(type))

return _container.Resolve(type, (string)key);

return null;

}

Bonus

Bien, una vez hecho público el servicio lo mejor era dar un ejemplo de implementación, por eso, otra de las cosas que he estado haciendo estas vacaciones ha sido la creación de este servicio de pluralización en castellano, aunque por ahora no lo he hecho público puesto que estoy mirando la mejor manera de hacerlo…en cuanto esté os comentaré como podréis utilizarlo….

Espero que os gustara la entrada y, como no, os invito a pasaros por el la página del proyecto en CodePlex y a contribuir de las muchas formas en las que se puede…

Saludos

Unai

EF 6: Buffering versus Streaming

Hace poco se incorporó un change set con un nuevo ‘breaking change’ dentro de la rama principal de Entity Framework. Este ‘breaking change’ se produce por el cambio en el modo de ejecución de las lecturas por parte de nuestras unidades de trabajo, pasando del modo habitual de lectura en streaming con un DbDataReader a un modo buffering, es decir, a la lectura temprana de los datos y al almacenamiento de los resultados en un buffer. A lo largo de esta entrada intentaremos ver desde que supone para nosotros este cambio como desarrolladores, hasta las justificaciones para realizarlo, pasando como no, por algunas piezas de código que nos permitan entender mejor como lo han implementado.

El cambio

Cuando trabajamos con EF generalmente, solemos tener cosas como la siguiente:

            <span class="kwrd">using</span> (var unitOfWork = <span class="kwrd">new</span> UnitOfWork())
            {
                var someenumerable = unitOfWork.Entities;
            }

using (var unitOfWork = new UnitOfWork())

{

var someenumerable = unitOfWork.Entities;

}

Y todos tenemos claro que ese enumerador es una consulta diferida, técnicamente por un shaper, la diferencia de este trabajo en EF 6 con respecto a las anteriores estriba en como se hace la materialización de este enumerable. En la versión actual de EF tendremos un data reader que será usado en cada llamada al MoveNext del iterador. Aunque todos sabemos que internamente DataReader funciona con bloques para conjuntos de datos grandes estos se van incorporando a medida que se necesitan, es decir, hay un proceso de streaming de los datos del servidor a cliente. Para ver esto solamente tendríamos que realizar una lectura de un cojunto grande y ver como el BatchStarting y el BatchCompleted sucenden al comienzo de la lectura y cuando hemos iterado por todos los resultado, es decir, para la siguiente consulta, podríamos ver los siguientes valores en nuestro profiler

             var enumerable = unitOfWork.Entities;

             <span class="kwrd">foreach</span> (var item <span class="kwrd">in</span> enumerable)
             {
                  <span class="rem">//TODO: Some work here!</span>
             }

             Console.ReadLine();

var enumerable = unitOfWork.Entities;

foreach (var item in enumerable)

{

//TODO: Some work here!

}

Console.ReadLine();

Comienzo de la lectura

final del bucle

Lógico según lo se sabemos sobre el comportamiento de nuestros data readers ¿ verdad ?. Bien, pues ahora intentamos hacer esto mismo con EF 6 y veremos lo siguiente nada más ejecutar el paso por el primero de los elementos…

La razón es la que comentamos más arriba, en la nueva versión de EF que tendremos el mecanismo de consultas reemplazará el DbDataReader por un BufferedDataReader (System.Data.Entity.Core.Objects.Internal.BufferedDataReader) el cual en realidad no es más que un envoltorio de un DataReader que hace todo la lectura de sus elementos en su inicialización y los almacena en una estructura interna BufferedDataRecord, de ahí el nombre de Buffered, que será usada por el materializador ( shaper ) para crear las distintas entidades.

Aunque esto pueda parecer un mero cambio interno a EF, en realidad no es tan sencillo y supone un breaking change porque tiene un impacto sobre las aplicaciones actuales. De entrada es lógico ver que hay una mayor presión de memoria, aunque sea memoria de generación 0, puesto que estamos duplicando los datos en el proceso de materialización. El segundo motivo es que por ejemplo si se rompe el bucle anterior por cualquier condición en la versión anterior no tendríamos porque haber traído todos los bloques del reader mientras que en EF 6 si habríamos traído todos los bloques del reader. Otro impacto posible lo podemos observar en la llamada a nuestro GetEnumerator, puesto que ahora necesitará más tiempo para completar el trabajo.

Los motivos

Las razones para movernos de un modo Streamed a Buffered se deben principalmente y tal como el equipo ha explicado en el siguiente design meeting a las siguientes razones:

Sql Azure connection resilience: Como todos sabéis, el trabajo con Sql Azure tiene una problemática especial que nos obliga a necesitar en ciertos escenarios de reintentos en nuestro trabajo con EF, Cesar de la Torre escribió hace ya mucho tiempo sobre esto. Dentro de la iniciativa del equipo por hacer más robusto el uso de EF con Sql Azure este cambio es necesario ya que no retarda el uso de una conexión más allá de lo necesario.
El tiempo de uso de una conexión se reduce potencialmente
Ya no es necesario MARS ( obligatorio con lazy loading en la versión actual )

Y si quiero mi antiguo comportamiento

Bien sea por compatibilidad o porque el escenario así lo requiera, en EF tendremos un mecanismo para seguir usando streaming en nuestras consultas, para ello, solamente tendremos que utilizar el método AsStreaming, gracias al cual EF volverá a usar un DbDataReader en lugar del ya mencionado BufferedDataReader. A continuación podemos ver un ejemplo de ello:

                var enumerable = unitOfWork.Entities
                                           .Where(a=&gt;a.Id&gt;0)
                                           .AsStreaming();

var enumerable = unitOfWork.Entities

.Where(a=>a.Id>0)

.AsStreaming();

Bueno, hasta aquí hemos llegado, espero que todos tengamos en cuenta este cambio si decidimos migrar aplicaciones de EF 5 a EF 6 puesto que tal y como hemos dicho puede tener impacto y producirse situaciones no deseadas sino nos fijamos…

Saludos

Unai

EF 6: Estableciendo las configuraciones de forma automática

La verdad es que no hace muchos días que publiqué un post con este trabajo para todos aquellos, que como yo, consideraran interesante el hecho de disponer de una forma automática de agregar las configuración de nuestro modelo, con el fin de facilitar el trabajo y prevenir ese código repetitivo que solemos ver muy a menudo. Para que no tengamos que recurrir a lo mismo en EF 6, me decidí por hacer un pequeño pull request que pudiera contener esta funcionalidad, ahora, que como ya sabréis todos, Entity Framework es Open Source y, por lo tanto, abierto a que la comunidad pueda contribuir. Los que hayáis pasado alguna vez por el portal del proyecto en Codeplex sabréis que hay multitud de información sobre las diferentes vías de contribución, que no tienen porque ser solamente código, y como hacer estas contribuciones de una forma ordenada y consensuada. La palabra consensuada es importante aquí puesto que por mucho que a nosotros nos parezca importante y válida una contribución esta no tiene por que tener la misma validez para el equipo, por ejemplo, porque la pieza o piezas en las que vayamos a tocar se vayan a rediseñar o, a otra multitud de factores que se nos puedan escapar. El principio Don’t Push Your Pull Request es la norma a seguir dentro del equipo de desarrollo y por lo tanto el primer trabajo que tenemos que hacer es discutir con ellos lo que queremos hacer y por supuesto como lo vamos a hacer, en este caso, la sugerencia de pull request y su discusión la podéis ver aquí.

Bueno, después de ver el feedback y de las guías sobre como les gustaría la aportación, el resultado que ha quedado es este Change Set con la característica comentada anteriormente y, que pasaremos a desgranar ahora mismo.

Carga automática de configuraciones

Bien, esto es lo más básico y a la vez lo más natural de esta característica, puesto que como ya comentamos su primer trabajo es hacer la carga de configuraciones de forma automática, eliminando las típicas líneas repetitivas de carga de configuraciones, que en un proyecto real serán muchas y por lo tanto con un impacto en legibilidad y mantenibilidad. Es decir, lo que nos permitiría es cambiar cosas como esta:

        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
        {
            <span class="rem">//.. more configurations entries</span>

            modelBuilder.Configurations.Add(<span class="kwrd">new</span> OrderEntityTypeConfiguration());
            modelBuilder.Configurations.Add(<span class="kwrd">new</span> CustomerEntityTypeConfiguration());

            <span class="rem">//.. more configurations entries</span>
        }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

//.. more configurations entries

modelBuilder.Configurations.Add(new OrderEntityTypeConfiguration());

modelBuilder.Configurations.Add(new CustomerEntityTypeConfiguration());

//.. more configurations entries

}

Por lo siguiente:

        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.AddFromAssembly(Assembly.GetExecutingAssembly());
        }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Configurations.AddFromAssembly(Assembly.GetExecutingAssembly());

}

&#160;

Visibilidad de tipos y constructores

Para realizar esta carga automática de configuraciones no estamos restringidos a ninguna visibilidad de nuestras clases, ni de sus constructores. De hecho, esto es lo ideal, puesto que estas clases solamente tienen fines de configuración y no están pensadas para ser usadas más que por la infraestructura, parece lógico que pudiéramos escribirlas como por ejemplo en la siguiente de forma no pública y con un constructor privado.

class OrderEntityTypeConfiguration :EntityTypeConfiguration<Order> { private OrderEntityTypeConfiguration() { this.Property(o => o.Total).HasPrecision(12, 2); } }

1
2
3
4
5
6
7
8

 class OrderEntityTypeConfiguration
 :EntityTypeConfiguration<Order>
 {
 private OrderEntityTypeConfiguration()
 {
 this.Property(o => o.Total).HasPrecision(12, 2);
 }
 }

Configuraciones en jerarquía

La última de las características de este trabajo, es el soporte a jerarquías de configuraciones, es decir, que nuestros tipos de configuración no implementen de forma directa EntityTypeConfiguration<>. Un ejemplo de este tipo de escenarios podría ser algo como lo siguiente:

abstract class CommonEntityTypeConfiguration<TEntity> :EntityTypeConfiguration<TEntity> where TEntity:class { public CommonEntityTypeConfiguration() { string tableName = PrefixTableName(typeof(TEntity).Name); this.ToTable(tableName); } string PrefixTableName(string name) { return "tbl" + name; } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

 abstract class CommonEntityTypeConfiguration<TEntity>
 :EntityTypeConfiguration<TEntity> where TEntity:class
 {
 public CommonEntityTypeConfiguration()
 {
 string tableName = PrefixTableName(typeof(TEntity).Name);

 this.ToTable(tableName);

 }

 string PrefixTableName(string name)
 {
 return "tbl" + name;
 }
 }

Si observa, lo que hemos hecho, con meros fines de ejemplo, es hacer una pequeña base para nuestras configuraciones que nos agrega un prefijo tbl a los nombres de nuestras tablas. Esta configuración base la podríamos utilizar en todas aquellas entidades que nos interesaran que ya tuvieran OOB esta característica.

    <span class="kwrd">class</span> OrderEntityTypeConfiguration
        : CommonEntityTypeConfiguration&lt;Order&gt;
    {
        <span class="kwrd">private</span> OrderEntityTypeConfiguration()
        {
            <span class="kwrd">this</span>.Property(o =&gt; o.Total).HasPrecision(12, 2);
        }
    }

class OrderEntityTypeConfiguration

: CommonEntityTypeConfiguration<Order>

{

private OrderEntityTypeConfiguration()

{

this.Property(o => o.Total).HasPrecision(12, 2);

}

Pues bien, como hemos dicho, aún en estas situaciones nuestro AddFromAssembly seguirá funcionando perfectamente y cargando nuestras configuraciones de la forma correcta, excluyendo tipos abstractos y definiciones de tipos genéricos…

Bueno, espero que os resulte interesante esta novedad que tendremos en EF 6 y espero, que esta contribución os sea de la mayor utilidad posible, con ese fin está hecha…

saludos

Unai

Recursos, mensajes de excepción y otras cadenas…..

Bueno, imagino que después de leer el título le quedará bastante claro de lo que vamos a hablar en este pequeño post. A lo largo de este tiempo he visto muchas y diversas formas de manejar los típicos mensajes de excepción y otros elementos localizables de nuestro código ( sin hablar nada de UI en este caso ), unas mejores y otras peores. Con la llegada de .NET y los recursos incrustados, muchos de los inconvenientes tradicionales que teníamos se vieron resueltos. Elementos como el fallback en la resolución de la cultura, los conceptos de culturas específicas y neutras, sin duda, facilitaron enormemente nuestro trabajo. El consumo de estos recursos incrustados de .NET, por regla general, se realiza utilizando las propiedades de la clase que se nos genera automáticamente por cada uno los archivos de recursos [ recuerde que por defecto estos ficheros tienen asociada una custom tool, ResXFileCodeGenerator, para la generación de esta clase ]. Elementos habituales podrían ser, algunos como los siguientes:

<span class="lnum">   1:          </span><span class="kwrd">throw</span> <span class="kwrd">new</span> InvalidOperationException(Resource.AnyExceptionMessageForOperation);

1	<span class="lnum"> 1: </span><span class="kwrd">throw</span> <span class="kwrd">new</span> InvalidOperationException(Resource.AnyExceptionMessageForOperation);

<span class="lnum">   1:  </span>        <span class="kwrd">static</span> <span class="kwrd">bool</span> AnyTryMethod(<span class="kwrd">out</span> <span class="kwrd">string</span> error)

1	<span class="lnum"> 1: </span> <span class="kwrd">static</span> <span class="kwrd">bool</span> AnyTryMethod(<span class="kwrd">out</span> <span class="kwrd">string</span> error)

<span class="lnum">   2:  </span>        {

1	<span class="lnum"> 2: </span> {

<span class="lnum">   3:  </span>            <span class="rem">//.... </span>

1	<span class="lnum"> 3: </span> <span class="rem">//.... </span>

<span class="lnum">   4:  </span>&nbsp;

1	<span class="lnum"> 4: </span>

<span class="lnum">   5:  </span>            error = Resource.AnyMessageToUser;

1	<span class="lnum"> 5: </span> error = Resource.AnyMessageToUser;

<span class="lnum">   6:  </span>&nbsp;

1	<span class="lnum"> 6: </span>

<span class="lnum">   7:  </span>            <span class="rem">//....</span>

1	<span class="lnum"> 7: </span> <span class="rem">//....</span>

<span class="lnum">   8:  </span>        }

1	<span class="lnum"> 8: </span> }

Alguno de los problemas con esta forma de trabajo surge por ejemplo cuando queremos hacer estos mensajes parametrizados, puesto que tendríamos que recurrir a cosas como la siguiente:

<span class="lnum">   1:          </span>var localizedMessage = <span class="kwrd">string</span>.Format(Resource.AnyMessageToUser, <span class="str">"p0"</span>, <span class="str">"p1"</span>);

1	<span class="lnum"> 1: </span>var localizedMessage = <span class="kwrd">string</span>.Format(Resource.AnyMessageToUser, <span class="str">"p0"</span>, <span class="str">"p1"</span>);

&nbsp;

Cuando se utiliza esta entrada de recursos, no hay más remedio que acudir a nuestro mensaje para descubrir si este toma parámetros o no y establecerlos en caso necesario, por no hablar de que la legibilidad podría verse afectada, sin duda. Mecanismos para intentar solventar estos problemas hay muchos y variados pero uno que últimamente me ha gustado y que he seguido ha sido el utilizado por el equipo de EF para hacer la gestión de esta problemática. Mecanismo que se basa en una sencilla plantilla .tt junto a un fichero de recursos que nos permite generar 2 clases fundamentales Strings y Error preparadas para ser utilizadas en el código de una forma más simple y legible que mediante el código por defecto de ResXFileCodeGenerator. De entre algunas de las características que incorpora esta plantilla podemos ver que expone en forma de parámetros los parámetros de las entradas del archivo de recursos, de tal forma que si, por ejemplo, tenemos una entrada con valor “any message for {0} and {1}” esta plantilla nos expondrá en nuestra clase Strings un método similar a lo siguiente:

<span class="lnum">   1:          </span><span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> AnyMessageToUser(<span class="kwrd">object</span> p0, <span class="kwrd">object</span> p1);

1	<span class="lnum"> 1: </span><span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">string</span> AnyMessageToUser(<span class="kwrd">object</span> p0, <span class="kwrd">object</span> p1);

Con lo cual, el uso anterior de esta clave de recurso podría realizarse como, por ejemplo de la siguiente manera:

<span class="lnum">   1:          </span>var localizedMessage = Strings.AnyMessageToUser(<span class="str">"p0"</span>, <span class="str">"p1"</span>);

1	<span class="lnum"> 1: </span>var localizedMessage = Strings.AnyMessageToUser(<span class="str">"p0"</span>, <span class="str">"p1"</span>);

La parte de Error, es quizás, más interesante todavía, puesto que nos permite generar a partir de los claves de nuestros ficheros de recurso métodos que devuelvan las excepciónes que necesitemos, cuyos tipos se extraen además del mismo archivo de recursos gracias a un pequeño trick con el campo comentarios, puesto que interpretan comentarios como ## ExceptionType=InvalidOperationException como la necesidad de generar un método que devuelva una excepción InvalidOperationException con el mensaje de la misma entrada del recurso. A continuación podemos ver un ejemplo de uno de los mensajes de Error que tenemos en el código de EF

<span class="lnum">   1:  </span>        <span class="kwrd">internal</span> <span class="kwrd">static</span> Exception AutomaticDataLoss()

1	<span class="lnum"> 1: </span> <span class="kwrd">internal</span> <span class="kwrd">static</span> Exception AutomaticDataLoss()

<span class="lnum">   2:  </span>        {

1	<span class="lnum"> 2: </span> {

<span class="lnum">   3:  </span>            <span class="kwrd">return</span> <span class="kwrd">new</span> Migrations.Infrastructure.AutomaticDataLossException(Strings.AutomaticDataLoss);

1	<span class="lnum"> 3: </span> <span class="kwrd">return</span> <span class="kwrd">new</span> Migrations.Infrastructure.AutomaticDataLossException(Strings.AutomaticDataLoss);

<span class="lnum">   4:  </span>        }

1	<span class="lnum"> 4: </span> }

Bueno, amigo lector, le invito desde aquí a revisar como otros resuelven problemas habituales en nuestro trabajo. En este caso, esta plantilla de la que acabamos de ver es un ejemplo bastante simple de tratar el problema. Aunque hay que tocar un par de cosas para que la misma se pueda utilizar en cualquier proyecto la verdad es que es terriblemente sencilla, por lo que le invito a probarla…

Saludos

Unai

EF Agregando configuraciones de forma automática

Hay ciertas situaciones en las que las convenciones de EF para nuestros mapeos de entidades no nos sirven o bien no nos sirven completamente, un ejemplo de esto es cuando trabajamos con una base de datos existente, dónde, seguramente, la convención del nombre de las tablas ( pluralización en inglés de los nombres de las entidades ) no nos sirva, y así con otras muchas convenciones. En estas situaciones, es más que seguro que tengamos que hacer uso de las configuraciones personalizadas, instancias de EntityTypeConfiguration<> y ComplexTypeConfiguration<>. En estos casos, cuando el modelo es grande, el aspecto que tendrá nuestro OnModelCreating será un poco esperpéntico, algo similar a lo siguiente:

<span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
{
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti1Configuration());
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti2Configuration());
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti3Configuration());
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti4Configuration());
          ...
          ...
          ...
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti20Configuration());
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti21Configuration());
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti22Configuration());
          modelBuilder.Configuration.Add(<span class="kwrd">new</span> Entiti23Configuration());
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Configuration.Add(new Entiti1Configuration());

modelBuilder.Configuration.Add(new Entiti2Configuration());

modelBuilder.Configuration.Add(new Entiti3Configuration());

modelBuilder.Configuration.Add(new Entiti4Configuration());

...

modelBuilder.Configuration.Add(new Entiti20Configuration());

modelBuilder.Configuration.Add(new Entiti21Configuration());

modelBuilder.Configuration.Add(new Entiti22Configuration());

modelBuilder.Configuration.Add(new Entiti23Configuration());

}

El problema de este tipo de códigos, amén del matenimiento, es la poca legibilidad del mismo, donde por ejemplo, nos costaría encontrar si una entidad está o no mapeada. Solventar este problema y hacer un código más legible y facilitar la vida al desarrollador no es difícil, ya que en realidad lo único que estamos haciendo ahí es configurar todas las clases de un determinado tipo, algo por lo tanto muy fácil de automatizar. En el siguiente repositorio de GitHub he implementado una posible solución para estos problemas, que nos permite cambiar este código anterior por algo como lo siguiente:

<span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
{
        modelBuilder.Configurations.Add(ConfigurationSolver.FromThisAssembly());
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Configurations.Add(ConfigurationSolver.FromThisAssembly());

}

o, si tenemos los mapas de configuración en otro ensamblado, podríamos hacer:

<span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
{
        modelBuilder.Configurations.Add(ConfigurationSolver.FromNamedAssembly(<span class="str">&quot;The_Assembly_With_Configs&quot;</span>));
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Configurations.Add(ConfigurationSolver.FromNamedAssembly("The_Assembly_With_Configs"));

}

Espero que os guste y, sobre todo, que os sea de utilidad…

&#160;

Saludos

Saludos

Unai

Unai

EF 6 Alpha: Custom Conventions

El tema de las convenciones personalizadas para el modelo de Code First sin duda ha sido una de las cosas que más echamos de menos en EF, de hecho, durante alguna de las betas estas posibilidades estaban incluidas como en su día vimos en algún post. De entre las distintas novedades de esta versión preliminar de EF 6 podemos destacar la vuelta al ruedo de estas features, aunque ahora con una implementación, en mi opinión, mucho más acertada. A lo largo de la siguiente entrada intentaremos darle un vistazo a estas nuevas posibilidades, si lo desea, también puede leer el walkthough que el equipo de ADO.NET tiene sobre este tema.

Introducción

Todas las convenciones de EF, están basadas en la siguiente interface, IConfigurationConvention:

    [ContractClass(<span class="kwrd">typeof</span>(IConfigurationConventionContracts&lt;,&gt;))]
    <span class="kwrd">public</span> <span class="kwrd">interface</span> IConfigurationConvention&lt;TMemberInfo, TConfiguration&gt; : IConvention
        <span class="kwrd">where</span> TMemberInfo : MemberInfo
        <span class="kwrd">where</span> TConfiguration : ConfigurationBase
    {
        <span class="kwrd">void</span> Apply(TMemberInfo memberInfo, Func&lt;TConfiguration&gt; configuration);
    }

[ContractClass(typeof(IConfigurationConventionContracts<,>))]

public interface IConfigurationConvention<TMemberInfo, TConfiguration> : IConvention

where TMemberInfo : MemberInfo

where TConfiguration : ConfigurationBase

{

void Apply(TMemberInfo memberInfo, Func<TConfiguration> configuration);

}

Esta interface, como observará tiene dos parámetros genéricos TMemberInfo y TConfiguration, que nos permite establecer, por un lado con TMemberInfo si la configuración es para un tipo o para una propiedad y en ultimo lugar a que elemento en concreto se aplica, para el caso de las propiedades ConfigurationBase tiene un jerarquía similar a esta:

ConfigurationBase

-> Property Configuration

->NavigationPropertyConfiguration

->PrimitivePropertyConfiguraiton

    -> BinaryPropertyConfiguraiton

    -> DateTimePropertyConfiguration

     -> ….

Dicho esto, para crear por ejemplo una convención que afecte a propiedades de tipo DateTime tendríamos que implementar una clase como la siguiente:

     <span class="kwrd">public</span> <span class="kwrd">class</span> DateTimeIsMappedToSqlServerDateTime2
        :IConfigurationConvention&lt;PropertyInfo,DateTimePropertyConfiguration&gt;
    {
        <span class="kwrd">public</span> <span class="kwrd">void</span> Apply(PropertyInfo memberInfo, Func&lt;DateTimePropertyConfiguration&gt; configuration)
        {
           
        }
    }

public class DateTimeIsMappedToSqlServerDateTime2

:IConfigurationConvention<PropertyInfo,DateTimePropertyConfiguration>

{

public void Apply(PropertyInfo memberInfo, Func<DateTimePropertyConfiguration> configuration)

{

}

Por supuesto, dentro del método Apply tendríamos que establecer que queremos en la convención, si se fija, el delegado configuration nos permite obtener la configuración actual de esa propiedad, con lo cual, podríamos ver/modificar la misma. En este caso optaremos por hacer lo mismo que el el walkthoug, puesto que me parece muy ‘real’ el hecho de adaptar el tipo de datos en Sql Server a datetime2 para estas propiedades.

    <span class="kwrd">public</span> <span class="kwrd">class</span> DateTimeIsMappedToSqlServerDateTime2
        :IConfigurationConvention&lt;PropertyInfo,DateTimePropertyConfiguration&gt;
    {
        <span class="kwrd">public</span> <span class="kwrd">void</span> Apply(PropertyInfo memberInfo, Func&lt;DateTimePropertyConfiguration&gt; configuration)
        {
            <span class="rem">//get the current datetimepropertyconfiguration</span>
            var dateTimeConfiguration = configuration();

public class DateTimeIsMappedToSqlServerDateTime2

:IConfigurationConvention<PropertyInfo,DateTimePropertyConfiguration>

{

public void Apply(PropertyInfo memberInfo, Func<DateTimePropertyConfiguration> configuration)

{

//get the current datetimepropertyconfiguration

var dateTimeConfiguration = configuration();

            <span class="kwrd">if</span> (dateTimeConfiguration.ColumnType == <span class="kwrd">null</span>)
                dateTimeConfiguration.ColumnType = <span class="str">"datetime2"</span>;
        }
    }

if (dateTimeConfiguration.ColumnType == null)

dateTimeConfiguration.ColumnType = "datetime2";

}

Por supuesto, usted puede revisar el miembro memberInfo para decidir a que propiedades se aplica, por ejemplo, le podría interesar solo aplicar esta convención a las propiedades cuyo nombre por ejemplo acaben con un postfijo determinado, aunque esto, en mi humilde opinión no es algo que me guste para nada. Las convenciones a nivel de entidad, son prácticamente iguales, con la salvedad de que lógicamente configuran aspectos de la entidad y no de las propiedades, por ejemplo, la convención de que la propiedad Id sea la clave primaria de una entidad podría haberse escrito así.

    <span class="kwrd">public</span> <span class="kwrd">class</span> IdPropertyIsPrimaryKeyConvention
       : IConfigurationConvention&lt;Type, EntityTypeConfiguration&gt;
    {

        <span class="kwrd">public</span> <span class="kwrd">void</span> Apply(Type memberInfo, Func&lt;EntityTypeConfiguration&gt; configuration)
        {
            var entityTypeConfiguration = configuration();

            var idProperty = memberInfo.GetProperty(<span class="str">"Id"</span>, BindingFlags.Public | BindingFlags.Instance);

            <span class="kwrd">if</span> (idProperty != <span class="kwrd">null</span>)
                entityTypeConfiguration.Key(idProperty);
        }
    }

public class IdPropertyIsPrimaryKeyConvention

: IConfigurationConvention<Type, EntityTypeConfiguration>

{

public void Apply(Type memberInfo, Func<EntityTypeConfiguration> configuration)

{

var entityTypeConfiguration = configuration();

var idProperty = memberInfo.GetProperty("Id", BindingFlags.Public | BindingFlags.Instance);

if (idProperty != null)

entityTypeConfiguration.Key(idProperty);

}

Bien, una vez que tenemos definidas nuestras convenciones, para agregarla usaremos la propiedad Conventions, que ya es conocida de nuestros DbContext, con la diferencia que ahora dispone de métodos para incluir convenciones y no solamente para eliminarlas. De hecho, incluso me permite establecer el orden de ejecución de las mismas.

      modelBuilder.Conventions.Add&lt;IdPropertyIsPrimaryKeyConvention&gt;();

1	modelBuilder.Conventions.Add<IdPropertyIsPrimaryKeyConvention>();

Con el fin de simplificarnos la vida, el equipo de ADO.NET nos ha creado una pequeña clase LightweigtConvention con la cual podremos establecer convenciones sin necesidad de escribir una nueva clase para las mismas. Esta clase no es más que una implementación de IConventionConfiguration para tipos y propiedades que hace uso de una clase, EntityConventionConfiguration para agregar convenciones mediante un API fluent.

    <span class="kwrd">public</span> <span class="kwrd">class</span> EntityConventionConfiguration
    {
        <span class="kwrd">private</span> <span class="kwrd">readonly</span> List&lt;Func&lt;Type, <span class="kwrd">bool</span>&gt;&gt; _predicates = <span class="kwrd">new</span> List&lt;Func&lt;Type, <span class="kwrd">bool</span>&gt;&gt;();
        <span class="kwrd">private</span> Action&lt;LightweightEntityConfiguration&gt; _configurationAction;
        <span class="kwrd">private</span> PropertyConventionConfiguration _propertyConfiguration;

        <span class="kwrd">internal</span> EntityConventionConfiguration()
        {
        }

        <span class="kwrd">internal</span> Action&lt;LightweightEntityConfiguration&gt; ConfigurationAction
        {
            get { <span class="kwrd">return</span> _configurationAction; }
        }

        <span class="kwrd">internal</span> List&lt;Func&lt;Type, <span class="kwrd">bool</span>&gt;&gt; Predicates
        {
            get { <span class="kwrd">return</span> _predicates; }
        }

        <span class="kwrd">internal</span> PropertyConventionConfiguration PropertyConfiguration
        {
            get { <span class="kwrd">return</span> _propertyConfiguration; }
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Filters the entity types that this convention applies to based on a</span>
        <span class="rem">/// predicate.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="predicate"&gt;A function to test each entity type for a condition.&lt;/param&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">/// The same EntityConventionConfiguration instance so that multiple calls can</span>
        <span class="rem">/// be chained.</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        <span class="kwrd">public</span> EntityConventionConfiguration Where(Func&lt;Type, <span class="kwrd">bool</span>&gt; predicate)
        {
            Contract.Requires(predicate != <span class="kwrd">null</span>);

            _predicates.Add(predicate);

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

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Allows configuration of the entity types that this convention applies to.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;param name="entityConfigurationAction"&gt;</span>
        <span class="rem">/// An action that performs configuration against a &lt;see cref="LightweightEntityConfiguration" /&gt;.</span>
        <span class="rem">/// &lt;/param&gt;</span>
        <span class="kwrd">public</span> <span class="kwrd">void</span> Configure(Action&lt;LightweightEntityConfiguration&gt; entityConfigurationAction)
        {
            Contract.Requires(entityConfigurationAction != <span class="kwrd">null</span>);

            _configurationAction = entityConfigurationAction;
        }

        <span class="rem">/// &lt;summary&gt;</span>
        <span class="rem">/// Allows further configuration of the convention based on the properties of</span>
        <span class="rem">/// the entity types that this convention applies to.</span>
        <span class="rem">/// &lt;/summary&gt;</span>
        <span class="rem">/// &lt;returns&gt;</span>
        <span class="rem">/// A configuration object that can be used to configure this convention based</span>
        <span class="rem">/// on properties.</span>
        <span class="rem">/// &lt;/returns&gt;</span>
        <span class="kwrd">public</span> PropertyConventionConfiguration Properties()
        {
            var propertyConfiguration = <span class="kwrd">new</span> PropertyConventionConfiguration();
            _propertyConfiguration = propertyConfiguration;

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

public class EntityConventionConfiguration

{

private readonly List<Func<Type, bool>> _predicates = new List<Func<Type, bool>>();

private Action<LightweightEntityConfiguration> _configurationAction;

private PropertyConventionConfiguration _propertyConfiguration;

internal EntityConventionConfiguration()

{

}

internal Action<LightweightEntityConfiguration> ConfigurationAction

{

get { return _configurationAction; }

}

internal List<Func<Type, bool>> Predicates

{

get { return _predicates; }

}

internal PropertyConventionConfiguration PropertyConfiguration

{

get { return _propertyConfiguration; }

}

/// <summary>

/// Filters the entity types that this convention applies to based on a

/// predicate.

/// </summary>

/// <param name="predicate">A function to test each entity type for a condition.</param>

/// <returns>

/// The same EntityConventionConfiguration instance so that multiple calls can

/// be chained.

/// </returns>

public EntityConventionConfiguration Where(Func<Type, bool> predicate)

{

Contract.Requires(predicate != null);

_predicates.Add(predicate);

return this;

}

/// <summary>

/// Allows configuration of the entity types that this convention applies to.

/// </summary>

/// <param name="entityConfigurationAction">

/// An action that performs configuration against a <see cref="LightweightEntityConfiguration" />.

/// </param>

public void Configure(Action<LightweightEntityConfiguration> entityConfigurationAction)

{

Contract.Requires(entityConfigurationAction != null);

_configurationAction = entityConfigurationAction;

}

/// <summary>

/// Allows further configuration of the convention based on the properties of

/// the entity types that this convention applies to.

/// </summary>

/// <returns>

/// A configuration object that can be used to configure this convention based

/// on properties.

/// </returns>

public PropertyConventionConfiguration Properties()

{

var propertyConfiguration = new PropertyConventionConfiguration();

_propertyConfiguration = propertyConfiguration;

return propertyConfiguration;

}

Utilizando esta clase, por lo tanto, podríamos crear una convención tal y como sigue:

   <span class="kwrd">public</span> <span class="kwrd">class</span> BlogUnitOfWork
        :DbContext
    {
        <span class="kwrd">public</span> IDbSet&lt;Blog&gt; Blogs { get; set; }

        <span class="kwrd">protected</span> <span class="kwrd">override</span> <span class="kwrd">void</span> OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Conventions.Add(entityConventionConfiguration =&gt;
            {
                entityConventionConfiguration.Properties()
                                            .Where(p =&gt; p.Name == <span class="str">"Id"</span>)
                                            .Configure(lpc =&gt; lpc.IsKey());
            });
        }
    }

public class BlogUnitOfWork

:DbContext

{

public IDbSet<Blog> Blogs { get; set; }

protected override void OnModelCreating(DbModelBuilder modelBuilder)

{

modelBuilder.Conventions.Add(entityConventionConfiguration =>

{

entityConventionConfiguration.Properties()

.Where(p => p.Name == "Id")

.Configure(lpc => lpc.IsKey());

});

}

Puede observar como el trabajo a realizar depende de si configura propiedad o entidad y este está representado por las clases LightweighPropertyConfiguration o LightweighEntityConfiguration.

Bien, pero ¿y si quiero hacer las convenciones con atributos? Pues sencillo, en vez de implementar IConfigurationConvention trabajaremos con AttributeConfigurationConvention, el cual, nos permite indicar que atributo es el que será el atributo marcador, es decir aquel atributo que EF revisará para saber que tiene que aplicar una convención. Para verlo, utilizaremos también el del walkthoug, puesto que al igual que con el DateTime es también bastante habitual. En este ejemplo el objetivo es poder disponer de un atributo, por ejemplo NonUnicodeAttribute que nos permita decorar a las propiedades como no unicode. Pues bien, este atributo será un atributo marcador, es decir, no necesita código de trabajo con EF, por ejemplo igual que así:

    [AttributeUsage(AttributeTargets.Property, AllowMultiple = <span class="kwrd">false</span>)]
    <span class="kwrd">public</span> <span class="kwrd">class</span> NonUnicodeAttribute : Attribute
    {

    }

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]

public class NonUnicodeAttribute : Attribute

{

}

Bien, ahora que tenemos creado el atributo marcador, solamente tenemos que aplicarle la convención ,tal cual podríamos hacer antes con nuestras PrimitivePropertyConfiguration…

    <span class="kwrd">class</span> NonUnicodeAttributeConvention :
        AttributeConfigurationConvention&lt;PropertyInfo, StringPropertyConfiguration, NonUnicodeAttribute&gt;
    {

        <span class="kwrd">public</span> <span class="kwrd">override</span> <span class="kwrd">void</span> Apply(

            PropertyInfo propertyInfo,

            StringPropertyConfiguration configuration,

            NonUnicodeAttribute attribute)
        {

            <span class="kwrd">if</span> (configuration.IsUnicode == <span class="kwrd">null</span>)
            {
                configuration.IsUnicode = <span class="kwrd">false</span>;
            }
        }
    }

class NonUnicodeAttributeConvention :

AttributeConfigurationConvention<PropertyInfo, StringPropertyConfiguration, NonUnicodeAttribute>

{

public override void Apply(

PropertyInfo propertyInfo,

StringPropertyConfiguration configuration,

NonUnicodeAttribute attribute)

{

if (configuration.IsUnicode == null)

{

configuration.IsUnicode = false;

}

Sencillo ¿verdad?…Bueno, espero poder publicar alguna entrada más sobre EF 6, de hecho hay un par de novedades que me parecen super interesantes.. y me gustaría también sacar algo de tiempo para colaborar un poco con el código, a ver si lo logro…

Saludos

Unai