Entity Framework Core——3.实体关系的配置

已于 2024-02-26 20:06:39 修改
阅读量1.0k 收藏 4
点赞数 1
分类专栏： # EF Core 文章标签： ef efcore 实体 外键 c#
于 2021-05-10 14:36:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/catshitone/article/details/116595400
版权

https://docs.microsoft.com/zh-cn/ef/core/modeling/relationships

文章目录

1. 术语介绍

  • Dependent entity: 依赖实体（子实体），包含外键的实体，实体关系中的子。
  • Principal entity: 主体实体（父实体），包含主键/备用键的实体，实体关系中的父。
  • Principal key: 主键/备用键
  • Foreign key: 外键
  • Navigation property: 导航属性，出现在父实体或主实体中，用来维系两个实体间的关系。
    • Collection navigation property：集合导航，是一个ICollection<T>。不要配置为IList、List等类型，可能会有性能问题，参见这里。
    • Reference navigation property：引用导航，是一个T
    • Inverse navigation property：反向导航属性
  • Self-referencing relationship：自引用的关系，如树形结构中的id和parentId

参考以下代码：

public class Blog//父实体
{
    public int BlogId { get; set; }//主键
    public string Url { get; set; }

    public ICollection<Post> Posts { get; set; }//导航属性，也是Post.Blog的反向导航属性
}

public class Post//子实体
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogId { get; set; }//外键
    public Blog Blog { get; set; }//导航属性，也是Blog.Posts的反向导航属性
}

2. 关系自动配置

如果实体类的一个属性无法映射为标量类型（scalar type）, 如int、long等，则认为它就是导航属性。
如果在某个实体类上发现了导航属性，将会创建一个关系。

2.1 完整配置

如上一小节的Post和Blog的关系，定义比较完备。定义完备有两点要求：

  • 实体两边有对应的导航属性，而非一边有一边没有
  • 如果“子实体”中某个属性的名称符合以下规则（即外键的命名规则），则被配置为外键：
    • <navigation property name><principal key property name>
    • <navigation property name>Id
    • <principal entity name><principal key property name>
    • <principal entity name>Id

2.2 无外键情况下进行配置

虽然建议要有外键，但是没有外键也ok。当没外键时会引入名称符合<navigation property name><principal key property name>或 <principal entity name><principal key property name>规则的影子属性作为外键。

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    
    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    
    public Blog Blog { get; set; }
}

此时会产生一个名为BlogId的影子属性。注意：这个BlogId仍然会出现在数据库中，且是可空类型

2.3 无“导航属性对”情况下配置（单向导航）

即使没有对应的反向导航属性，没有外键属性，但只要存在一个导航属性就能建立起关系

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

3. 关系手动配置

使用HasOne/HasMany配置导航属性，使用WithOne/WithMany配置反向导航属性。

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)//表示一个Post对应一个Blog
            .WithMany(b => b.Posts);//表示一个Blog对应多个Post
            
        //上述代码等效于下面这两行
        modelBuilder.Entity<Post>().HasOne(p=>p.Blog);
        modelBuilder.Entity<Blog>().HasMany(b=>b.Posts);
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public Blog Blog { get; set; }
}

当然也可以通过特性配置：

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int AuthorUserId { get; set; }
    public User Author { get; set; }

    public int ContributorUserId { get; set; }
    public User Contributor { get; set; }
}

public class User
{
    public string UserId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }

    [InverseProperty("Author")]
    public ICollection<Post> AuthoredPosts { get; set; }

    [InverseProperty("Contributor")]
    public ICollection<Post> ContributedToPosts { get; set; }
}

看下建表语句都是什么：

CREATE TABLE "SysRole" (
    "Id" INTEGER NOT NULL CONSTRAINT "PK_SysRole" PRIMARY KEY AUTOINCREMENT,
    "RoleName" TEXT NOT NULL
);

