public void TestCreateDatabaseScript()
{
var context = new BlogDbContext();
IObjectContextAdapter iObject = (IObjectContextAdapter)context;
string script = iObject.ObjectContext.CreateDatabaseScript();
Assert.IsNotNull(script);
}
public IHttpActionResult Logout()
{
var db = new BlogDbContext();
var username = db.Users.Find(User.Identity.GetUserId()).UserName;
AuthenticationManager.SignOut();
return Ok(username);
}
public void TestIsBlogTitleUnique()
{
Database.SetInitializer(new DatabaseInitializer());
var context = new BlogDbContext();
context.Blogs.Add(new Blog() { Title = "abc" });
context.SaveChanges();
context.Blogs.Add(new Blog() { Title = "abc" });
context.SaveChanges();
}
public BlogUnitOfWork(string connectionString)
{
_context = new BlogDbContext(connectionString);
_context.Database.CreateIfNotExists();
if (_context.Database.Exists())
{
if (!_context.Articles.Any())
{
var task = Task.Run(SeedAsync);
task.Wait();
}
}
}
public void PersistedTest()
{
using (BlogDbContext context = new BlogDbContext())
{
var blueprints = GetBlueprints(context);
var user = blueprints.Make<User>();
context.Database.Connection.Close();
var users = context.Users;
Assert.AreEqual(1, users.Count());
Assert.AreEqual("user1", users.First().Username);
}
}
/// <summary>
/// 帮我们返回当前线程内的数据库上下文，如果当前线程内没有上下文，那么创建一个上下文，并保证
/// 上下文是实例在线程内部唯一
/// </summary>
/// <returns></returns>
public static DbContext GetCurrentDbContext()
{
//当第二次执行的时候直接取出线程嘈里面的对象
//CallContext:是线程内部唯一的独用的数据槽(一块内存空间)
//数据存储在线程栈中
//线程内共享一个单例
DbContext dbcontext = CallContext.GetData("BlogDbContext") as DbContext;
//判断线程里面是否有数据
if (dbcontext == null) //线程的数据槽里面没有次上下文
{
dbcontext = new BlogDbContext(); //创建了一个EF上下文
//存储指定对象
CallContext.SetData("BlogDbContext", dbcontext);
}
return dbcontext;
}
public UpdateAuthorCommandEFCH(BlogDbContext context) : base(context)
{
}
public CommentsController(BlogDbContext context, IMapper mapper, ICommentRepository repository)
{
this.mapper = mapper;
this.repository = repository;
}
public UserRoleRepository(BlogDbContext context)
{
_context = context;
}
public CommentRepository(BlogDbContext blogDbContext)
{
_blogDbContext = blogDbContext;
}
public DeleteModel(BlogDbContext blogDbContext)
{
_blogDbContext = blogDbContext;
}
public GetSearchResultBlogPostsBySearchTextViewModelEFQH(BlogDbContext context) : base(context)
{
}
public UnitOfWork(BlogDbContext db)
{
_db = db;
}
public GetAllPostsByDateViewModelEFQH(BlogDbContext context) : base(context)
{
}
public HomeController(BlogDbContext dbContext, IPostService postService)
{
_dbContext = dbContext;
_mapper = BlogMapper.Mapper;
_postService = postService;
}
public BlogController(BlogDbContext db, ILoggerFactory loggerFactory)
{
_db = db;
_logger = loggerFactory.CreateLogger <BlogController>();
}
public ArticleManager(BlogDbContext ctx) : base(ctx)
{
}
public TagRepository(BlogDbContext dbContext)
{
_blogDbContext = dbContext;
}
public UpdateBlogPostCommandEFCH(BlogDbContext context) : base(context)
{
}
public PostRepository(BlogDbContext context)
{
this.context = context;
}
public UserRepository(BlogDbContext dbContext) : base(dbContext)
{
_dbContext = dbContext;
}
public GetTopicsEFQH(BlogDbContext context) : base(context)
{
}
public PostRepository(BlogDbContext contex) : base(contex)
{
}
public PostPhotosRepository(BlogDbContext dbContext)
{
this.dbContext = dbContext;
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
_context = (BlogDbContext)context.ServiceProvider.GetService(typeof(BlogDbContext));
var returnType = context.ImplementationMethod.ReturnType;
if (_context.DbContextTransaction != null)
{
await next(context);
return;
}
try
{
await _context.BeginTransactionAsync();
await next(context);
dynamic returnValue = context.ReturnValue;
//异步返回值
if (returnType != null && returnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var genericType = returnType.GetGenericArguments()[0];
if (genericType == typeof(ApiResult) || genericType.GetEnumUnderlyingType() == typeof(ApiResult <>))
{
if (returnValue.Result != null && returnValue.Result.Code != Code.Ok)
{
await _context.RollbackAsync();
return;
}
}
}
else if (returnType != null)
{
var returnTypeInterface = returnType.GetInterfaces().FirstOrDefault(i => i.FullName == typeof(ApiResult).FullName);
if (returnTypeInterface != null || returnType == typeof(ApiResult))
{
if (returnValue != null && returnValue.Code != Code.Ok)
{
await _context.RollbackAsync();
return;
}
}
}
await _context.CommitAsync();
}
catch (Exception ex)
{
await _context.RollbackAsync();
//异步返回值
if (returnType != null && returnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var genericType = returnType.GetGenericArguments()[0];
var genericTypeInterface = genericType.GetInterfaces().FirstOrDefault(i => i.FullName == typeof(ApiResult).FullName);
if (genericTypeInterface != null || genericType == typeof(ApiResult))
{
dynamic returnValue = Activator.CreateInstance(genericType);
returnValue.Code = Code.Error;
returnValue.Message = $"事务拦截器异常，{ex.Message}";
context.ReturnValue = Task.FromResult(returnValue);
return;
}
}
else if (returnType != null)
{
var returnTypeInterface = returnType.GetInterfaces().FirstOrDefault(i => i.FullName == typeof(ApiResult).FullName);
if (returnTypeInterface != null || returnType == typeof(ApiResult))
{
dynamic returnValue = Activator.CreateInstance(returnType);
returnValue.Code = Code.Error;
returnValue.Message = $"事务拦截器异常，{ex.Message}";
context.ReturnValue = returnValue;
return;
}
}
}
}
public GetManageCategoriesViewModelEFQH(BlogDbContext context) : base(context)
{
}
public AuthorController(BlogDbContext context, UserManager <ApplicationUser> userManager)
{
_context = context;
_userManager = userManager;
}
public PostService(BlogDbContext context, UserManager <BlogUser> userManager)
{
_context = context;
this.userManager = userManager;
}
public ClientManager(BlogDbContext context)
{
_db = context;
}
public CategoryRepository(BlogDbContext dbContext)
{
this.dbContext = dbContext;
}
public DetailsModel(BlogDbContext db)
{
_db = db;
Blog = new();
}
public CommentManager(BlogDbContext ctx) : base(ctx)
{
}
public BlogRepository(BlogDbContext context)
{
_context = context;
}
public GetPostByIdHandler(BlogDbContext dbContext, IMapper mapper)
{
_dbContext = dbContext;
_mapper = mapper;
}
public DbContextRepository(BlogDbContext dbContext)
{
DbContext = dbContext;
}
public UsersController(BlogDbContext context)
{
_context = context;
}
public void TestInMemoryDbContext()
{
var optionsBuilder = new DbContextOptionsBuilder <BlogDbContext>().UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
BlogDbContext db = new BlogDbContext(optionsBuilder);
Author authorTest = new Author()
{
ApplicationUserId = Guid.NewGuid().ToString(),
FirstName = "John",
LastName = "Smith",
Biography = "Born somewhere, someday."
};
db.Authors.Add(authorTest);
db.SaveChanges();
var x = (from author in db.Authors
select author).FirstOrDefault();
Assert.NotNull(x);
Assert.Equal(x.FirstName, authorTest.FirstName);
Assert.Equal(x.LastName, authorTest.LastName);
Assert.Equal(x.Biography, authorTest.Biography);
BlogPost bp = new BlogPost()
{
Author = authorTest,
Title = "Hello",
Content = "Content",
Description = "Description",
CreatedAt = DateTime.Now,
Public = true,
PublishOn = DateTime.Now,
ModifiedAt = DateTime.Now,
};
db.BlogPosts.Add(bp);
db.SaveChanges();
var y = db.BlogPosts.Include(b => b.Author).Select(b => b).FirstOrDefault();
Assert.Equal(y.Author.FirstName, authorTest.FirstName);
var catList = new List <Category>()
{
new Category()
{
Name = "Cat1"
},
new Category()
{
Name = "Cat2"
}
};
db.Categories.AddRange(catList);
var bpcList = new List <BlogPostCategory>()
{
new BlogPostCategory()
{
BlogPost = bp,
Category = catList[0]
},
new BlogPostCategory()
{
BlogPost = bp,
Category = catList[1]
}
};
db.BlogPostCategory.AddRange(bpcList);
db.SaveChanges();
var featureList = new List <Feature>()
{
new Feature()
{
Title = "Feature 1"
},
new Feature()
{
Title = "Feature 2"
}
};
db.Features.AddRange(featureList);
db.SaveChanges();
var bpfList = new List <BlogPostFeature>()
{
new BlogPostFeature()
{
BlogPost = bp,
Feature = featureList[0]
},
new BlogPostFeature()
{
BlogPost = bp,
Feature = featureList[1]
}
};
db.BlogPostFeature.AddRange(bpfList);
db.SaveChanges();
var bpTest = db.BlogPosts
.Include(b => b.Author)
.Include(b => b.BlogPostFeature)
.ThenInclude(bbpf => bbpf.Feature)
.Include(b => b.BlogPostCategory)
.ThenInclude(bbpc => bbpc.Category)
.Select(b => b)
.FirstOrDefault();
Assert.Equal(bpTest.BlogPostFeature.Select(bpf => bpf.Feature).Count(), 2);
Assert.Equal(bpTest.BlogPostCategory.Select(bpc => bpc.Category).Count(), 2);
Assert.Equal(bpTest.Author.FirstName, authorTest.FirstName);
}
public BlogDbContext Get()
{
return _dbContext ?? (_dbContext = new BlogDbContext());
}
public TopicRepository(BlogDbContext context) : base(context)
{
_context = context;
}
public BlogsService(ModelStateDictionary modelState)
{
_modelState = modelState;
_db = new BlogDbContext();
}
public void GetEntitySetMappingCache_produces_multiple_entitysets_for_single_clr_type_present_in_multiple_models()
{
var blogType = typeof(Blog);
Internal.EntitySetTypePair blog1PairForBlogType;
using (var blog1 = new BlogDbContext())
{
using (var blog2 = new BlogDbContextVersion2())
{
//obtain the type to entityset dictionaries and update the mappings
var workspace1 = ((IObjectContextAdapter)blog1).ObjectContext.MetadataWorkspace.MetadataOptimization;
var entitySetMappingCache1 = workspace1.EntitySetMappingCache;
workspace1.TryUpdateEntitySetMappingsForType(blogType);
var workspace2 = ((IObjectContextAdapter)blog2).ObjectContext.MetadataWorkspace.MetadataOptimization;
var entitySetMappingCache2 = workspace2.EntitySetMappingCache;
workspace2.TryUpdateEntitySetMappingsForType(blogType);
//check that the same clr type maps to different entity sets on different metadata workspaces
blog1PairForBlogType = entitySetMappingCache1[blogType];
Assert.NotNull(blog1PairForBlogType);
Assert.False(
ReferenceEquals(blog1PairForBlogType, entitySetMappingCache2[blogType]),
"Single CLR type on two different metadata workspaces erroneously maps to the same entity set instance");
}
}
using (var blog1Bis = new BlogDbContext())
{
var workspace1Bis = ((IObjectContextAdapter)blog1Bis).ObjectContext.MetadataWorkspace.MetadataOptimization;
var entitySetMappingCache1Bis = workspace1Bis.EntitySetMappingCache;
workspace1Bis.TryUpdateEntitySetMappingsForType(blogType);
Assert.True(
blog1PairForBlogType.Equals(entitySetMappingCache1Bis[blogType]),
"Metadata workspace should produce same entity set for same CLR type on different context instances");
Assert.True(
blog1PairForBlogType.Equals(entitySetMappingCache1Bis[new Blog().GetType()]),
"Metadata workspace should produce the same entity set for the same CLR type using different instances of the same type");
}
}
