.NET (Core and Framework)

List<TableC> cs = tablea.TablesCs.Include(c => c.TableB.TableA).ToList();

public override void Up()
        {
            DropForeignKey("dbo.Violations", "NOVId", "dbo.NOVs");
            DropIndex("dbo.Violations", new[] { "NOVId" });
            CreateTable(
                "dbo.ViolationTypeNOVs",
                c => new
                    {
                        ViolationTypeNOVId = c.Int(nullable: false, identity: true),
                        NOVId = c.Int(nullable: false),
                        ViolationTypeId = c.Int(nullable: false),
                    })
                .PrimaryKey(t => t.ViolationTypeNOVId)
                .ForeignKey("dbo.NOVs", t => t.NOVId, cascadeDelete: true)
                .ForeignKey("dbo.ViolationTypes", t => t.ViolationTypeId, cascadeDelete: true)
                .Index(t => new { t.NOVId, t.ViolationTypeId }, unique: true, name: "IX_UniqueConstraintViolationTypeNOV");
            
            CreateTable(
                "dbo.CaseNOVs",
                c => new
                    {
                        CaseNOVId = c.Int(nullable: false, identity: true),
                        NOVId = c.Int(nullable: false),
                        CaseId = c.Int(nullable: false),
                    })
                .PrimaryKey(t => t.CaseNOVId)
                .ForeignKey("dbo.Cases", t => t.CaseId, cascadeDelete: true)
                .ForeignKey("dbo.NOVs", t => t.NOVId, cascadeDelete: true)
                .Index(t => new { t.NOVId, t.CaseId }, unique: true, name: "IX_UniqueConstraintCaseNov");
            
            CreateTable(
                "dbo.ViolationNOVs",
                c => new
                    {
                        ViolationNOVId = c.Int(nullable: false, identity: true),
                        NOVId = c.Int(nullable: false),
                        ViolationId = c.Int(nullable: false),
                    })
                .PrimaryKey(t => t.ViolationNOVId)
                .ForeignKey("dbo.NOVs", t => t.NOVId, cascadeDelete: true)
                .ForeignKey("dbo.Violations", t => t.ViolationId, cascadeDelete: true)
                .Index(t => new { t.NOVId, t.ViolationId }, unique: true, name: "IX_UniqueConstraintNOVViolation");
            
            AlterColumn("dbo.OneToManies", "ParentEntity", c => c.String());
            AlterColumn("dbo.OneToManies", "ChildEntity", c => c.String());
            //DropColumn("dbo.Violations", "NOVId");
        }

public DataAccessUnitOfWork UnitOfWork { get; set; }
        public RoleManager<ApplicationRole> RoleManager { get; set; }
        public UserManager<ApplicationUser> UserManager { get; set; }
        public ApplicationUser CurrentUser { get; set; }
    
        public DomainLogicManager(DataAccessUnitOfWork unitOfWork)
        {
            this.UnitOfWork = unitOfWork;           
    
            this.RoleManager = new RoleManager<ApplicationRole>(new RoleStore<ApplicationRole>(UnitOfWork.Context));
            this.UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(UnitOfWork.Context));
        }

public bool Delete(IdT id)
        {
            T item = this.DbSet.Find(id);
            var entry = this.Context.Entry(item);
            entry.State = EntityState.Deleted;
            this.DbSet.Attach(item);
            this.DbSet.Remove(item);
            this.Context.SaveChanges();
    
            BuildMetaData(item, false, false);
            return true;
        }

Gerry Schmitz wrote:

If you used "cascading deletes" you wouldn't have to worry so much about the details.

List<ViolationTypeNOV> novRels = UnitOfWork.Context.ViolationTypeNOVs.Where(x => x.NOVId == nov.NOVId).Include("ViolationType").Include("NOV").ToList();
                    
    foreach (ViolationTypeNOV o in novRels)
    {
         UnitOfWork.Context.ViolationTypeNOVs.Remove(o);
    }                
    UnitOfWork.Context.SaveChanges();

The operation failed: The relationship could not be changed because one or more of the foreign-key properties is non-nullable. When a change is made to a relationship, the related foreign-key property is set to a null value. If the foreign-key does not support null values, a new relationship must be defined, the foreign-key property must be assigned another non-null value, or the unrelated object must be deleted.

Delete ViolationTypeNOVs where ViolationTypeNOVId = 2

