C# DbContext类代码示例

        protected static void AddActiveDirectoryUser(Guid userId, string name, string accountName, bool isDisabled = false,
            IEnumerable<KeyValuePair<string, string>> customProperties = null)
        {
            using (DbContext writeDbContext = new DbContext())
            {
                User user = new User
                {
                    Id = userId,
                    Name = name,
                    IsDisabled = isDisabled,
                };

                Account account = new Account
                {
                    UserId = user.Id,
                    Name = accountName,
                    Type = AccountType.ActiveDirectory
                };

                user.Accounts.Add(account);

                if (customProperties != null)
                {
                    user.CustomProperties.AddRange(customProperties.Select(c => new CustomProperty { Id = Guid.NewGuid(), Name = c.Key, Value = c.Value }));
                }

                writeDbContext.Users.Add(user);
                writeDbContext.SaveChanges();
            }
        }

 public ConcreteDatabase(
     DbContext context,
     IRelationalDataStoreCreator dataStoreCreator,
     ILoggerFactory loggerFactory)
     : base(context, dataStoreCreator, loggerFactory)
 {
 }

        public void ShouldQueryFirms()
        {
            var model = CreateModel();

            using (var connection = CreateConnection())
            using (var context = new DbContext(connection, model.Compile(), false))
            {
                var firm = context.Set<Firm>()
                    .Include(x => x.Balances)
                    .Include(x => x.Categories)
                    .Include(x => x.CategoryGroup)
                    .Include(x => x.Client)
                    .Include(x => x.Client.CategoryGroup)
                    .Include(x => x.Client.Contacts)
                    .Include(x => x.Territories)
                    .OrderBy(x => x.Id)
                    .FirstOrDefault();

                Assert.That(firm, Is.Not.Null);
                Assert.That(firm.Name, Is.Not.Null.And.EqualTo("Firm 1"));
                Assert.That(firm.Balances, Is.Not.Null.And.Count.EqualTo(2));
                Assert.That(firm.Categories, Is.Not.Empty.And.Count.EqualTo(1));
                Assert.That(firm.CategoryGroup, Is.Not.Null);
                Assert.That(firm.Client, Is.Not.Null.And.Property("Name").EqualTo("Client 1"));
                Assert.That(firm.Client.CategoryGroup, Is.Not.Null);
                Assert.That(firm.Client.Contacts, Is.Not.Null.And.Count.EqualTo(3));
                Assert.That(firm.Territories, Is.Not.Empty.And.Count.EqualTo(2));
            }
        }

 public void Store(DbContext dbContext)
 {
     if (HttpContext.Current.Items.Contains(DataContextKey))
         HttpContext.Current.Items[DataContextKey] = dbContext;
     else
         HttpContext.Current.Items.Add(DataContextKey, dbContext);
 }

        /// <summary>
        ///     Attempts to get the model hash calculated by Code First for the given context.
        ///     This method will return null if the context is not being used in Code First mode.
        /// </summary>
        /// <param name = "context">The context.</param>
        /// <returns>The hash string.</returns>
        public static string TryGetModelHash(DbContext context)
        {
            //Contract.Requires(context != null);

            var compiledModel = context.InternalContext.CodeFirstModel;
            return compiledModel == null ? null : new ModelHashCalculator().Calculate(compiledModel);
        }

        public static void CheckRegionAllowed(IPrincipal principal,DbContext db, string regionID)
        {
            String userID = ((KawalDesaIdentity)principal.Identity).User.Id;
            if (userID == null)
                throw new ApplicationException("region is not allowed for thee");

            var region = db.Set<Region>()
                .AsNoTracking()
                .Include(r => r.Parent)
                .Include(r => r.Parent.Parent)
                .Include(r => r.Parent.Parent.Parent)
                .Include(r => r.Parent.Parent.Parent.Parent)
                .First(r => r.Id == regionID);

            var regionIDs = new List<string>();
            var current = region;
            while(current != null)
            {
                regionIDs.Add(current.Id);
                current = current.Parent;
            }

            var allowed = db.Set<UserScope>()
                .Any(s => s.fkUserId == userID && regionIDs.Contains(s.fkRegionId));
            if (!allowed)
                throw new ApplicationException("region is not allowed for thee");
        }

 public EntityEntryGraphIterator(
     [NotNull] DbContext context,
     [NotNull] IStateManager stateManager)
 {
     _context = context;
     _stateManager = stateManager;
 }

        public DbContextWrapper(DbContext context)
        {
            Context = context;

            objectContext = ((IObjectContextAdapter) context).ObjectContext;
            objectContext.ObjectMaterialized += ObjectMaterializedHandler;
        }

        public void CheckValue(DbContext ctx, object actual)
        {
            var propertyType = Accessor.MemberType;

            var objectContext = ((IObjectContextAdapter)ctx).ObjectContext;
            var entitySet = objectContext.GetEntitySet(propertyType);
            var keyMembers = entitySet.ElementType.KeyMembers;

            ctx.Entry(actual).Reference(Accessor.Name).Load();

            var actualEntity = Accessor.GetValue(actual);
            if (actualEntity == null)
            {
                throw new AssertionException(ExpectedEntity.Dump(), "NULL");
            }
            foreach (var keyMember in keyMembers)
            {
                var accessor = new PropertyAccessor(propertyType.GetProperty(keyMember.Name));

                var actualKeyValue = accessor.GetValue(actualEntity);
                var expectedKeyValue = accessor.GetValue(ExpectedEntity);

                if (!expectedKeyValue.Equals(actualKeyValue))
                {
                    throw new AssertionException(ExpectedEntity.Dump(), actualEntity.Dump());
                }
            }
        }

 protected virtual void FindSets(ModelBuilder modelBuilder, DbContext context)
 {
     foreach (var setInfo in SetFinder.FindSets(context))
     {
         modelBuilder.Entity(setInfo.EntityType);
     }
 }

        public void Registrar(DbContext dbContext)
        {
            RegistrarModulo();
            RegistrarOperaciones();

            dbContext.Set<Formulario>().Add(_moduloFormulario);
        }

 public EntityFrameworkExternalDataSource(DbContext dbContext)
 {
     _dbContext = dbContext;
     SetOptionsForDbContext(_dbContext);
     _efManager = new EFManager(dbContext);
     _efManager.ReloadDbEntries();
 }

 public UserService(DbContext context, IRepository<User> users, IRepository<Message, int> messages)
 {
     this.users = users;
     this.messages = messages;
     this.userManager = new UserManager<User>(new UserStore<User>(context));
     this.roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
 }

		public void GuardClause_all()
		{
			Assert.Throws<ArgumentNullException>(() =>
			{
				var value = new DbContext(null, null);
			});
		}

 /// <copydocfrom cref="IDbContextProvider.CurrentContext" />
 public DbContext CurrentContext()
 {
     lock (syncLock)
     {
         return context ?? (context = func());
     }
 }