\n\u4f7f\u7528\u672c\u4e66\u7b2c\u4e8c\u7ae0\u4e2d\u7684\u793a\u4f8b\uff0c\u6211\u4eec\u5c06\u63d0\u53d6\u4e00\u4e2a\u540d\u4e3a Entities \u7684\u65b0\u7c7b\u5e93 \uff08.NET Core\uff09 \u9879\u76ee\u3002(\u65b0\u5efa\u4e00\u4e2aEntities\u7c7b\u5e93\u9879\u76ee)<\/p>\n
Don\u2019t forget to add the reference from the main project to the Entities project.
\n\u4e0d\u8981\u5fd8\u8bb0\u5c06\u4e3b\u9879\u76ee\u4e2d\u7684\u5f15\u7528\u6dfb\u52a0\u5230\u5b9e\u4f53\u9879\u76ee\u4e2d\u3002<\/p>\n
Inside it, we are going to create a folder named Models, which will contain all the model classes (entities). Entities represent classes that Entity Framework Core uses to map our database model with the tables from the database. The properties from entity classes will be mapped to the database columns.
\n\u5728\u5176\u4e2d\uff0c\u6211\u4eec\u5c06\u521b\u5efa\u4e00\u4e2a\u540d\u4e3a Models \u7684\u6587\u4ef6\u5939\uff0c\u8be5\u6587\u4ef6\u5939\u5c06\u5305\u542b\u6240\u6709\u6a21\u578b\u7c7b\uff08\u5b9e\u4f53\uff09\u3002\u5b9e\u4f53\u8868\u793a\u5b9e\u4f53\u6846\u67b6\u6838\u5fc3\u7528\u4e8e\u5c06\u6570\u636e\u5e93\u6a21\u578b\u4e0e\u8868\u6620\u5c04\u7684\u7c7b\u4ece\u6570\u636e\u5e93\u4e2d\u3002\u5b9e\u4f53\u7c7b\u7684\u5c5e\u6027\u5c06\u6620\u5c04\u5230\u6570\u636e\u5e93\u5217\u3002<\/p>\n
So, in the Models folder we are going to create two classes and modify them:
\n\u56e0\u6b64\uff0c\u5728 Models \u6587\u4ef6\u5939\u4e2d\uff0c\u6211\u4eec\u5c06\u521b\u5efa\u4e24\u4e2a\u7c7b\u5e76\u5bf9\u5176\u8fdb\u884c\u4fee\u6539\uff1a<\/p>\n
\n\/\/Company.cs\nusing System;\nusing System.Collections.Generic;\nusing System.ComponentModel.DataAnnotations.Schema;\nusing System.ComponentModel.DataAnnotations;\n\nnamespace Entities.Models\n{\n public class Company { \n [Column("CompanyId")] \n public Guid Id { get; set; } \n [Required(ErrorMessage = "Company name is a required field.")]\n [MaxLength(60, ErrorMessage = "Maximum length for the Name is 60 characters.")] \n public string Name { get; set; } \n\n [Required(ErrorMessage = "Company address is a required field.")]\n [MaxLength(60, ErrorMessage = "Maximum length for the Address is 60 characters")] \n public string Address { get; set; } \n\n public string Country { get; set; } \n public ICollection<Employee> Employees { get; set; } }\n public class Employee { \n [Column("EmployeeId")] \n public Guid Id { get; set; } \n\n [Required(ErrorMessage = "Employee name is a required field.")]\n [MaxLength(30, ErrorMessage = "Maximum length for the Name is 30 characters.")] \n public string Name { get; set; } \n\n [Required(ErrorMessage = "Age is a required field.")] \n public int Age { get; set; }\n\n [Required(ErrorMessage = "Position is a required field.")]\n [MaxLength(20, ErrorMessage = "Maximum length for the Position is 20 characters.")] \n public string Position { get; set; } \n\n [ForeignKey(nameof(Company))] \n public Guid CompanyId { get; set; } \n\n public Company Company { get; set; } }\n}\n<\/pre>\nWe have created two classes: the Company and Employee. Those classes contain the properties which Entity Framework Core is going to map to the columns in our tables in the database. But not all the properties will be mapped as columns. The last property of the Company class (Employees) and the last property of the Employee class (Company) are navigational properties; these properties serve the purpose of defining the relationship between our models.
\n\u6211\u4eec\u521b\u5efa\u4e86\u4e24\u4e2a\u7c7b\uff1a\u516c\u53f8\u548c\u5458\u5de5\u3002\u8fd9\u4e9b\u7c7b\u5305\u542b\u5b9e\u4f53\u6846\u67b6\u6838\u5fc3\u5c06\u6620\u5c04\u5230\u6570\u636e\u5e93\u4e2d\u8868\u4e2d\u7684\u5217\u7684\u5c5e\u6027\u3002\u4f46\u5e76\u975e\u6240\u6709\u5c5e\u6027\u90fd\u5c06\u6620\u5c04\u4e3a\u5217\u3002\u516c\u53f8\u7c7b\uff08\u5458\u5de5\uff09\u7684\u6700\u540e\u4e00\u4e2a\u5c5e\u6027\u548c\u5458\u5de5\u7c7b\uff08\u516c\u53f8\uff09\u7684\u6700\u540e\u4e00\u4e2a\u5c5e\u6027\u662f\u5bfc\u822a\u5c5e\u6027;\u8fd9\u4e9b\u5c5e\u6027\u7528\u4e8e\u5b9a\u4e49\u6a21\u578b\u4e4b\u95f4\u7684\u5173\u7cfb\u3002<\/p>\n
We can see several attributes in our entities. The [Column]<\/strong> attribute will specify that the Id<\/strong> property is going to be mapped with a different name in the database. The [Required]<\/strong> and [MaxLength]<\/strong> properties are here for validation purposes. The first one declares the property as mandatory and the second one defines its maximum length.
\n\u6211\u4eec\u53ef\u4ee5\u5728\u5b9e\u4f53\u4e2d\u770b\u5230\u51e0\u4e2a\u5c5e\u6027\u3002[Column]<\/strong> \u7279\u6027\u5c06\u6307\u5b9a Id<\/strong> \u5c5e\u6027\u5c06\u5728\u6570\u636e\u5e93\u4e2d\u4f7f\u7528\u4e0d\u540c\u7684\u540d\u79f0\u8fdb\u884c\u6620\u5c04\u3002\u6b64\u5904\u7684 [Required]<\/strong> \u548c [MaxLength]<\/strong> \u5c5e\u6027\u7528\u4e8e\u9a8c\u8bc1\u76ee\u7684\u3002\u7b2c\u4e00\u4e2a\u5c06\u5c5e\u6027\u58f0\u660e\u4e3a\u5fc5\u9700\u5c5e\u6027\uff0c\u7b2c\u4e8c\u4e2a\u5b9a\u4e49\u5176\u6700\u5927\u957f\u5ea6\u3002<\/p>\nOnce we transfer our database model to the real database, we are going to see how all these validation attributes and navigational properties affect the column definitions.
\n\u5c06\u6570\u636e\u5e93\u6a21\u578b\u4f20\u8f93\u5230\u5b9e\u9645\u6570\u636e\u5e93\u540e\uff0c\u6211\u4eec\u5c06\u770b\u5230\u6240\u6709\u8fd9\u4e9b\u9a8c\u8bc1\u7279\u6027\u548c\u5bfc\u822a\u5c5e\u6027\u5982\u4f55\u5f71\u54cd\u5217\u5b9a\u4e49\u3002<\/p>\n
3.2 Context Class and The Database Connection<\/h2>\n
Now, let's create the context class, which will be a middleware component for communication with the database. It must inherit from the Entity Framework Core\u2019s DbContext<\/strong> class and it consists of DbSet<\/strong> properties, which EF Core is going to use for the communication with the database. Because we are working with the DBContext class, we need to install the Microsoft.EntityFrameworkCore<\/strong> package in the Entities project.
\n\u73b0\u5728\uff0c\u8ba9\u6211\u4eec\u521b\u5efa\u4e0a\u4e0b\u6587\u7c7b\uff0c\u5b83\u5c06\u662f\u7528\u4e8e\u4e0e\u6570\u636e\u5e93\u901a\u4fe1\u7684\u4e2d\u95f4\u4ef6\u7ec4\u4ef6\u3002\u5b83\u5fc5\u987b\u7ee7\u627f\u81ea\u5b9e\u4f53\u6846\u67b6\u6838\u5fc3\u7684 DbContext<\/strong> \u7c7b\uff0c\u5e76\u4e14\u5b83\u7531 DbSet<\/strong> \u5c5e\u6027\u7ec4\u6210\uff0cEF Core \u5c06\u4f7f\u7528\u8fd9\u4e9b\u5c5e\u6027\u4e0e\u6570\u636e\u5e93\u8fdb\u884c\u901a\u4fe1\u3002\u7531\u4e8e\u6211\u4eec\u4f7f\u7528\u7684\u662f DBContext \u7c7b\uff0c\u56e0\u6b64\u9700\u8981\u5b89\u88c5Entities \u9879\u76ee\u4e2d\u7684 Microsoft.EntityFrameworkCore<\/strong> \u5305\u3002<\/p>\nSo, let\u2019s navigate to the root of the Entities project and create the RepositoryContext class:
\n\u56e0\u6b64\uff0c\u8ba9\u6211\u4eec\u5bfc\u822a\u5230Entities\u9879\u76ee\u7684\u6839\u5e76\u521b\u5efaRepositoryContext\u7c7b\uff1a<\/p>\n
\n\/\/RepositoryContext.cs\nusing Entities.Models;\nusing Microsoft.EntityFrameworkCore;\nnamespace Entities\n{\n public class RepositoryContext : DbContext\n {\n public RepositoryContext(DbContextOptions options) : base(options) { }\n public DbSet<Company> Companies { get; set; }\n public DbSet<Employee> Employees { get; set; }\n }\n}\n<\/pre>\nAfter the class modification, let\u2019s open the appsettings.json<\/strong> file and add the connection string named sqlconnection<\/strong>:
\n\u4fee\u6539\u7c7b\u540e\uff0c\u8ba9\u6211\u4eec\u6253\u5f00 appsettings.json<\/strong> \u6587\u4ef6\u5e76\u6dfb\u52a0\u540d\u4e3a sqlconnection<\/strong> \u7684\u8fde\u63a5\u5b57\u7b26\u4e32\uff1a<\/p>\n\n\/\/appsettings.json\n{\n "Logging": {\n "LogLevel": {\n "Default": "Information",\n "Microsoft": "Warning",\n "Microsoft.Hosting.Lifetime": "Information"\n }\n },\n "ConnectionStrings": {\n "sqlConnection": "server=.; database=CompanyEmployee; Integrated Security=true"\n },\n "AllowedHosts": "*"\n }\n<\/pre>\nIt is quite important to have the JSON object with the ConnectionStrings name in our appsettings.json file, and soon you will see why.
\n\u5728\u6211\u4eec\u7684 appsettings.json \u6587\u4ef6\u4e2d\u5177\u6709 ConnectionStrings \u540d\u79f0\u7684 JSON \u5bf9\u8c61\u975e\u5e38\u91cd\u8981\uff0c\u5f88\u5feb\u4f60\u5c31\u4f1a\u660e\u767d\u4e3a\u4ec0\u4e48\u3002<\/p>\n
We have one more step to finish the database model configuration. We need to register the RepositoryContext<\/strong> class in the application\u2019s dependency injection container as we did with the LoggerManager<\/strong> class in the previous chapter.
\n\u6211\u4eec\u8fd8\u6709\u4e00\u4e2a\u6b65\u9aa4\u6765\u5b8c\u6210\u6570\u636e\u5e93\u6a21\u578b\u914d\u7f6e\u3002\u6211\u4eec\u9700\u8981\u5728\u5e94\u7528\u7a0b\u5e8f\u7684\u4f9d\u8d56\u5173\u7cfb\u6ce8\u5165\u5bb9\u5668\u4e2d\u6ce8\u518c RepositoryContext<\/strong> \u7c7b\uff0c\u5c31\u50cf\u6211\u4eec\u5728\u4e0a\u4e00\u7ae0\u4e2d\u5bf9 LoggerManager<\/strong> \u7c7b\u6240\u505a\u7684\u90a3\u6837\u3002<\/p>\nSo, let\u2019s open the ServiceExtensions<\/strong> class and add the additional method:
\n\u56e0\u6b64\uff0c\u8ba9\u6211\u4eec\u6253\u5f00 ServiceExtensions<\/strong> \u7c7b\u5e76\u6dfb\u52a0\u5176\u4ed6\u65b9\u6cd5\uff1a<\/p>\n\n\/\/ServiceExtensions.cs\nusing Contracts;\nusing Entities;\nusing LoggerService;\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.Extensions.Configuration;\nusing Microsoft.Extensions.DependencyInjection;\n\/\/using Microsoft.EntityFrameworkCore.SqlServer;\nusing Microsoft.EntityFrameworkCore;\n\nnamespace CompanyEmployees.Extensions\n{\n public static class ServiceExtensions\n {\n\n public static void ConfigureCors(this IServiceCollection services) =>\n services.AddCors(options =>\n {\n options.AddPolicy("CorsPolicy", builder =>\n builder.AllowAnyOrigin()\n .AllowAnyMethod()\n .AllowAnyHeader());\n });\n\n public static void ConfigureIISIntegration(this IServiceCollection service) =>\n service.Configure<IISOptions>(options => { });\n\n public static void ConfigureLoggerService(this IServiceCollection services) => \n services.AddScoped<ILoggerManager, LoggerManager>();\n\n public static void ConfigureSqlContext(this IServiceCollection services, \n IConfiguration configuration) =>\n services.AddDbContext<RepositoryContext>(opts =>\n opts.UseSqlServer(configuration.GetConnectionString("sqlConnection")));\n\n }\n}\n<\/pre>\nWith the help of the IConfiguration configuration<\/strong> parameter, we can use the GetConnectionString<\/strong> method to access the connection string from the appsettings.json<\/strong> file. Moreover, to be able to use the UseSqlServer<\/strong> method, we need to install the Microsoft.EntityFrameworkCore.SqlServer<\/strong> package. If we navigate to the GetConnectionString<\/strong> method definition, we will see that it is an extension method that uses the ConnectionStrings name from the appsettings.json<\/strong> file to fetch the connection string by the provided key:
\n\u5728 IConfiguration configuration<\/strong>\u914d\u7f6e\u53c2\u6570\u7684\u5e2e\u52a9\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528 GetConnectionString<\/strong> \u65b9\u6cd5\u4ece appsettings.json<\/strong> \u6587\u4ef6\u4e2d\u8bbf\u95ee\u8fde\u63a5\u5b57\u7b26\u4e32\u3002\u6b64\u5916\uff0c\u4e3a\u4e86\u80fd\u591f\u4f7f\u7528 UseSqlServer<\/strong> \u65b9\u6cd5\uff0c\u6211\u4eec\u9700\u8981\u5b89\u88c5 Microsoft.EntityFrameworkCore.SqlServer<\/strong> \u5305\u3002\u5982\u679c\u6211\u4eec\u5bfc\u822a\u5230 GetConnectionString<\/strong> \u65b9\u6cd5\u5b9a\u4e49\uff0c\u6211\u4eec\u5c06\u770b\u5230\u5b83\u662f\u4e00\u4e2a\u6269\u5c55\u65b9\u6cd5\uff0c\u5b83\u4f7f\u7528 appsettings.json<\/strong> \u6587\u4ef6\u4e2d\u7684 ConnectionStrings<\/strong> \u540d\u79f0\u901a\u8fc7\u63d0\u4f9b\u7684\u952e\u83b7\u53d6\u8fde\u63a5\u5b57\u7b26\u4e32\uff1a<\/p>\n![\"alt\"](\"\/img\/20220824-ultimate-asp-net-core-web-api\/Image_2004.jpg\")
<\/p>\n
Afterward, in the Startup<\/strong> class in the ConfigureServices<\/strong> method, we are going to add the context service to the IOC right above the services.AddControllers()<\/strong> line:
\n\u4e4b\u540e\uff0c\u5728 ConfigureServices<\/strong> \u65b9\u6cd5\u7684 Startup<\/strong> \u7c7b\u4e2d\uff0c\u6211\u4eec\u5c06\u4e0a\u4e0b\u6587\u670d\u52a1\u6dfb\u52a0\u5230 services.AddControllers()<\/strong> \u6b63\u4e0a\u65b9\u7684\u884c\uff1a<\/p>\n\n\/\/Startup.cs\npublic void ConfigureServices(IServiceCollection services)\n {\n services.ConfigureCors();\n services.ConfigureIISIntegration();\n services.ConfigureLoggerService();\n services.ConfigureSqlContext(Configuration);\n\n services.AddControllers();\n }\n<\/pre>\n<\/p>\n3.3 Migration and Initial Data Seed<\/h2>\n
Migration is a standard process of creating and updating the database from our application. Since we are finished with the database model creation, we can transfer that model to the real database. But we need to modify our ConfigureSqlContext<\/strong> method first:
\n\u8fc1\u79fb\u662f\u4ece\u6211\u4eec\u7684\u5e94\u7528\u7a0b\u5e8f\u521b\u5efa\u548c\u66f4\u65b0\u6570\u636e\u5e93\u7684\u6807\u51c6\u8fc7\u7a0b\u3002\u7531\u4e8e\u6211\u4eec\u5df2\u5b8c\u6210\u6570\u636e\u5e93\u6a21\u578b\u7684\u521b\u5efa\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u5c06\u8be5\u6a21\u578b\u4f20\u8f93\u5230\u5b9e\u9645\u6570\u636e\u5e93\u3002\u4f46\u662f\u6211\u4eec\u9700\u8981\u5148\u4fee\u6539\u6211\u4eec\u7684 ConfigureSqlContext<\/strong> \u65b9\u6cd5\uff1a<\/p>\n\n\/\/ServiceExtensions.cs\nusing Contracts;\nusing Entities;\nusing LoggerService;\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.Extensions.Configuration;\nusing Microsoft.Extensions.DependencyInjection;\nusing Microsoft.EntityFrameworkCore;\n\nnamespace CompanyEmployees.Extensions\n{\n public static class ServiceExtensions\n {\n\n public static void ConfigureCors(this IServiceCollection services) =>\n services.AddCors(options =>\n {\n options.AddPolicy("CorsPolicy", builder =>\n builder.AllowAnyOrigin()\n .AllowAnyMethod()\n .AllowAnyHeader());\n });\n\n public static void ConfigureIISIntegration(this IServiceCollection service) =>\n service.Configure<IISOptions>(options => { });\n\n public static void ConfigureLoggerService(this IServiceCollection services) => \n services.AddScoped<ILoggerManager, LoggerManager>();\n\n \/\/public static void ConfigureSqlContext(this IServiceCollection services, \n \/\/ IConfiguration configuration) =>\n \/\/ services.AddDbContext<RepositoryContext>(opts =>\n \/\/ opts.UseSqlServer(configuration.GetConnectionString("sqlConnection")));\n\n public static void ConfigureSqlContext(this IServiceCollection services, \n IConfiguration configuration) => \n services.AddDbContext<RepositoryContext>(opts => \n opts.UseSqlServer(configuration.GetConnectionString("sqlConnection"), b => \n b.MigrationsAssembly("CompanyEmployees")));\n }\n}\n<\/pre>\nWe have to make this change because migration assembly is not in our main project, but in the Entities<\/strong> project. So, we just change the project for the migration assembly.
\n\u6211\u4eec\u5fc5\u987b\u8fdb\u884c\u6b64\u66f4\u6539\uff0c\u56e0\u4e3a\u8fc1\u79fb\u7a0b\u5e8f\u96c6\u4e0d\u5728\u6211\u4eec\u7684\u4e3b\u9879\u76ee\u4e2d\uff0c\u800c\u662f\u5728 Entities<\/strong> \u9879\u76ee\u4e2d\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u53ea\u9700\u66f4\u6539\u8fc1\u79fb\u7a0b\u5e8f\u96c6\u7684\u9879\u76ee\u3002<\/p>\nBefore we execute our migration commands, we have to install an additional ef core library: Microsoft.EntityFrameworkCore.Tools<\/strong>
\n\u5728\u6267\u884c\u8fc1\u79fb\u547d\u4ee4\u4e4b\u524d\uff0c\u6211\u4eec\u5fc5\u987b\u5b89\u88c5\u4e00\u4e2a\u989d\u5916\u7684 ef \u6838\u5fc3\u5e93\uff1aMicrosoft.EntityFrameworkCore.Tools<\/strong><\/p>\nNow, let\u2019s open the Package Manager Console window and create our first migration: PM> Add-Migration DatabaseCreation
\n\u73b0\u5728\uff0c\u8ba9\u6211\u4eec\u6253\u5f00\u7a0b\u5e8f\u5305\u7ba1\u7406\u5668\u63a7\u5236\u53f0(Package Manager Console)\u7a97\u53e3\u5e76\u521b\u5efa\u6211\u4eec\u7684\u7b2c\u4e00\u4e2a\u8fc1\u79fb\uff1a <\/p>\n
PM> Add-Migration DatabaseCreation<\/p>\n
\n\u6bcf\u4e2a\u5305\u90fd\u7531\u5176\u6240\u6709\u8005\u8bb8\u53ef\u7ed9\u4f60\u3002NuGet \u4e0d\u8d1f\u8d23\u7b2c\u4e09\u65b9\u5305\uff0c\u4e5f\u4e0d\u6388\u4e88\u5176\u8bb8\u53ef\u8bc1\u3002\u4e00\u4e9b\u5305\u53ef\u80fd\u5305\u62ec\u53d7\u5176\u4ed6\u8bb8\u53ef\u8bc1\u7ea6\u675f\u7684\u4f9d\u8d56\u5173\u7cfb\u3002\u5355\u51fb\u5305\u6e90(\u6e90) URL \u53ef\u786e\u5b9a\u4efb\u4f55\u4f9d\u8d56\u5173\u7cfb\u3002\n\u7a0b\u5e8f\u5305\u7ba1\u7406\u5668\u63a7\u5236\u53f0\u4e3b\u673a\u7248\u672c 6.3.0.131\n\u952e\u5165 "get-help NuGet" \u53ef\u67e5\u770b\u6240\u6709\u53ef\u7528\u7684 NuGet \u547d\u4ee4\u3002\nPM> Add-Migration DatabaseCreation\nBuild started...\nBuild succeeded.\nTo undo this action, use Remove-Migration.\n<\/pre>\n<\/p>\nWith this command, we are creating migration files and we can find them in the Migrations<\/strong> folder in our main project:
\n\u4f7f\u7528\u6b64\u547d\u4ee4\uff0c\u6211\u4eec\u6b63\u5728\u521b\u5efa\u8fc1\u79fb\u6587\u4ef6\uff0c\u5e76\u4e14\u53ef\u4ee5\u5728\u4e3b\u9879\u76ee\u7684\u201c Migrations<\/strong> \u201d\u6587\u4ef6\u5939\u4e2d\u627e\u5230\u5b83\u4eec\uff1a<\/p>\n![\"alt\"](\"\/img\/20220824-ultimate-asp-net-core-web-api\/Image_3001.jpg\")
<\/p>\n
With those files in place, we can apply migration: PM> Update-Database
\n\u6709\u4e86\u8fd9\u4e9b\u6587\u4ef6\uff0c\u6211\u4eec\u5c31\u53ef\u4ee5\u5e94\u7528\u8fc1\u79fb\uff1aPM> Update-Database<\/p>\n
Excellent. We can inspect our database now:
\n\u975e\u5e38\u597d\u3002\u6211\u4eec\u73b0\u5728\u53ef\u4ee5\u68c0\u67e5\u6211\u4eec\u7684\u6570\u636e\u5e93\uff1a<\/p>\n
![\"alt\"](\"\/img\/20220824-ultimate-asp-net-core-web-api\/Image_3002.jpg\")
<\/p>\n
Once we have the database and tables created, we should populate them with some initial data. To do that, we are going to create another folder called Configuration<\/strong> in the Entities<\/strong> project and add the CompanyConfiguration<\/strong> class:
\n\u521b\u5efa\u6570\u636e\u5e93\u548c\u8868\u540e\uff0c\u6211\u4eec\u5e94\u8be5\u7528\u4e00\u4e9b\u521d\u59cb\u6570\u636e\u586b\u5145\u5b83\u4eec\u3002\u4e3a\u6b64\uff0c\u6211\u4eec\u5c06\u5728 Entities<\/strong> \u9879\u76ee\u4e2d\u521b\u5efa\u53e6\u4e00\u4e2a\u540d\u4e3a\u201cConfiguration<\/strong>\u201d\u7684\u6587\u4ef6\u5939\uff0c\u5e76\u6dfb\u52a0 CompanyConfiguration<\/strong> \u7c7b\uff1a<\/p>\n\nusing Entities.Models;\nusing Microsoft.EntityFrameworkCore.Metadata.Builders;\nusing Microsoft.EntityFrameworkCore;\nusing System;\n\nnamespace Entities.Configuration\n{\n public class CompanyConfiguration : IEntityTypeConfiguration<Company>\n {\n public void Configure(EntityTypeBuilder<Company> builder)\n { \n builder.HasData(\n new Company \n { \n Id = new Guid("c9d4c053-49b6-410c-bc78-2d54a9991870"), \n Name = "IT_Solutions Ltd", \n Address = "583 Wall Dr. Gwynn Oak, MD 21207", Country = "USA" }, \n new Company { Id = new Guid("3d490a70-94ce-4d15-9494-5248280c2ce3"), \n Name = "Admin_Solutions Ltd", \n Address = "312 Forest Avenue, BF 923", \n Country = "USA" }); \n }\n }\n}\n<\/pre>\nLet\u2019s do the same thing for the EmployeeConfiguration<\/strong> class:
\n\u8ba9\u6211\u4eec\u5bf9 EmployeeConfiguration<\/strong> \u7c7b\u6267\u884c\u76f8\u540c\u7684\u64cd\u4f5c\uff1a<\/p>\n\nusing Entities.Models;\nusing Microsoft.EntityFrameworkCore.Metadata.Builders;\nusing Microsoft.EntityFrameworkCore;\nusing System;\n\nnamespace Entities.Configuration\n{\n public class EmployeeConfiguration : IEntityTypeConfiguration<Employee>\n { \n public void Configure(EntityTypeBuilder<Employee> builder) \n { \n builder.HasData(\n new Employee { \n Id = new Guid("80abbca8-664d-4b20-b5de-024705497d4a"), \n Name = "Sam Raiden", \n Age = 26, \n Position = "Software developer", \n CompanyId = new Guid("c9d4c053-49b6-410c-bc78-2d54a9991870") \n }, \n new Employee { \n Id = new Guid("86dba8c0-d178-41e7-938c-ed49778fb52a"), \n Name = "Jana McLeaf", \n Age = 30, \n Position = "Software developer", \n CompanyId = new Guid("c9d4c053-49b6-410c-bc78-2d54a9991870") \n }, \n new Employee { Id = new Guid("021ca3c1-0deb-4afd-ae94-2159a8479811"), \n Name = "Kane Miller", \n Age = 35, \n Position = "Administrator", \n CompanyId = new Guid("3d490a70-94ce-4d15-9494-5248280c2ce3") \n }); \n } \n }\n}\n<\/pre>\nTo invoke this configuration, we have to change the RepositoryContext<\/strong> class:
\n\u8981\u8c03\u7528\u6b64\u914d\u7f6e\uff0c\u6211\u4eec\u5fc5\u987b\u66f4\u6539 RepositoryContext<\/strong> \u7c7b\uff1a<\/p>\n\nusing Entities.Configuration;\nusing Entities.Models;\nusing Microsoft.EntityFrameworkCore;\nnamespace Entities\n{\n public class RepositoryContext : DbContext\n {\n public RepositoryContext(DbContextOptions options) : base(options) { }\n\n protected override void OnModelCreating(ModelBuilder modelBuilder) \n { \n modelBuilder.ApplyConfiguration(new CompanyConfiguration()); \n modelBuilder.ApplyConfiguration(new EmployeeConfiguration()); \n }\n public DbSet<Company> Companies { get; set; }\n public DbSet<Employee> Employees { get; set; }\n }\n}\n<\/pre>\nNow, we can create and apply another migration to seed these data to the database:
\n\u73b0\u5728\uff0c\u6211\u4eec\u53ef\u4ee5\u521b\u5efa\u5e76\u5e94\u7528\u53e6\u4e00\u4e2a\u8fc1\u79fb\uff0c\u4ee5\u5c06\u8fd9\u4e9b\u6570\u636e\u79cd\u5b50\u8bbe\u5b9a\u5230\u6570\u636e\u5e93\u4e2d\uff1a<\/p>\n
\nPM> Add-Migration InitialData \nBuild started...\nBuild succeeded.\nTo undo this action, use Remove-Migration.\n\nPM> Update-Database\nBuild started...\nBuild succeeded.\nDone.\n<\/pre>\nThis will transfer all the data from our configuration files to the respective tables.
\n\u8fd9\u4f1a\u5c06\u6240\u6709\u6570\u636e\u4ece\u6211\u4eec\u7684\u914d\u7f6e\u6587\u4ef6\u4f20\u8f93\u5230\u76f8\u5e94\u7684\u8868\u4e2d\u3002<\/p>\n
3.4 Repository Pattern Logic<\/h2>\n
After establishing a connection to the database and creating one, it's time to create a generic repository that will provide us with the CRUD methods. As a result, all the methods can be called upon any repository class in our project.
\n\u5efa\u7acb\u4e0e\u6570\u636e\u5e93\u7684\u8fde\u63a5\u5e76\u521b\u5efa\u4e00\u4e2a\u8fde\u63a5\u540e\uff0c\u662f\u65f6\u5019\u521b\u5efa\u4e00\u4e2a\u901a\u7528\u5b58\u50a8\u5e93\uff0c\u8be5\u5b58\u50a8\u5e93\u5c06\u4e3a\u6211\u4eec\u63d0\u4f9bCRUD\u65b9\u6cd5\u3002\u56e0\u6b64\uff0c\u53ef\u4ee5\u5728\u6211\u4eec\u9879\u76ee\u4e2d\u7684\u4efb\u4f55\u5b58\u50a8\u5e93\u7c7b\u4e0a\u8c03\u7528\u6240\u6709\u65b9\u6cd5\u3002<\/p>\n
Furthermore, creating the generic repository and repository classes that use that generic repository is not going to be the final step. We will go a step further and create a wrapper class around repository classes and inject it as a service in a dependency injection container.
\n\u6b64\u5916\uff0c\u521b\u5efa\u901a\u7528\u5b58\u50a8\u5e93\u548c\u4f7f\u7528\u8be5\u901a\u7528\u5b58\u50a8\u5e93\u7684\u5b58\u50a8\u5e93\u7c7b\u4e0d\u4f1a\u662f\u6700\u540e\u4e00\u6b65\u3002\u6211\u4eec\u5c06\u66f4\u8fdb\u4e00\u6b65\uff0c\u56f4\u7ed5\u5b58\u50a8\u5e93\u7c7b\u521b\u5efa\u4e00\u4e2a\u5305\u88c5\u7c7b\uff0c\u5e76\u5c06\u5176\u4f5c\u4e3a\u670d\u52a1\u6ce8\u5165\u5230\u4f9d\u8d56\u5173\u7cfb\u6ce8\u5165\u5bb9\u5668\u4e2d\u3002<\/p>\n
Consequently, we will be able to instantiate this class once and then call any repository class we need inside any of our controllers.
\n\u56e0\u6b64\uff0c\u6211\u4eec\u5c06\u80fd\u591f\u5b9e\u4f8b\u5316\u4e00\u6b21\u6b64\u7c7b\uff0c\u7136\u540e\u5728\u4efb\u4f55\u63a7\u5236\u5668\u4e2d\u8c03\u7528\u6240\u9700\u7684\u4efb\u4f55\u5b58\u50a8\u5e93\u7c7b\u3002<\/p>\n
The advantages of this approach will become clearer once we use it in the project.
\n\u4e00\u65e6\u6211\u4eec\u5728\u9879\u76ee\u4e2d\u4f7f\u7528\u5b83\uff0c\u8fd9\u79cd\u65b9\u6cd5\u7684\u4f18\u52bf\u5c06\u53d8\u5f97\u66f4\u52a0\u6e05\u6670\u3002<\/p>\n
That said, let\u2019s start by creating an interface for the repository inside the Contracts<\/strong> project:
\n\u4e5f\u5c31\u662f\u8bf4\uff0c\u8ba9\u6211\u4eec\u9996\u5148\u4e3a\u5b58\u50a8\u5e93\u521b\u5efa\u4e00\u4e2a\u63a5\u53e3Contracts<\/strong>\u9879\u76ee\uff1a<\/p>\n\nusing System;\nusing System.Linq;\nusing System.Linq.Expressions;\nnamespace Contracts\n{\n public interface IRepositoryBase<T>\n {\n IQueryable<T> FindAll(bool trackChanges);\n IQueryable<T> FindByCondition(Expression<Func<T, bool>> expression, bool trackChanges);\n void Create(T entity);\n void Update(T entity);\n void Delete(T entity);\n }\n}\n<\/pre>\nRight after the interface creation, we are going to create a new Class Library (.NET Core) project with the name Repository<\/strong> and add the reference to the Contracts<\/strong> and Entities<\/strong> class libraries. Inside the Repository<\/strong> project, we are going to create an abstract class RepositoryBase<\/strong> \u2014 which is going to implement the IRepositoryBase<\/strong> interface.
\n\u5728\u521b\u5efa\u63a5\u53e3\u4e4b\u540e\uff0c\u6211\u4eec\u5c06\u521b\u5efa\u4e00\u4e2a\u540d\u4e3a Repository<\/strong> \u7684\u65b0\u7c7b\u5e93\uff08.NET Core\uff09\u9879\u76ee\uff0c\u5e76\u6dfb\u52a0\u5bf9 Contracts<\/strong> \u548c Entities<\/strong> \u7c7b\u5e93\u7684\u5f15\u7528\u3002\u5728 Repository<\/strong> \u9879\u76ee\u4e2d\uff0c\u6211\u4eec\u5c06\u521b\u5efa\u4e00\u4e2a\u62bd\u8c61\u7c7b RepositoryBase<\/strong> \u2014 \u5b83\u5c06\u5b9e\u73b0 IRepositoryBase<\/strong> \u63a5\u53e3\u3002<\/p>\nWe need to reference this project from the main project as well.
\n\u6211\u4eec\u8fd8\u9700\u8981\u4ece\u4e3b\u9879\u76ee\u4e2d\u5f15\u7528\u6b64\u9879\u76ee\u3002<\/p>\n
Additional info:<\/strong> We are going to use EF Core functionalities in the Repository project. Therefore, we need to install it inside the Repository project.
\n\u5176\u4ed6\u4fe1\u606f\uff1a<\/strong>\u6211\u4eec\u5c06\u5728\u5b58\u50a8\u5e93\u9879\u76ee\u4e2d\u4f7f\u7528 EF Core \u529f\u80fd\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u9700\u8981\u5c06\u5176\u5b89\u88c5\u5728\u5b58\u50a8\u5e93\u9879\u76ee\u4e2d\u3002<\/p>\nLet\u2019s add the following code to the RepositoryBase<\/strong> class:
\n\u8ba9\u6211\u4eec\u5c06\u4ee5\u4e0b\u4ee3\u7801\u6dfb\u52a0\u5230RepositoryBase<\/strong>\u7c7b\u4e2d\uff1a<\/p>\n\n\/\/RepositoryBase.cs\nusing Contracts;\nusing Entities;\nusing Microsoft.EntityFrameworkCore;\nusing System;\nusing System.Linq;\nusing System.Linq.Expressions;\nnamespace Repository\n{\n public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class\n {\n protected RepositoryContext RepositoryContext; \n public RepositoryBase(RepositoryContext repositoryContext) { \n RepositoryContext = repositoryContext; }\n public IQueryable<T> FindAll(bool trackChanges) => \n !trackChanges ? \n RepositoryContext.Set<T>().\n AsNoTracking() :\n RepositoryContext.Set<T>(); \n public IQueryable<T> FindByCondition(Expression<Func<T, bool>> expression, \n bool trackChanges) => \n !trackChanges ? \n RepositoryContext.Set<T>()\n .Where(expression).AsNoTracking() : \n RepositoryContext.Set<T>().Where(expression); \n public void Create(T entity) => RepositoryContext.Set<T>().Add(entity); \n public void Update(T entity) => RepositoryContext.Set<T>().Update(entity); \n public void Delete(T entity) => RepositoryContext.Set<T>().Remove(entity);\n }\n}\n<\/pre>\nThis abstract class as well as the IRepositoryBase<\/strong> interface works with the generic type T<\/strong>. This type T<\/strong> gives even more reusability to the RepositoryBase<\/strong> class. That means we don\u2019t have to specify the exact model (class) right now for the RepositoryBase<\/strong> to work with. We can do that later on.
\n\u6b64\u62bd\u8c61\u7c7b\u4ee5\u53ca IRepositoryBase<\/strong> \u63a5\u53e3\u9002\u7528\u4e8e\u6cdb\u578b\u7c7b\u578b T<\/strong>\u3002\u6b64\u7c7b\u578b T<\/strong> \u4e3a RepositoryBase<\/strong> \u7c7b\u63d0\u4f9b\u4e86\u66f4\u591a\u7684\u53ef\u91cd\u7528\u6027\u3002\u8fd9\u610f\u5473\u7740\u6211\u4eec\u73b0\u5728\u4e0d\u5fc5\u4e3aRepositoryBase<\/strong>\u7c7b\u6307\u5b9a\u786e\u5207\u7684\u6a21\u578b\uff08\u7c7b\uff09\u3002\u6211\u4eec\u53ef\u4ee5\u7a0d\u540e\u518d\u8fd9\u6837\u505a\u3002<\/p>\nMoreover, we can see the trackChanges<\/strong> parameter. We are going to use it to improve our read-only query performance. When it\u2019s set to false, we attach the AsNoTracking<\/strong> method to our query to inform EF Core that it doesn\u2019t need to track changes for the required entities. This greatly improves the speed of a query.
\n\u6b64\u5916\uff0c\u6211\u4eec\u53ef\u4ee5\u770b\u5230 trackChanges<\/strong> \u53c2\u6570\u3002\u6211\u4eec\u5c06\u4f7f\u7528\u5b83\u6765\u63d0\u9ad8\u53ea\u8bfb\u67e5\u8be2\u6027\u80fd\u3002\u5f53\u5b83\u8bbe\u7f6e\u4e3a false \u65f6\uff0c\u6211\u4eec\u4f1a\u5c06 AsNoTracking<\/strong> \u65b9\u6cd5\u9644\u52a0\u5230\u67e5\u8be2\uff0c\u4ee5\u901a\u77e5 EF Core \u5b83\u4e0d\u9700\u8981\u8ddf\u8e2a\u6240\u9700\u5b9e\u4f53\u7684\u66f4\u6539\u3002\u8fd9\u5927\u5927\u63d0\u9ad8\u4e86\u67e5\u8be2\u7684\u901f\u5ea6\u3002<\/p>\n3.5 Repository User InterFaces and Classes<\/h2>\n
Now that we have the RepositoryBase<\/strong> class, let\u2019s create the user classes that will inherit this abstract class.
\n\u73b0\u5728\u6211\u4eec\u6709\u4e86 RepositoryBase<\/strong> \u7c7b\uff0c\u8ba9\u6211\u4eec\u521b\u5efa\u5c06\u7ee7\u627f\u6b64\u62bd\u8c61\u7c7b\u7684\u7528\u6237\u7c7b\u3002<\/p>\nBy inheriting from the RepositoryBase class, they will have access to all the methods from it. Furthermore, every user class will have its interface for additional model-specific methods.
\n\u901a\u8fc7\u4ece RepositoryBase<\/strong> \u7c7b\u7ee7\u627f\uff0c\u4ed6\u4eec\u5c06\u6709\u6743\u8bbf\u95ee\u8be5\u7c7b\u4e2d\u7684\u6240\u6709\u65b9\u6cd5\u3002\u6b64\u5916\uff0c\u6bcf\u4e2a\u7528\u6237\u7c7b\u90fd\u5c06\u5177\u6709\u7528\u4e8e\u5176\u4ed6\u7279\u5b9a\u4e8e\u6a21\u578b\u7684\u65b9\u6cd5\u7684\u63a5\u53e3\u3002<\/p>\nThis way, we are separating the logic that is common for all our repository user classes and also specific for every user class itself.
\n\u901a\u8fc7\u8fd9\u79cd\u65b9\u5f0f\uff0c\u6211\u4eec\u5c06\u6240\u6709\u5b58\u50a8\u5e93\u7528\u6237\u7c7b\u901a\u7528\u7684\u903b\u8f91\u4ee5\u53ca\u6bcf\u4e2a\u7528\u6237\u7c7b\u672c\u8eab\u7684\u903b\u8f91\u5206\u5f00\u3002<\/p>\n
Let\u2019s create the interfaces in the Contracts<\/strong> project for the Company<\/strong> and Employee<\/strong> classes.
\n\u8ba9\u6211\u4eec\u5728 Contracts<\/strong> \u9879\u76ee\u4e2d\u4e3a Company<\/strong> \u521b\u5efa\u63a5\u53e3\uff0c\u7136\u540e Employee<\/strong> \u7c7b\u3002<\/p>\n\nnamespace Contracts\n{\n public interface ICompanyRepository { }\n}\n\nnamespace Contracts\n{\n public interface IEmployeeRepository { }\n}\n<\/pre>\nAfter this, we can create repository user classes in the Repository<\/strong> project.
\n\u5728\u6b64\u4e4b\u540e\uff0c\u6211\u4eec\u53ef\u4ee5\u5728 Repository<\/strong> \u4e2d\u521b\u5efa\u5b58\u50a8\u5e93\u7528\u6237\u7c7b\u3002<\/p>\nThe first thing we are going to do is to create the CompanyRepository<\/strong> class:
\n\u6211\u4eec\u8981\u505a\u7684\u7b2c\u4e00\u4ef6\u4e8b\u662f\u521b\u5efaCompanyRepository\u7c7b\uff1a<\/p>\n\nusing Contracts;\nusing Entities.Models;\nusing Entities;\nnamespace Repository\n{\n public class CompanyRepository : RepositoryBase<Company>, ICompanyRepository\n { \n public CompanyRepository(RepositoryContext repositoryContext) : base(repositoryContext) { } \n }\n}\n```\nAnd then, the **EmployeeRepository** class: \n\u7136\u540e\uff0c**EmployeeRepository** \u7c7b\uff1a\n```\nusing Contracts;\nusing Entities.Models;\nusing Entities;\nnamespace Repository\n{\n public class EmployeeRepository : RepositoryBase<Employee>, IEmployeeRepository { \n public EmployeeRepository(RepositoryContext repositoryContext) : base(repositoryContext) { }\n }\n}\n<\/pre>\nAfter these steps, we are finished creating the repository and repository user classes. But there are still more things to do.
\n\u5b8c\u6210\u8fd9\u4e9b\u6b65\u9aa4\u540e\uff0c\u6211\u4eec\u5b8c\u6210\u4e86\u5b58\u50a8\u5e93\u548c\u5b58\u50a8\u5e93\u7528\u6237\u7c7b\u7684\u521b\u5efa\u3002\u4f46\u8fd8\u6709\u66f4\u591a\u7684\u4e8b\u60c5\u8981\u505a\u3002<\/p>\n
3.6 Creating a Repository Manager<\/h2>\n
It is quite common for the API to return a response that consists of data from multiple resources; for example, all the companies and just some employees older than 30. In such a case, we would have to instantiate both of our repository classes and fetch data from their resources.
\nAPI \u8fd4\u56de\u7531\u6765\u81ea\u591a\u4e2a\u8d44\u6e90\u7684\u6570\u636e\u7ec4\u6210\u7684\u54cd\u5e94\u662f\u5f88\u5e38\u89c1\u7684;\u4f8b\u5982\uff0c\u6240\u6709\u516c\u53f8\u548c\u4e00\u4e9b 30 \u5c81\u4ee5\u4e0a\u7684\u5458\u5de5\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u5fc5\u987b\u5b9e\u4f8b\u5316\u4e24\u4e2a\u5b58\u50a8\u5e93\u7c7b\uff0c\u5e76\u4ece\u5176\u8d44\u6e90\u4e2d\u83b7\u53d6\u6570\u636e\u3002\u200c<\/p>\n
Maybe it\u2019s not a problem when we have only two classes, but what if we need the combined logic of five or even more different classes? It would just be too complicated to pull that off.
\n\u5f53\u6211\u4eec\u53ea\u6709\u4e24\u4e2a\u7c7b\u65f6\uff0c\u4e5f\u8bb8\u8fd9\u4e0d\u662f\u95ee\u9898\uff0c\u4f46\u662f\u5982\u679c\u6211\u4eec\u9700\u8981\u4e94\u4e2a\u751a\u81f3\u66f4\u591a\u4e0d\u540c\u7c7b\u7684\u7ec4\u5408\u903b\u8f91\u5462\uff1f\u8981\u505a\u5230\u8fd9\u4e00\u70b9\u592a\u590d\u6742\u4e86\u3002<\/p>\n
With that in mind, we are going to create a repository manager class, which will create instances of repository user classes for us and then register it inside the dependency injection container. After that, we can inject it inside our controllers (or inside a business layer class, if we have a bigger app) with constructor injection (supported by ASP.NET Core). With the repository manager class in place, we may call any repository user class we need.
\n\u8003\u8651\u5230\u8fd9\u4e00\u70b9\uff0c\u6211\u4eec\u5c06\u521b\u5efa\u4e00\u4e2a\u5b58\u50a8\u5e93\u7ba1\u7406\u5668\u7c7b\uff0c\u5b83\u5c06\u4e3a\u6211\u4eec\u521b\u5efa\u5b58\u50a8\u5e93\u7528\u6237\u7c7b\u7684\u5b9e\u4f8b\uff0c\u7136\u540e\u5728\u4f9d\u8d56\u6ce8\u5165\u5bb9\u5668\u4e2d\u6ce8\u518c\u5b83\u3002\u4e4b\u540e\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5176\u6ce8\u5165\u63a7\u5236\u5668\uff08\u6216\u8005\u5982\u679c\u6211\u4eec\u6709\u66f4\u5927\u7684\u5e94\u7528\u7a0b\u5e8f\uff0c\u5219\u5728\u4e1a\u52a1\u5c42\u7c7b\u4e2d\uff09\u4f7f\u7528\u6784\u9020\u51fd\u6570\u6ce8\u5165\uff08\u7531 ASP.NET Core\u652f\u6301\uff09\u3002\u6709\u4e86\u5b58\u50a8\u5e93\u7ba1\u7406\u5668\u7c7b\uff0c\u6211\u4eec\u53ef\u4ee5\u8c03\u7528\u6211\u4eec\u9700\u8981\u7684\u4efb\u4f55\u5b58\u50a8\u5e93\u7528\u6237\u7c7b\u3002<\/p>\n
But we are also missing one important part. We have the Create<\/strong>, Update<\/strong>, and Delete<\/strong> methods in the RepositoryBase<\/strong> class, but they won\u2019t make any change in the database until we call the SaveChanges<\/strong> method. Our repository manager class will handle that as well.
\n\u4f46\u6211\u4eec\u4e5f\u7f3a\u5c11\u4e00\u4e2a\u91cd\u8981\u90e8\u5206\u3002\u6211\u4eec\u5728 RepositoryBase<\/strong> \u7c7b\u4e2d\u6709 Create<\/strong>\u3001Update<\/strong> \u548c Delete<\/strong> \u65b9\u6cd5\uff0c\u4f46\u5728\u6211\u4eec\u8c03\u7528 SaveChanges<\/strong> \u65b9\u6cd5\u4e4b\u524d\uff0c\u5b83\u4eec\u4e0d\u4f1a\u5728\u6570\u636e\u5e93\u4e2d\u8fdb\u884c\u4efb\u4f55\u66f4\u6539\u3002\u6211\u4eec\u7684\u5b58\u50a8\u5e93\u7ba1\u7406\u5668\u7c7b\u4e5f\u5c06\u5904\u7406\u8fd9\u4e2a\u95ee\u9898\u3002<\/p>\nThat said, let\u2019s get to it and create a new interface in the Contract<\/strong> project:
\n\u4e5f\u5c31\u662f\u8bf4\uff0c\u8ba9\u6211\u4eec\u5f00\u59cb\u4f7f\u7528\u5b83\uff0c\u5e76\u5728Contract<\/strong> \u9879\u76ee\u4e2d\u521b\u5efa\u4e00\u4e2a\u65b0\u63a5\u53e3\uff1a<\/p>\n\nnamespace Contracts\n{\n public interface IRepositoryManager { \n ICompanyRepository Company { get; } \n IEmployeeRepository Employee { get; } \n void Save(); }\n}\n<\/pre>\nAnd add a new class to the Repository<\/strong> project:
\n\u5e76\u5411 Repository<\/strong> \u9879\u76ee\u6dfb\u52a0\u4e00\u4e2a\u65b0\u7c7b\uff1a<\/p>\n\nusing Contracts;\nusing Entities;\nnamespace Repository\n{\n public class RepositoryManager : IRepositoryManager\n {\n private RepositoryContext _repositoryContext;\n private ICompanyRepository _companyRepository;\n private IEmployeeRepository _employeeRepository;\n public RepositoryManager(RepositoryContext repositoryContext)\n {\n _repositoryContext = repositoryContext;\n }\n public ICompanyRepository Company\n {\n get\n {\n if (_companyRepository == null)\n _companyRepository = new CompanyRepository(_repositoryContext);\n return _companyRepository;\n }\n }\n public IEmployeeRepository Employee\n {\n get\n {\n if (_employeeRepository == null)\n _employeeRepository = new EmployeeRepository(_repositoryContext);\n return _employeeRepository;\n }\n }\n public void Save() => _repositoryContext.SaveChanges();\n }\n}\n<\/pre>\nAs you can see, we are creating properties that will expose the concrete repositories and also we have the Save()<\/strong> method to be used after all the modifications are finished on a certain object. This is a good practice because now we can, for example, add two companies, modify two employees, and delete one company \u2014 all in one action \u2014 and then just call the Save method once. All the changes will be applied or if something fails, all the changes will be reverted:
\n\u5982\u60a8\u6240\u89c1\uff0c\u6211\u4eec\u6b63\u5728\u521b\u5efa\u5c06\u516c\u5f00\u5177\u4f53\u5b58\u50a8\u5e93\u7684\u5c5e\u6027\uff0c\u5e76\u4e14\u6211\u4eec\u8fd8\u5177\u6709\u5728\u5bf9\u67d0\u4e2a\u5bf9\u8c61\u5b8c\u6210\u6240\u6709\u4fee\u6539\u540e\u8981\u4f7f\u7528\u7684 Save()<\/strong> \u65b9\u6cd5\u3002\u8fd9\u662f\u4e00\u4e2a\u5f88\u597d\u7684\u505a\u6cd5\uff0c\u56e0\u4e3a\u73b0\u5728\u6211\u4eec\u53ef\u4ee5\u6dfb\u52a0\u4e24\u4e2a\u516c\u53f8\uff0c\u4fee\u6539\u4e24\u4e2a\u5458\u5de5\uff0c\u5e76\u5220\u9664\u4e00\u4e2a\u516c\u53f8 - \u6240\u6709\u8fd9\u4e9b\u90fd\u5728\u4e00\u4e2a\u64cd\u4f5c\u4e2d - \u7136\u540e\u53ea\u9700\u8c03\u7528\u4e00\u6b21 Save \u65b9\u6cd5\u3002\u5c06\u5e94\u7528\u6240\u6709\u66f4\u6539\uff0c\u6216\u8005\u5982\u679c\u67d0\u4e9b\u5185\u5bb9\u5931\u8d25\uff0c\u5219\u6240\u6709\u66f4\u6539\u90fd\u5c06\u88ab\u8fd8\u539f\uff1a<\/p>\n\n_repository.Company.Create(company); \n_repository.Company.Create(anotherCompany); \n_repository.Employee.Update(employee); \n_repository.Employee.Update(anotherEmployee);\n_repository.Company.Delete(oldCompany);\n_repository.Save();\n<\/pre>\nAfter these changes, we need to register our manager class and add a reference from the Repository to our main project if not already done so. So, let\u2019s first modify the ServiceExtensions<\/strong> class by adding this code:
\n\u5b8c\u6210\u8fd9\u4e9b\u66f4\u6539\u540e\uff0c\u6211\u4eec\u9700\u8981\u6ce8\u518c\u7ba1\u7406\u5668\u7c7b\uff0c\u5e76\u5c06\u5b58\u50a8\u5e93\u4e2d\u7684\u5f15\u7528\u6dfb\u52a0\u5230\u4e3b\u9879\u76ee\u4e2d\uff08\u5982\u679c\u5c1a\u672a\u8fd9\u6837\u505a\uff09\u3002\u56e0\u6b64\uff0c\u8ba9\u6211\u4eec\u9996\u5148\u901a\u8fc7\u6dfb\u52a0\u4ee5\u4e0b\u4ee3\u7801\u6765\u4fee\u6539 ServiceExtensions<\/strong> \u7c7b\uff1a<\/p>\n\nusing Contracts;\nusing Entities;\nusing LoggerService;\nusing Microsoft.AspNetCore.Builder;\nusing Microsoft.Extensions.Configuration;\nusing Microsoft.Extensions.DependencyInjection;\nusing Microsoft.EntityFrameworkCore;\nusing Repository;\n\nnamespace CompanyEmployees.Extensions\n{\n public static class ServiceExtensions\n {\n public static void ConfigureCors(this IServiceCollection services) =>\n services.AddCors(options =>\n {\n options.AddPolicy("CorsPolicy", builder =>\n builder.AllowAnyOrigin()\n .AllowAnyMethod()\n .AllowAnyHeader());\n });\n\n public static void ConfigureIISIntegration(this IServiceCollection service) =>\n service.Configure<IISOptions>(options => { });\n\n public static void ConfigureLoggerService(this IServiceCollection services) => \n services.AddScoped<ILoggerManager, LoggerManager>();\n\n \/\/public static void ConfigureSqlContext(this IServiceCollection services, \n \/\/ IConfiguration configuration) =>\n \/\/ services.AddDbContext<RepositoryContext>(opts =>\n \/\/ opts.UseSqlServer(configuration.GetConnectionString("sqlConnection")));\n public static void ConfigureSqlContext(this IServiceCollection services, \n IConfiguration configuration) => \n services.AddDbContext<RepositoryContext>(opts => \n opts.UseSqlServer(configuration.GetConnectionString("sqlConnection"), b => \n b.MigrationsAssembly("CompanyEmployees")));\n\n public static void ConfigureRepositoryManager(this IServiceCollection services) => \n services.AddScoped<IRepositoryManager, RepositoryManager>();\n }\n}\n<\/pre>\nAnd in the Startup<\/strong> class inside the ConfigureServices<\/strong> method, above the services.AddController()<\/strong> line, we have to add this code:
\n\u5728 ConfigureServices<\/strong> \u65b9\u6cd5\u5185\u7684 Startup<\/strong> \u7c7b\u4e2d\uff0c\u5728 services.AddController()<\/strong> \u4e0a\u65b9\u884c\uff0c\u6211\u4eec\u5fc5\u987b\u6dfb\u52a0\u4ee5\u4e0b\u4ee3\u7801\uff1a<\/p>\n\npublic void ConfigureServices(IServiceCollection services)\n {\n services.ConfigureCors();\n services.ConfigureIISIntegration();\n services.ConfigureLoggerService();\n services.ConfigureSqlContext(Configuration);\n services.ConfigureRepositoryManager();\n\n services.AddControllers();\n }\n<\/pre>\nExcellent.
\n\u975e\u5e38\u597d\u3002<\/p>\n
As soon as we add some methods to the specific repository classes, we are going to be able to test this logic, but we can just take a peek at how we can inject and use this repository manager.
\n\u4e00\u65e6\u6211\u4eec\u5c06\u4e00\u4e9b\u65b9\u6cd5\u6dfb\u52a0\u5230\u7279\u5b9a\u7684\u5b58\u50a8\u5e93\u7c7b\u4e2d\uff0c\u6211\u4eec\u5c06\u80fd\u591f\u6d4b\u8bd5\u6b64\u903b\u8f91\uff0c\u4f46\u662f\u6211\u4eec\u53ef\u4ee5\u770b\u4e00\u4e0b\u5982\u4f55\u6ce8\u5165\u548c\u4f7f\u7528\u6b64\u5b58\u50a8\u5e93\u7ba1\u7406\u5668\u3002<\/p>\n
All we have to do is to inject the RepositoryManager<\/strong> service inside the controller and we are going to see the Company and Employee properties that will provide us access to the specific repository methods:
\n\u6211\u4eec\u6240\u8981\u505a\u7684\u5c31\u662f\u5728\u63a7\u5236\u5668\u4e2d\u6ce8\u5165 RepositoryManager<\/strong> \u670d\u52a1\uff0c\u6211\u4eec\u5c06\u770b\u5230 Company \u548c Employee \u5c5e\u6027\uff0c\u8fd9\u4e9b\u5c5e\u6027\u5c06\u4f7f\u6211\u4eec\u80fd\u591f\u8bbf\u95ee\u7279\u5b9a\u7684\u5b58\u50a8\u5e93\u65b9\u6cd5\uff1a<\/p>\n\nusing Contracts;\nusing Microsoft.AspNetCore.Mvc;\nusing System;\nusing System.Collections.Generic;\n\nnamespace CompanyEmployees\n{\n \/\/public class WeatherForecast\n \/\/{\n \/\/ public DateTime Date { get; set; }\n \/\/ public int TemperatureC { get; set; }\n \/\/ public int TemperatureF => 32 + (int)(TemperatureC \/ 0.5556);\n \/\/ public string Summary { get; set; }\n \/\/}\n\n \/\/[Route("[controller]")]\n \/\/[ApiController]\n \/\/public class WeatherForecastController : ControllerBase\n \/\/{\n \/\/ private ILoggerManager _logger;\n \/\/ public WeatherForecastController(ILoggerManager logger) { _logger = logger; }\n \/\/ [HttpGet]\n \/\/ public IEnumerable<string> Get()\n \/\/ {\n \/\/ _logger.LogInfo("Here is info message from our values controller.");\n \/\/ _logger.LogDebug("Here is debug message from our values controller.");\n \/\/ _logger.LogWarn("Here is warn message from our values controller.");\n \/\/ _logger.LogError("Here is an error message from our values controller.");\n \/\/ return new string[] { "value1", "value2" };\n \/\/ }\n \/\/}\n\n [Route("[controller]")]\n [ApiController]\n public class WeatherForecastController : ControllerBase\n {\n private readonly IRepositoryManager _repository;\n public WeatherForecastController(IRepositoryManager repository)\n {\n _repository = repository;\n }\n [HttpGet]\n public ActionResult<IEnumerable<string>> Get()\n {\n \/\/_repository.Company.AnyMethodFromCompanyRepository();\n \/\/_repository.Employee.AnyMethodFromEmployeeRepository();\n return new string[] { "value1", "value2" };\n }\n }\n\n}\n<\/pre>\nWe did an excellent job here. The repository layer is prepared and ready to be used to fetch data from the database.
\n\u6211\u4eec\u5728\u8fd9\u91cc\u505a\u5f97\u5f88\u597d\u3002\u5b58\u50a8\u5e93\u5c42\u5df2\u51c6\u5907\u5c31\u7eea\uff0c\u53ef\u7528\u4e8e\u4ece\u6570\u636e\u5e93\u83b7\u53d6\u6570\u636e\u3002 <\/p>\n
As you can see, we have injected our repository inside the controller; this is a good practice for an application of this size. But for larger-scale applications, we would create an additional business layer between our controllers and repository logic and our RepositoryManager service would be injected inside that Business layer \u2014 thus freeing the controller from repository logic.
\n\u5982\u60a8\u6240\u89c1\uff0c\u6211\u4eec\u5df2\u7ecf\u5728\u63a7\u5236\u5668\u4e2d\u6ce8\u5165\u4e86\u6211\u4eec\u7684\u5b58\u50a8\u5e93;\u5bf9\u4e8e\u8fd9\u79cd\u5927\u5c0f\u7684\u5e94\u7528\u7a0b\u5e8f\uff0c\u8fd9\u662f\u4e00\u4e2a\u5f88\u597d\u7684\u505a\u6cd5\u3002\u4f46\u5bf9\u4e8e\u66f4\u5927\u89c4\u6a21\u7684\u5e94\u7528\u7a0b\u5e8f\uff0c\u6211\u4eec\u5c06\u5728\u63a7\u5236\u5668\u548c\u5b58\u50a8\u5e93\u903b\u8f91\u4e4b\u95f4\u521b\u5efa\u4e00\u4e2a\u989d\u5916\u7684\u4e1a\u52a1\u5c42\uff0c\u5e76\u4e14\u6211\u4eec\u7684 RepositoryManager \u670d\u52a1\u5c06\u6ce8\u5165\u8be5\u4e1a\u52a1\u5c42\u4e2d\uff0c\u4ece\u800c\u5c06\u63a7\u5236\u5668\u4ece\u5b58\u50a8\u5e93\u903b\u8f91\u4e2d\u89e3\u653e\u51fa\u6765\u3002<\/p>\n
Now, we can continue towards handling Get requests in our application.
\n\u73b0\u5728\uff0c\u6211\u4eec\u53ef\u4ee5\u7ee7\u7eed\u5904\u7406\u5e94\u7528\u7a0b\u5e8f\u4e2d\u7684 Get \u8bf7\u6c42\u3002<\/p>\n","protected":false},"excerpt":{"rendered":"
3 DATABASE MODEL AND REPOSITORY PATTERN In this chapter, we are going to create a database model and transfer it to the MSSQL database by using the code first approach. So, we are going to learn how to create entities (model classes), how to work with the DbContext class, and how to use migrations to […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[23],"class_list":["post-143","post","type-post","status-publish","format-standard","hentry","category-csharp","tag-ultimate-asp-net-core-web-api"],"_links":{"self":[{"href":"https:\/\/diji.net\/index.php?rest_route=\/wp\/v2\/posts\/143","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/diji.net\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/diji.net\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/diji.net\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/diji.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=143"}],"version-history":[{"count":0,"href":"https:\/\/diji.net\/index.php?rest_route=\/wp\/v2\/posts\/143\/revisions"}],"wp:attachment":[{"href":"https:\/\/diji.net\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=143"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/diji.net\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=143"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/diji.net\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=143"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}