CREATE TABLE "SysUsers" (
    "Id" INTEGER NOT NULL CONSTRAINT "PK_SysUsers" PRIMARY KEY AUTOINCREMENT,
    "UserName" TEXT NOT NULL,
    "Pwd" TEXT NOT NULL,
    "CreateTime" TEXT NULL,
    "RoleId" INTEGER NULL,
    CONSTRAINT "FK_SysUsers_SysRole_RoleId" FOREIGN KEY ("RoleId") REFERENCES "SysRole" ("Id") ON DELETE RESTRICT
);

3.1 无“导航属性对”时手动配置（单向导航）

如果你的导航属性不是成对的，则WithOne和WithMany可以不传入参数。

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasMany(b => b.Posts)
            .WithOne();
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

同样：

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public Blog Blog {get; set; }
}

可配置为：
modelBuilder.Entity<Post>().HasOne(b => b.Blog).WithMany();

3.2 手动指定外键

使用FluentAPI可以配置单一外键和复合外键：
单一外键：

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey(p => p.BlogForeignKey);
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogForeignKey { get; set; }
    public Blog Blog { get; set; }
}

复合外键：

internal class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Car>()
            .HasKey(c => new { c.State, c.LicensePlate });//复合主键

        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => new { s.CarState, s.CarLicensePlate });//复合外键
    }
}

public class Car
{
    public string State { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public ICollection<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarState { get; set; }
    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}

除了FluentAPI外，也可以使用特性配置单一外键：

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogForeignKey { get; set; }

    [ForeignKey("BlogForeignKey")]//如果BlogForeignKey不存在，则会创建影子属性
    public Blog Blog { get; set; }
}

配置影子外键：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
        //1.首先配置影子属性
        modelBuilder.Entity<Post>()
            .Property<int>("BlogForeignKey");

        //2.然后将影子属性配置成外键
        modelBuilder.Entity<Post>()
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            .HasForeignKey("BlogForeignKey");
}

配置外键的名称：默认情况下外键约束的名称规则为FK _<依赖实体的类名>_<主体实体的类名>_<外键属性的名称>。在数据库中可以看到实际的名称，如FK_SysUsers_SysRole_RoleId。
当然也可以手动更改外键约束的名称：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasOne(p => p.Blog)
        .WithMany(b => b.Posts)
        .HasForeignKey(p => p.BlogId)
        .HasConstraintName("ForeignKey_Post_Blog");
}

3.3 无导航属性时手动配置

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Post>()
            .HasOne<Blog>()
            .WithMany()
            .HasForeignKey(p => p.BlogId);
    }
}

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogId { get; set; }
}

3.4 将外键指向到非主键上

如果希望外键指向到非实体主键的属性上。则可以如下配置：

  1. 单一外键
internal class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => s.CarLicensePlate)
            .HasPrincipalKey(c => c.LicensePlate);
    }
}

public class Car
{
    public int CarId { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public ICollection<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}
  1. 复合外键
internal class MyContext : DbContext
{
    public DbSet<Car> Cars { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<RecordOfSale>()
            .HasOne(s => s.Car)
            .WithMany(c => c.SaleHistory)
            .HasForeignKey(s => new { s.CarState, s.CarLicensePlate })//CarState, CarLicensePlate的顺序需要和State, LicensePlate对应
            .HasPrincipalKey(c => new { c.State, c.LicensePlate });
    }
}

public class Car
{
    public int CarId { get; set; }
    public string State { get; set; }
    public string LicensePlate { get; set; }
    public string Make { get; set; }
    public string Model { get; set; }

    public ICollection<RecordOfSale> SaleHistory { get; set; }
}

public class RecordOfSale
{
    public int RecordOfSaleId { get; set; }
    public DateTime DateSold { get; set; }
    public decimal Price { get; set; }

