Asp.net core 学习笔记 ( ef core )

更新: 2021-06-17

5.0 之后多了一些不错的功能

https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-5.0/whatsnew

1.Split queries

_db.Subcategories.AsSplitQuery();
_db.Subcategories.AsSingleQuery();

include 太多的情况下, split query 可能性能会好一些. 所以 ef core 让我们自己调.

也可以像 AsTracking 那样调 global

o => o.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)

2. Filtered include

include 之前是写不了 filter 的. 现在总算可以了

var blogs = context.Blogs
    .Include(e => e.Posts.Where(p => p.Title.Contains("Cheese")))
    .ToList();

3. Table-per-type (TPT) mapping

这个也是 ef 6 就有的功能，终于有了

4. Shadow and Indexer Properties

https://docs.microsoft.com/en-us/ef/core/modeling/shadow-properties

处理 c# class 里面没有属性，但是 sql 却有 column

比如 n-n 的情况下, 中间表就是一个 c# 没有 class 但是 sql 有 table 的情况了.

5. Database collations

可以指定 column 支持 case sensitive 了.

6. many to many

以前是用 2 个 1-n 来实现的. 总算是有了.

配置的方法是

builder
    .HasMany(e => e.Subcategories)
    .WithMany(e => e.Products)
    .UsingEntity<Dictionary<string, object>>(
        "ProductSubcategory",
        e =>
        {
            e.Property<string>("MainCategory");
            e.Property<string>("Subcategory");
            return e
            .HasOne<Subcategory>()
            .WithMany()
            .HasForeignKey(new[] { "MainCategory", "Subcategory" })
            .HasPrincipalKey(e => new { e.MainCategory, e.SubcategoryName })
            .OnDelete(DeleteBehavior.Cascade);
        },
        e => e
            .HasOne<Product>()
            .WithMany()
            .HasForeignKey("Product")
            .HasPrincipalKey(e => e.ProductName)
            .OnDelete(DeleteBehavior.Cascade)
    );

我这个是比较复杂的, 用到了 alt key 和 shadowns properties 的概念

补充一点 ef core 默认行为, 中间 table 的 naming ProductCategory or CategoryProduct

ef core 是通过名字 a-z 排序来做的. 比如上面这个的话是 CategoryProduct 因为 C 在 P 之前

更新: 2020-11-04

migration 添加 row version 去 exsiting table 的话, 需要手动把 defualt value 去掉不然会有 error 哦

refer: https://stackoverflow.com/questions/63703638/generating-non-nullable-rowversion-on-sql-server-with-ef-core-3-1

更新: 2020-10-05

ef core 5.0

https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-5.0/whatsnew#rc1

比较会用到的 :

https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-5.0/whatsnew#many-to-many (多对多)

https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-5.0/whatsnew#stored-persisted-computed-columns (persisted computed column)

https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-5.0/whatsnew#configure-database-precisionscale-in-model (decimal)

https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-5.0/whatsnew#filtered-include (filter + include)

更新: 2020-07-11

今天才发现的坑

sql select 的时候如果没有指定 orderby, 那么它是无法预测的. 并不是 order by Id asc 也不是依据 clustered. 我猜是看它有没有走索引之类的瓜.

总之如果你需要次序，那么就一定要放 orderby

https://stackoverflow.com/questions/26236352/default-row-order-in-select-query-sql-server-2008-vs-sql-2012

ef core include 是不能 orderby 的

https://stackoverflow.com/questions/15378136/entity-framework-ordering-includes

ef core insert save change 的顺序是不一定的. 如果你要确保 insert 的顺序，那么最好的方式是进一条 save 一次.

不要用 add range 也不要 add 多多了才 save.

https://github.com/dotnet/efcore/issues/7894

更新 : 2020-02-28

乐观锁

依据某些数据 -> 计算 -> 决定结果. 在这个过程中确保依赖数据不变，这个就是锁的作用.

比如一个客户跟我要了一个货，我得锁着给他，不可以给其它同事拿去卖. 一样的道理

更新 2020-01-01

当 nullable + unique 时, ef 会自动的帮我们添加 filter... 如果不希望它自作聪明的话，可以把它关了。

clustered 就没有 filter 哦

更新: 2019-11-17

ef core 没法 where COLLATE SQL_Latin1_General_CP1_CS_AS 区分大小写.

https://github.com/aspnet/EntityFrameworkCore/issues/8813

https://github.com/aspnet/EntityFrameworkCore/issues/1222