foreach (ViolationTypeNOV o in novRels)
                    {
                        string str = string.Format("Delete ViolationTypeNOVs where ViolationTypeNOVId = {0}", new object[] { o.ViolationTypeNOVId });
UnitOfWork.Context.Database.ExecuteSqlCommand(str);
                    }
    UnitOfWork.Context.SaveChanges();

public bool Delete(NOV nov, bool performCommit = true)
{
    System.Data.Entity.DbContextTransaction dbOperation = null;
    if (performCommit)
        dbOperation = UnitOfWork.BeginTransaction();
    try
    {
        //-- Remove the Items - "foreach" approach was a problem
        // http://weblogs.asp.net/ricardoperes/entity-framework-pitfalls-deleting-orphans

        //------------------------------------------------------
        // Remove the Violations that are in this NOV
        //------------------------------------------------------
        List<Violation> violationIdlist = new List<Violation>();

        foreach (var v in nov.ViolationNOVs)
        {
            var a = UnitOfWork.ViolationRepository.GetAll().Where(z => z.ViolationId == v.ViolationId).FirstOrDefault();
            violationIdlist.Add(a);
        }

        foreach (var v in violationIdlist)
        {
            var a = nov.ViolationNOVs.Where(x => x.NOVId == nov.NOVId && x.ViolationId == v.ViolationId)?.FirstOrDefault();
            nov.ViolationNOVs.Remove(a);
        }

        nov.IssuedBy.Clear();

        //deleting all OneToMany references to NOV
        List<ViolationTypeNOV> novRels = UnitOfWork.Context.ViolationTypeNOVs.Where(x => x.NOVId == nov.NOVId).Include("ViolationType").Include("NOV").ToList();
        nov?.ViolationTypeNOVs?.Clear();
        //foreach (ViolationTypeNOV o in novRels)
        //{
        //    UnitOfWork.Context.ViolationTypeNOVs.Remove(o);
        //    o?.ViolationType?.ViolationTypeNOVs?.Remove(o);
        //    nov?.ViolationTypeNOVs?.Remove(o);
        //}
        UnitOfWork.Context.ViolationTypeNOVs.RemoveRange(novRels);

        List<ViolationNOV> violationNOVs = UnitOfWork.Context.ViolationNOVs.Where(x => x.NOVId == nov.NOVId).Include("Violation").Include("NOV").ToList();
        nov?.ViolationNOVs?.Clear();
        UnitOfWork.Context.ViolationNOVs.RemoveRange(violationNOVs);

        List<CaseNOV> caseNOVs = UnitOfWork.Context.CaseNOVs.Where(x => x.NOVId == nov.NOVId).Include("Case").Include("NOV").ToList();
        nov?.CaseNOVs?.Clear();
        UnitOfWork.Context.CaseNOVs.RemoveRange(caseNOVs);

        UnitOfWork.Context.SaveChanges();
        if (dbOperation != null)
            dbOperation.Commit();

        LogHandler.LogInfo(2521, "Deleted NOV " + nov.NOVNumber);
        return true;
    }
    catch (Exception ex)
    {
        LogHandler.LogError(2523, "Commit Fail in NOV Delete", ex);
        if (dbOperation != null)
            dbOperation.Rollback();
        throw ex;
    }
}

if (item.InspectionItemId.HasValue && !inspectionItemIds.Contains(item.InspectionItemId.Value))
{
   inspectionItemIds.Add(item.InspectionItemId.Value);
}

if (item.InspectionItemId is int inspectionItemId && !inspectionItemIds.Contains(inspectionItemId))
{
    inspectionItemIds.Add(inspectionItemId);
}

if (item.InspectionItemId is int inspectionItemId)
{
    inspectionItemIds.Add(inspectionItemId);
}

First of all you have to change localhost with the host name or with the ip of the sql server hosting pc. then you have to enable tcp/ip on the sql server Configuration Manager on the hosting pc then go to SQL Server Network Configuration and click on Protocols for SQLEXPRESS. Then you will see that TCP/IP is disabled. Double Click on TCP/IP and select yes to enabled.

Quote:

I thought about having the database file saved in computer A, and computer B and C should connect to it, even through usb cables. I don’t know if this is the best practice, and if it is, how could I do it?

Maciej Los wrote:

For further details, please see Richard's MacCutchan answer.

Maciej Los wrote:

good polish