Asp.net mvc &引用；INSERT语句与外键“冲突”；所有用户的完整系统的例外情况

我有一个asp.net mvc web应用程序

"The INSERT statement conflicted with the FOREIGN KEY"

这不是主要问题。我知道为什么我会得到这个例外。但问题是它会让所有用户的整个系统瘫痪

我的存储库界面：

public interface IRepository<TEntity> : IDisposable where TEntity : class
{
    IEnumerable<TEntity> Get(
                Expression<Func<TEntity, bool>> filter = null,
                Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
                string includeProperties = "");
    TEntity GetByID(int id);
    int Insert(TEntity entity);
    int Delete(int id);
    int Delete(TEntity entityToDelete);
    int Update(TEntity entityToUpdate);
    DbRawSqlQuery<TEntity> SQLQuery<TEntity>(string sql, params object[] parameters);
    int Save();
}

公共接口IRepository:IDisposable其中tenty:class
{
数不清的(
表达式筛选器=空，
Func orderBy=null，
字符串includeProperty=“”）；
TEntity GetByID（intid）；
int Insert（TEntity实体）；
int-Delete（int-id）；
int Delete（TEntity entityToDelete）；
int更新（TEntity entityToUpdate）；
DbRawSqlQuery SQLQuery（字符串sql，参数对象[]参数）；
int Save（）；
}

存储库实现：

public class Repository<TEntity> : IRepository<TEntity>, IDisposable where TEntity : class
{
    internal DbContext context;
    internal DbSet<TEntity> dbSet;

    public Repository(DbContext context)
    {
        this.context = context;
        this.dbSet = context.Set<TEntity>();
    }

    public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {

        try
        {
            IQueryable<TEntity> query = dbSet.AsNoTracking();

            if (filter != null)
            {
                query = query.Where(filter);
            }

            foreach (var includeProperty in includeProperties.Split
                (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            {
                query = query.Include(includeProperty);
            }
            if (orderBy != null)
            {
                return orderBy(query).ToList();
            }
            else
            {
                return query.ToList();
            }
        }
        catch (Exception)
        {
            return null;
        }
    }


    public virtual TEntity GetByID(int id)
    {
        try
        {
            return dbSet.Find(id);
        }
        catch (Exception)
        {
            return null;
        }

    }

    public virtual int Insert(TEntity entity)
    {
        try
        {
            dbSet.Add(entity);
            return 1;
        }
        catch (Exception ex)
        {
            return 0;
        }

    }

    public virtual int Delete(int id)
    {
        try
        {
            TEntity entityToDelete = dbSet.Find(id);
            Delete(entityToDelete);
            return 1;
        }
        catch (Exception ex)
        {
            return 0;
        }
    }

    public virtual int Delete(TEntity entityToDelete)
    {
        try
        {
            if (context.Entry(entityToDelete).State == EntityState.Detached)
            {
                dbSet.Attach(entityToDelete);
            }
            dbSet.Remove(entityToDelete);
            return 1;
        }
        catch (Exception ex)
        {
            return 0;
        }
    }

    public virtual int Update(TEntity entityToUpdate)
    {
        try
        {
            context.Set<TEntity>().AddOrUpdate(entityToUpdate);
            return 1;
        }
        catch (Exception ex)
        {
            return 0;
        }
    }

    public DbRawSqlQuery<TEntity> SQLQuery<TEntity>(string sql, params object[] parameters)
    {
        try

        {
            var result = context.Database.SqlQuery<TEntity>(sql, parameters);
            return result;
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }


    public int Save()
    {            
        try
        {
            context.SaveChanges();
            return 1;
        }
        catch (Exception ex)
        {
            //foreach (var entry in context.ChangeTracker.Entries())
            //{
            //    switch (entry.State)
            //    {
            //        case EntityState.Modified:
            //        case EntityState.Deleted:
            //            entry.State = EntityState.Modified; //Revert changes made to deleted entity.
            //            entry.State = EntityState.Unchanged;
            //            break;
            //        case EntityState.Added:
            //            entry.State = EntityState.Detached;
            //            break;
            //    }
            //}
            //return 0;
            throw ex;
        }
        //}
    }

    #region Disposal Methods

    // Dispose Methods

    private bool _disposed;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~Repository()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing)
        {
            // free other managed objects that implement
            // IDisposable only
        }

        // release any unmanaged objects
        // set the object references to null

        _disposed = true;
    }

    #endregion
}

公共类存储库：IRepository，IDisposable其中tenty:class
{
内部语境；
内部数据库集；
公共存储库（DbContext上下文）
{
this.context=上下文；
this.dbSet=context.Set（）；
}
公共虚拟IEnumerable Get(
表达式筛选器=空，
Func orderBy=null，
字符串includeProperties=“”）
{
尝试
{
IQueryable query=dbSet.AsNoTracking（）；
if（过滤器！=null）
{
query=query.Where（过滤器）；
}
foreach（includeProperty.Split中的var includeProperty
（新字符[]{'，}，StringSplitOptions.RemoveEmptyEntries）
{
query=query.Include（includeProperty）；
}
if（orderBy！=null）
{
returnorderby（query.ToList（）；
}
其他的
{
返回query.ToList（）；
}
}
捕获（例外）
{
返回null；
}
}
公共虚拟地址GetByID（int id）
{
尝试
{
返回dbSet.Find（id）；
}
捕获（例外）
{
返回null；
}
}
公共虚拟整数插入（TEntity实体）
{
尝试
{
添加（实体）；
返回1；
}
捕获（例外情况除外）
{
返回0；
}
}
公共虚拟整数删除（整数id）
{
尝试
{
TEntity entityToDelete=dbSet.Find（id）；
删除（entityToDelete）；
返回1；
}
捕获（例外情况除外）
{
返回0；
}
}
公共虚拟整数删除（TEntity entityToDelete）
{
尝试
{
if（context.Entry（entityToDelete.State==EntityState.Detached）
{
数据库集连接（entityToDelete）；
}
dbSet.Remove（entityToDelete）；
返回1；
}
捕获（例外情况除外）
{
返回0；
}
}
公共虚拟整数更新（TEntity entityToUpdate）
{
尝试
{
context.Set（）.AddOrUpdate（entityToUpdate）；
返回1；
}
捕获（例外情况除外）
{
返回0；
}
}
公共DbRawSqlQuery SQLQuery（字符串sql，参数对象[]参数）
{
尝试
{
var result=context.Database.SqlQuery（sql，参数）；
返回结果；
}
捕获（例外情况除外）
{
掷骰子；
}
}
公共整数保存（）
{            
尝试
{
SaveChanges（）；
返回1；
}
捕获（例外情况除外）
{
//foreach（context.ChangeTracker.Entries（）中的var条目）
//{
//开关（进入状态）
//    {
//案例实体状态。已修改：
//案例实体状态。已删除：
//entry.State=EntityState.Modified；//还原对已删除实体所做的更改。
//entry.State=EntityState.Unchanged；
//中断；
//案例实体状态。添加：
//entry.State=EntityState.Detached；
//中断；
//    }
//}
//返回0；
掷骰子；
}
//}
}
#区域处置方法
//处置方法
私人住宅；
公共空间处置（）
{
处置（真实）；
总干事（本）；
}
~Repository（）
{
处置（虚假）；
}
受保护的虚拟void Dispose（bool disposing）
{
如果（_）
回来
如果（处置）
{
//释放实现的其他托管对象
//只能识别
}
//释放任何非托管对象
//将对象引用设置为null
_这是真的；
}
#端区
}

依赖项注入类：

 private static IUnityContainer BuildUnityContainer()
    {
        var container = new UnityContainer();

        container.RegisterType(typeof(IRepository<>), typeof(Repository<>), new InjectionConstructor(new DbContext("PLLEntities")));


        container.RegisterType(typeof(IBaseService<>), typeof(BaseService<>));

        container.RegisterType<IErrorEngine, ErrorEngine>();
        container.RegisterType<ILoggingEngine, LoggingEngine>();
        container.RegisterType<IIdentityManager, IdentityManager>();

私有静态IUnityContainer BuildUnityContainer（）
{
var container=new UnityContainer（）；
RegisterType（typeof（IRepository）、typeof（Repository）、newinjectionconstructor（newdbcontext（“pllenties”））；
RegisterType（typeof（IBaseService），typeof（BaseService））；
container.RegisterType（）；
container.RegisterType（）；
container.RegisterType（）；

---

无法确定主要问题在哪里。

该问题很可能与缺少主键定义有关。请检查相关实体，并确保使用实体类中的[Key]属性定义主键。否则会遇到“INSERT语句与外键约束冲突…”错误

希望这有助于

public class YourEntity
{
    [Key]
    public int Id { get; set; }

    //other properties
}