Entity Framework Agregar si no existe sin actualización

El tutorial o código que encontrarás en este artículo es la solución más rápida y efectiva que hallamos a tus dudas o dilema.

Solución:

¿Ha intentado verificar si la entidad existe y, si no, agregarla? Me gusta esto :

ACTUALIZAR

using System.Linq.Expressions;
    public class ContextWithExtensionExample
    
        public void DoSomeContextWork(DbContext context)
        
            var uni = new Unicorn();
            context.Set().AddIfNotExists(uni , x => x.Name == "James");
        
    

    public static class DbSetExtensions
    
        public static T AddIfNotExists(this DbSet dbSet, T entity, Expression> predicate = null) where T : class, new()
        
            var exists = predicate != null ? dbSet.Any(predicate) : dbSet.Any();
            return !exists ? dbSet.Add(entity) : null;
        
    

Puede usar este método directamente y recordar llamar a DbContext.SaveChanges() después de la llamada.

Todas las demás respuestas son incorrectas.

“Leer antes de escribir” puede violar la integridad de los datos sin colocarse dentro de un control de transacción.

En SQL Server, puede usar la declaración de combinación. Sin embargo, la declaración de combinación no está disponible en EF.

Usé algo como leer estas dos publicaciones para hacer mi código. Espero ayudar a aquellos que necesitan una firma similar a AddOrUpdate.

Entity Framework Agregar si no existe sin actualización

Hacer que AddOrUpdate cambie solo algunas propiedades

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace System.Data.Entity.Migrations

    //
    // Summary:
    //     Metodos de extensão para System.Data.Entity.IDbSet
    public static class DbSetMigrationsGustavoExtensions
    
        /// 

        /// Adiciona uma entidade se ela não existe ainda
        /// Assinatura semelhante ao AddOrUpdate
        /// 
        /// 
        /// Set onde serão adicionadas as entidades
        /// Campos usados na comparação
        /// Entidades para adicionar
        public static void AddIfNotExists(this IDbSet set, Expression> identifierExpression, params TEntity[] entities) where TEntity : class
        

            var identifyingProperties = GetProperties(identifierExpression).ToList();
            var parameter = Expression.Parameter(typeof(TEntity));
            foreach (var entity in entities)
            
                var matches = identifyingProperties.Select(pi => Expression.Equal(Expression.Property(parameter, pi.Name), Expression.Constant(pi.GetValue(entity, null))));
                var matchExpression = matches.Aggregate(null, (agg, v) => (agg == null) ? v : Expression.AndAlso(agg, v));

                var predicate = Expression.Lambda>(matchExpression, new[]  parameter );
                if (!set.Any(predicate))
                
                    set.Add(entity);
                
            
        

        private static IEnumerable GetProperties(Expression> exp) where T : class
        
            Debug.Assert(exp != null);
            Debug.Assert(exp.Body != null);
            Debug.Assert(exp.Parameters.Count == 1);

            var type = typeof(T);
            var properties = new List();

            if (exp.Body.NodeType == ExpressionType.MemberAccess)
            
                var memExp = exp.Body as MemberExpression;
                if (memExp != null && memExp.Member != null)
                    properties.Add(type.GetProperty(memExp.Member.Name));
            
            else if (exp.Body.NodeType == ExpressionType.Convert)
            
                var unaryExp = exp.Body as UnaryExpression;
                if (unaryExp != null)
                
                    var propExp = unaryExp.Operand as MemberExpression;
                    if (propExp != null && propExp.Member != null)
                        properties.Add(type.GetProperty(propExp.Member.Name));
                
            
            else if (exp.Body.NodeType == ExpressionType.New)
            
                var newExp = exp.Body as NewExpression;
                if (newExp != null)
                    properties.AddRange(newExp.Members.Select(x => type.GetProperty(x.Name)));
            

            return properties.OfType();
        

        /// 

        /// Faz um set.Any(predicate)
        /// Se não existe nada no set então adiciona
        /// 
        /// 
        /// Set onde será adicionada a entidade
        /// Condição (exemplo: dbUser => dbUser.Nome == "Gustavo")
        /// Entidade para adicionar
        /// 
        public static T AddIfNotExists(this IDbSet set, Expression> predicate, T entity) where T : class, new()
        
            return !set.Any(predicate) ? set.Add(entity) : null;
        
    

Si piensas que te ha sido de ayuda nuestro post, sería de mucha ayuda si lo compartieras con más entusiastas de la programación así nos ayudas a dar difusión a nuestro contenido.

---

---

Utiliza Nuestro Buscador