    public string CarState { get; set; }
    public string CarLicensePlate { get; set; }
    public Car Car { get; set; }
}

3.5 设置外键可否为空

默认情况下外键可否为空是根据实体类中外键属性可否为空来的。

你可以通过 以下方式配置影子外键可否为空：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>().HasOne(p => p.Blog).WithMany(b => b.Posts).IsRequired();
}

3.6 设置级联删除

父实体删除时删除对应的子实体

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasOne(p => p.Blog)
        .WithMany(b => b.Posts)
        .OnDelete(DeleteBehavior.Cascade);
}

4. 其他关系的配置

上面的例子我们介绍的都是一对多的关系，接下来介绍其他类型的关系

4.1 一对一

两侧的导航属性都不是集合，在外键属性上有唯一索引。EF会自动区分子实体和父实体。

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public BlogImage BlogImage { get; set; }
}

public class BlogImage
{
    public int BlogImageId { get; set; }
    public byte[] Image { get; set; }
    public string Caption { get; set; }
    //定义了外键，EF认为这个就是子实体
    public int BlogId { get; set; }
    public Blog Blog { get; set; }
}

如果EF自动区分时出错，则可以根据之前介绍的使用FluentAPI和特性手动指定。

4.2 多对多

两侧的导航属性都是集合。

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public ICollection<Tag> Tags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }

    public ICollection<Post> Posts { get; set; }
}

会额外创建一个关联表：

CREATE TABLE [Posts] (
    [PostId] int NOT NULL IDENTITY,
    [Title] nvarchar(max) NULL,
    [Content] nvarchar(max) NULL,
    CONSTRAINT [PK_Posts] PRIMARY KEY ([PostId])
);

CREATE TABLE [Tags] (
    [TagId] nvarchar(450) NOT NULL,
    CONSTRAINT [PK_Tags] PRIMARY KEY ([TagId])
);

CREATE TABLE [PostTag] (
    [PostsId] int NOT NULL,
    [TagsId] nvarchar(450) NOT NULL,
    CONSTRAINT [PK_PostTag] PRIMARY KEY ([PostsId], [TagsId]),//复合主键
    CONSTRAINT [FK_PostTag_Posts_PostsId] FOREIGN KEY ([PostsId]) REFERENCES [Posts] ([PostId]) ON DELETE CASCADE,
    CONSTRAINT [FK_PostTag_Tags_TagsId] FOREIGN KEY ([TagsId]) REFERENCES [Tags] ([TagId]) ON DELETE CASCADE
);

当然也可以显示的创建一个PostTag实体来定义多对多的关系：

public class MyContext : DbContext
{
    public MyContext(DbContextOptions<MyContext> options)
        : base(options)
    {
    }

    public DbSet<Post> Posts { get; set; }
    public DbSet<Tag> Tags { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<PostTag>()
            .HasKey(t => new { t.PostId, t.TagId });

        modelBuilder.Entity<PostTag>()
            .HasOne(pt => pt.Post)
            .WithMany(p => p.PostTags)
            .HasForeignKey(pt => pt.PostId);

        modelBuilder.Entity<PostTag>()
            .HasOne(pt => pt.Tag)
            .WithMany(t => t.PostTags)
            .HasForeignKey(pt => pt.TagId);
    }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public ICollection<PostTag> PostTags { get; set; }
}

public class Tag
{
    public string TagId { get; set; }

    public ICollection<PostTag> PostTags { get; set; }
}

public class PostTag
{
    public DateTime PublicationDate { get; set; }

    public int PostId { get; set; }
    public Post Post { get; set; }

