Exportar (0) Imprimir
Expandir todo

Cómo: Ejecutar la lógica de negocios al guardar los cambios (Entity Framework)

Entity Framework le permite ejecutar la lógica de negocios personalizada antes de guardar cambios en la base de datos. Antes de que se procese la operación SaveChanges, se desencadena el evento SavingChanges. Controle este evento para implementar la lógica de negocios personalizada antes de que se guarden los cambios en la base de datos. A partir de la versión 4 de .NET Framework el método SaveChanges es virtual. Esto significa que puede reemplazar directamente este método en lugar de suscribirse al evento SavingChanges.

En los ejemplos de este tema, se muestra cómo reemplazar el método SaveChanges y controlar el evento SavingChanges para validar los objetos modificados en un contexto de objetos antes de que se guarden los cambios en la base de datos.

El ejemplo de este tema se basa en el modelo Adventure Works Sales. Para ejecutar el código de este ejemplo, debe haber agregado el modelo AdventureWorks Sales al proyecto y haber configurado el proyecto para que use Entity Framework . Para ello, complete los procedimientos de Cómo configurar manualmente un proyecto de Entity Framework y Cómo: Definir manualmente los archivos de asignación y modelo (Entity Framework).

El primer ejemplo muestra cómo reemplazar el método SaveChanges en la clase de contexto de objetos personalizada. En el segundo ejemplo se muestra cómo utilizar OnContextCreated para registrar un controlador para el evento SavingChanges en una instancia de ObjectContext. En el tercer ejemplo se muestra cómo controlar este evento en una clase proxy que se deriva de ObjectContext. En el cuarto ejemplo se muestra código que realiza cambios en objetos utilizando la clase proxy del segundo ejemplo y, a continuación, llama a SaveChanges.

Ejemplo

En este ejemplo, el método SaveChanges se reemplaza para permitir validar objetos que presentan un valor Added o Modified en EntityState. Este ejemplo está basado en el contexto de objetos personalizado definido en Cómo: Definir un contexto del objeto personalizado (Entity Framework).

public override int SaveChanges(SaveOptions options)
{

    foreach (ObjectStateEntry entry in
        ObjectStateManager.GetObjectStateEntries(
        EntityState.Added | EntityState.Modified))
    {
        // Validate the objects in the Added and Modified state
        // if the validation fails throw an exeption.
    }
    return base.SaveChanges(options);
}

En este ejemplo, el método OnContextCreated se define como un método parcial de AdventureWorksEntities. El controlador para el evento SavingChanges se define en este método parcial. El controlador de eventos comprueba que el código de llamada no ha agregado texto inadecuado a la propiedad SalesOrderHeader.Comment antes de que se guarden los cambios. Si la cadena que comprueba el algoritmo (no se muestra) encuentra cualquier problema, se produce una excepción.

public partial class AdventureWorksEntities
{
    partial void OnContextCreated()
    {
        // Register the handler for the SavingChanges event.
        this.SavingChanges
            += new EventHandler(context_SavingChanges);
    }
    // SavingChanges event handler.
    private static void context_SavingChanges(object sender, EventArgs e)
    {
        // Validate the state of each entity in the context
        // before SaveChanges can succeed.
        foreach (ObjectStateEntry entry in
            ((ObjectContext)sender).ObjectStateManager.GetObjectStateEntries(
            EntityState.Added | EntityState.Modified))
        {
            // Find an object state entry for a SalesOrderHeader object. 
            if (!entry.IsRelationship && (entry.Entity.GetType() == typeof(SalesOrderHeader)))
            {
                SalesOrderHeader orderToCheck = entry.Entity as SalesOrderHeader;

                // Call a helper method that performs string checking 
                // on the Comment property.
                string textNotAllowed = Validator.CheckStringForLanguage(
                    orderToCheck.Comment);

                // If the validation method returns a problem string, raise an error.
                if (textNotAllowed != string.Empty)
                {
                    throw new ArgumentException(String.Format("Changes cannot be "
                        + "saved because the {0} '{1}' object contains a "
                        + "string that is not allowed in the property '{2}'.",
                        entry.State, "SalesOrderHeader", "Comment"));
                }
            }
        }
    }
}

En este ejemplo, se usa una instancia de AdventureWorksProxy para cambiar la propiedad Comment de un objeto SalesOrderHeader. Cuando se llama a SaveChanges en la instancia de ObjectContext que proporciona la clase AdventureWorksProxy, se ejecuta el código de validación del ejemplo anterior.


// Create an instance of the proxy class that returns an object context.
AdventureWorksProxy context = new AdventureWorksProxy();
// Get the first order from the context.
SalesOrderHeader order =
    context.Context.SalesOrderHeaders.First();

// Add some text that we want to catch before saving changes.
order.Comment = "some text";

try
{
    // Save changes using the proxy class.
    int changes = context.Context.SaveChanges();
}
catch (InvalidOperationException ex)
{
    // Handle the exception returned by the proxy class
    // validation if a problem string is found.
    Console.WriteLine(ex.ToString());
}


En este ejemplo se realizan cambios en objetos en la clase de proxy que deriva de ObjectContext y, a continuación, se llama a SaveChanges. Este ejemplo se utiliza para invocar el control de eventos que se muestra en el ejemplo anterior.

public class AdventureWorksProxy
{
    // Define the object context to be provided.
    private AdventureWorksEntities contextProxy =
        new AdventureWorksEntities();

    public AdventureWorksProxy()
    {
        // When the object is initialized, register the 
        // handler for the SavingChanges event.
        contextProxy.SavingChanges
            += new EventHandler(context_SavingChanges);
    }

    // Method that provides an object context.
    public AdventureWorksEntities Context
    {
        get
        {
            return contextProxy;
        }
    }

    // SavingChanges event handler.
    private void context_SavingChanges(object sender, EventArgs e)
    {
        // Ensure that we are passed an ObjectContext
        ObjectContext context = sender as ObjectContext;
        if (context != null)
        {

            // Validate the state of each entity in the context
            // before SaveChanges can succeed.
            foreach (ObjectStateEntry entry in
                context.ObjectStateManager.GetObjectStateEntries(
                EntityState.Added | EntityState.Modified))
            {
                // Find an object state entry for a SalesOrderHeader object. 
                if (!entry.IsRelationship && (entry.Entity.GetType() == typeof(SalesOrderHeader)))
                {
                    SalesOrderHeader orderToCheck = entry.Entity as SalesOrderHeader;

                    // Call a helper method that performs string checking 
                    // on the Comment property.
                    string textNotAllowed = Validator.CheckStringForLanguage(
                        orderToCheck.Comment);

                    // If the validation method returns a problem string, raise an error.
                    if (textNotAllowed != string.Empty)
                    {
                        throw new ArgumentException(String.Format("Changes cannot be "
                            + "saved because the {0} '{1}' object contains a "
                            + "string that is not allowed in the property '{2}'.",
                            entry.State, "SalesOrderHeader", "Comment"));
                    }
                }
            }
        }
    }
}

Vea también

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft