ASP.NET Core使用EF创建关系模型_综合编程-免费资源网

来自：网络

时间：2022-04-07

阅读：

1.关系

关系定义两个实体之间的关系。在关系型数据库中，这由外键约束表示。

2.术语定义

有许多术语用于描述关系：

相关实体：这是包含外键属性的实体。有时称为关系的"子级"。
主体实体：这是包含主/备用键属性的实体。有时称为关系的 "父项"。
外键：依赖实体中的属性，用于存储与实体相关的主体键属性的值。
主体密钥：唯一标识主体实体的属性。这可能是主键或备用密钥。
导航属性：在主体和/或从属实体上定义的属性，该属性包含对相关实体的引用。
集合导航属性：一个导航属性，其中包含对多个相关实体的引用。
引用导航属性：保存对单个相关实体的引用的导航属性。
反向导航属性：讨论特定导航属性时，此术语是指关系另一端的导航属性。

下面的代码列表显示了与之间Blog的一对多关系Post

Post是依赖实体
Blog是主体实体
Post.BlogId为外键
Blog.BlogId是主体键（在这种情况下是主键，而不是备用键）
Post.Blog是一个引用导航属性
Blog.Posts是集合导航属性
Post.Blog是的Blog.Posts反向导航属性（反之亦然）

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    public List<Post> Posts { 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; }
    public Blog Blog { get; set; }
}

3.约定

按照约定，当发现类型上有导航属性时，将创建关系。如果属性指向的类型不能由当前的数据库提供程序映射为标量类型，则该属性视为一个导航属性。

4.完全定义的关系

关系最常见的模式是在关系两端定义导航属性，在依赖实体类中定义外键属性。
如果在两个类型之间找到一对导航属性，则这些属性将配置为同一关系的反向导航属性。
如果依赖实体包含名为<primary key property name>、<navigation property name><primary key property name>或<principal entity name><primary key property name>的属性，则该属性将被配置为外键。

public class Blog
{
    public int BlogId { get; set; }
　public string Url { get; set; }
    //导航属性
    public List<Post> Posts { 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; }
    //反向导航属性
    public Blog Blog { get; set; }
}

5.无外键属性

尽管建议在依赖实体类中定义外键属性，但这并不是必需的。如果未找到外键属性，则会以该名称<navigation property name><principal key property name>引入阴影外键属性。

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    //阴影导航属性
    public List<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; }
}

6.单个导航属性

只包含一个导航属性（无反向导航，没有外键属性）就足以具有约定定义的关系。还可以有一个导航属性和一个外键属性。

public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    //阴影导航属性
    public List<Post> Posts { get; set; }
}
public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

7.数据注释

可以使用两个数据批注来配置关系[ForeignKey]和[InverseProperty]。System.ComponentModel.DataAnnotations.Schema命名空间中提供了这些项。

7.1ForeignKey

你可以使用数据批注来配置应用程序作给定关系的外键属性的属性。通常，当不按约定发现外键属性时，会执行此操作。

namespace EFModeling.DataAnnotations.Relationships.ForeignKey
{
    class MyContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }
    }
    #region Entities
    public class Blog
    {
        public int BlogId { get; set; }
        public string Url { get; set; }
        //导航属性
        public List<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")]
        public Blog Blog { get; set; }
    }
    #endregion
}

7.2InverseProperty

您可以使用数据批注来配置依赖项和主体实体上的导航属性如何配对。这通常在两个实体类型之间存在多个导航属性对时执行。

namespace EFModeling.DataAnnotations.Relationships.InverseProperty
{
    class MyContext : DbContext
    {
        public DbSet<Post> Posts { get; set; }
        public DbSet<User> Users { get; set; }
    }
    #region Entities
    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 List<Post> AuthoredPosts { get; set; }
       
        [InverseProperty("Contributor")]
        public List<Post> ContributedToPosts { get; set; }
    }
    #endregion
}

8.Fluent API

若要在熟知的API中配置关系，请首先标识构成关系的导航属性。HasOne或HasMany标识要开始配置的实体类型上的导航属性。然后，将调用链接到WithOne或WithMany以标识反向导航。HasOne/WithOne用于引用导航属性，HasMany / WithMany用于集合导航属性。

