public static void GenerateData()
{
 	using EntityContext context = new();
    context.Customers.Add(new Customer() { Name = "Customer_A", Description = "Description", IsActive = true });
}

public void SaveCalculatedCycles(string discriminator, IEnumerable<AuditCycle> calculatedCycles)
        {
            foreach (AuditCycle cycle in calculatedCycles)
            {
                MissionAuditCycle saveableCycle = new MissionAuditCycle
                {
                    DateOfEarliestAuditPerformed = cycle.DateOfEarliestAuditPerformed,
                    StartDate = cycle.StartDate,
                    EndDate = cycle.EndDate,
                    MissionDiscriminatorWithoutIndex = discriminator,
                    ShiftId = cycle.ShiftId
                };
                _dbContext.Set<MissionAuditCycle>().Add(saveableCycle);
            }
        }

public void AddToACCESS_RIGHT_STATUS(ACCESS_RIGHT_STATUS aCCESS_RIGHT_STATUS)
{
    base.AddObject("ACCESS_RIGHT_STATUS", aCCESS_RIGHT_STATUS);
}

public void RemoveEntry()        
{
            var rec = dbContext.Contractor.FirstOrDefault();
            dbContext.Contractor.Remove(rec);
            dbContext.SaveChanges();
}

public void DeleteACCESS_RIGHT_STATUS(ACCESS_RIGHT_STATUS aCCESS_RIGHT_STATUS)
{
	base.DeleteObject(aCCESS_RIGHT_STATUS);
}

public override void DeleteEntity(Entities context, object entity)
        {
            var entityToRemove = (Role_SupplierComplaints_ProcessingStage)entity;
            if (entityToRemove.AdditionApprovalId != null) { context.AdditionApprovals.Remove(entityToRemove.AdditionApproval); }
            if (entityToRemove.DeletionApprovalId != null) { context.DeletionApprovals.Remove(entityToRemove.DeletionApproval); }
            context.Role_SupplierComplaints_ProcessingStage.Remove(entityToRemove);
        }

public void UpdateContractorAddress()        
{
            var contractor = dbContext.Contractor.FirstOrDefault();
            contractor.Address = ModelFakes.ContractorFake.Generate().Address;
            dbContext.Contractor.Update(contractor);
            dbContext.SaveChanges();
}         

public static void UpdateRows()
{
			
	EntityContext context = new ();
			
	context.Customers.Where(x => x.Name == "Customer_C").Update(x => new Customer {Description = "Updated_C",IsActive = false});
}

public static void BulkOperations()
    {
		List<InvoiceItem> invoiceDetails = new List<InvoiceItem>
        {
            new InvoiceItem { InvoiceItemId = 1, ProductName ="Apple" },
            new InvoiceItem { InvoiceItemId = 2, ProductName = "Orange"},
            // Add more invoice details to synchronize
        };
		
		var context = new EntityContext();
        context.BulkInsertOrUpdateOrDelete(invoiceDetails);
     }

protected void AssignPermissionToUser(User user, int depotId, Entities context)
{
 	var user_depotEntity = context.User_Depots.Find(user.Id, depotId);

    if (user_depotEntity.ShelfInspectionCreationPermission != null)
    {
    	throw new EntityConflictException("Permission already existing or pending.");
    }

}

public static void QueryDeferredTrial()
{
	using EntityContext context = new();
		
	//Query Cache
	context.Customers.DeferredCount().FromCache();

}		
		

public string[] GetColumnPermissionsOfUser(int id, string tableName)
{
	using (var context = new Entities())
    {
    	List<int> userRoles = context.User_Roles
        .Where(ur => ur.UserId == id)
        .Where(ur => ur.AdditionApproval.ApprovedAt.HasValue)
        .Where(ur => ur.Role.AdditionApproval.ApprovedAt.HasValue)
        .Select(ur => ur.RoleId)
        .ToList();

    }
}

public DomainModel.Portaalstatus OpslaanLogin(Account account)        
{
            using (new LoggingMonitoredScope(LogConstants.Diagnostics))
            {
                ValidationHelper.Validate(account);
                if (ClaimHelper.IsMeekijker())
                    return new DomainModel.Portaalstatus();
                var cacheKey = CacheSettingsHelper.CreateCacheKey(account);
                                _cacheHelper.Remove(cacheKey, CacheGroups.CacheGroupPortaalStatussen);
                DomainModel.Portaalstatus cacheItem;
                using (var dbContext = new ApfPortalenDbContext())
                {
                    var portaalstatus =
                        dbContext.Portaalstatussen.FirstOrDefault(
                            p => p.AdministratieId.Equals(account.AdministratieIdentificatie) &&
                                 p.RelatienummerDeelnemerMaia.Equals(account.RelatienummerDeelnemerMAIA));
		    if (portaalstatus == null)
                    {
                        portaalstatus = dbContext.Portaalstatussen.Add(new Portaalstatus());
		    }
		}; 
                   
}

public async Task<IActionResult> Create(Distribution distribution)
        {
            if (ModelState.IsValid)
            {
                context.Add(distribution);
                await context.SaveChangesAsync();

                return RedirectToAction("Index");
            }
            else
                return View();
        }

protected void InsertInfo(List<DispatcherInfo> entities)
        {
            int chunkSize = 1000;
            var pendingBar = new PendingBar(Logger);
            pendingBar.Start();

            Entities context = new Entities();

            try
            {
                entities.GroupBy(e => e.DepotId).ToList().ForEach(g =>
                {
                    context.Database.ExecuteSqlCommand("DELETE FROM DispatcherInfoes WHERE DepotId = {0}", g.Key);
                    context.BulkInsert(g.ToList(), chunkSize);
                    context.SaveChanges();
                });
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                pendingBar.Stop();
                if (context != null)
                    context.Dispose();
            }
        }
    }

internal void AddDataChangeApprover(DataChangeApprover dca)
        {
            _context.DataChangeApprovers.Add(dca);
        }

public partial class DisplayConfigEntities : DbContext
    {
        public DisplayConfigEntities()
            : base("name=DisplayConfigEntities")
        {
        }
    
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            throw new UnintentionalCodeFirstException();
        }
    
        public virtual DbSet<DataChangeApprover> DataChangeApprovers { get; set; }
}

<EntitySetMapping Name="DataChangeApprovers">
            <EntityTypeMapping TypeName="DispalyConfiguration.DataChangeApprover">
              <MappingFragment StoreEntitySet="Approval">

public class AppDbContext : DbContext
    {
        public DbSet<CreditCard> CreditCard { get; set; }


        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<BillingDetail>().ToTable("BankingBillingDetails");
        }
    }


    public abstract class BillingDetail
    {
        [Required]
		public int BillingDetailId { get; set; } 
        public string Owner { get; set; } 
        public string Number { get; set; } 
    }

    public class CreditCard : BillingDetail
    {
        public int CardType { get; set; } 	
        public string ExpiryMonth { get; set; } 
        public string ExpiryYear { get; set; } 
    }