目前能做的就是 rawSql 或者在 column 上 set collate

alter table Products alter column name nvarchar(64) collate SQL_Latin1_General_CP1_CS_AS;
alter table Products alter column name nvarchar(64) collate SQL_Latin1_General_CP1_CI_AS;

更新: 2019-08-03

rename table 有时候会很麻烦， migration 会删除表和从创。里面有资料就不方便了。

可以手动写代码

https://stackoverflow.com/questions/13296996/entity-framework-migrations-renaming-tables-and-columns

public override void Up()
{
    RenameTable("ReportSections", "ReportPages");
    RenameTable("ReportSectionGroups", "ReportSections");
    RenameColumn("ReportPages", "Group_Id", "Section_Id");
}

就如同我们跑 sql 语句类似了。

use klc2;
EXEC sp_rename 'TableSettings', 'UserSettings';
EXEC sp_rename 'UserSettings.tableName', 'name', 'COLUMN'; 
EXEC sp_rename 'UserSettings.settingJson', 'json', 'COLUMN'; -- INDEX 也是这个换法
EXEC sp_rename 'dbo.PK_UserSettingsa', 'PK_UserSettings';  
EXEC sp_rename 'dbo.FK_UserSettings_AspNetUsers_userIa', 'FK_UserSettings_AspNetUsers_userId';  

-- 检查名字
SELECT name, SCHEMA_NAME(schema_id) AS schema_name, type_desc  
FROM sys.objects  
WHERE parent_object_id = (OBJECT_ID('UserSettings'))   
AND type IN ('C','F', 'PK');