    public string TagId { get; set; }
    public Tag Tag { get; set; }
}
JimCarter
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
EntityFramework.SqlServer.dll
11-22
EntityFramework.SqlServer
http://show.ku6.com/app.html,恶意软件分析 & URL链接扫描 免费在线病毒分析平台 | 魔盾安全分析...
weixin_39949776的博客
06-24 2万+
META-INF/MANIFEST.MFA${dc;y/62IB*E6P~ \_9M`;'6tUlc#gl_~S75[A#r\Ub&M[)34~a_i5sn;8]UoH#zZkV4pOZJ-s";jMi5b978E9swnvvgD`b:|0X+DQ+kYo}OYaY]Dm?4Dis*3cT0WU]~dtKA6q7&o0@pY,*!T{KSL_eEt,=`;^U7]8+oZMPu, ...
【EF Core】HasOne()、HasMany() 、WithOne()、WithMany()、HasForeignKey(）
指错||纠正||建议||水评+点赞&&评论&&关注&&转发，在这里你大概率会有所收获
05-18 2642
public override void Map(EntityTypeBuilder builderTable) { //多个BaseProcessingMethod对应一个ProcessingType builderTable.HasOne(t => t.ProcessingType).WithMany().HasForeignKey(t => t.ProcessingTypeId);
Entity Framework Core
Oracel 11G安装过程
03-06 1315
Entity Framework Core (EF Core) 是适用于 .NET 的新式对象数据库映射器。 它支持 LINQ查询、更改跟踪、更新和架构迁移。EF Core 通过数据库提供程序插件模型与 SQL Server/Azure SQL 数据库、SQLite、Azure、Cosmos DB、MySQL、PostgreSQL 和更多数据库配合使用。
EntityFramework 外键值映射
weixin_34368949的博客
10-09 683
如果在 EF OnModelCreating 中配置了实体外键映射，也就是 SQL Server 中的 ForeignKey，那么我们在添加实体的时候，主实体的主键值会自动映射到子实体的外键值，并且这个操作在一个 SaveChanges 中，但如果没有在 OnModelCreating 中进行外键映射配置，我们添加实体的时候，就不会自动映射外键值了，什么意思呢？我们先看一个示例代码： public...
示例：EntityFrameWorkCore 一对一、一对多和多对多模型的建立
HeBianGu的博客
05-15 5535
一、目的：测试再EntityFrameWorkCore中如何建立一对一、一对多和多对多模型 二、环境：VS2019、.NetCore 2.2、Mysql 8.0、Win10 三、一对一模型的建立： 1、定义模型 示例：学生和桌子的一对一关系：每个学生需要对应一个桌位信息，桌位信息不用包含学生信息 public class Desk { publ...
Entity FrameWork对有外键关联的数据表的添加操作
ghyCharles的博客
12-09 546
在使用EF Code First Mode开发时插入一条数据进入带有外键的数据表时，需要先获取外键表的实体，将实体数据赋予要编辑表的外键。这样的话，实现主外键关联。真正实现编辑，而不是编辑变添加。 ...
Entity Framework 插入带有外键的数据，重新添加了外建表里的数据
weixin_30485799的博客
09-05 747
在使用EF Code First Mode开发时插一条带有关联实体B的数据A时，大多数情况下，业务逻辑上都是要插入数据A，而B在插入数据前已经存在，只是B的主键是A的外键，在设计A实体时，包含了一个实体B对象，导致在插入数据A时，需要传入一个A.B的实体对象， 但是在插入A的过程中，B也被当作一个新的实体插入到表B里了，这不是我们想要的结果，经查找资料，找到了一个解决方案（也许不是最好的但是有效就...
EFCore额外的外键字段
ahao214——Dreamspace
09-03 460
EFCore 外键
EntityFrameworkCore的使用教程
csdn2990的博客
11-21 7213
一、先安装对应的数据库映射工具。一般对于的数据库映射工具包含EntityFrameworkCore的依赖。 1.一般EntityFrameworkCore（ORM映射工具）安装在你的数据项目工程中，这里我通过nuget安装的sqlserver的包。对应的数据和安装对应的包就行。包名如下： Microsoft.EntityFrameworkCore.SqlServer 2.然后我们建立好对应的数据Model 3.Model建立完成后，我们建立数据库上下文文件如下： 该类需要继承DbContext,跟数据库的
EntityFrameworkCore 一表对多表存在外键的设计
L.的博客
12-08 569
表的基本设计 机械M由多个零件C组成 不同的零件有不同的属性，所以有C1，C2等等 由于零件的差异化，导致C1、C2不能通过统一的表C来表示 同时设计接口InterfaceC作为零件表的接口，整合一些统一的内容 综上所述，有表M，C1，C2和接口InterfaceC，C1、C2实现InterfaceC 遇到的问题 在M表中，定义 public virtual ICollection<InterfaceC> CList { get; set; } 在C1、C2表中定义 public int MI
Microsoft.EntityFrameworkCore.SqlServer.dll
09-30
Microsoft.EntityFrameworkCore.SqlServer.dll NuGet 程序包，用以在.NET Core程序中连接SqlServer数据库的组件，当nuget程序包管理器无法正常安装时可以添加此引用到项目中。
Z.EntityFramework.Extensions.EFCore.dll
06-05
Z.EntityFramework.Extensions.EFCore 破解 ，支持.NET Core 3.1批量插入数据，速度很快。
Z.EntityFramework.Extensions破解版
07-08
Z.EntityFramework.Extensions，基于2019年7月，3.21.2.0去除每月验证和强签名。适合.net4.0及以上
Pomelo.EntityFrameworkCore.MySql：基于MySqlConnector构建MySQL和MariaDB实体框架核心提供程序
02-03
Pomelo.EntityFrameworkCore.MySql ...兼容性依存关系以下版本的MySqlConnector，EF Core和.NET Standard与Pomelo.EntityFrameworkCore.MySql兼容： 释放科MySqlConnector EF核心.NET标准.NET（核心） .NET Framework>
Shiro的Java原生反序列化漏洞
公众号shadow sock7
07-28 1万+
参考： http://www.lmxspace.com/2019/10/17/Shiro-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E8%AE%B0%E5%BD%95/ https://github.com/jas502n/Shiro_Xray 环境搭建 git clone https://github.com/apache/shiro.git # wget https://codeload.github.com/apache/shiro/zip/shiro-root-1
【c#，.NET】Entity Framework Core基础详解
最新发布
xll的博客
09-30 2790
Entity Framework Core(简称EF Core) 是.NET Core中的ORM (object relational mapping,对象关系映射) 框架。它可以让开发者面向对象的方式进行数据库操作。c#中的对象关系数据库关系数据库和c#对象之间搭建的一座桥梁我们知道在.NET中可以用过ADO.NET连接数据库然后执行SQL语句来操作数据库中的数据。而ORM可以直接通过操作c#对象的方式操作数据库。
Dinky0.7.0源码初探
u010782920的博客
12-02 3184
Dinky0.7.0; Flink; StreamGraph; Pipeline
吾爱2023新年红包题第六题 （CTF）
热门推荐
Codeoooo 博客
06-27 3万+
而且这里面还判断了key的长度，16位，正常key长度也是16位；上面这个 aWfkuqokj454836 15位，心态崩了，看来是假的，这个里面才是真的啊~~~~~~这几道题，完全就是整人玩，一个一直点999次，一个大喊大叫还说你是细狗，还得声音分贝大于100才解锁开始找flag;直接将这个 |wfkuqokj4548366 key 扔进去 get_RealKey方法，在比较的时候打断点，或者hook，拿到正确的可以；看伪C代码，memcmp比较， 是有个和真key比较的地方，返回bool;
Pomelo.EntityFrameworkCore.MySql.Desiner
07-09
Pomelo.EntityFrameworkCore.MySql.Designer 是一个用于 MySQL 数据库的 Entity Framework Core 设计器插件。它由 Pomelo Foundation 开发，为开发人员提供了在 Visual Studio 中设计和生成 MySQL 数据库模型的功能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JimCarter

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值