namespace EFModeling.FluentAPI.Relationships.NoForeignKey
{
    #region Model
    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);
        }
    }
    public class Blog
    {
        public int BlogId { get; set; }
        public string Url { get; set; }
        public List<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; }
    }
    #endregion
}

8.1单个导航属性

如果只有一个导航属性，则用WithOne、WithMany的无参数重载。这表示在概念上，关系的另一端有一个引用或集合，但实体类中不包含导航属性。

namespace EFModeling.FluentAPI.Relationships.OneNavigation
{
    #region Model
    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 List<Post> Posts { get; set; }
    }
    public class Post
    {
        public int PostId { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
    }
    #endregion
}

8.2ForeignKey

你可以使用API来配置应用程序的外键属性。

namespace EFModeling.Configuring.DataAnnotations.Samples.Relationships.ForeignKey
{
    #region Model
    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 List<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; }
    }
    #endregion
}

下面的代码列表演示如何配置复合外键：

namespace EFModeling.Configuring.DataAnnotations.Samples.Relationships.CompositeForeignKey
{
    #region Model
    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 List<RecordOfSale> SaleHistory { get; set; }
    }
    public class RecordOfSale
    {
        public int RecordOfSaleId { get; set; }
        public DateTime DateSold { get; set; }
        public decimal Price { get; set; }
        //State对应CarState
        public string CarState { get; set; }
        //LicensePlate 对应CarLicensePlate
        public string CarLicensePlate { get; set; }
        public Car Car { get; set; }
    }
    #endregion
}

您可以使用的HasForeignKey(...)字符串重载将影子属性配置为外键。建议先将影子属性显式添加到模型，然后再将其用作外键：

class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Add the shadow property to the model
        modelBuilder.Entity<Post>()
             //配置外键
            .Property<int>("BlogForeignKey");
        // Use the shadow property as a foreign key
        modelBuilder.Entity<Post>()
            //配置一对多关系
            .HasOne(p => p.Blog)
            .WithMany(b => b.Posts)
            //配置外键
            .HasForeignKey("BlogForeignKey");
    }
}
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }
    public List<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; }
}

8.3无导航属性

不一定需要提供导航属性。你可以直接在关系的一端提供外键。

namespace EFModeling.FluentAPI.Relationships.NoNavigation
{
    #region Model
    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; }
    }
    #endregion
}

9.主体密钥

如果你希望外键引用主键之外的属性，则可以使用熟知的API来配置关系的主体键属性。配置为主体密钥的属性将自动设置为备用密钥。

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 List<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; }
}

下面的代码列表演示如何配置复合主体键：

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 })
            .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 List<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; }
}

10.必需和可选的关系

您可以使用熟知的API来配置是必需的还是可选的关系。最终，这会控制外键属性是必需的还是可选的。当使用阴影状态外键时，这非常有用。如果实体类中具有外键属性，则关系的requiredness取决于外键属性是必需还是可选。

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)
            .IsRequired();
    }
}
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<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; }
}

11.级联删除

您可以使用熟知的API显式配置给定关系的级联删除行为。

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)
            .OnDelete(DeleteBehavior.Cascade);
    }
}
public class Blog
{
    public int BlogId { get; set; }
    public string Url { get; set; }

    public List<Post> Posts { 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; }
    public Blog Blog { get; set; }
}

12.其他关系模式

12.1一对一

一对多关系在两侧都有一个引用导航属性。它们遵循与一对多关系相同的约定，但在外键属性上引入了唯一索引，以确保只有一个依赖项与每个主体相关。

12.1.1数据注释

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; }

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

12.1.2Fluent API

使用API 配置关系时，请使用HasOne和WithOne方法。配置外键时，需要指定依赖实体类型，请注意以下列表HasForeignKey中提供的泛型参数。在一对多关系中，可以清楚地表明具有引用导航的实体是依赖项，并且具有集合的实体是主体。但这并不是一对一的关系，因此需要显式定义它。

class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<BlogImage> BlogImages { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .HasOne(p => p.BlogImage)
            .WithOne(i => i.Blog)
            .HasForeignKey<BlogImage>(b => b.BlogForeignKey);
    }
}
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; }

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

12.2多对多