直接跑

   migrationBuilder.Sql(
             @"
                EXEC sp_rename 'TableSettings', 'UserSettings';
                EXEC sp_rename 'UserSettings.tableName', 'name', 'COLUMN'; 
                EXEC sp_rename 'UserSettings.settingJson', 'json', 'COLUMN'; 
                EXEC sp_rename 'dbo.PK_TableSettings', 'PK_UserSettings';  
                EXEC sp_rename 'dbo.FK_TableSettings_AspNetUsers_userId', 'FK_UserSettings_AspNetUsers_userId';  
            ");

如果是要换 column length for 有 relation 的也是不可以用 ef core migrations, 去 sql management studio 换, 它会批量, 然后 migration 里面放 return 假假跑一下就可以了.

还有 index 也是要换, 找的方式是 :

select * from (
select i.[name] as index_name,
    substring(column_names, 1, len(column_names)-1) as [columns],
    case when i.[type] = 1 then 'Clustered index'
        when i.[type] = 2 then 'Nonclustered unique index'
        when i.[type] = 3 then 'XML index'
        when i.[type] = 4 then 'Spatial index'
        when i.[type] = 5 then 'Clustered columnstore index'
        when i.[type] = 6 then 'Nonclustered columnstore index'
        when i.[type] = 7 then 'Nonclustered hash index'
        end as index_type,
    case when i.is_unique = 1 then 'Unique'
        else 'Not unique' end as [unique],
    schema_name(t.schema_id) + '.' + t.[name] as table_view, 
    case when t.[type] = 'U' then 'Table'
        when t.[type] = 'V' then 'View'
        end as [object_type]
from sys.objects t
    inner join sys.indexes i
        on t.object_id = i.object_id
    cross apply (select col.[name] + ', '
                    from sys.index_columns ic
                        inner join sys.columns col
                            on ic.object_id = col.object_id
                            and ic.column_id = col.column_id
                    where ic.object_id = t.object_id
                        and ic.index_id = i.index_id
                            order by key_ordinal
                            for xml path ('') ) D (column_names)
where t.is_ms_shipped <> 1
and index_id > 0 
) indexes where table_view = 'dbo.QuotationItems';

修改记得哦是 dbo.tableName.indexName

EXEC sp_rename N'dbo.QuotationItems.IX_DocumentItems_createdBy', N'IX_QuotationItems_createdBy', N'INDEX';

更新: 2019-06-12

不小心踩坑

var adidas = new Supplier { name = "adidas" };
Db.Suppliers.Add(adidas);
Db.SaveChanges(); // 关键
Db.Products.Add(new Product
{
    supplier = adidas,
    code = "001",
    // supplierId = adidas.Id 
});
Db.SaveChanges();

这样会报错哦.

因为第一个 savechange 已经把 adidas 有了 id 那么 product.add 时我又传入了 adidas

那么 ef 会以为我要去创建, 但是它有 id 了啊, sql 就会报错了 (这里 id 是 auto increment 的情况)

所以按上面的写法其实第一个 save change 是多余的, 如果第一个 save change 是必须的话，下面就应该 update foreign key 就好了。

更新 : 2019-05-04

动态生成 fluent api

enum to string 这个方式我们可以通过 fluent api 来实现, 比如下面这样.

modelBuilder.Entity<Order>().Property(p => p.status).IsRequired().HasMaxLength(128)
    .HasConversion(
        v => v.ToString(),
        v => (OrderStatus)Enum.Parse(typeof(OrderStatus), v)
    );

但是如果我们有非常多的 table 和 enum，每一个属性都写这么一行...累丫

那么我们可以通过反射来实现这个调用.

步骤如下，首先找出所有的 EntityType

foreach (var entity in modelBuilder.Model.GetEntityTypes())

接着把所有 enum property 找出来

var props = entity.ClrType.GetProperties()
    .Where(p => p.PropertyType.IsEnum)
    .ToList();

然后每一个 prop 都要绑定 HasConversion

foreach (var prop in props)

接着就是反射调用

// modelBuilder.Entity<Order>()
var entityMethod = modelBuilder.GetType().GetMethod(nameof(ModelBuilder.Entity), 1, new Type[] { });
entityMethod = entityMethod.MakeGenericMethod(new[] { entity.ClrType });
var entityTypeBuilder = entityMethod.Invoke(modelBuilder, new object[] { });

接着

// ...Property(entity => entity.status) 
var paramType = typeof(Expression<>).MakeGenericType(new[] { typeof(Func<,>).MakeGenericType(new[] { entity.ClrType, prop.PropertyType }) });
var propertyMethod = entityTypeBuilder.GetType().GetMethods()
    .Where(m => m.Name == nameof(EntityTypeBuilder.Property) && m.GetGenericArguments().Count() == 1)
    .Select(m => m.MakeGenericMethod(prop.PropertyType))
    .Single(m =>
    {
        var parameters = m.GetParameters();
        if (parameters.Count() != 1) return false;
        return parameters[0].ParameterType == paramType;
    });
var paramEntityExp = Expression.Parameter(entity.ClrType, "entity");
var getPropExp = Expression.Property(paramEntityExp, prop);
var lambdaExp = Expression.Lambda(getPropExp, paramEntityExp);
var propertyBuilder = propertyMethod.Invoke(entityTypeBuilder, new[] { lambdaExp });

最后

// ...HasConversion(propertyValue => propertyValue.ToString(), sqlValue => (OrderStatus)Enum.Parse(typeof(OrderStatus), propertyValue));        
var firstParamPropertyExp = Expression.Parameter(prop.PropertyType, "propertyValue");
var firstParamCallMethod = typeof(Enum).GetMethod(nameof(Enum.ToString), new Type[] { });
var firstParamCallMethodExp = Expression.Call(
    firstParamPropertyExp, firstParamCallMethod
);
var firstLambdaExp = Expression.Lambda(firstParamCallMethodExp, firstParamPropertyExp);


var secondParamPropertyExp = Expression.Parameter(typeof(string), "sqlValue");
var secondParamCallMethod = typeof(Enum).GetMethod(nameof(Enum.Parse), new[] { typeof(Type), typeof(string) });
var secondParamCallMethodExp = Expression.Call(
        secondParamCallMethod, new Expression[] { Expression.Constant(prop.PropertyType), secondParamPropertyExp }
    );
var secondParamConvertExp = Expression.Convert(
    secondParamCallMethodExp,
    prop.PropertyType
);
var secondLambdaExp = Expression.Lambda(secondParamConvertExp, secondParamPropertyExp);

var firstParamType = typeof(Expression<>).MakeGenericType(new[] { typeof(Func<,>).MakeGenericType(new[] { prop.PropertyType, typeof(string) }) });
var secondParamType = typeof(Expression<>).MakeGenericType(new[] { typeof(Func<,>).MakeGenericType(new[] { typeof(string), prop.PropertyType }) });
var hasConversionMethod = propertyBuilder.GetType().GetMethods()
    .Where(m => m.Name == nameof(PropertyBuilder.HasConversion) && m.GetGenericArguments().Count() == 1)
    .Select(m => m.MakeGenericMethod(typeof(string)))
    .Single(m =>
    {
        var parameters = m.GetParameters();
        if (parameters.Count() != 2) return false;
        return parameters[0].ParameterType == firstParamType && parameters[1].ParameterType == secondParamType;
    });
hasConversionMethod.Invoke(propertyBuilder, new[] { firstLambdaExp, secondLambdaExp });

这样就可以了, 其实那些 data annotation 也是这样子做出来，通过反射获取 Attribute 的值，然后调用 fluent api. 有了上面这个概念就可以写自己的 data annotation 啦~~

反射和表达式树是 c# 常用到的功能，大家可以多学学.

更新 : 2018-11-26

这里记入一下关于 foreignKey cascade action

默认情况下如果我们使用 data annotation

required + foreginkey . ef 会帮我们设计成 cascade delete

如果 foreignkey + nullable 就会是 cascade restrict.

如果使用 fluent api 的话就由我们设计了.

ef 6.x 有一个功能可以把所有的 cascade delete 停掉, ef core 不一样了

https://github.com/aspnet/EntityFrameworkCore/issues/3815

我看了一下 identity 也是有用 cascade delete 的，所以停到完好像不是 best practices.

所以我的规范是, 要 cascade delete 的话，可以用 data annotations

如果要限制的话，用 fluent api

fluent api 可以双向设置.

modelBuilder.Entity<QuestionVsSkill>().HasOne(e => e.skill).WithMany().HasForeignKey(e => e.skillId).OnDelete(DeleteBehavior.Restrict);
modelBuilder.Entity<Skill>().HasMany<QuestionVsSkill>().WithOne(e => e.skill).HasForeignKey(e => e.skillId).OnDelete(DeleteBehavior.Restrict);

上面 2 个是一样的结果.

注意 : 如果我们的 entity 有 navigation property 就要放, 如果没有就空 e.g. WithMany() <--params is empty

有一个比较难搞的东西，就是 database 循环引用, 比如我们有继承 table, foreignkey 就不支持 sql cascade null or delete 了

这时需要设置成 restrict 然后在处理的时候自己写程序实现 cascade null or delete.

Entity Framework 已经很多年了.

ef core 和从前的 ef 6.x 用起来是差不多的.

ef core 的有点事跨平台，更好的性能，持续发展中 ...

ef 6.x 是功能比较齐全, 但是逐渐被淘汰了..

基本用法和从前是一样的, 比如

创建 DbContext, 定义 Entity 还有关系等等

namespace Project.Models
{
    public class DB : DbContext
    {
        public DB(DbContextOptions<DB> options) : base(options)
        {

        }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {  
        }
        public virtual DbSet<Product> Products { get; set; }      
    }
}

在 startup.cs 里的 ConfigureServices 加入

    services.AddDbContext<SchoolContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

appsetting.json

"ConnectionStrings": {
  "DefaultConnection": "Server=(localdb)\mssqllocaldb;Database=ContosoUniversity1;Trusted_Connection=True;MultipleActiveResultSets=true"
  //"DefaultConnection": "Server=192.168.1.152;Database=databaseName;User Id=username;Password=password;"
}

在 controller 依赖注入调用就可以了

public class HomeController : Controller
{
    public DB Db { get; set; }
    public HomeController(DB db) {
        Db = db;
    }
    public async Task<IActionResult> Index()
    {
        var products = await Db.Products.ToListAsync();
        return View();
    } 
}

要生产 database 或需要 update database 可以使用 ef core 的工具 migrations

这个有点像是 version control 一样, 创建 migrations -> 工具会生产一个 Up 的代码和一个 Down 的代码用于对数据库添加内容和移除内容.

自动生产以后，我们可以手动修改这些代码，然后 update database, 这样当我们 commit 的时候 Up 代码被执行, rollback 的时候 Down 代码被执行, 大概就是这个过程.

它是用命令来操作的, 打开 Package Manager Console

输入 add-migration init (或者 dotnet ef migrations add init)

init 是一个名字，可以随意放.

输入 update-database (或者 dotnet ef database update)

这时 Up 代码执行, 数据库就被更新了.

如果做错了要删除

输入 remove-migration (或者 dotnet ef migrations remove)

如果要 rollback 某个 version

输入 update-database somename

somename 就是你第一步我们为那一次 migrations 取得名字.

这样 Down 代码被执行，数据库成功还原了.

migrations 仅适合用于数据库架构的更新, 而不是数据库资料的更新哦.

多个 context 的时候，我们需要表示名字

add-migration ids -context PersistedGrantDbContext

或者 dotnet ef migrations add init --context applicationdbcontext