目前尚不支持多对多关系，没有实体类来表示联接表。但是，您可以通过包含联接表的实体类并映射两个不同的一对多关系，来表示多对多关系。

class MyContext : DbContext
{
    public DbSet<Post> Posts { get; set; }
    public DbSet<Tag> Tags { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<PostTag>()
            .HasKey(pt => new { pt.PostId, pt.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 List<PostTag> PostTags { get; set; }
}
public class Tag
{
    public string TagId { get; set; }

    public List<PostTag> PostTags { get; set; }
}
public class PostTag
{
    public int PostId { get; set; }
    public Post Post { get; set; }

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

到此这篇关于ASP.NET Core使用EF创建关系模型的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。

问题描述A 页面有个按钮，点击后会跳转到一个新页面 B，如果我们跳转之后再打开 devtools 工具条就会无法看到 B 页面初始化发起的请求，那你会说我刷新下不就好了吗？大多数时候这

2024-10-18 23:12:41

在 Rust 中，*、ref、mut、& 和 ref mut 是用于处理引用、解引用和可变性的关键字和操作符，它们在不同的上下文中有不同的用法。一、* 解引用* 属于操作符1. 作用用于解引用指

2024-07-25 21:49:58

目录一.系统环境二.前言三.Open Policy Agent 简介四.Rego 语言简介五.配置基本环境六.docker安装OPA插件 6.1 安装docker 6.2 docker安装OPA插件 6.3 启用OPA

2024-06-05 22:14:00

HTTP 长连接，也称为 HTTP 持久连接（HTTP Persistent Connection）或 HTTP 连接重用，是一种在 HTTP 协议中实现的机制。在传统的 HTTP 通信中，每个 HTTP 请求和响应都会伴随着 TCP

2024-06-05 22:11:55

先给出公式 ans = n - LPS[n-1]其中ans为最小周期,n为给出的由假设的周期字符串中提取出的子串长度,LPS为前缀函数,n-1为字符串最后的位置下标证明如下
证明ans = n - LPS[n

2024-05-26 14:39:26

原文出处：改造 Kubernetes 自定义调度器 | Jayden's Blog (jaydenchang.top)OverviewKubernetes 默认调度器在调度 Pod 时并不关心特殊资源例如磁盘、GPU 等，因此突发奇想

2024-05-26 14:38:11

检索增强生成 (Retrieval Augmented Generation，RAG) 可将存储在外部数据库中的新鲜领域知识纳入大语言模型以增强其文本生成能力。其提供了一种将公司数据与训练期间语言模

2024-05-25 11:53:26

目录 Ceph存储池 1. Ceph的存储流程 1. 数据写入 2. 数据读取 2. 资源池的配置 2.1 资源池创建 pgp是什么（Placement Group for Placement purpose）

2024-05-25 11:48:13

rust 处理错误，不使用 try catch，而是使用 Result<T, E>。简单的处理rust错误在各种关于rust错误处理的文档中，为了解释清楚其背后的机制，看着内容很多，不好理解。比如我们写一

2024-05-10 21:43:40

在上文中我们学会学会更改加载路径，加载对应文件夹下的Lua脚本。默认解析加载的lua脚本存在的文件位置非AB包或者Resources文件夹下往往不能随包体更新，这显然不符合热更需要

2024-05-10 21:29:47

方便我们在项目中使用Lua解析方法，我们封装管理一个lua解析器，管理LuaState的方法执行。解析器脚本：using LuaInterface;namespace BaseFramework{ /// <summary> /// 自

2024-05-10 21:29:22

使用自定义委托来调用lua脚本中的多返回值函数和长参数类型的函数。先看代码，依旧是上篇文章中所贴的脚本。新增调用两个函数testFuncusing System;using BaseFramework;usin

2024-05-10 21:28:53

访问数组类型的tableCallLuaEntrance测试脚本中内容： //--------------------------------------访问table-----------------------------//4.1 访问list/数组类型的table//

2024-05-10 21:28:16

在并发的世界中，最常见的并发安全问题就是数据竞争，也就是两个线程同时对一个变量进行读写操作。但当你在 Safe Rust 中写出有数据竞争的代码时，编译器会直接拒绝编译。那么它

2024-04-30 21:37:14

使用ollama + AnythingLLM快速且简单的在本地部署llama3不多说，直接开始一、安装ollamaollama官网：https://ollama.com/
下载地址：https://ollama.com/download打开以后注册并

2024-04-23 22:31:56

为什么需要 CNI在 kubernetes 中，pod 的网络是使用 network namespace 隔离的，但是我们有时又需要互相访问网络，这就需要一个网络插件来实现 pod 之间的网络通信。CNI 就是为了

2024-04-21 22:16:12

背景我是有个基于DOM实现的简历编辑器项目的，因为暂时找不到可以用Canvas实现的比较有意思的场景，所以才选择了继续做简历编辑器，最开始做简历编辑器就是因为很多简历网站都是

2024-04-15 11:46:07

前言在Canvas2D中实现圆形的绘制比较简单，只要调用arc指令就能在Canvas画布上绘制出一个圆形，类似的，在SVG中我们也只需要一个<circle>标签就能在页面上绘制一个圆形。那么在We

2024-04-13 21:52:27

第一章：引言导言在当今数字化时代，数据安全和完整性变得至关重要。消息摘要算法是一种用于验证数据完整性和安全性的重要工具。在众多消息摘要算法中，MD5（Message
Digest Algori

2024-04-11 21:57:55

1.概述传统应用开发中，为了提升系统的查询性能，往往会在系统架构设计中加入缓存机制。在AI大模型领域，虽然功能非常强大，但是使用成本也是非常昂贵的，比如OpenAI的GPT-4按照token

2024-03-31 22:20:53

目录简介架构 Application 和组件简单入门示例先决条件创建项目编译库文件引用库文件运行项目界面交互示例创建项目编译库文件实现应用函数引

2024-03-26 11:54:50

目录简介 hello world 常用功能动态路径多个片段(segments) 静态文件服务器简单WebAPI示例添加依赖实现接口接口测试参考链接简介Rust中最知名的两个web

2024-03-19 23:21:01

一、RabbitMQ的集群模式主要有两种：普通集群模式和镜像队列模式。下面分别介绍这两种模式的原理：1.普通集群模式：在普通集群模式下，RabbitMQ的集群节点之间主要同步元数据，而不

2024-03-19 23:07:45

0 前言在物联网领域中，mqtt消息一直是海量设备连接到平台的标配协议，而平台向移动端开放的操作接口往往是http协议，这就要求平台为两种协议作消息一一适配。在某些情况下，这些设

2024-03-19 23:04:15

目录前言 git rm 命令 git reset 命令 git rm 和 git reset 的比较不同用例的适用性比较对文件状态的影响比较 git update-index 命令 git clean 命令实际应用

2024-03-18 21:30:10

一、?=、?!、?＜=、?＜!、?:的解释1. 先看一下比较官方的解释 (?=pattern)：正向先行断言，表示匹配位置后面必须紧跟着满足 pattern 的字符串，但不包括这个字符串在匹配结果中。 (?!

2024-03-18 21:24:29

4）Playbook4.1）Playbook 介绍PlayBook 与 ad-hoc 相比，是一种完全不同的运用 Ansible 的方式，类似与 Saltstack 的 state 状态文件。ad-hoc 无法持久使用，PlayBook 可以持久使用

2024-03-17 23:18:56

尽管ggez提供了很多相关特性的demo供运行查看，但笔者第一次使用的时候还是有很多疑惑不解。经过仔细阅读demo代码并结合自己的实践，逐步了解了ggez在不同场景下的绘图方式，在此

2024-03-17 22:57:09

前言最近在学习 ES，所以需要在服务器上装一个单节点的 ES服务器环境：centos 7.9安装下载镜像目前最新版本是 8.12.2docker pull docker.elastic.co/elasticsearch/elasticsear

2024-03-15 20:55:15

MD5算法起源：MD5（Message Digest Algorithm 5）算法是由MIT的计算机科学家Ronald Rivest于1991年设计的一种消息摘要算法。MD5算法最初被用于提供数据完整性和一致性的验证，后来

2024-03-15 20:51:05

2020-09-27

2018-09-21

2018-09-02

2021-03-15

2022-12-16

2021-03-10

2019-08-24

2020-09-16

2019-07-29

2022-12-12

ASP.NET Core使用EF创建关系模型

目录