\n\u60a8\u53ef\u4ee5\u4ece GitHub \u4e0b\u8f7d\u672c\u4e66\u7684\u793a\u4f8b\u4ee3\u7801\u6587\u4ef6\uff0c\u7f51\u5740\u4e3a https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\u3002\u5982\u679c\u4ee3\u7801\u6709\u66f4\u65b0\uff0c\u5b83\u5c06\u5728<\/a> GitHub \u5b58\u50a8\u5e93\u4e2d\u66f4\u65b0\u3002<\/p>\n
We also have other code bundles from our rich catalog of books and videos available at https:\/\/github.com\/PacktPublishing\/<\/a>. Check them out! Download the color images We also provide a PDF file that has color images of the screenshots and diagrams used in this book.You can download it here: https:\/\/packt.link\/GmUNL<\/a> Conventions used There are a number of text conventions used throughout this book. Code in text: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: \u201cIn minimal APIs, we define the route patterns using the Map methods of the WebApplication object.\u201d A block of code is set as follows: When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold: Any command-line input or output is written as follows: Bold: Indicates a new term, an important word, or words that you see onscreen. For instance, words in menus or dialog boxes appear in bold. Here is an example: \u201cOpen Visual Studio 2022 and from the main screen, click on Create a new project.\u201d Get in touch Feedback from our readers is always welcome. General feedback: If you have questions about any aspect of this book, email us at customercare@packtpub.com and mention the book title in the subject of your message. Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packtpub.com\/support\/errata and fill in the form. Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at copyright@packt.com with a link to the material. If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com. Share Your Thoughts Once you\u2019ve read Mastering Minimal APIs in ASP.NET Core, we\u2019d love to hear your thoughts! Please click here to go straight to the Amazon review page for this book and share your feedback. Your review is important to us and the tech community and will help us make sure we\u2019re delivering excellent quality content. \u7b2c 1 \u90e8\u5206\uff1a\u7b80\u4ecb<\/p>\n In the first part of the book, we want to introduce you to the context of the book. We will explain the basics of minimal APIs and how they work. We want to add, brick by brick, the knowledge needed to take advantage of all the power that minimal APIs can grant us. We will cover the following chapters in this part: Chapter 1, Introduction to Minimal APIs Chapter 2, Exploring Minimal APIs and Their Advantages Chapter 3, Working with Minimal APIs 1 \u6700\u5c0f API \u7b80\u4ecb<\/p>\n In this chapter of the book, we will introduce some basic themes related to minimal APIs in .NET 6.0, showing how to set up a development environment for .NET 6 and more specifically for developing minimal APIs with ASP.NET Core. We will first begin with a brief history of minimal APIs. Then, we will create a new minimal API project with Visual Studio 2022 and Visual Code Studio. At the end, we will take a look at the structure of our project. By the end of this chapter, you will be able to create a new minimal API project and start to work with this new template for a REST API. In this chapter, we will be covering the following topics: \u2022 A brief history of the Microsoft Web API Technical requirements To work with the ASP.NET Core 6 minimal APIs you need to install, first of all, .NET 6 on your development environment. If you have not already installed it, let\u2019s do that now: Navigate to the following link: https:\/\/dotnet.microsoft.com<\/a>. Click on the Download button. By default, the browser chooses the right operating system for you, but if not, select your operating system at the top of the page. Download the LTS version of the .NET 6.0 SDK. Start the installer. Reboot the machine (this is not mandatory). You can see which SDKs are installed on your development machine using the following command in a terminal: Before you start coding, you will need a code editor or an Integrated Development Environment (IDE). You can choose your favorite from the following list: \u2022 Visual Studio Code for Windows, Mac, or Linux In the last few years, Visual Studio Code has become very popular not only in the developer community but also in the Microsoft community. Even if you use Visual Studio 2022 for your day-to-day work, we recommend downloading and installing Visual Studio Code and giving it a try. Let\u2019s download and install Visual Studio Code and some extensions: Navigate to https:\/\/code.visualstudio.com<\/a>. Download the Stable or the Insiders edition. Start the installer. Launch Visual Studio Code. Click on the Extensions icon. You will see the C# extension at the top of the list. You can install other recommended extensions for developing with C# and ASP.NET Core. If you want to install them, you see our recommendations in the following table: Additionally, if you want to proceed with the IDE that\u2019s most widely used by .NET developers, you can download and install Visual Studio 2022. If you don\u2019t have a license, check if you can use the Community Edition. There are a few restrictions on getting a license, but you can use it if you are a student, have open source projects, or want to use it as an individual. Here\u2019s how to download and install Visual Studio 2022: Navigate to https:\/\/visualstudio.microsoft.com\/downloads\/<\/a>. Select Visual Studio 2022 version 17.0 or later and download it. Start the installer. On the Workloads tab, select the following: \u2022 ASP.NET and web development \u2022 Git for Windows<\/p>\n All the code samples in this chapter can be found in the GitHub repository for this book at https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\/tree\/main\/Chapter01<\/a>. Now, you have an environment in which you can follow and try the code used in this book. A brief history of the Microsoft Web API A few years ago in 2007, .NET web applications went through an evolution with the introduction of ASP.NET MVC. Since then, .NET has provided native support for the Model-View-Controller pattern that was common in other languages. Five years later, in 2012, RESTful APIs were the new trend on the internet and .NET responded to this with a new approach for developing APIs, called ASP.NET Web API. It was a significant improvement over Windows Communication Foundation (WCF) because it was easier to develop services for the web. Later, in ASP.NET Core these frameworks were unified under the name ASP.NET Core MVC: one single framework with which to develop web applications and APIs. In ASP.NET Core MVC applications, the controller is responsible for accepting inputs, orchestrating operations, and at the end, returning a response. A developer can extend the entire pipeline with filters, binding, validation, and much more. It\u2019s a fully featured framework for building modern web applications. But in the real world, there are also scenarios and use cases where you don\u2019t need all the features of the MVC framework or you have to factor in a constraint on performance. ASP.NET Core implements a lot of middleware that you can remove from or add to your applications at will, but there are a lot of common features that you would need to implement by yourself in this scenario. At last, ASP.NET Core 6.0 has filled these gaps with minimal APIs. Now that we have covered a brief history of minimal APIs, we will start creating a new minimal API project in the next section. Creating a new minimal API project Let\u2019s start with our first project and try to analyze the new template for the minimal API approach when writing a RESTful API. In this section, we will create our first minimal API project. We will start by using Visual Studio 2022 and then we will show how you can also create the project with Visual Studio Code and the .NET CLI. Creating the project with Visual Studio 2022 Follow these steps to create a new project in Visual Studio 2022: Figure 1.1 \u2013 Visual Studio 2022 splash screen On the next screen, write API in the textbox at the top of the window and select the template called ASP.NET Core Web API: Figure 1.2 \u2013 Create a new project screen Next, on the Configure your new project screen, insert a name for the new project and select the root folder for your new solution: Figure 1.3 \u2013 Configure your new project screen For this example we will use the name Chapter01, but you can choose any name that appeals to you. Figure 1.4 \u2013 Additional information screen<\/p>\n Now we are going to show how to create the same project using Visual Studio Code and the .NET CLI. Creating the project with Visual Studio Code Creating a project with Visual Studio Code is easier and faster than with Visual Studio 2022 because you don\u2019t have to use a UI or wizard, rather just a terminal and the .NET CLI. You don\u2019t need to install anything new for this because the .NET CLI is included with the .NET 6 installation (as in the previous versions of the .NET SDKs). Follow these steps to create a project using Visual Studio Code: Open your console, shell, or Bash terminal, and switch to your working directory. Use the following command to create a new Web API application: As you can see, we have inserted the -minimal parameter in the preceding command to use the minimal API project template instead of the ASP.NET Core template with the controllers. Now that we know how to create a new minimal API project, we are going to have a quick look at the structure of this new template. Looking at the structure of the project Whether you are using Visual Studio or Visual Studio Code, you should see the following code in the Program.cs file: First of all, with the minimal API approach, all of your code will be inside the Program.cs file. If you are a seasoned .NET developer, it\u2019s easy to understand the preceding code, and you\u2019ll find it similar to some of the things you\u2019ve always used with the controller approach. At the end of the day, it\u2019s another way to write an API, but it\u2019s based on ASP.NET Core. However, if you are new to ASP.NET, this single file approach is easy to understand. It\u2019s easy to understand how to extend the code in the template and add more features to this API. Don\u2019t forget that minimal means that it contains the minimum set of components needed to build an HTTP API but it doesn\u2019t mean that the application you are going to build will be simple. It will require a good design like any other .NET application. As a final point, the minimal API approach is not a replacement for the MVC approach. It\u2019s just another way to write the same thing. Let\u2019s go back to the code. Even the template of the minimal API uses the new approach of .NET 6 web applications: a top-level statement. It means that the project has a Program.cs file only instead of using two files to configure an application. If you don\u2019t like this style of coding, you can convert your application to the old template for ASP.NET Core 3.x\/5. This approach still continues to work in .NET as well. Important note : We can find more information about the .NET 6 top-level statements template at https:\/\/docs.microsoft.com\/dotnet\/core\/tutorials\/top-level-templates<\/a>. By default, the new template includes support for the OpenAPI Specification and more specifically, Swagger. Let\u2019s say that we have our documentation and playground for the endpoints working out of the box without any additional configuration needed. You can see the default configuration for Swagger in the following two lines of codes: Very often, you don\u2019t want to expose Swagger and all the endpoints to the production or staging environments. The default template enables Swagger out of the box only in the development environment with the following lines of code: If the application is running on the dev elopment environment, you must also include the Swagger documentation, but otherwise not. Note : We\u2019ll talk in detail about Swagger in Chapter 3, Working with Minimal APIs. In these last few lines of code in the template, we are introducing another generic concept for .NET 6 web applications: environments. Typically, when we develop a professional application, there are a lot of phases through which an application is developed, tested, and finally published to the end users. By convention, these phases are regulated and called development, staging, and production. As developers, we might like to change the behavior of the application based on the current environment. There are several ways to access this information but the typical way to retrieve the actual environment in modern .NET 6 applications is to use environment variables. You can access the environment variables directly from the app variable in the Program.cs file. The following code block shows how to retrieve all the information about the environments directly from the startup point of the application: In many cases, you can define additional environments, and you can check your custom environment with the following code: To define routes and handlers in minimal APIs, we use the MapGet, MapPost, MapPut, and MapDelete methods. If you are used to using HTTP verbs, you will have noticed that the verb Patch is not present, but you can define any set of verbs using MapMethods. For instance, if you want to create a new endpoint to post some data to the API, you can write the following code:<\/p>\n \u4f8b\u5982\uff0c\u5982\u679c\u8981\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u7ec8\u7aef\u8282\u70b9\u4ee5\u5c06\u4e00\u4e9b\u6570\u636e\u53d1\u5e03\u5230 API\uff0c\u5219\u53ef\u4ee5\u7f16\u5199\u4ee5\u4e0b\u4ee3\u7801\uff1a<\/p>\n As you can see in the short preceding code, it\u2019s very easy to add a new endpoint with the new minimal API template. It was more difficult previously, especially for a new developer, to code a new endpoint with binding parameters and use dependency injection. Important note : We\u2019ll talk in detail about routing in Chapter 2, Exploring Minimal APIs and Their Advantages, and about dependency injection in Chapter 4, Dependency Injection in a Minimal API Project. Summary In this chapter, we first started with a brief history of minimal APIs. Next, we saw how to create a project with Visual Studio 2022 as well as Visual Studio Code and the .NET CLI. After that, we examined the structure of the new template, how to access different environments, and how to start interacting with REST endpoints. In the next chapter, we will see how to bind parameters, the new routing configuration, and how to customize a response. \u63a2\u7d22\u6700\u5c0f API \u53ca\u5176\u4f18\u52bf<\/p>\n In this chapter of the book, we will introduce some of the basic themes related to minimal APIs in .NET 6.0, showing how they differ from the controller-based web APIs that we have written in the previous version of .NET. We will also try to underline both the pros and the cons of this new approach of writing APIs. In this chapter, we will be covering the following topics: \u2022 Routing Technical requirements To follow the descriptions in this chapter, you will need to create an ASP.NET Core 6.0 Web API application. You can either use one of the following options: \u2022 Option 1: Click on the New | Project command in the File menu of Visual Studio 2022 \u2013 then, choose the ASP.NET Core Web API template. Select a name and the working directory in the wizard and be sure to uncheck the Use controllers (uncheck to use minimal APIs) option in the next step. \u2022 Option 2: Open your console, shell, or Bash terminal, and change to your working directory. Use the following command to create a new Web API application: Now, open the project in Visual Studio by double-clicking the project file, or in Visual Studio Code, by typing the following command in the already open console: Finally, you can safely remove all the code related to the WeatherForecast sample, as we don\u2019t need it for this chapter. All the code samples in this chapter can be found in the GitHub repository for this book at https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\/tree\/main\/Chapter02<\/a>. Routing According to the official Microsoft documentation available at https:\/\/docs.microsoft.com\/aspnet\/core\/fundamentals\/routing<\/a>, the following definition is given for routing: Routing is responsible for matching incoming HTTP requests and dispatching those requests to the app\u2019s executable endpoints. Endpoints are the app\u2019s units of executable request-handling code. Endpoints are defined in the app and configured when the app starts. The endpoint matching process can extract values from the request\u2019s URL and provide those values for request processing. Using endpoint information from the app, routing is also able to generate URLs that map to endpoints. In controller-based web APIs, routing is defined via the UseEndpoints() method in Startup.cs or using data annotations such as Route, HttpGet, HttpPost, HttpPut, HttpPatch, and HttpDelete right over the action methods. As mentioned in Chapter 1, Introduction to Minimal APIs in minimal APIs, we define the route patterns using the Map methods of the WebApplication object. Here\u2019s an example: In this code, we have defined four endpoints, each with a different routing and method. Of course, we can use the same route pattern with different HTTP verbs. Note : As soon as we add an endpoint to our application (for example, using MapGet()), UseRouting() is automatically added at the start of the middleware pipeline and UseEndpoints() at the end of the pipeline. As shown here, ASP.NET Core 6.0 provides Map methods for the most common HTTP verbs. If we need to use other verbs, we can use the generic MapMethods: In the following sections, we will show in detail how routing works effectively and how we can control its behavior. Route handlers Methods that execute when a route URL matches (according to parameters and constraints, as described in the following sections) are called route handlers. Route handlers can be a lambda expression, a local function, an instance method, or a static method, whether synchronous or asynchronous: \u2022 Here\u2019s an example of a lambda expression (inline or using a variable): \u2022 Here\u2019s an example of a local function: \u2022 The following is an example of an instance method: \u2022 Here, we can see an example of a static method: Route parameters As with the previous versions of .NET, we can create route patterns with parameters that will be automatically captured by the handler: A route can contain an arbitrary number of parameters. When a request is made to this route, the parameters will be captured, parsed, and passed as arguments to the corresponding handler. In this way, the handler will always receive typed arguments (in the preceding sample, we are sure that the username is string and the product ID is int). If the route values cannot be casted to the specified types, then an exception of the BadHttpRequestException type will be thrown, and the API will respond with a 400 Bad Request message. Route constraints Route constraints are used to restrict valid types for route parameters. Typical constraints allow us to specify that a parameter must be a number, a string, or a GUID. To specify a route constraint, we simply need to add a colon after the parameter name, then specify the constraint name: Minimal APIs support all the route constraints that were already available in the previous versions of ASP.NET Core. You can find the full list of route constraints at the following link: https:\/\/docs.microsoft.com\/aspnet\/core\/fundamentals\/routing#route-constraint-reference<\/a>. If, according to the constraints, no route matches the specified path, we don\u2019t get an exception. Instead we obtain a 404 Not Found message, because, in fact, if the constraints do not fit, the route itself isn\u2019t reachable. So, for example, in the following cases we get 404 responses: Table 2.1 \u2013 Examples of an invalid path according to the route constraints Every other argument in the handler that is not declared as a route constraint is expected, by default, in the query string. For example, see the following: In the next section, Parameter binding, we\u2019ll go deeper into how to use binding to further customize routing by specifying, for example, where to search for routing arguments, how to change their names, and how to have optional route parameters. Parameter binding Parameter binding is the process that converts request data (i.e., URL paths, query strings, or the body) into strongly typed parameters that can be consumed by route handlers. ASP.NET Core minimal APIs support the following binding sources: \u2022 Route values We\u2019ll talk in detail about dependency injection in Chapter 4, Implementing Dependency Injection. As we\u2019ll see later in this chapter, if necessary, we can customize the way in which binding is performed for a particular input. Unfortunately, in the current version, binding from Form is not natively supported in minimal APIs. This means that, for example, IFormFile is not supported either. To better understand how parameter binding works, let\u2019s take a look at the following API: Parameters that are passed to the handler are resolved in the following ways: Table 2.2 \u2013 Parameter binding sources As we can see, ASP.NET Core is able to automatically understand where to search for parameters for binding, based on the route pattern and the types of the parameters themselves. For example, a complex type such as the Person class is expected in the request body. If needed, as in the previous versions of ASP.NET Core, we can use attributes to explicitly specify where parameters are bound from and, optionally, use different names for them. See the following endpoint: The API can be invoked with \/search?q=text. However, using q as the name of the argument isn\u2019t a good idea, because its meaning is not self-explanatory. So, we can modify the handler using FromQueryAttribute: In this way, the API still expects a query string parameter named q, but in the handler its value is now bound to the searchText argument. Note : According to the standard, the GET, DELETE, HEAD, and OPTIONS HTTP options should never have a body. If, nevertheless, you want to use it, you need to explicitly add the [FromBody] attribute to the handler argument; otherwise, you\u2019ll get an InvalidOperationException error. However, keep in mind that this is a bad practice. By default, all the parameters in route handlers are required. So, if, according to routing, ASP.NET Core finds a valid route, but not all the required parameters are provided, we will get an error. For example, let\u2019s look at the following method: If we call the endpoint without the pageIndex or itemsPerPage query string values, we will obtain a BadHttpRequestException error, and the response will be 400 Bad Request. To make the parameters optional, we just need to declare them as nullable or provide a default value. The latter case is the most common. However, if we adopt this solution, we cannot use a lambda expression for the handler. We need another approach, for example, a local function: In this case, we are dealing with a query string, but the same rules apply to all the binding sources. Keep in mind that if we use nullable reference types (which are enabled by default in .NET 6.0 projects) and we have, for example, a string parameter that could be null, we need to declare it as nullable \u2013 otherwise, we\u2019ll get a BadHttpRequestException error again. The following example correctly defines the orderBy query string parameter as optional: Special bindings In controller-based web APIs, a controller that inherits from Microsoft.AspNetCore.Mvc.ControllerBase has access to some properties that allows it to get the context of the request and response: HttpContext, Request, Response, and User. In minimal APIs, we don\u2019t have a base class, but we can still access this information because it is treated as a special binding that is always available to any handler: Tip : We can also access all these objects using the IHttpContextAccessor interface, as we did in the previous ASP.NET Core versions. Custom binding In some cases, the default way in which parameter binding works isn\u2019t enough for our purpose. In minimal APIs, we don\u2019t have support for the IModelBinderProvider and IModelBinder interfaces, but we have two alternatives to implement custom model binding. Important note : The IModelBinderProvider and IModelBinder interfaces in controller-based projects allow us to define the mapping between the request data and the application model. The default model binder provided by ASP.NET Core supports most of the common data types, but, if necessary, we can extend the system by creating our own providers. We can find more information at the following link: https:\/\/docs.microsoft.com\/aspnet\/core\/mvc\/advanced\/custom-model-binding<\/a>. If we want to bind a parameter that comes from a route, query string, or header to a custom type, we can add a static TryParse method to the type: In the TryParse method, we can try to split the input parameter and check whether it contains two decimal values: in this case, we parse the numbers to build the Location object and we return true. Otherwise, we return false because the Location object cannot be initialized. Important note : When the minimal API finds that a type contains a static TryParse method, even if it is a complex type, it assumes that it is passed in the route or the query string, based on the routing template. We can use the [FromHeader] attributes to change the binding source. In any case, TryParse will never be invoked for the body of the request. If we need to completely control how binding is performed, we can implement a static BindAsync method on the type. This isn\u2019t a very common solution, but in some cases, it can be useful: As we can see, the BindAsync method takes the whole HttpContext as an argument, so we can read all the information we need to create the actual Location object that is passed to the route handler. In this example, we read two query string parameters (lat and lon), but (in the case of POST, PUT, or PATCH methods) we can also read the entire body of the request and manually parse its content. This can be useful, for instance, if we need to handle requests that have a format other than JSON (which, as said before, is the only one supported by default). If the BindAsync method returns null, while the corresponding route handler parameter cannot assume this value (as in the previous example), we will get an HttpBadRequestException error, which. as usual, will be wrapped in a 400 Bad Request response. Important note : We shouldn\u2019t define both the TryParse and BindAsync methods using a type; if both are present, BindAsync always has precedence (that is, TryParse will never be invoked). Now that we have looked at parameter binding and understood how to use it and customize its behavior, let\u2019s see how to work with responses in minimal APIs. Exploring responses As with controller-based projects, with route handlers of minimal APIs as well, we can directly return a string or a class (either synchronously or asynchronously): \u2022 If we return a string (as in the examples of the previous section), the framework writes the string directly to the response, setting its content type to text\/plain and the status code to 200 OK \u2022 If we use a class, the object is serialized into the JSON format and sent to the response with the application\/json content type and a 200 OK status code However, in a real application, we typically need to control the response type and the status code. In this case, we can use the static Results class, which allows us to return an instance of the IResult interface, which in minimal APIs acts how IActionResult does for controllers. For instance, we can use it to return a 201 Created response rather than a 400 Bad Request or a 404 Not Found message. L et\u2019s look at some examples: Each method of the Results class is responsible for setting the response type and status code that correspond to the meaning of the method itself (e.g., the Results.NotFound() method returns a 404 Not Found response). Note that even if we typically need to return an object in the case of a 200 OK response (with Results.Ok()), it isn\u2019t the only method that allows this. Many other methods allow us to include a custom response; in all these cases, the response type will be set to application\/json and the object will automatically be JSON-serialized. The current version of minimal APIs does not support content negotiation. We only have a few methods that allow us to explicitly set the content type, when getting a file with Results.Bytes(), Results.Stream(), and Results.File(), or when using Results.Text() and Results.Content(). In all other cases, when we\u2019re dealing with complex objects, the response will be in JSON format. This is a precise design choice since most developers rarely need to support other media types. By supporting only JSON without performing content negotiation, minimal APIs can be very efficient. However, this approach isn\u2019t enough in all scenarios. In some cases, we may need to create a custom response type, for example, if we want to return an HTML or XML response instead of the standard JSON. We can manually use the Results.Content() method (which allows us to specify the content as a simple string with a particular content type), but, if we have this requirement, it is better to implement a custom IResult type, so that the solution can be reused. For example, let\u2019s suppose that we want to serialize objects in XML instead of JSON. We can then define an XmlResult class that implements the IResult interface: The IResult interface requires us to implement the ExecuteAsync method, which receives the current HttpContext as an argument. We serialize the value using the XmlSerializer class and then write it to the response, specifying the correct response type. Now, we can directly use the new XmlResult type in our route handlers. However, best practices suggest that we create an extension method for the IResultExtensions interface, as with the following one: In this way, we have a new Xml method available on the Results.Extensions property: The benefit of this approach is that we can reuse it everywhere we need to deal with XML without having to manually handle the serialization and the response type (as we should have done using the Result.Content() method instead). Tip : If we want to perform content validation, we need to manually check the Accept header of the HttpRequest object, which we can pass to our handlers, and then create the correct response accordingly. After analyzing how to properly handle responses in minimal APIs, we\u2019ll see how to control the way our data is serialized and deserialized in the next section. Controlling serialization As described in the previous sections, minimal APIs only provide built-in support for the JSON format. In particular, the framework uses System.Text.Json for serialization and deserialization. In controller-based APIs, we can change this default and use JSON.NET instead. This is not possible when working with minimal APIs: we can\u2019t replace the serializer at all. The built-in serializer uses the following options: \u2022 Case-insensitive property names during serialization \u2022 Camel case property naming policy \u2022 Support for quoted numbers (JSON strings for number properties) Note : We can find more information about the System.Text.Json namespace and all the APIs it provides at the following link: https:\/\/docs.microsoft.com\/dotnet\/api\/system.text.json<\/a>. In controller-based APIs, we can customize these settings by calling AddJsonOptions() fluently after AddControllers(). In minimal APIs, we can\u2019t use this approach since we don\u2019t have controllers at all, so we need to explicitly call the Configure method for JsonOptions. So, let\u2019s consider this handler: Using the default JSON options, we get this result: Now, let\u2019s configure JsonOptions: Calling the \/product endpoint again, we\u2019ll now get the following: As expected, the Description property hasn\u2019t been serialized because it is null, as well as TotalPrice, which isn\u2019t included in the response because it is read-only. Another typical use case for JsonOptions is when we want to add converters that will be automatically applied for each serialization or deserialization, for example, JsonStrinEnumConverter to convert enumeration values into or from strings. Important note : Be aware that the JsonOptions class used by minimal APIs is the one available in the Microsoft.AspNetCore.Http.Json namespace. Do not confuse it with the one that is defined in the Microsoft.AspNetCore.Mvc namespace; the name of the object is the same, but the latter is valid only for controllers, so it has no effect if set in a minimal API project. Because of the JSON-only support, if we do not explicitly add support for other formats, as described in the previous sections (using, for example, the BindAsync method on a custom type), minimal APIs will automatically perform some validations on the body binding source and handle the following scenarios: Table 2.3 \u2013 The response status codes for body binding problems In these cases, because body validation fails, our route handlers will never be invoked, and we will get the response status codes shown in the preceding table directly. Now, we have covered all the pillars that we need to start developing minimal APIs. However, there is another important thing to talk about: the correct way to design a real project to avoid common mistakes within the architecture. Architecting a minimal API project Up to now, we have written route handlers directly in the Program.cs file. This is a perfectly supported scenario: with minimal APIs, we can write all our code inside this single file. In fact, almost all the samples show this solution. However, while this is allowed, we can easily imagine how this approach can lead to unstructured and therefore unmaintainable projects. If we have fewer endpoints, it is fine \u2013 otherwise, it is better to organize our handlers in separate files. Let\u2019s suppose that we have the following code right in the Program.cs file because we have to handle CRUD operations: It\u2019s easy to imagine that, if we have all the implementation here (even if we\u2019re using PeopleService to extract the business logic), this file can easily explode. So, in real scenarios, the inline lambda approach isn\u2019t the best practice. We should use the other methods that we have covered in the Routing section to define the handlers instead. So, it is a good idea to create an external class to hold all the route handlers: We have grouped all the endpoint definitions inside the PeopleHandler.MapEndpoints static method, which takes the IEndpointRouteBuilder interface as an argument, which in turn is implemented by the WebApplication class. Then, instead of using lambda expressions, we have created separate methods for each handler, so that the code is much cleaner. In this way, to register all these handlers in our minimal API, we just need the following code in Program.cs: Going forward The approach just shown allows us to better organize a minimal API project, but still requires that we explicitly add a line to Program.cs for every handler we want to define. Using an interface and a bit of reflection, we can create a straightforward and reusable solution to simplify our work with minimal APIs. So, let\u2019s start by defining the following interface: As the name implies, we need to make all our handlers (as with PeopleHandler previously) implement it: Note : The MapEndpoints method isn\u2019t static anymore, because now it is the implementation of the IEndpointRouteHandler interface. Now we need a new extension method that, using reflection, scans an assembly for all the classes that implement this interface and automatically calls their MapEndpoints methods: Tip : If you want to go into further detail about reflection and how it works in .NET, you can start by browsing the following page: https:\/\/docs.microsoft.com\/dotnet\/csharp\/programming-guide\/concepts\/reflection<\/a>. With all these pieces in place, the last thing to do is to call the extension method in the Program.cs file, before the Run() method: In this way, when we add new handlers, we should only need to create a new class that implements the IEndpointRouteHandler interface. No other changes will be required in Program.cs to add the new endpoints to the routing engine. Writing route handlers in external files and thinking about a way to automate endpoint registrations so that Program.cs won\u2019t grow for each feature addition is the right way to architect a minimal API project. Summary ASP.NET Core minimal APIs represent a new way of writing HTTP APIs in the .NET world. In this chapter, we covered all the pillars that we need to start developing minimal APIs, how to effectively approach them, and the best practices to take into consideration when deciding to follow this architecture. In the next chapter, we\u2019ll focus on some advanced concepts such as documenting APIs with Swagger, defining a correct error handling system, and integrating a minimal API with a single-page application. \u4f7f\u7528\u6700\u5c11\u7684 API<\/p>\n In this chapter, we will try to apply some advanced development techniques available in earlier versions of .NET. We will touch on four common topics that are disjointed from each other. We\u2019ll cover productivity topics and best practices for frontend interfacing and configuration management. Every developer, sooner or later, will encounter the issues that we describe in this chapter. A programmer will have to write documentation for APIs, will have to make the API talk to a JavaScript frontend, will have to handle errors and try to fix them, and will have to configure the application according to parameters. The themes we will touch on in this chapter are as follows: \u2022 Exploring Swagger Technical requirements As reported in the previous chapters, it will be necessary to have the .NET 6 development framework available; you will also need to use .NET tools to run an in-memory web server. To validate the functionality of cross-origin resource sharing (CORS), we should exploit a frontend application residing on a different HTTP address from the one where we will host the API. To test the CORS example that we will propose within the chapter, we will take advantage of a web server in memory, which will allow us to host a simple static HTML page. To host the web page (HTML and JavaScript), we will therefore use LiveReloadServer, which you can install as a .NET tool with the following command: All the code samples in this chapter can be found in the GitHub repository for this book at https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\/tree\/main\/Chapter03<\/a>. Exploring Swagger Swagger has entered the life of .NET developers in a big way; it\u2019s been present on the project shelves for several versions of Visual Studio. Swagger is a tool based on the OpenAPI specification and allows you to document APIs with a web application. According to the official documentation available at https:\/\/oai.github.io\/Documentation\/introduction.xhtml<\/a>: \u201cThe OpenAPI Specification allows the description of a remote API accessible through HTTP or HTTP-like protocols.<\/p>\n An API defines the allowed interactions between two pieces of software, just like a user interface defines the ways in which a user can interact with a program. An API is composed of the list of possible methods to call (requests to make), their parameters, return values and any data format they require (among other things). This is equivalent to how a user\u2019s interactions with a mobile phone app are limited to the buttons, sliders and text boxes in the app\u2019s user interface.\u201d Swagger in the Visual Studio scaffold We understand then that Swagger, as we know it in the .NET world, is nothing but a set of specifications defined for all applications that expose web-based APIs: Figure 3.1 \u2013 Visual Studio scaffold<\/p>\n By selecting Enable OpenAPI support, Visual Studio goes to add a NuGet package called Swashbuckle.AspNetCore and automatically configures it in the Program.cs file. We show the few lines that are added with a new project. With these few pieces of information, a web application is enabled only for the development environment, which allows the developer to test the API without generating a client or using tools external to the application: The graphical part generated by Swagger greatly increases productivity and allows the developer to share information with those who will interface with the application, be it a frontend application or a machine application. Note : We remind you that enabling Swagger in a production environment is strongly discouraged because sensitive information could be publicly exposed on the web or on the network where the application resides. We have seen how to introduce Swagger into our API applications; this functionality allows us to document our API, as well as allow users to generate a client to call our application. Let\u2019s see the options we have to quickly interface an application with APIs described with OpenAPI. OpenAPI Generator With Swagger, and especially with the OpenAPI standard, you can automatically generate clients to connect to the web application. Clients can be generated for many languages but also for development tools. We know how tedious and repetitive it is to write clients to access the Web API. Open API Generator helps us automate code generation, inspect the API documentation made by Swagger and OpenAPI, and automatically generate code to interface with the API. Simple, easy, and above all, fast. The @openapitools\/openapi-generator-cli npm package is a very well-known package wrapper for OpenAPI Generator, which you can find at https:\/\/openapi-generator.tech\/<\/a>. With this tool, you can generate clients for programming languages as well as load testing tools such as JMeter and K6. It is not necessary to install the tool on your machine, but if the URL of the application is accessible from the machine, you can use a Docker image, as described by the following command: The command allows you to generate a Go client using the OpenAPI definition found in the petstore.yaml file that is mounted on the Docker volume. Now, let\u2019s go into detail to understand how you can leverage Swagger in .NET 6 projects and with minimal APIs. Swagger in minimal APIs In ASP.NET Web API, as in the following code excerpt, we see a method documented with C# language annotations with the triple slash (\/\/\/). The documentation section is leveraged to add more information to the API description. In addition, the ProducesResponseType annotations help Swagger identify the possible codes that the client must handle as a result of the method call: Swagger, in addition to the annotations on single methods, is also instructed by the documentation of the language to give further information to those who will then have to use the API application. A description of the methods of the parameters is always welcome by those who will have to interface; unfortunately, it is not possible to exploit this functionality in the minimal API. Let\u2019s go in order and see how to start using Swagger on a single method: With this first example, we have configured Swagger and general Swagger information. We have included additional information that enriches Swagger\u2019s UI. The only mandatory information is the title, while the version, contact, description, license, and terms of service are optional. The UseSwaggerUI() method automatically configures where to put the UI and the JSON file describing the API with the OpenAPI format. Here is the result at the graphical level: Figure 3.2 \u2013 The Swagger UI<\/p>\n We can immediately see that the OpenAPI contract information has been placed in the \/swagger\/v1\/swagger.json path. The contact information is populated, but no operations are reported as we haven\u2019t entered any yet. Should the API have versioning? In the top-right section, we can select the available operations for each version. We can customize the Swagger URL and insert the documentation on a new path; the important thing is to redefine SwaggerEndpoint, as follows: Let\u2019s now go on to add the endpoints that describe the business logic. It is very important to define RouteHandlerBuilder because it allows us to describe all the properties of the endpoint that we have written in code. The UI of Swagger must be enriched as much as possible; we must describe at best what the minimal APIs allow us to specify. Unfortunately, not all the functionalities are available, as in ASP.NET Web API. Versioning in minimal APIs Versioning in minimal APIs is not handled in the framework functionality; as a result, even Swagger cannot handle UI-side API versioning. So, we observe that when we go to the Select a definition section shown in Figure 3.2, only one entry for the current version of the API is visible. Swagger features We just realized that not all features are available in Swagger; let\u2019s now explore what is available instead. To describe the possible output values of an endpoint, we can call functions that can be called after the handler, such as the Produces or WithTags functions, which we are now going to explore. The Produces function decorates the endpoint with all the possible responses that the client should be able to manage. We can add the name of the operation ID; this information will not appear in the Swagger screen, but it will be the name with which the client will create the method to call the endpoint. OperationId is the unique name of the operation made available by the handler. To exclude an endpoint from the API description, you need to call ExcludeFromDescription(). This function is rarely used, but it is very useful in cases where you don\u2019t want to expose endpoints to programmers who are developing the frontend because that particular endpoint is used by a machine application. Finally, we can add and tag the various endpoints and segment them for better client management: This is the graphical result of Swagger; as I anticipated earlier, the tags and operation IDs are not shown by the web client: Figure 3.3 \u2013 Swagger UI methods The endpoint description, on the other hand, is very useful to include. It\u2019s very easy to implement: just insert C# comments in the method (just insert three slashes, \/\/\/, in the method). Minimal APIs don\u2019t have methods like we are used to in web-based controllers, so they are not natively supported. Swagger isn\u2019t just the GUI we\u2019re used to seeing. Above all, Swagger is the JSON file that supports the OpenAPI specification, of which the latest version is 3.1.0. In the following snippet, we show the section containing the description of the first endpoint that we inserted in the API. We can infer both the tag and the operation ID; this information will be used by those who will interface with the API: In this section, we have seen how to configure Swagger and what is currently not yet supported. In the following chapters, we will also see how to configure OpenAPI, both for the OpenID Connect standard and authentication via the API key. In the preceding code snippet of the Swagger UI, Swagger makes the schematics of the objects involved available, both inbound to the various endpoints and outbound from them. Figure 3.4 \u2013 Input and output data schema We will learn how to deal with these objects and how to validate and define them in Chapter 6, Exploring Validation and Mapping. Swagger OperationFilter The operation filter allows you to add behavior to all operations shown by Swagger. In the following example, we\u2019ll show you how to add an HTTP header to a particular call, filtering it by OperationId. When you go to define an operation filter, you can also set filters based on routes, tags, and operation IDs: To define an operation filter, the IOperationFilter interface must be implemented. In the constructor, you can define all interfaces or objects that have been previously registered in the dependency inject engine. The filter then consists of a single method, called Apply, which provides two objects: \u2022 OpenApiOperation: An operation where we can add parameters or check the operation ID of the current call Finally, to enable the operation filter in Swagger, we will need to register it inside the SwaggerGen method. In this method, we should then add the filter, as follows: Here is the result at the UI level; in the endpoint and only for a particular operation ID, we would have a new mandatory header with a default parameter that, in development, will not have to be inserted: Figure 3.5 \u2013 API key section This case study helps us a lot when we have an API key that we need to set up and we don\u2019t want to insert it on every single call. Operation filter in production Since Swagger should not be enabled in the production environment, the filter and its default value will not create application security problems. We recommend that you disable Swagger in the production environment. In this section, we figured out how to enable a UI tool that describes the API and allows us to test it. In the next section, we will see how to enable the call between single-page applications (SPAs) and the backend via CORS. Enabling CORS CORS is a security mechanism whereby an HTTP\/S request is blocked if it arrives from a different domain than the one where the application is hosted. More information can be found in the Microsoft documentation or on the Mozilla site for developers. A browser prevents a web page from making requests to a domain other than the domain that serves that web page. A web page, SPA, or server-side web page can make HTTP requests to several backend APIs that are hosted in different origins. This restriction is called the same-origin policy. The same-origin policy prevents a malicious site from reading data from another site. Browsers don\u2019t block HTTP requests but do block response data. We, therefore, understand that the CORS qualification, as it relates to safety, must be evaluated with caution. The most common scenario is that of SPAs that are released on web servers with different web addresses than the web server hosting the minimal API: Figure 3.6 \u2013 SPA and minimal API A similar scenario is that of microservices, which need to talk to each other. Each microservice will reside at a particular web address that will be different from the others. Figure 3.7 \u2013 Microservices and minimal APIs In all these cases, therefore, a CORS problem is encountered. We now understand the cases in which a CORS request can occur. Now let\u2019s see what the correct HTTP request flow is and how the browser handles the request. CORS flow from an HTTP request What happens when a call leaves the browser for a different address other than the one where the frontend is hosted? The HTTP call is executed and it goes all the way to the backend code, which executes correctly. The response, with the correct data inside, is blocked by the browser. That\u2019s why when we execute a call with Postman, Fiddler, or any HTTP client, the response reaches us correctly. Figure 3.8 \u2013 CORS flow In the following figure, we can see that the browser makes the first call with the OPTIONS method, to which the backend responds correctly with a 204 status code: Figure 3.9 \u2013 First request for the CORS call (204 No Content result) In the second call that the browser makes, an error occurs; the strict-origin-when-cross-origin value is shown in Referrer Policy, which indicates the refusal by the browser to accept data from the backend: Figure 3.10 \u2013 Second request for the CORS call (blocked by the browser) When CORS is enabled, in the response to the OPTIONS method call, three headers are inserted with the characteristics that the backend is willing to respect: Figure 3.11 \u2013 Request for CORS call (with CORS enabled) In this case, we can see that three headers are added that define Access-Control-Allow-Headers, Access-Control-Allow-Methods, and Access-Control-Allow-Origin. The browser with this information can accept or block the response to this API. Setting CORS with a policy Many configurations are possible within a .NET 6 application for activating CORS. We can define authorization policies in which the four available settings can be configured. CORS can also be activated by adding extension methods or annotations. But let us proceed in order. The CorsPolicyBuilder class allows us to define what is allowed or not allowed within the CORS acceptance policy. We have, therefore, the possibility to set different methods, for example: \u2022 AllowAnyHeader While the first three methods are descriptive and allow us to enable any settings relating to the header, method, and origin of the HTTP call, respectively, AllowCredentials allows us to include the cookie with the authentication credentials. CORS policy recommendations We recommend that you don\u2019t use the AllowAny methods but instead filter out the necessary information to allow for greater security. As a best practice, when enabling CORS, we recommend the use of these methods: \u2022 WithExposedHeaders To simulate a scenario for CORS, we created a simple frontend application with three different buttons. Each button allows you to test one of the possible configurations of CORS within the minimal API. We will explain these configurations in a few lines. To enable the CORS scenario, we have created a single-page application that can be launched on a web server in memory. We have used LiveReloadServer, a tool that can be installed with the .NET CLI. We talked about it at the start of the chapter and now it\u2019s time to use it. After installing it, you need to launch the SPA with the following command: Here, BasePath is the folder where you are going to download the examples available on GitHub. Then you must start the application backend, either through Visual Studio or Visual Studio Code or through the .NET CLI with the following command: We\u2019ve figured out how to start an example that highlights the CORS problem; now we need to configure the server to accept the request and inform the browser that it is aware that the request is coming from a different source. Next, we will talk about policy configuration. We will understand the characteristics of the default policy as well as how to create a custom one. Configuring a default policy To configure a single CORS enabling policy, you need to define the behavior in the Program.cs file and add the desired configurations. Let\u2019s implement a policy and define it as Default. Then, to enable the policy for the whole application, simply add app.UseCors(); before defining the handlers: Configuring custom policies We can create several policies within an application; each policy may have its own configuration and each policy may be associated with one or more endpoints. In the case of microservices, having several policies helps to precisely segment access from a different source. In order to configure a new policy, it is necessary to add it and give it a name; this name will give access to the policy and allow it to be associated with the endpoint. The customized policy, as in the previous example, is assigned to the entire application: We next look at how to apply a single policy to a specific endpoint; to this end, two methods are available. The first is via an extension method to the IEndpointConventionBuilder interface. The second method is to add the EnableCors annotation followed by the name of the policy to be enabled for that method. Setting CORS with extensions It is necessary to use the RequireCors method followed by the name of the policy. With this method, it is then possible to enable one or more policies for an endpoint: Setting CORS with an annotation The second method is to add the EnableCors annotation followed by the name of the policy to be enabled for that method: Regarding controller programming, it soon becomes apparent that it is not possible to apply a policy to all methods of a particular controller. It is also not possible to group controllers and enable the policy. It is therefore necessary to apply the individual policy to the method or the entire application. In this section, we found out how to configure browser protection for applications hosted on different domains. In the next section, we will start configuring our applications. Working with global API settings We have just defined how you can load data with the options pattern within an ASP.NET application. In this section, we want to describe how you can configure an application and take advantage of everything we saw in the previous section. With the birth of .NET Core, the standard has moved from the Web.config file to the appsettings.json file. The configurations can also be read from other sources, such as other file formats like the old .ini file or a positional file. In minimal APIs, the options pattern feature remains unchanged, but in the next few paragraphs, we will see how to reuse the interfaces or the appsettings.json file structure. Configuration in .NET 6 The object provided from .NET is IConfiguration, which allows us to read some specific configurations inside the appsettings file. But, as described earlier, this interface does much more than just access a file for reading. The following extract from the official documentation helps us understand how the interface is the generic access point that allows us to access the data inserted in various services: Configuration in ASP.NET Core is performed using one or more configuration providers. Configuration providers read configuration data from key-value pairs using a variety of configuration sources. The following is a list of configuration sources: \u2022 Settings files, such as appsettings.json (https:\/\/docs.microsoft.com\/aspnet\/core\/fundamentals\/configuration\/<\/a>)<\/p>\n The IConfiguration and IOptions interfaces, which we will see in the next chapter, are designed to read data from the various providers. These interfaces are not suitable for reading and editing the configuration file while the program is running. The IConfiguration interface is available through the builder object, builder.Configuration, which provides all the methods needed to read a value, an object, or a connection string. After looking at one of the most important interfaces that we will use to configure the application, we want to define good development practices and use a fundamental building block for any developer: namely, classes. Copying the configuration into a class will allow us to better enjoy the content anywhere in the code. We define classes containing a property and classes corresponding appsettings file: Configuration classes<\/p>\n And here, we bring back the corresponding JSON of the C# class that we just saw: appsettings.json definition Next, we will be performing several operations. The first operation we perform creates an instance of the startupConfig object that will be of the MyCustomStartupObject type. To populate the instance of this object, through IConfiguration, we are going to read the data from the section called MyCustomStartupObject: The newly created object can then be used in the various handlers of the minimal APIs. Instead, in this second operation, we use the dependency injection engine to request the instance of the IConfiguration object: With the IConfiguration object, we will retrieve the data similarly to the operation just described. We select the GetSection(nameof(MyCustomObject)) section and type the object with the Finally, in these last two examples, we read a single key, present at the root level of the appsettings file: The In the next line, we can see how you can leverage an IConfiguration method to read ConnectionString. In the appsettings file, connection strings are placed in a specific section, ConnectionStrings, that allows you to name the string and read it. Multiple connection strings can be placed in this section to exploit it in different objects. In the configuration provider for Azure App Service, connection strings should be entered with a prefix that also indicates the SQL provider you are trying to use, as described in the following link: https:\/\/docs.microsoft.com\/azure\/app-service\/configure-common#configure-connection-strings<\/a>. At runtime, connection strings are available as environment variables, prefixed with the following connection types: \u2022 SQLServer: SQLCONNSTR For completeness, we will bring back the entire code just described in order to have a better general picture of how to exploit the IConfiguration object inside the code: We\u2019ve seen how to take advantage of the appsettings file with connection strings, but very often, we have many different files for each environment. Let\u2019s see how to take advantage of one file for each environment. Priority in appsettings files The appsettings file can be managed according to the environments in which the application is located. In this case, the practice is to place key information for that environment in the appsettings.{ENVIRONMENT}.json file. The root file (that is, appsettings.json) should be used for the production environment only. For example, if we created these examples in the two files for the \u201cPriority\u201d key, what would we get? appsettings.json<\/p>\n appsettings.Development.json<\/p>\n If it is a Development environment, the value of the key would result in Dev, while in a Production environment, the value would result in Root. What would happen if the environment was anything other than Production or Development? For example, if it were called Stage? In this case, having not specified any appsettings.Stage.json file, the read value would be that of one of the appsettings.json files and therefore, Root. However, if we specified the appsettings.Stage.json file, the value would be read from the that file. Next, let\u2019s visit the Options pattern. There are objects that the framework provides to load configuration information upon startup or when changes are made by the systems department. Let\u2019s go over how. Options pattern The options pattern uses classes to provide strongly typed access to groups of related settings, that is, when configuration settings are isolated by scenario into separate classes. The options pattern will be implemented with different interfaces and different functionalities. Each interface (see the following subsection) has its own features that help us achieve certain goals. But let\u2019s start in order. We define an object for each type of interface (we will do it to better represent the examples), but the same class can be used to register more options inside the configuration file. It is important to keep the structure of the file identical: Each option is registered in the dependency injection engine via the Configure method, which also requires the registration of the T type present in the method signature. As you can see, in the registration phase, we declared the types and the section of the file where to retrieve the information, and nothing more: We have not yet defined how the object should be read, how often, and with what type of interface. The only thing that changes is the parameter, as seen in the last two examples of the preceding code snippet. This parameter allows you to add a name to the option type. The name is required to match the type used in the method signature. This feature is called named options. Different option interfaces Different interfaces can take advantage of the recordings you just defined. Some support named options and some do not: \u2022 \u2022 We want to point you to the use of The Configure method can also be followed by another method in the configuration pipeline. This method is called PostConfigure and is intended to modify the configuration each time it is configured or reread. Here is an example of how to record this behavior: Putting it all together Having defined the theory of these numerous interfaces, it remains for us to see IOptions at work with a concrete example. Let\u2019s see the use of the three interfaces just described and the use of IOptionsFactory, which, along with the Create method and with the named options function, retrieves the correct instance of the object: In the previous code snippet, we want to bring attention to the use of the different interfaces available. Each individual interface used in the previous snippet has a particular life cycle that characterizes its behavior. Finally, each interface has slight differences in the methods, as we have already described in the previous paragraphs. IOptions and validation Last but not least is the validation functionality of the data present in the configuration. This is very useful when the team that has to release the application still performs manual or delicate operations that need to be at least verified by the code. Before the advent of .NET Core, very often, the application would not start because of an incorrect configuration. Now, with this feature, we can validate the data in the configuration and throw errors. Here is an example: Register option with validation This is the configuration file where an error is explicitly reported: Appsettings section for configuration validation And here is the class containing the validation logic: The application then encounters errors while using the particular configuration and not at startup. This is also because, as we have seen before, IOptions could reload information following a change in appsettings:
\n\u6211\u4eec\u8fd8\u5728 https:\/\/github.com\/PacktPublishing\/<\/a> \u4e0a\u63d0\u4f9b\u4e86\u4e30\u5bcc\u7684\u4e66\u7c4d\u548c\u89c6\u9891\u76ee\u5f55\u4e2d\u7684\u5176\u4ed6\u4ee3\u7801\u5305\u3002\u770b\u770b\u4ed6\u4eec\u5427\uff01<\/p>\n
\n\u4e0b\u8f7d\u5f69\u8272\u56fe\u50cf<\/p>\n
\n\u6211\u4eec\u8fd8\u63d0\u4f9b\u4e86\u4e00\u4e2a PDF \u6587\u4ef6\uff0c\u5176\u4e2d\u5305\u542b\u672c\u4e66\u4e2d\u4f7f\u7528\u7684\u5c4f\u5e55\u622a\u56fe\u548c\u56fe\u8868\u7684\u5f69\u8272\u56fe\u50cf\u3002\u60a8\u53ef\u4ee5\u5728\u6b64\u5904\u4e0b\u8f7d\uff1ahttps:\/\/packt.link\/GmUNL<\/a><\/p>\n
\n\u4f7f\u7528\u7684\u7ea6\u5b9a<\/p>\n
\n\u672c\u4e66\u4e2d\u4f7f\u7528\u4e86\u8bb8\u591a\u6587\u672c\u7ea6\u5b9a\u3002<\/p>\n
\n\u6587\u672c\u4e2d\u7684\u4ee3\u7801\uff1a\u6307\u793a\u6587\u672c\u4e2d\u7684\u4ee3\u7801\u8bcd\u3001\u6570\u636e\u5e93\u8868\u540d\u79f0\u3001\u6587\u4ef6\u5939\u540d\u79f0\u3001\u6587\u4ef6\u540d\u3001\u6587\u4ef6\u6269\u5c55\u540d\u3001\u8def\u5f84\u540d\u3001\u865a\u62df URL\u3001\u7528\u6237\u8f93\u5165\u548c Twitter \u53e5\u67c4\u3002\u4e0b\u9762\u662f\u4e00\u4e2a\u793a\u4f8b\uff1a\u201c\u5728\u6700\u5c0f\u7684 API \u4e2d\uff0c\u6211\u4eec\u4f7f\u7528 WebApplication \u5bf9\u8c61\u7684 Map<\/em> \u65b9\u6cd5\u5b9a\u4e49\u8def\u7531\u6a21\u5f0f\u3002<\/p>\n
\n\u4ee3\u7801\u5757\u8bbe\u7f6e\u5982\u4e0b\uff1a<\/p>\napp.MapGet("\/hello-get", () => "[GET] Hello World!"); \napp.MapPost("\/hello-post", () => "[POST] Hello World!"); \napp.MapPut("\/hello-put", () => "[PUT] Hello World!"); \napp.MapDelete("\/hello-delete", () => "[DELETE] Hello World!");<\/code><\/pre>\n
\n\u5f53\u6211\u4eec\u5e0c\u671b\u60a8\u6ce8\u610f\u5230\u4ee3\u7801\u5757\u7684\u7279\u5b9a\u90e8\u5206\u65f6\uff0c\u76f8\u5173\u884c\u6216\u9879\u76ee\u4ee5\u7c97\u4f53\u8bbe\u7f6e\uff1a<\/p>\nif (app.Environment.IsDevelopment()) \n{\n app.UseSwagger(); \n app.UseSwaggerUI(); \n}<\/code><\/pre>\n
\n\u4efb\u4f55\u547d\u4ee4\u884c\u8f93\u5165\u6216\u8f93\u51fa\u7684\u7f16\u5199\u65b9\u5f0f\u5982\u4e0b\uff1a<\/p>\ndotnet new webapi -minimal -o Chapter01<\/code><\/pre>\n
\n\u7c97\u4f53\uff1a\u8868\u793a\u65b0\u8bcd\u3001\u91cd\u8981\u5b57\u8bcd\u6216\u60a8\u5728\u5c4f\u5e55\u4e0a\u770b\u5230\u7684\u5b57\u8bcd\u3002\u4f8b\u5982\uff0c\u83dc\u5355\u6216\u5bf9\u8bdd\u6846\u4e2d\u7684\u5355\u8bcd\u4ee5\u7c97\u4f53\u663e\u793a\u3002\u8fd9\u662f\u4e00\u4e2a\u4f8b\u5b50\uff1a\u201c\u6253\u5f00 Visual Studio 2022\uff0c\u7136\u540e\u5728\u4e3b\u5c4f\u5e55\u4e0a\u5355\u51fb\u521b\u5efa\u65b0\u9879\u76ee\u3002<\/p>\nTips or important notes\n\u63d0\u793a\u6216\u91cd\u8981\u8bf4\u660e\nAppear like this.\n\u5982\u4e0b\u6240\u793a\u3002<\/code><\/pre>\n
\n\u8054\u7cfb\u6211\u4eec<\/p>\n
\n\u6211\u4eec\u59cb\u7ec8\u6b22\u8fce\u8bfb\u8005\u7684\u53cd\u9988\u3002<\/p>\n
\n\u4e00\u822c\u53cd\u9988\uff1a\u5982\u679c\u60a8\u5bf9\u672c\u4e66\u7684\u4efb\u4f55\u65b9\u9762\u6709\u4efb\u4f55\u7591\u95ee\uff0c\u8bf7\u53d1\u9001\u7535\u5b50\u90ae\u4ef6\u81f3 customercare@packtpub.com \u5e76\u5728\u90ae\u4ef6\u4e3b\u9898\u4e2d\u63d0\u53ca\u4e66\u540d\u3002<\/p>\n
\n\u52d8\u8bef\u8868\uff1a \u5c3d\u7ba1\u6211\u4eec\u5df2\u5c3d\u4e00\u5207\u52aa\u529b\u786e\u4fdd\u5185\u5bb9\u7684\u51c6\u786e\u6027\uff0c\u4f46\u9519\u8bef\u8fd8\u662f\u4f1a\u53d1\u751f\u3002\u5982\u679c\u60a8\u53d1\u73b0\u672c\u4e66\u4e2d\u6709\u9519\u8bef\uff0c\u5982\u679c\u60a8\u80fd\u5411\u6211\u4eec\u62a5\u544a\uff0c\u6211\u4eec\u5c06\u4e0d\u80dc\u611f\u6fc0\u3002\u8bf7\u8bbf\u95ee www.packtpub.com\/support\/errata \u5e76\u586b\u5199\u8868\u683c\u3002<\/p>\n
\n\u76d7\u7248\uff1a\u5982\u679c\u60a8\u5728\u4e92\u8054\u7f51\u4e0a\u53d1\u73b0\u4efb\u4f55\u5f62\u5f0f\u7684\u975e\u6cd5\u590d\u5236\u6211\u4eec\u7684\u4f5c\u54c1\uff0c\u5982\u679c\u60a8\u80fd\u5411\u6211\u4eec\u63d0\u4f9b\u4f4d\u7f6e\u5730\u5740\u6216\u7f51\u7ad9\u540d\u79f0\uff0c\u6211\u4eec\u5c06\u4e0d\u80dc\u611f\u6fc0\u3002\u8bf7\u901a\u8fc7 copyright@packt.com \u4e0e\u6211\u4eec\u8054\u7cfb\uff0c\u5e76\u63d0\u4f9b\u6750\u6599\u94fe\u63a5\u3002<\/p>\n
\n\u5982\u679c\u60a8\u6709\u5174\u8da3\u6210\u4e3a\u4f5c\u8005\uff1a\u5982\u679c\u60a8\u64c5\u957f\u67d0\u4e2a\u4e3b\u9898\uff0c\u5e76\u4e14\u60a8\u5bf9\u5199\u4f5c\u6216\u4e3a\u4e00\u672c\u4e66\u505a\u51fa\u8d21\u732e\u611f\u5174\u8da3\uff0c\u8bf7\u8bbf\u95ee authors.packtpub.com\u3002<\/p>\n
\n\u5206\u4eab\u60a8\u7684\u60f3\u6cd5<\/p>\n
\n\u9605\u8bfb\u4e86\u638c\u63e1 ASP.NET Core \u4e2d\u7684\u6700\u5c0f API \u540e\uff0c\u6211\u4eec\u5f88\u60f3\u542c\u542c\u4f60\u7684\u60f3\u6cd5\uff01\u8bf7\u5355\u51fb\u6b64\u5904\u76f4\u63a5\u8fdb\u5165\u672c\u4e66\u7684\u4e9a\u9a6c\u900a\u8bc4\u8bba\u9875\u9762\u5e76\u5206\u4eab\u60a8\u7684\u53cd\u9988\u3002<\/p>\n
\n\u60a8\u7684\u8bc4\u8bba\u5bf9\u6211\u4eec\u548c\u6280\u672f\u793e\u533a\u90fd\u5f88\u91cd\u8981\uff0c\u8fd9\u5c06\u6709\u52a9\u4e8e\u6211\u4eec\u786e\u4fdd\u6211\u4eec\u63d0\u4f9b\u5353\u8d8a\u7684\u5185\u5bb9\u8d28\u91cf\u3002<\/p>\nPart 1: Introduction<\/h1>\n
\n\u5728\u672c\u4e66\u7684\u7b2c\u4e00\u90e8\u5206\uff0c\u6211\u4eec\u60f3\u5411\u60a8\u4ecb\u7ecd\u8fd9\u672c\u4e66\u7684\u80cc\u666f\u3002\u6211\u4eec\u5c06\u89e3\u91ca\u6700\u5c0f API \u7684\u57fa\u7840\u77e5\u8bc6\u53ca\u5176\u5de5\u4f5c\u539f\u7406\u3002\u6211\u4eec\u5e0c\u671b\u4e00\u7816\u4e00\u74e6\u5730\u6dfb\u52a0\u6240\u9700\u7684\u77e5\u8bc6\uff0c\u4ee5\u5229\u7528\u6700\u5c0f API \u53ef\u4ee5\u8d4b\u4e88\u6211\u4eec\u7684\u6240\u6709\u529f\u80fd\u3002<\/p>\n
\n\u6211\u4eec\u5c06\u5728\u8fd9\u90e8\u5206\u4ecb\u7ecd\u4ee5\u4e0b\u7ae0\u8282\uff1a<\/p>\n
\n\u7b2c 1 \u7ae0 \u6700\u5c0f API \u7b80\u4ecb<\/p>\n
\n\u7b2c 2 \u7ae0 \u63a2\u7d22\u6700\u5c0f API \u53ca\u5176\u4f18\u70b9<\/p>\n
\n\u7b2c 3 \u7ae0 \u4f7f\u7528\u6700\u5c11\u7684 API<\/p>\n1 Introduction to Minimal APIs<\/h1>\n
\n\u5728\u672c\u4e66\u7684\u8fd9\u4e00\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u4ecb\u7ecd\u4e00\u4e9b\u4e0e .NET 6.0 \u4e2d\u7684\u6700\u5c0f API \u76f8\u5173\u7684\u57fa\u672c\u4e3b\u9898\uff0c\u5c55\u793a\u5982\u4f55\u4e3a .NET 6 \u8bbe\u7f6e\u5f00\u53d1\u73af\u5883\uff0c\u66f4\u5177\u4f53\u5730\u8bf4\uff0c\u5982\u4f55\u4e3a ASP.NET Core \u5f00\u53d1\u6700\u5c0f API\u3002<\/p>\n
\n\u9996\u5148\uff0c\u6211\u4eec\u5c06\u4ece\u6700\u5c0f API \u7684\u7b80\u8981\u5386\u53f2\u5f00\u59cb\u3002\u7136\u540e\uff0c\u6211\u4eec\u5c06\u4f7f\u7528 Visual Studio 2022 \u548c Visual Code Studio \u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u6700\u5c0f API \u9879\u76ee\u3002\u6700\u540e\uff0c\u6211\u4eec\u5c06\u770b\u770b\u6211\u4eec\u9879\u76ee\u7684\u7ed3\u6784\u3002<\/p>\n
\n\u5728\u672c\u7ae0\u7ed3\u675f\u65f6\uff0c\u60a8\u5c06\u80fd\u591f\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u6700\u5c0f API \u9879\u76ee\uff0c\u5e76\u5f00\u59cb\u4e3a REST API \u4f7f\u7528\u8fd9\u4e2a\u65b0\u6a21\u677f\u3002<\/p>\n
\n\u5728\u672c\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u4ecb\u7ecd\u4ee5\u4e0b\u4e3b\u9898\uff1a<\/p>\n
\n\u2022 Creating a new minimal API project
\n\u2022 Looking at the structure of the project<\/p>\n
\n\u6280\u672f\u8981\u6c42<\/p>\n
\n\u8981\u4f7f\u7528 ASP.NET Core 6 \u6700\u5c0f API\uff0c\u60a8\u9700\u8981\u9996\u5148\u5728\u5f00\u53d1\u73af\u5883\u4e2d\u5b89\u88c5 .NET 6\u3002<\/p>\n
\n\u5982\u679c\u60a8\u8fd8\u6ca1\u6709\u5b89\u88c5\u5b83\uff0c\u6211\u4eec\u73b0\u5728\u5c31\u5b89\u88c5\u5b83\uff1a<\/p>\n\n
\n\u5bfc\u822a\u5230\u4ee5\u4e0b\u94fe\u63a5\uff1ahttps:\/\/dotnet.microsoft.com<\/a>\u3002<\/p>\n<\/li>\n
\n\u70b9\u51fb \u4e0b\u8f7d \u6309\u94ae\u3002<\/p>\n<\/li>\n
\n\u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u6d4f\u89c8\u5668\u4f1a\u4e3a\u60a8\u9009\u62e9\u5408\u9002\u7684\u4f5c\u7cfb\u7edf\uff0c\u5982\u679c\u6ca1\u6709\uff0c\u8bf7\u5728\u9875\u9762\u9876\u90e8\u9009\u62e9\u60a8\u7684\u4f5c\u7cfb\u7edf\u3002<\/p>\n<\/li>\n
\n\u4e0b\u8f7d .NET 6.0 SDK \u7684 LTS \u7248\u672c\u3002<\/p>\n<\/li>\n
\n\u542f\u52a8\u5b89\u88c5\u7a0b\u5e8f\u3002<\/p>\n<\/li>\n
\n\u91cd\u65b0\u542f\u52a8\u8ba1\u7b97\u673a\uff08\u8fd9\u4e0d\u662f\u5f3a\u5236\u6027\u7684\uff09\u3002<\/p>\n<\/li>\n<\/ol>\n
\n\u60a8\u53ef\u4ee5\u5728\u7ec8\u7aef\u4e2d\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u67e5\u770b\u5f00\u53d1\u8ba1\u7b97\u673a\u4e0a\u5b89\u88c5\u4e86\u54ea\u4e9b SDK\uff1a<\/p>\ndotnet \u2013list-sdks<\/code><\/pre>\n
\n\u5728\u5f00\u59cb\u7f16\u7801\u4e4b\u524d\uff0c\u60a8\u9700\u8981\u4e00\u4e2a\u4ee3\u7801\u7f16\u8f91\u5668\u6216\u96c6\u6210\u5f00\u53d1\u73af\u5883 \uff08IDE\uff09\u3002\u60a8\u53ef\u4ee5\u4ece\u4ee5\u4e0b\u5217\u8868\u4e2d\u9009\u62e9\u60a8\u6700\u559c\u6b22\u7684\uff1a<\/p>\n
\n\u2022 Visual Studio 2022
\n\u2022 Visual Studio 2022 for Mac<\/p>\n
\n\u5728\u8fc7\u53bb\u7684\u51e0\u5e74\u91cc\uff0cVisual Studio Code \u4e0d\u4ec5\u5728\u5f00\u53d1\u4eba\u5458\u793e\u533a\u4e2d\u975e\u5e38\u6d41\u884c\uff0c\u800c\u4e14\u5728 Microsoft \u793e\u533a\u4e2d\u4e5f\u975e\u5e38\u6d41\u884c\u3002\u5373\u4f7f\u60a8\u5c06 Visual Studio 2022 \u7528\u4e8e\u65e5\u5e38\u5de5\u4f5c\uff0c\u6211\u4eec\u4e5f\u5efa\u8bae\u60a8\u4e0b\u8f7d\u5e76\u5b89\u88c5 Visual Studio Code \u5e76\u8bd5\u4e00\u8bd5\u3002<\/p>\n
\n\u8ba9\u6211\u4eec\u4e0b\u8f7d\u5e76\u5b89\u88c5 Visual Studio Code \u548c\u4e00\u4e9b\u6269\u5c55\uff1a<\/p>\n\n
\n\u5bfc\u822a\u5230 https:\/\/code.visualstudio.com<\/a>\u3002<\/p>\n<\/li>\n
\n\u4e0b\u8f7d Stable \u6216 Insiders \u7248\u672c\u3002<\/p>\n<\/li>\n
\n\u542f\u52a8\u5b89\u88c5\u7a0b\u5e8f\u3002<\/p>\n<\/li>\n
\n\u542f\u52a8 Visual Studio Code\u3002<\/p>\n<\/li>\n
\n\u5355\u51fb Extensions \u56fe\u6807\u3002<\/p>\n<\/li>\n<\/ol>\n
\n\u60a8\u5c06\u5728\u5217\u8868\u9876\u90e8\u770b\u5230 C# \u6269\u5c55\u3002<\/p>\n\n
\n\u70b9\u51fb Install \u5b89\u88c5 \u6309\u94ae\u5e76\u7b49\u5f85\u3002<\/li>\n<\/ol>\n
\n\u60a8\u53ef\u4ee5\u5b89\u88c5\u5176\u4ed6\u63a8\u8350\u7684\u6269\u5c55\uff0c\u4ee5\u4fbf\u4f7f\u7528 C# \u548c ASP.NET Core \u8fdb\u884c\u5f00\u53d1\u3002\u5982\u679c\u60a8\u60f3\u5b89\u88c5\u5b83\u4eec\uff0c\u60a8\u53ef\u4ee5\u5728\u4e0b\u8868\u4e2d\u770b\u5230\u6211\u4eec\u7684\u5efa\u8bae\uff1a<\/p>\n
\n\u6b64\u5916\uff0c\u5982\u679c\u60a8\u60f3\u7ee7\u7eed\u4f7f\u7528 .NET \u5f00\u53d1\u4eba\u5458\u4f7f\u7528\u6700\u5e7f\u6cdb\u7684 IDE\uff0c\u60a8\u53ef\u4ee5\u4e0b\u8f7d\u5e76\u5b89\u88c5 Visual Studio 2022\u3002<\/p>\n
\n\u5982\u679c\u60a8\u6ca1\u6709\u8bb8\u53ef\u8bc1\uff0c\u8bf7\u68c0\u67e5\u662f\u5426\u53ef\u4ee5\u4f7f\u7528 Community Edition\u3002\u83b7\u5f97\u8bb8\u53ef\u8bc1\u6709\u4e00\u4e9b\u9650\u5236\uff0c\u4f46\u5982\u679c\u60a8\u662f\u5b66\u751f\u3001\u62e5\u6709\u5f00\u6e90\u9879\u76ee\u6216\u60f3\u4ee5\u4e2a\u4eba\u8eab\u4efd\u4f7f\u7528\u5b83\uff0c\u5219\u53ef\u4ee5\u4f7f\u7528\u5b83\u3002\u4ee5\u4e0b\u662f\u4e0b\u8f7d\u548c\u5b89\u88c5 Visual Studio 2022 \u7684\u65b9\u6cd5\uff1a<\/p>\n\n
\n\u5bfc\u822a\u5230 https:\/\/visualstudio.microsoft.com\/downloads\/<\/a>\u3002<\/p>\n<\/li>\n
\n\u9009\u62e9 Visual Studio 2022 \u7248\u672c 17.0 \u6216\u66f4\u9ad8\u7248\u672c\u5e76\u4e0b\u8f7d\u5b83\u3002<\/p>\n<\/li>\n
\n\u542f\u52a8\u5b89\u88c5\u7a0b\u5e8f\u3002<\/p>\n<\/li>\n
\n\u5728 Workloads \uff08\u5de5\u4f5c\u8d1f\u8f7d\uff09 \u9009\u9879\u5361\u4e0a\uff0c\u9009\u62e9\u4ee5\u4e0b\u9009\u9879\uff1a<\/p>\n<\/li>\n<\/ol>\n
\n\u2022 Azure Development<\/p>\n\n
\n\u5728 Individual Components \u9009\u9879\u5361\u4e0a\uff0c\u9009\u62e9\u4ee5\u4e0b\u9009\u9879\uff1a<\/li>\n<\/ol>\n
\n\u672c\u7ae0\u4e2d\u7684\u6240\u6709\u4ee3\u7801\u793a\u4f8b\u90fd\u53ef\u4ee5\u5728\u672c\u4e66\u7684 GitHub \u5b58\u50a8\u5e93\u4e2d\u627e\u5230\uff0c\u7f51\u5740\u4e3a https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\/tree\/main\/Chapter01<\/a>\u3002<\/p>\n
\n\u73b0\u5728\uff0c\u60a8\u6709\u4e00\u4e2a\u73af\u5883\uff0c\u53ef\u4ee5\u5728\u5176\u4e2d\u9075\u5faa\u548c\u5c1d\u8bd5\u672c\u4e66\u4e2d\u4f7f\u7528\u7684\u4ee3\u7801\u3002<\/p>\n
\nMicrosoft Web API \u7b80\u53f2<\/p>\n
\n\u51e0\u5e74\u524d\u7684 2007 \u5e74\uff0c\u968f\u7740 ASP.NET MVC \u7684\u63a8\u51fa\uff0c.NET Web \u5e94\u7528\u7a0b\u5e8f\u7ecf\u5386\u4e86\u4e00\u573a\u6f14\u53d8\u3002\u4ece\u90a3\u65f6\u8d77\uff0c.NET \u5c31\u4e3a\u5176\u4ed6\u8bed\u8a00\u4e2d\u5e38\u89c1\u7684 Model-View-Controller \u6a21\u5f0f\u63d0\u4f9b\u4e86\u672c\u673a\u652f\u6301\u3002<\/p>\n
\n\u4e94\u5e74\u540e\uff0c\u5373 2012 \u5e74\uff0cRESTful API \u6210\u4e3a Internet \u4e0a\u7684\u65b0\u8d8b\u52bf\uff0c.NET \u4ee5\u4e00\u79cd\u79f0\u4e3a ASP.NET Web API \u7684 API \u5f00\u53d1\u65b0\u65b9\u6cd5\u5bf9\u6b64\u505a\u51fa\u4e86\u56de\u5e94\u3002\u4e0e Windows Communication Foundation \uff08WCF\uff09 \u76f8\u6bd4\uff0c\u8fd9\u662f\u4e00\u4e2a\u91cd\u5927\u6539\u8fdb\uff0c\u56e0\u4e3a\u5b83\u66f4\u5bb9\u6613\u5f00\u53d1 Web \u670d\u52a1\u3002\u540e\u6765\uff0c\u5728 ASP.NET Core \u4e2d\uff0c\u8fd9\u4e9b\u6846\u67b6\u7edf\u4e00\u4e3a ASP.NET Core MVC\uff1a\u4e00\u4e2a\u7528\u4e8e\u5f00\u53d1 Web \u5e94\u7528\u7a0b\u5e8f\u548c API \u7684\u5355\u4e00\u6846\u67b6\u3002<\/p>\n
\n\u5728 ASP.NET Core MVC \u5e94\u7528\u7a0b\u5e8f\u4e2d\uff0c\u63a7\u5236\u5668\u8d1f\u8d23\u63a5\u53d7\u8f93\u5165\u3001\u7f16\u6392\u4f5c\uff0c\u5e76\u5728\u6700\u540e\u8fd4\u56de\u54cd\u5e94\u3002\u5f00\u53d1\u4eba\u5458\u53ef\u4ee5\u4f7f\u7528\u8fc7\u6ee4\u5668\u3001\u7ed1\u5b9a\u3001\u9a8c\u8bc1\u7b49\u6765\u6269\u5c55\u6574\u4e2a\u7ba1\u9053\u3002\u5b83\u662f\u4e00\u4e2a\u529f\u80fd\u9f50\u5168\u7684\u6846\u67b6\uff0c\u7528\u4e8e\u6784\u5efa\u73b0\u4ee3 Web \u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u4f46\u5728\u73b0\u5b9e\u4e16\u754c\u4e2d\uff0c\u4e5f\u6709\u4e00\u4e9b\u573a\u666f\u548c\u7528\u4f8b\u4e0d\u9700\u8981 MVC \u6846\u67b6\u7684\u6240\u6709\u529f\u80fd\uff0c\u6216\u8005\u5fc5\u987b\u8003\u8651\u6027\u80fd\u7ea6\u675f\u3002ASP.NET Core \u5b9e\u73b0\u4e86\u8bb8\u591a\u4e2d\u95f4\u4ef6\uff0c\u4f60\u53ef\u4ee5\u968f\u610f\u4ece\u5e94\u7528\u7a0b\u5e8f\u4e2d\u5220\u9664\u6216\u6dfb\u52a0\u5230\u5e94\u7528\u7a0b\u5e8f\u4e2d\uff0c\u4f46\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6709\u8bb8\u591a\u5e38\u89c1\u529f\u80fd\u9700\u8981\u4f60\u81ea\u5df1\u5b9e\u73b0\u3002<\/p>\n
\n\u6700\u540e\uff0cASP.NET Core 6.0 \u7528\u6700\u5c11\u7684 API \u586b\u8865\u4e86\u8fd9\u4e9b\u7a7a\u767d\u3002<\/p>\n
\n\u73b0\u5728\u6211\u4eec\u5df2\u7ecf\u7b80\u8981\u4ecb\u7ecd\u4e86\u6700\u5c0f API \u7684\u5386\u53f2\uff0c\u6211\u4eec\u5c06\u5728\u4e0b\u4e00\u8282\u4e2d\u5f00\u59cb\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u6700\u5c0f API \u9879\u76ee\u3002<\/p>\n
\n\u521b\u5efa\u65b0\u7684\u6700\u5c0f API \u9879\u76ee<\/p>\n
\n\u8ba9\u6211\u4eec\u4ece\u7b2c\u4e00\u4e2a\u9879\u76ee\u5f00\u59cb\uff0c\u5c1d\u8bd5\u5728\u7f16\u5199 RESTful API \u65f6\u5206\u6790\u6700\u5c0f API \u65b9\u6cd5\u7684\u65b0\u6a21\u677f\u3002<\/p>\n
\n\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5c06\u521b\u5efa\u6211\u4eec\u7684\u7b2c\u4e00\u4e2a\u6700\u5c0f API \u9879\u76ee\u3002\u6211\u4eec\u5c06\u4ece\u4f7f\u7528 Visual Studio 2022 \u5f00\u59cb\uff0c\u7136\u540e\u6211\u4eec\u5c06\u5c55\u793a\u5982\u4f55\u4f7f\u7528 Visual Studio Code \u548c .NET CLI \u521b\u5efa\u9879\u76ee\u3002<\/p>\n
\n\u4f7f\u7528 Visual Studio 2022 \u521b\u5efa\u9879\u76ee<\/p>\n
\n\u6309\u7167\u4ee5\u4e0b\u6b65\u9aa4\u5728 Visual Studio 2022 \u4e2d\u521b\u5efa\u65b0\u9879\u76ee\uff1a<\/p>\n\n
\n\u6253\u5f00 Visual Studio 2022 \u5e76\u5728\u4e3b\u5c4f\u5e55\u4e0a\u5355\u51fb Create a new project\uff1a<\/li>\n<\/ol>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0101.jpg\")
<\/p>\n
\n\u56fe 1.1 \u2013 Visual Studio 2022 \u521d\u59cb\u5c4f\u5e55<\/p>\n\n
\n\u5728\u4e0b\u4e00\u4e2a\u5c4f\u5e55\u4e0a\uff0c\u5728\u7a97\u53e3\u9876\u90e8\u7684\u6587\u672c\u6846\u4e2d\u7f16\u5199 API\uff0c\u7136\u540e\u9009\u62e9\u540d\u4e3a ASP.NET Core Web API \u7684\u6a21\u677f\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0102.jpg\")
<\/p>\n
\n\u56fe 1.2 \u2013 Create a new project \u5c4f\u5e55<\/p>\n<\/li>\n
\n\u63a5\u4e0b\u6765\uff0c\u5728 Configure your new project \u5c4f\u5e55\u4e0a\uff0c\u63d2\u5165\u65b0\u9879\u76ee\u7684\u540d\u79f0\uff0c\u7136\u540e\u9009\u62e9\u65b0\u89e3\u51b3\u65b9\u6848\u7684\u6839\u6587\u4ef6\u5939\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0103.jpg\")
<\/p>\n
\n\u56fe 1.3 \u2013 \u914d\u7f6e\u60a8\u7684\u65b0\u9879\u76ee\u5c4f\u5e55<\/p>\n<\/li>\n<\/ol>\n
\n\u5728\u6b64\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u5c06\u4f7f\u7528\u540d\u79f0 Chapter01\uff0c\u4f46\u60a8\u53ef\u4ee5\u9009\u62e9\u4efb\u4f55\u5438\u5f15\u60a8\u7684\u540d\u79f0\u3002<\/p>\n\n
\n\u5728\u4e0b\u9762\u7684 Additional information \u5c4f\u5e55\u4e0a\uff0c\u786e\u4fdd\u4ece Framework \u4e0b\u62c9\u5217\u8868\u4e2d\u9009\u62e9 .NET 6.0 \uff08Long-term-support\uff09\u3002\u6700\u91cd\u8981\u7684\u662f\uff0c\u53d6\u6d88\u9009\u4e2d Use controllers \uff08\u53d6\u6d88\u9009\u4e2d\u4ee5\u4f7f\u7528\u6700\u5c11\u7684 API\uff09 \u9009\u9879\u3002<\/li>\n<\/ol>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0104.jpg\")
<\/p>\n\n
\n\u5355\u51fb Create\uff08\u521b\u5efa\uff09\uff0c\u51e0\u79d2\u949f\u540e\uff0c\u60a8\u5c06\u770b\u5230\u65b0\u7684\u6700\u5c0f API \u9879\u76ee\u7684\u4ee3\u7801\u3002<\/li>\n<\/ol>\n
\n\u73b0\u5728\uff0c\u6211\u4eec\u5c06\u5c55\u793a\u5982\u4f55\u4f7f\u7528 Visual Studio Code \u548c .NET CLI \u521b\u5efa\u76f8\u540c\u7684\u9879\u76ee\u3002<\/p>\n
\n\u4f7f\u7528 Visual Studio Code \u521b\u5efa\u9879\u76ee<\/p>\n
\n\u4f7f\u7528 Visual Studio Code \u521b\u5efa\u9879\u76ee\u6bd4\u4f7f\u7528 Visual Studio 2022 \u66f4\u5bb9\u6613\u3001\u66f4\u5feb\u6377\uff0c\u56e0\u4e3a\u60a8\u4e0d\u5fc5\u4f7f\u7528 UI \u6216\u5411\u5bfc\uff0c\u800c\u53ea\u9700\u4f7f\u7528\u7ec8\u7aef\u548c .NET CLI\u3002<\/p>\n
\n\u60a8\u65e0\u9700\u4e3a\u6b64\u5b89\u88c5\u4efb\u4f55\u65b0\u5185\u5bb9\uff0c\u56e0\u4e3a .NET CLI \u5305\u542b\u5728 .NET 6 \u5b89\u88c5\u4e2d\uff08\u4e0e\u4ee5\u524d\u7248\u672c\u7684 .NET SDK \u4e00\u6837\uff09\u3002\u6309\u7167\u4ee5\u4e0b\u6b65\u9aa4\u4f7f\u7528 Visual Studio Code \u521b\u5efa\u9879\u76ee\uff1a<\/p>\n\n
\n\u6253\u5f00\u60a8\u7684\u63a7\u5236\u53f0\u3001shell \u6216 Bash \u7ec8\u7aef\uff0c\u7136\u540e\u5207\u6362\u5230\u60a8\u7684\u5de5\u4f5c\u76ee\u5f55\u3002<\/p>\n<\/li>\n
\n\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u521b\u5efa\u65b0\u7684 Web API \u5e94\u7528\u7a0b\u5e8f\uff1a<\/p>\ndotnet new webapi -minimal -o Chapter01<\/code><\/pre>\n<\/li>\n<\/ol>\n
\n\u5982\u60a8\u6240\u89c1\uff0c\u6211\u4eec\u5728\u524d\u9762\u7684\u547d\u4ee4\u4e2d\u63d2\u5165\u4e86 -minimal \u53c2\u6570\uff0c\u4ee5\u4f7f\u7528\u6700\u5c0f API \u9879\u76ee\u6a21\u677f\uff0c\u800c\u4e0d\u662f\u63a7\u5236\u5668\u7684 ASP.NET Core \u6a21\u677f\u3002<\/p>\n\n
\n\u73b0\u5728\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u4f7f\u7528 Visual Studio Code \u6253\u5f00\u65b0\u9879\u76ee\uff1a<\/p>\ncd Chapter01\ncode.<\/code><\/pre>\n<\/li>\n<\/ol>\n
\n\u73b0\u5728\u6211\u4eec\u77e5\u9053\u5982\u4f55\u521b\u5efa\u4e00\u4e2a\u65b0\u7684\u6700\u5c0f API \u9879\u76ee\uff0c\u6211\u4eec\u5c06\u5feb\u901f\u4e86\u89e3\u4e00\u4e0b\u8fd9\u4e2a\u65b0\u6a21\u677f\u7684\u7ed3\u6784\u3002<\/p>\n
\n\u67e5\u770b\u9879\u76ee\u7ed3\u6784<\/p>\n
\n\u65e0\u8bba\u60a8\u4f7f\u7528\u7684\u662f Visual Studio \u8fd8\u662f Visual Studio Code\uff0c\u60a8\u90fd\u5e94\u8be5\u5728 Program.cs \u6587\u4ef6\u4e2d\u770b\u5230\u4ee5\u4e0b\u4ee3\u7801\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\n\/\/ Add services to the container.\n\/\/ Learn more about configuring Swagger\/OpenAPI at https:\/\/aka.\nms\/aspnetcore\/swashbuckle\nbuilder.Services.AddEndpointsApiExplorer();\nbuilder.Services.AddSwaggerGen();\nvar app = builder.Build();\n\/\/ Configure the HTTP request pipeline.\nif (app.Environment.IsDevelopment())\n{\napp.UseSwagger();\napp.UseSwaggerUI();\n}\napp.UseHttpsRedirection();\nvar summaries = new[]\n{\n"Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm",\n"Balmy", "Hot", "Sweltering", "Scorching"\n};\napp.MapGet("\/weatherforecast", () =>\n{\nvar forecast = Enumerable.Range(1, 5).Select(index =>\nnew WeatherForecast\n(\nDateTime.Now.AddDays(index),\nRandom.Shared.Next(-20, 55),\nsummaries[Random.Shared.Next(summaries.Length)]\n))\n.ToArray();\nreturn forecast;\n})\n.WithName("GetWeatherForecast");\napp.Run();\ninternal record WeatherForecast(DateTime Date, int\nTemperatureC, string? Summary)\n{\npublic int TemperatureF => 32 + (int)(TemperatureC \/\n0.5556);\n}<\/code><\/pre>\n
\n\u9996\u5148\uff0c\u4f7f\u7528\u6700\u5c0f API \u65b9\u6cd5\uff0c\u60a8\u7684\u6240\u6709\u4ee3\u7801\u90fd\u5c06\u4f4d\u4e8e Program.cs \u6587\u4ef6\u4e2d\u3002\u5982\u679c\u60a8\u662f\u4e00\u4f4d\u7ecf\u9a8c\u4e30\u5bcc\u7684 .NET \u5f00\u53d1\u4eba\u5458\uff0c\u5219\u5f88\u5bb9\u6613\u7406\u89e3\u524d\u9762\u7684\u4ee3\u7801\uff0c\u5e76\u4e14\u60a8\u4f1a\u53d1\u73b0\u5b83\u7c7b\u4f3c\u4e8e\u60a8\u4e00\u76f4\u4f7f\u7528\u63a7\u5236\u5668\u65b9\u6cd5\u7684\u4e00\u4e9b\u5185\u5bb9\u3002<\/p>\n
\n\u5f52\u6839\u7ed3\u5e95\uff0c\u8fd9\u662f\u7f16\u5199 API \u7684\u53e6\u4e00\u79cd\u65b9\u5f0f\uff0c\u4f46\u5b83\u57fa\u4e8e ASP.NET Core\u3002<\/p>\n
\n\u4f46\u662f\uff0c\u5982\u679c\u60a8\u4e0d\u719f\u6089 ASP.NET\uff0c\u8fd9\u79cd\u5355\u6587\u4ef6\u65b9\u6cd5\u5f88\u5bb9\u6613\u7406\u89e3\u3002\u5f88\u5bb9\u6613\u7406\u89e3\u5982\u4f55\u6269\u5c55\u6a21\u677f\u4e2d\u7684\u4ee3\u7801\u5e76\u5411\u6b64 API \u6dfb\u52a0\u66f4\u591a\u529f\u80fd\u3002<\/p>\n
\n\u4e0d\u8981\u5fd8\u8bb0\uff0cminimal \u610f\u5473\u7740\u5b83\u5305\u542b\u6784\u5efa HTTP API \u6240\u9700\u7684\u6700\u5c11\u7ec4\u4ef6\u96c6\uff0c\u4f46\u8fd9\u5e76\u4e0d\u610f\u5473\u7740\u60a8\u8981\u6784\u5efa\u7684\u5e94\u7528\u7a0b\u5e8f\u4f1a\u5f88\u7b80\u5355\u3002\u4e0e\u4efb\u4f55\u5176\u4ed6 .NET \u5e94\u7528\u7a0b\u5e8f\u4e00\u6837\uff0c\u5b83\u9700\u8981\u826f\u597d\u7684\u8bbe\u8ba1\u3002<\/p>\n
\n\u6700\u540e\u4e00\u70b9\uff0c\u6700\u5c0f API \u65b9\u6cd5\u4e0d\u80fd\u66ff\u4ee3 MVC \u65b9\u6cd5\u3002\u8fd9\u53ea\u662f\u53e6\u4e00\u79cd\u5199\u540c\u6837\u4e1c\u897f\u7684\u65b9\u6cd5\u3002<\/p>\n
\n\u8ba9\u6211\u4eec\u56de\u5230\u4ee3\u7801\u3002<\/p>\n
\n\u5373\u4f7f\u662f\u6700\u5c0f API \u7684\u6a21\u677f\u4e5f\u4f7f\u7528 .NET 6 Web \u5e94\u7528\u7a0b\u5e8f\u7684\u65b0\u65b9\u6cd5\uff1a\u9876\u7ea7\u8bed\u53e5\u3002<\/p>\n
\n\u8fd9\u610f\u5473\u7740\u9879\u76ee\u53ea\u6709\u4e00\u4e2a Program.cs \u6587\u4ef6\uff0c\u800c\u4e0d\u662f\u4f7f\u7528\u4e24\u4e2a\u6587\u4ef6\u6765\u914d\u7f6e\u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u5982\u679c\u60a8\u4e0d\u559c\u6b22\u8fd9\u79cd\u7f16\u7801\u6837\u5f0f\uff0c\u53ef\u4ee5\u5c06\u5e94\u7528\u7a0b\u5e8f\u8f6c\u6362\u4e3a ASP.NET Core 3.x\/5 \u7684\u65e7\u6a21\u677f\u3002\u6b64\u65b9\u6cd5\u5728 .NET \u4e2d\u4e5f\u5c06\u7ee7\u7eed\u6709\u6548\u3002<\/p>\n
\n\u91cd\u8981\u63d0\u793a : \u6211\u4eec\u53ef\u4ee5\u5728 https:\/\/docs.microsoft.com\/dotnet\/core\/tutorials\/top-level-templates<\/a> \u4e2d\u627e\u5230\u6709\u5173 .NET 6 \u9876\u7ea7\u8bed\u53e5\u6a21\u677f\u7684\u66f4\u591a\u4fe1\u606f\u3002<\/p>\n
\n\u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u65b0\u6a21\u677f\u5305\u62ec\u5bf9 OpenAPI \u89c4\u8303\u7684\u652f\u6301\uff0c\u66f4\u5177\u4f53\u5730\u8bf4\uff0c\u5305\u62ec\u5bf9 Swagger \u7684\u652f\u6301\u3002<\/p>\n
\n\u5047\u8bbe\u6211\u4eec\u6709\u73b0\u6210\u7684\u7aef\u70b9\u6587\u6863\u548c Playground\uff0c\u65e0\u9700\u4efb\u4f55\u989d\u5916\u7684\u914d\u7f6e\u3002<\/p>\n
\n\u60a8\u53ef\u4ee5\u5728\u4ee5\u4e0b\u4e24\u884c\u4ee3\u7801\u4e2d\u770b\u5230 Swagger \u7684\u9ed8\u8ba4\u914d\u7f6e\uff1a<\/p>\nbuilder.Services.AddEndpointsApiExplorer();\nbuilder.Services.AddSwaggerGen();<\/code><\/pre>\n
\n\u901a\u5e38\uff0c\u60a8\u4e0d\u5e0c\u671b\u5c06 Swagger \u548c\u6240\u6709\u7ec8\u7aef\u8282\u70b9\u516c\u5f00\u7ed9\u751f\u4ea7\u6216\u6682\u5b58\u73af\u5883\u3002\u9ed8\u8ba4\u6a21\u677f\u4ec5\u5728\u5f00\u53d1\u73af\u5883\u4e2d\u542f\u7528\u5f00\u7bb1\u5373\u7528\u7684 Swagger\uff0c\u4ee3\u7801\u884c\u5982\u4e0b\uff1a<\/p>\nif (app.Environment.IsDevelopment())\n{\n app.UseSwagger();\n app.UseSwaggerUI();\n}<\/code><\/pre>\n
\n\u5982\u679c\u5e94\u7528\u7a0b\u5e8f\u5728 dev elopment \u73af\u5883\u4e2d\u8fd0\u884c\uff0c\u5219\u8fd8\u5fc5\u987b\u5305\u542b Swagger \u6587\u6863\uff0c\u5426\u5219\u4e0d\u5f97\u5305\u542b\u3002<\/p>\n
\n\u6ce8\u610f:\u6211\u4eec\u5c06\u5728\u7b2c 3 \u7ae0 \u4f7f\u7528\u6700\u5c0f API \u4e2d\u8be6\u7ec6\u8ba8\u8bba Swagger\u3002<\/p>\n
\n\u5728\u6a21\u677f\u7684\u6700\u540e\u51e0\u884c\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u5f15\u5165\u4e86 .NET 6 Web \u5e94\u7528\u7a0b\u5e8f\u7684\u53e6\u4e00\u4e2a\u901a\u7528\u6982\u5ff5\uff1a\u73af\u5883\u3002<\/p>\n
\n\u901a\u5e38\uff0c\u5f53\u6211\u4eec\u5f00\u53d1\u4e13\u4e1a\u5e94\u7528\u7a0b\u5e8f\u65f6\uff0c\u5e94\u7528\u7a0b\u5e8f\u4f1a\u7ecf\u5386\u8bb8\u591a\u5f00\u53d1\u3001\u6d4b\u8bd5\u5e76\u6700\u7ec8\u53d1\u5e03\u7ed9\u6700\u7ec8\u7528\u6237\u7684\u9636\u6bb5\u3002<\/p>\n
\n\u6309\u7167\u60ef\u4f8b\uff0c\u8fd9\u4e9b\u9636\u6bb5\u53d7\u5230\u76d1\u7ba1\uff0c\u79f0\u4e3a\u5f00\u53d1\u3001\u6682\u5b58\u548c\u751f\u4ea7\u3002\u4f5c\u4e3a\u5f00\u53d1\u4eba\u5458\uff0c\u6211\u4eec\u53ef\u80fd\u5e0c\u671b\u6839\u636e\u5f53\u524d\u73af\u5883\u66f4\u6539\u5e94\u7528\u7a0b\u5e8f\u7684\u884c\u4e3a\u3002<\/p>\n
\n\u6709\u591a\u79cd\u65b9\u6cd5\u53ef\u4ee5\u8bbf\u95ee\u6b64\u4fe1\u606f\uff0c\u4f46\u5728\u73b0\u4ee3 .NET 6 \u5e94\u7528\u7a0b\u5e8f\u4e2d\u68c0\u7d22\u5b9e\u9645\u73af\u5883\u7684\u5178\u578b\u65b9\u6cd5\u662f\u4f7f\u7528\u73af\u5883\u53d8\u91cf\u3002\u60a8\u53ef\u4ee5\u76f4\u63a5\u4ece Program.cs \u6587\u4ef6\u4e2d\u7684 app \u53d8\u91cf\u8bbf\u95ee\u73af\u5883\u53d8\u91cf\u3002<\/p>\n
\n\u4ee5\u4e0b\u4ee3\u7801\u5757\u6f14\u793a\u5982\u4f55\u76f4\u63a5\u4ece\u5e94\u7528\u7a0b\u5e8f\u7684\u542f\u52a8\u70b9\u68c0\u7d22\u6709\u5173\u73af\u5883\u7684\u6240\u6709\u4fe1\u606f\uff1a<\/p>\nif (app.Environment.IsDevelopment())\n{\n \/\/ your code here\n}\nif (app.Environment.IsStaging())\n{\n \/\/ your code here\n}\nif (app.Environment.IsProduction())\n{\n \/\/ your code here\n}<\/code><\/pre>\n
\n\u5728\u8bb8\u591a\u60c5\u51b5\u4e0b\uff0c\u60a8\u53ef\u4ee5\u5b9a\u4e49\u5176\u4ed6\u73af\u5883\uff0c\u5e76\u4e14\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u4ee3\u7801\u68c0\u67e5\u60a8\u7684\u81ea\u5b9a\u4e49\u73af\u5883\uff1a<\/p>\nif (app.Environment.IsEnvironment("TestEnvironment"))\n{\n \/\/ your code here\n}<\/code><\/pre>\n
\n\u8981\u5728\u6700\u5c0f\u7684 API \u4e2d\u5b9a\u4e49\u8def\u7531\u548c\u5904\u7406\u7a0b\u5e8f\uff0c\u6211\u4eec\u4f7f\u7528 MapGet\u3001MapPost\u3001MapPut \u548c MapDelete \u65b9\u6cd5\u3002\u5982\u679c\u60a8\u4e60\u60ef\u4f7f\u7528 HTTP \u52a8\u8bcd\uff0c\u60a8\u4f1a\u6ce8\u610f\u5230\u52a8\u8bcd Patch \u4e0d\u5b58\u5728\uff0c\u4f46\u60a8\u53ef\u4ee5\u4f7f\u7528 MapMethods \u5b9a\u4e49\u4efb\u4f55\u52a8\u8bcd\u96c6\u3002<\/p>\napp.MapPost("\/weatherforecast", async (WeatherForecast \n model, IWeatherService repo) =>\n{\n \/\/ ...\n});<\/code><\/pre>\n
\n\u6b63\u5982\u60a8\u5728\u524d\u9762\u7684\u7b80\u77ed\u4ee3\u7801\u4e2d\u6240\u770b\u5230\u7684\uff0c\u4f7f\u7528\u65b0\u7684\u6700\u5c0f API \u6a21\u677f\u6dfb\u52a0\u65b0\u7ec8\u7aef\u8282\u70b9\u975e\u5e38\u5bb9\u6613\u3002<\/p>\n
\n\u4ee5\u524d\uff0c\u4f7f\u7528\u7ed1\u5b9a\u53c2\u6570\u7f16\u5199\u65b0\u7ec8\u7aef\u8282\u70b9\u5e76\u4f7f\u7528\u4f9d\u8d56\u9879\u6ce8\u5165\u66f4\u52a0\u56f0\u96be\uff0c\u5c24\u5176\u662f\u5bf9\u4e8e\u65b0\u5f00\u53d1\u4eba\u5458\u800c\u8a00\u3002<\/p>\n
\n\u91cd\u8981\u63d0\u793a : \u6211\u4eec\u5c06\u5728\u7b2c 2 \u7ae0 \u63a2\u7d22\u6700\u5c0f API \u53ca\u5176\u4f18\u52bf\u4e2d\u8be6\u7ec6\u8ba8\u8bba\u8def\u7531\uff0c\u5e76\u5728\u7b2c 4 \u7ae0 \u6700\u5c0f API \u9879\u76ee\u4e2d\u7684\u4f9d\u8d56\u6ce8\u5165\u3002<\/p>\n
\n\u603b\u7ed3<\/p>\n
\n\u5728\u672c\u7ae0\u4e2d\uff0c\u6211\u4eec\u9996\u5148\u4ece\u6700\u5c0f API \u7684\u7b80\u8981\u5386\u53f2\u5f00\u59cb\u3002\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u4e86\u89e3\u4e86\u5982\u4f55\u4f7f\u7528 Visual Studio 2022 \u4ee5\u53ca Visual Studio Code \u548c .NET CLI \u521b\u5efa\u9879\u76ee\u3002\u4e4b\u540e\uff0c\u6211\u4eec\u68c0\u67e5\u4e86\u65b0\u6a21\u677f\u7684\u7ed3\u6784\u3001\u5982\u4f55\u8bbf\u95ee\u4e0d\u540c\u7684\u73af\u5883\u4ee5\u53ca\u5982\u4f55\u5f00\u59cb\u4e0e REST \u7aef\u70b9\u4ea4\u4e92\u3002<\/p>\n
\n\u5728\u4e0b\u4e00\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u4e86\u89e3\u5982\u4f55\u7ed1\u5b9a\u53c2\u6570\u3001\u65b0\u7684\u8def\u7531\u914d\u7f6e\u4ee5\u53ca\u5982\u4f55\u81ea\u5b9a\u4e49\u54cd\u5e94\u3002<\/p>\n2 Exploring Minimal APIs and Their Advantages<\/h1>\n
\n\u5728\u672c\u4e66\u7684\u8fd9\u4e00\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u4ecb\u7ecd\u4e0e .NET 6.0 \u4e2d\u7684\u6700\u5c0f API \u76f8\u5173\u7684\u4e00\u4e9b\u57fa\u672c\u4e3b\u9898\uff0c\u5c55\u793a\u5b83\u4eec\u4e0e\u6211\u4eec\u5728\u65e9\u671f\u7248\u672c\u7684 .NET \u4e2d\u7f16\u5199\u7684\u57fa\u4e8e\u63a7\u5236\u5668\u7684 Web API \u6709\u4f55\u4e0d\u540c\u3002\u6211\u4eec\u8fd8\u5c06\u5c1d\u8bd5\u5f3a\u8c03\u8fd9\u79cd\u7f16\u5199 API \u7684\u65b0\u65b9\u6cd5\u7684\u4f18\u7f3a\u70b9\u3002<\/p>\n
\n\u5728\u672c\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u4ecb\u7ecd\u4ee5\u4e0b\u4e3b\u9898\uff1a<\/p>\n
\n\u2022 Parameter binding
\n\u2022 Exploring responses
\n\u2022 Controlling serialization
\n\u2022 Architecting a minimal API project<\/p>\n
\n\u6280\u672f\u8981\u6c42<\/p>\n
\n\u8981\u6309\u7167\u672c\u7ae0\u4e2d\u7684\u63cf\u8ff0\u8fdb\u884c\u4f5c\uff0c\u60a8\u9700\u8981\u521b\u5efa\u4e00\u4e2a ASP.NET Core 6.0 Web API \u5e94\u7528\u7a0b\u5e8f\u3002\u60a8\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u9009\u9879\u4e4b\u4e00\uff1a<\/p>\n
\n\u9009\u9879 1\uff1a\u70b9\u51fb\u65b0\u5efa |Visual Studio 2022 \u7684 File \uff08\u6587\u4ef6\uff09 \u83dc\u5355\u4e2d\u7684 Project \uff08\u9879\u76ee\uff09 \u547d\u4ee4\uff0c\u7136\u540e\u9009\u62e9 ASP.NET Core Web API \u6a21\u677f\u3002\u5728\u5411\u5bfc\u4e2d\u9009\u62e9\u4e00\u4e2a\u540d\u79f0\u548c\u5de5\u4f5c\u76ee\u5f55\uff0c\u5e76\u786e\u4fdd\u5728\u4e0b\u4e00\u6b65\u4e2d\u53d6\u6d88\u9009\u4e2d Use controllers \uff08\u4e0d\u9009\u4e2d\u4f7f\u7528\u6700\u5c11\u7684 API\uff09 \u9009\u9879\u3002<\/p>\n
\n\u9009\u9879 2\uff1a\u6253\u5f00\u60a8\u7684\u63a7\u5236\u53f0\u3001shell \u6216 Bash \u7ec8\u7aef\uff0c\u7136\u540e\u5207\u6362\u5230\u60a8\u7684\u5de5\u4f5c\u76ee\u5f55\u3002\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u521b\u5efa\u65b0\u7684 Web API \u5e94\u7528\u7a0b\u5e8f\uff1a<\/p>\ndotnet new webapi -minimal -o Chapter02<\/code><\/pre>\n
\n\u73b0\u5728\uff0c\u901a\u8fc7\u5728 Visual Studio \u4e2d\u53cc\u51fb\u9879\u76ee\u6587\u4ef6\u6216\u5728 Visual Studio Code \u4e2d\u901a\u8fc7\u5728\u5df2\u6253\u5f00\u7684\u63a7\u5236\u53f0\u4e2d\u952e\u5165\u4ee5\u4e0b\u547d\u4ee4\u6765\u6253\u5f00\u9879\u76ee\uff1a<\/p>\ncd Chapter02\ncode.<\/code><\/pre>\n
\n\u6700\u540e\uff0c\u60a8\u53ef\u4ee5\u5b89\u5168\u5730\u5220\u9664\u4e0e WeatherForecast \u793a\u4f8b\u76f8\u5173\u7684\u6240\u6709\u4ee3\u7801\uff0c\u56e0\u4e3a\u672c\u7ae0\u4e0d\u9700\u8981\u5b83\u3002<\/p>\n
\n\u672c\u7ae0\u4e2d\u7684\u6240\u6709\u4ee3\u7801\u793a\u4f8b\u90fd\u53ef\u4ee5\u5728\u672c\u4e66\u7684 GitHub \u5b58\u50a8\u5e93\u4e2d\u627e\u5230\uff0c\u7f51\u5740\u4e3a https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\/tree\/main\/Chapter02<\/a>\u3002<\/p>\n
\n\u8def\u7531<\/p>\n
\n\u6839\u636e https:\/\/docs.microsoft.com\/aspnet\/core\/fundamentals\/routing<\/a> \u4e0a\u63d0\u4f9b\u7684\u5b98\u65b9 Microsoft \u6587\u6863\uff0c\u8def\u7531\u7ed9\u51fa\u4e86\u4ee5\u4e0b\u5b9a\u4e49\uff1a<\/p>\n
\n\u8def\u7531\u8d1f\u8d23\u5339\u914d\u4f20\u5165\u7684 HTTP \u8bf7\u6c42\u5e76\u5c06\u8fd9\u4e9b\u8bf7\u6c42\u5206\u6d3e\u5230\u5e94\u7528\u7a0b\u5e8f\u7684\u53ef\u6267\u884c\u7aef\u70b9\u3002\u7aef\u70b9\u662f\u5e94\u7528\u7a0b\u5e8f\u7684\u53ef\u6267\u884c\u8bf7\u6c42\u5904\u7406\u4ee3\u7801\u5355\u5143\u3002\u7ec8\u7aef\u8282\u70b9\u5728\u5e94\u7528\u7a0b\u5e8f\u4e2d\u5b9a\u4e49\uff0c\u5e76\u5728\u5e94\u7528\u7a0b\u5e8f\u542f\u52a8\u65f6\u8fdb\u884c\u914d\u7f6e\u3002\u7ec8\u7aef\u8282\u70b9\u5339\u914d\u8fc7\u7a0b\u53ef\u4ee5\u4ece\u8bf7\u6c42\u7684 URL \u4e2d\u63d0\u53d6\u503c\uff0c\u5e76\u63d0\u4f9b\u8fd9\u4e9b\u503c\u4ee5\u4f9b\u8bf7\u6c42\u5904\u7406\u3002\u4f7f\u7528\u5e94\u7528\u7a0b\u5e8f\u4e2d\u7684\u7ec8\u7aef\u8282\u70b9\u4fe1\u606f\uff0c\u8def\u7531\u8fd8\u80fd\u591f\u751f\u6210\u6620\u5c04\u5230\u7ec8\u7aef\u8282\u70b9\u7684 URL\u3002<\/p>\n
\n\u5728\u57fa\u4e8e\u63a7\u5236\u5668\u7684 Web API \u4e2d\uff0c\u8def\u7531\u662f\u901a\u8fc7 Startup.cs \u4e2d\u7684 UseEndpoints\uff08\uff09 \u65b9\u6cd5\u5b9a\u4e49\u7684\uff0c\u6216\u8005\u4f7f\u7528\u4f5c\u65b9\u6cd5\u4e0a\u7684\u6570\u636e\u6ce8\u91ca\uff08\u5982 Route\u3001HttpGet\u3001HttpPost\u3001HttpPut\u3001HttpPatch \u548c HttpDelete\uff09\u6765\u5b9a\u4e49\u3002<\/p>\n
\n\u5982\u7b2c 1 \u7ae0 \u6700\u5c0f API \u7b80\u4ecb\u4e2d\u6240\u8ff0\uff0c\u5728\u6700\u5c0f API \u4e2d\uff0c\u6211\u4eec\u4f7f\u7528 WebApplication \u5bf9\u8c61\u7684 Map<\/em> \u65b9\u6cd5\u5b9a\u4e49\u8def\u7531\u6a21\u5f0f\u3002\u4e0b\u9762\u662f\u4e00\u4e2a\u793a\u4f8b\uff1a<\/p>\napp.MapGet("\/hello-get", () => "[GET] Hello World!");\napp.MapPost("\/hello-post", () => "[POST] Hello World!");\napp.MapPut("\/hello-put", () => "[PUT] Hello World!");\napp.MapDelete("\/hello-delete", () => "[DELETE] Hello\n World!");<\/code><\/pre>\n
\n\u5728\u6b64\u4ee3\u7801\u4e2d\uff0c\u6211\u4eec\u5b9a\u4e49\u4e86\u56db\u4e2a\u7ec8\u7aef\u8282\u70b9\uff0c\u6bcf\u4e2a\u7ec8\u7aef\u8282\u70b9\u90fd\u6709\u4e0d\u540c\u7684\u8def\u7531\u548c\u65b9\u6cd5\u3002\u5f53\u7136\uff0c\u6211\u4eec\u53ef\u4ee5\u5bf9\u4e0d\u540c\u7684 HTTP \u52a8\u8bcd\u4f7f\u7528\u76f8\u540c\u7684\u8def\u7531\u6a21\u5f0f\u3002<\/p>\n
\n\u6ce8\u610f : \u4e00\u65e6\u6211\u4eec\u5c06\u7aef\u70b9\u6dfb\u52a0\u5230\u5e94\u7528\u7a0b\u5e8f\uff08\u4f8b\u5982\uff0c\u4f7f\u7528 MapGet\uff08\uff09\uff09\uff0cUseRouting\uff08\uff09 \u5c31\u4f1a\u81ea\u52a8\u6dfb\u52a0\u5230\u4e2d\u95f4\u4ef6\u7ba1\u9053\u7684\u5f00\u5934\uff0cUseEndpoints\uff08\uff09 \u4f1a\u81ea\u52a8\u6dfb\u52a0\u5230\u7ba1\u9053\u7684\u672b\u5c3e\u3002<\/p>\n
\n\u5982\u6b64\u5904\u6240\u793a\uff0cASP.NET Core 6.0 \u4e3a\u6700\u5e38\u89c1\u7684 HTTP \u52a8\u8bcd\u63d0\u4f9b\u4e86 Map<\/em> \u65b9\u6cd5\u3002\u5982\u679c\u6211\u4eec\u9700\u8981\u4f7f\u7528\u5176\u4ed6\u52a8\u8bcd\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u901a\u7528\u7684 MapMethods\uff1a<\/p>\napp.MapMethods("\/hello-patch", new[] { HttpMethods.Patch }, \n () => "[PATCH] Hello World!");\napp.MapMethods("\/hello-head", new[] { HttpMethods.Head }, \n () => "[HEAD] Hello World!");\napp.MapMethods("\/hello-options", new[] { \n HttpMethods.Options }, () => "[OPTIONS] Hello World!");<\/code><\/pre>\n
\n\u5728\u4ee5\u4e0b\u90e8\u5206\u4e2d\uff0c\u6211\u4eec\u5c06\u8be6\u7ec6\u5c55\u793a\u8def\u7531\u5982\u4f55\u6709\u6548\u5de5\u4f5c\u4ee5\u53ca\u5982\u4f55\u63a7\u5236\u5176\u884c\u4e3a\u3002<\/p>\n
\n\u8def\u7531\u5904\u7406\u7a0b\u5e8f<\/p>\n
\n\u5f53\u8def\u7531 URL \u5339\u914d\u65f6\u6267\u884c\u7684\u65b9\u6cd5\uff08\u6839\u636e\u53c2\u6570\u548c\u7ea6\u675f\uff0c\u5982\u4ee5\u4e0b\u90e8\u5206\u6240\u8ff0\uff09\u79f0\u4e3a\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u3002\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u53ef\u4ee5\u662f lambda \u8868\u8fbe\u5f0f\u3001\u672c\u5730\u51fd\u6570\u3001\u5b9e\u4f8b\u65b9\u6cd5\u6216\u9759\u6001\u65b9\u6cd5\uff0c\u65e0\u8bba\u662f\u540c\u6b65\u65b9\u6cd5\u8fd8\u662f\u5f02\u6b65\u65b9\u6cd5\uff1a<\/p>\n
\n\u4ee5\u4e0b\u662f lambda \u8868\u8fbe\u5f0f\u7684\u793a\u4f8b\uff08\u5185\u8054\u6216\u4f7f\u7528\u53d8\u91cf\uff09\uff1a<\/p>\napp.MapGet("\/hello-inline", () => "[INLINE LAMBDA]\n\n Hello World!");\n\nvar handler = () => "[LAMBDA VARIABLE] Hello World!";\n\napp.MapGet("\/hello", handler);<\/code><\/pre>\n
\n\u4e0b\u9762\u662f\u4e00\u4e2a\u672c\u5730\u51fd\u6570\u7684\u793a\u4f8b\uff1a<\/p>\nstring Hello() => "[LOCAL FUNCTION] Hello World!";\n\napp.MapGet("\/hello", Hello);<\/code><\/pre>\n
\n\u4ee5\u4e0b\u662f\u5b9e\u4f8b\u65b9\u6cd5\u7684\u793a\u4f8b\uff1a<\/p>\nvar handler = new HelloHandler();\n\napp.MapGet("\/hello", handler.Hello);\n\nclass HelloHandler\n\n{\n\n public string Hello()\n\n => "[INSTANCE METHOD] Hello\n\n World!";\n\n}<\/code><\/pre>\n
\n\u5728\u8fd9\u91cc\uff0c\u6211\u4eec\u53ef\u4ee5\u770b\u5230\u4e00\u4e2a\u9759\u6001\u65b9\u6cd5\u7684\u793a\u4f8b\uff1a<\/p>\napp.MapGet("\/hello", HelloHandler.Hello);\n\nclass HelloHandler\n\n{\n\n public static string Hello()\n\n => "[STATIC METHOD] Hello World!";\n\n}<\/code><\/pre>\n
\n\u8def\u7531\u53c2\u6570<\/p>\n
\n\u4e0e\u4ee5\u524d\u7248\u672c\u7684 .NET \u4e00\u6837\uff0c\u6211\u4eec\u53ef\u4ee5\u521b\u5efa\u8def\u7531\u6a21\u5f0f\uff0c\u5176\u4e2d\u5305\u542b\u5904\u7406\u7a0b\u5e8f\u5c06\u81ea\u52a8\u6355\u83b7\u7684\u53c2\u6570\uff1a<\/p>\napp.MapGet("\/users\/{username}\/products\/{productId}", \n (string username, int productId) \n => $"The Username is {username} and the product Id \n is {productId}");<\/code><\/pre>\n
\n\u8def\u7531\u53ef\u4ee5\u5305\u542b\u4efb\u610f\u6570\u91cf\u7684\u53c2\u6570\u3002\u5f53\u5411\u6b64\u8def\u7531\u53d1\u51fa\u8bf7\u6c42\u65f6\uff0c\u53c2\u6570\u5c06\u88ab\u6355\u83b7\u3001\u89e3\u6790\u5e76\u4f5c\u4e3a\u53c2\u6570\u4f20\u9012\u7ed9\u76f8\u5e94\u7684\u5904\u7406\u7a0b\u5e8f\u3002\u8fd9\u6837\uff0c\u5904\u7406\u7a0b\u5e8f\u5c06\u59cb\u7ec8\u63a5\u6536\u7c7b\u578b\u5316\u53c2\u6570\uff08\u5728\u524d\u9762\u7684\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u786e\u4fdd username \u662f string\uff0c\u4ea7\u54c1 ID \u662f int\uff09\u3002<\/p>\n
\n\u5982\u679c\u65e0\u6cd5\u5c06\u8def\u7531\u503c\u5f3a\u5236\u8f6c\u6362\u4e3a\u6307\u5b9a\u7c7b\u578b\uff0c\u5219\u5c06\u5f15\u53d1 BadHttpRequestException \u7c7b\u578b\u7684\u5f02\u5e38\uff0c\u5e76\u4e14 API \u5c06\u4ee5 400 Bad Request \u6d88\u606f\u8fdb\u884c\u54cd\u5e94\u3002<\/p>\n
\n\u8def\u7531\u7ea6\u675f<\/p>\n
\n\u8def\u7531\u7ea6\u675f\u7528\u4e8e\u9650\u5236\u8def\u7531\u53c2\u6570\u7684\u6709\u6548\u7c7b\u578b\u3002\u5178\u578b\u7ea6\u675f\u5141\u8bb8\u6211\u4eec\u6307\u5b9a\u53c2\u6570\u5fc5\u987b\u662f\u6570\u5b57\u3001\u5b57\u7b26\u4e32\u6216 GUID\u3002\u8981\u6307\u5b9a\u8def\u7531\u7ea6\u675f\uff0c\u6211\u4eec\u53ea\u9700\u8981\u5728\u53c2\u6570\u540d\u79f0\u540e\u6dfb\u52a0\u4e00\u4e2a\u5192\u53f7\uff0c\u7136\u540e\u6307\u5b9a\u7ea6\u675f\u540d\u79f0\uff1a<\/p>\napp.MapGet("\/users\/{id:int}", (int id) => $"The user Id is \n {id}");\napp.MapGet("\/users\/{id:guid}", (Guid id) => $"The user Guid \n is {id}");<\/code><\/pre>\n
\n\u6700\u5c0f API \u652f\u6301\u4ee5\u524d\u7248\u672c\u7684 ASP.NET Core \u4e2d\u5df2\u7ecf\u63d0\u4f9b\u7684\u6240\u6709\u8def\u7531\u7ea6\u675f\u3002\u60a8\u53ef\u4ee5\u5728\u4ee5\u4e0b\u94fe\u63a5\u4e2d\u627e\u5230\u8def\u7531\u7ea6\u675f\u7684\u5b8c\u6574\u5217\u8868\uff1ahttps:\/\/docs.microsoft.com\/aspnet\/core\/fundamentals\/routing#route-constraint-reference<\/a>\u3002<\/p>\n
\n\u5982\u679c\u6839\u636e\u7ea6\u675f\uff0c\u6ca1\u6709\u8def\u7531\u4e0e\u6307\u5b9a\u7684\u8def\u5f84\u5339\u914d\uff0c\u5219\u4e0d\u4f1a\u6536\u5230\u5f02\u5e38\u3002\u76f8\u53cd\uff0c\u6211\u4eec\u4f1a\u6536\u5230 404 Not Found \u6d88\u606f\uff0c\u56e0\u4e3a\u4e8b\u5b9e\u4e0a\uff0c\u5982\u679c\u7ea6\u675f\u4e0d\u5408\u9002\uff0c\u5219\u8def\u7531\u672c\u8eab\u65e0\u6cd5\u8bbf\u95ee\u3002\u56e0\u6b64\uff0c\u4f8b\u5982\uff0c\u5728\u4ee5\u4e0b\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u4f1a\u6536\u5230 404 \u4e2a\u54cd\u5e94\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0201.jpg\")
<\/p>\n
\n\u8868 2.1 \u2013 \u6839\u636e\u8def\u7531\u7ea6\u675f\u7684\u65e0\u6548\u8def\u5f84\u793a\u4f8b<\/p>\n
\n\u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u5904\u7406\u7a0b\u5e8f\u4e2d\u672a\u58f0\u660e\u4e3a\u8def\u7531\u7ea6\u675f\u7684\u6240\u6709\u5176\u4ed6\u53c2\u6570\u90fd\u5e94\u5728\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u3002\u4f8b\u5982\uff0c\u8bf7\u53c2\u9605\u4ee5\u4e0b\u5185\u5bb9\uff1a<\/p>\n\/\/ Matches hello?name=Marco\napp.MapGet("\/hello", (string name) => $"Hello, {name}!"); <\/code><\/pre>\n
\n\u5728\u4e0b\u4e00\u8282 \u53c2\u6570\u7ed1\u5b9a \u4e2d\uff0c\u6211\u4eec\u5c06\u66f4\u6df1\u5165\u5730\u4ecb\u7ecd\u5982\u4f55\u4f7f\u7528 binding \u8fdb\u4e00\u6b65\u81ea\u5b9a\u4e49\u8def\u7531\uff0c\u4f8b\u5982\uff0c\u6307\u5b9a\u5728\u4f55\u5904\u641c\u7d22\u8def\u7531\u53c2\u6570\u3001\u5982\u4f55\u66f4\u6539\u5176\u540d\u79f0\u4ee5\u53ca\u5982\u4f55\u62e5\u6709\u53ef\u9009\u7684\u8def\u7531\u53c2\u6570\u3002<\/p>\n
\n\u53c2\u6570\u7ed1\u5b9a<\/p>\n
\n\u53c2\u6570\u7ed1\u5b9a\u662f\u5c06\u8bf7\u6c42\u6570\u636e\uff08\u5373 URL \u8def\u5f84\u3001\u67e5\u8be2\u5b57\u7b26\u4e32\u6216\u6b63\u6587\uff09\u8f6c\u6362\u4e3a\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u53ef\u4ee5\u4f7f\u7528\u7684\u5f3a\u7c7b\u578b\u53c2\u6570\u7684\u8fc7\u7a0b\u3002ASP.NET Core \u6700\u5c0f API \u652f\u6301\u4ee5\u4e0b\u7ed1\u5b9a\u6e90\uff1a<\/p>\n
\n\u2022 Query strings
\n\u2022 Headers
\n\u2022 The body (as JSON, the only format supported by default)
\n\u2022 A service provider (dependency injection)<\/p>\n
\n\u6211\u4eec\u5c06\u5728 \u7b2c 4 \u7ae0 \u5b9e\u73b0\u4f9d\u8d56\u6ce8\u5165 \u4e2d\u8be6\u7ec6\u8ba8\u8bba\u4f9d\u8d56\u6ce8\u5165\u3002<\/p>\n
\n\u6b63\u5982\u6211\u4eec\u5728\u672c\u7ae0\u540e\u9762\u770b\u5230\u7684\u90a3\u6837\uff0c\u5982\u6709\u5fc5\u8981\uff0c\u6211\u4eec\u53ef\u4ee5\u81ea\u5b9a\u4e49\u5bf9\u7279\u5b9a input \u6267\u884c\u7ed1\u5b9a\u7684\u65b9\u5f0f\u3002\u9057\u61be\u7684\u662f\uff0c\u5728\u5f53\u524d\u7248\u672c\u4e2d\uff0c\u6700\u5c0f\u7684 API \u672c\u8eab\u5e76\u4e0d\u652f\u6301\u4ece Form \u8fdb\u884c\u7ed1\u5b9a\u3002\u8fd9\u610f\u5473\u7740\uff0c\u4f8b\u5982\uff0cIFormFile \u4e5f\u4e0d\u53d7\u652f\u6301\u3002<\/p>\n
\n\u4e3a\u4e86\u66f4\u597d\u5730\u7406\u89e3\u53c2\u6570\u7ed1\u5b9a\u7684\u5de5\u4f5c\u539f\u7406\uff0c\u6211\u4eec\u6765\u770b\u4e00\u4e0b\u4ee5\u4e0b API\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nbuilder.Services.AddScoped<PeopleService>();\nvar app = builder.Build();\napp.MapPut("\/people\/{id:int}", (int id, bool notify, Person \n person, PeopleService peopleService) => { });\napp.Run();\npublic class PeopleService { }\npublic record class Person(string FirstName, string \n LastName);<\/code><\/pre>\n
\n\u4f20\u9012\u7ed9\u5904\u7406\u7a0b\u5e8f\u7684\u53c2\u6570\u901a\u8fc7\u4ee5\u4e0b\u65b9\u5f0f\u89e3\u6790\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0202.jpg\")
<\/p>\n
\n\u8868 2.2 \u2013 \u53c2\u6570\u7ed1\u5b9a\u6e90<\/p>\n
\n\u6b63\u5982\u6211\u4eec\u6240\u770b\u5230\u7684\uff0cASP.NET Core \u80fd\u591f\u6839\u636e\u8def\u7531\u6a21\u5f0f\u548c\u53c2\u6570\u672c\u8eab\u7684\u7c7b\u578b\uff0c\u81ea\u52a8\u7406\u89e3\u5728\u4f55\u5904\u641c\u7d22\u8981\u7ed1\u5b9a\u7684\u53c2\u6570\u3002\u4f8b\u5982\uff0c\u8bf7\u6c42\u6b63\u6587\u4e2d\u5e94\u5305\u542b\u590d\u6742\u7c7b\u578b\uff08\u5982 Person \u7c7b\uff09\u3002<\/p>\n
\n\u5982\u679c\u9700\u8981\uff0c\u5c31\u50cf\u5728\u65e9\u671f\u7248\u672c\u7684 ASP.NET Core \u4e2d\u4e00\u6837\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u5c5e\u6027\u6765\u663e\u5f0f\u6307\u5b9a\u53c2\u6570\u7684\u7ed1\u5b9a\u4f4d\u7f6e\uff0c\u5e76\u53ef\u9009\u62e9\u4e3a\u5b83\u4eec\u4f7f\u7528\u4e0d\u540c\u7684\u540d\u79f0\u3002\u8bf7\u53c2\u9605\u4ee5\u4e0b\u7ec8\u7aef\u8282\u70b9\uff1a<\/p>\napp.MapGet("\/search", string q) => { });<\/code><\/pre>\n
\n\u53ef\u4ee5\u4f7f\u7528 \/search\uff1fq=text \u8c03\u7528 API\u3002\u4f46\u662f\uff0c\u4f7f\u7528 q \u4f5c\u4e3a\u53c2\u6570\u7684\u540d\u79f0\u5e76\u4e0d\u662f\u4e00\u4e2a\u597d\u4e3b\u610f\uff0c\u56e0\u4e3a\u5b83\u7684\u542b\u4e49\u4e0d\u8a00\u81ea\u660e\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528 FromQueryAttribute \u4fee\u6539\u5904\u7406\u7a0b\u5e8f\uff1a<\/p>\napp.MapGet("\/search", ([FromQuery(Name = "q")] string \n searchText) => { });<\/code><\/pre>\n
\n\u8fd9\u6837\uff0cAPI \u4ecd\u7136\u9700\u8981\u540d\u4e3a q \u7684\u67e5\u8be2\u5b57\u7b26\u4e32\u53c2\u6570\uff0c\u4f46\u5728\u5904\u7406\u7a0b\u5e8f\u4e2d\uff0c\u5176\u503c\u73b0\u5728\u7ed1\u5b9a\u5230 searchText \u53c2\u6570\u3002<\/p>\n
\n\u6ce8\u610f : \u6839\u636e\u8be5\u6807\u51c6\uff0cGET\u3001DELETE\u3001HEAD \u548c OPTIONS HTTP \u9009\u9879\u4e0d\u5e94\u6709\u6b63\u6587\u3002\u4f46\u662f\uff0c\u5982\u679c\u8981\u4f7f\u7528\u5b83\uff0c\u5219\u9700\u8981\u5c06 [FromBody] \u5c5e\u6027\u663e\u5f0f\u6dfb\u52a0\u5230 handler \u53c2\u6570;\u5426\u5219\uff0c\u60a8\u5c06\u6536\u5230 InvalidOperationException \u9519\u8bef\u3002\u4f46\u662f\uff0c\u8bf7\u8bb0\u4f4f\uff0c\u8fd9\u662f\u4e00\u79cd\u4e0d\u597d\u7684\u505a\u6cd5\u3002<\/p>\n
\n\u9ed8\u8ba4\u60c5\u51b5\u4e0b\uff0c\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u4e2d\u7684\u6240\u6709\u53c2\u6570\u90fd\u662f\u5fc5\u9700\u7684\u3002\u56e0\u6b64\uff0c\u5982\u679c\u6839\u636e\u8def\u7531\uff0cASP.NET Core \u627e\u5230\u4e86\u4e00\u4e2a\u6709\u6548\u7684\u8def\u7531\uff0c\u4f46\u672a\u63d0\u4f9b\u6240\u6709\u5fc5\u9700\u7684\u53c2\u6570\uff0c\u6211\u4eec\u5c06\u6536\u5230\u9519\u8bef\u3002\u4f8b\u5982\uff0c\u8ba9\u6211\u4eec\u770b\u770b\u4e0b\u9762\u7684\u65b9\u6cd5\uff1a<\/p>\napp.MapGet("\/people", (int pageIndex, int itemsPerPage) => { });<\/code><\/pre>\n
\n\u5982\u679c\u6211\u4eec\u5728\u6ca1\u6709 pageIndex \u6216 itemsPerPage \u67e5\u8be2\u5b57\u7b26\u4e32\u503c\u7684\u60c5\u51b5\u4e0b\u8c03\u7528\u7ec8\u7aef\u8282\u70b9\uff0c\u6211\u4eec\u5c06\u83b7\u5f97 BadHttpRequestException \u9519\u8bef\uff0c\u5e76\u4e14\u54cd\u5e94\u5c06\u4e3a 400 Bad Request\u3002<\/p>\n
\n\u8981\u4f7f\u53c2\u6570\u6210\u4e3a\u53ef\u9009\u7684\uff0c\u6211\u4eec\u53ea\u9700\u8981\u5c06\u5b83\u4eec\u58f0\u660e\u4e3a nullable \u6216\u63d0\u4f9b\u9ed8\u8ba4\u503c\u3002\u540e\u4e00\u79cd\u60c5\u51b5\u662f\u6700\u5e38\u89c1\u7684\u3002\u4f46\u662f\uff0c\u5982\u679c\u6211\u4eec\u91c7\u7528\u6b64\u89e3\u51b3\u65b9\u6848\uff0c\u5219\u4e0d\u80fd\u5bf9\u5904\u7406\u7a0b\u5e8f\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\u3002\u6211\u4eec\u9700\u8981\u53e6\u4e00\u79cd\u65b9\u6cd5\uff0c\u4f8b\u5982\u672c\u5730\u51fd\u6570\uff1a<\/p>\n\/\/ This won't compile\n\/\/app.MapGet("\/people", (int pageIndex = 0, int \n itemsPerPage = 50) => { });\nstring SearchMethod(int pageIndex = 0, \n int itemsPerPage = 50) => $"Sample \n result for page {pageIndex} getting \n {itemsPerPage} elements";\napp.MapGet("\/people", SearchMethod);<\/code><\/pre>\n
\n\u5728\u672c\u4f8b\u4e2d\uff0c\u6211\u4eec\u6b63\u5728\u5904\u7406\u67e5\u8be2\u5b57\u7b26\u4e32\uff0c\u4f46\u76f8\u540c\u7684\u89c4\u5219\u9002\u7528\u4e8e\u6240\u6709\u7ed1\u5b9a\u6e90\u3002<\/p>\n
\n\u8bf7\u8bb0\u4f4f\uff0c\u5982\u679c\u6211\u4eec\u4f7f\u7528\u53ef\u4e3a null \u7684\u5f15\u7528\u7c7b\u578b\uff08\u5728 .NET 6.0 \u9879\u76ee\u4e2d\u9ed8\u8ba4\u542f\u7528\uff09\uff0c\u5e76\u4e14\u6211\u4eec\u6709\u4e00\u4e2a\u53ef\u80fd\u4e3a null \u7684\u5b57\u7b26\u4e32\u53c2\u6570\uff0c\u5219\u9700\u8981\u5c06\u5176\u58f0\u660e\u4e3a\u53ef\u4e3a null\uff0c\u5426\u5219\uff0c\u6211\u4eec\u5c06\u518d\u6b21\u6536\u5230 BadHttpRequestException \u9519\u8bef\u3002\u4ee5\u4e0b\u793a\u4f8b\u6b63\u786e\u5730\u5c06 orderBy \u67e5\u8be2\u5b57\u7b26\u4e32\u53c2\u6570\u5b9a\u4e49\u4e3a\u53ef\u9009\uff1a<\/p>\napp.MapGet("\/people", (string? orderBy) => $"Results ordered by {orderBy}");<\/code><\/pre>\n
\n\u7279\u6b8a\u7ed1\u5b9a<\/p>\n
\n\u5728\u57fa\u4e8e\u63a7\u5236\u5668\u7684 Web API \u4e2d\uff0c\u4ece Microsoft.AspNetCore.Mvc.ControllerBase \u7ee7\u627f\u7684\u63a7\u5236\u5668\u6709\u6743\u8bbf\u95ee\u4e00\u4e9b\u5c5e\u6027\uff0c\u8fd9\u4e9b\u5c5e\u6027\u5141\u8bb8\u5b83\u83b7\u53d6\u8bf7\u6c42\u548c\u54cd\u5e94\u7684\u4e0a\u4e0b\u6587\uff1aHttpContext\u3001Request\u3001Response \u548c User\u3002\u5728\u6700\u5c0f\u7684 API \u4e2d\uff0c\u6211\u4eec\u6ca1\u6709\u57fa\u7c7b\uff0c\u4f46\u6211\u4eec\u4ecd\u7136\u53ef\u4ee5\u8bbf\u95ee\u6b64\u4fe1\u606f\uff0c\u56e0\u4e3a\u5b83\u88ab\u89c6\u4e3a\u4efb\u4f55\u5904\u7406\u7a0b\u5e8f\u59cb\u7ec8\u53ef\u7528\u7684\u7279\u6b8a\u7ed1\u5b9a\uff1a<\/p>\napp.MapGet("\/products", (HttpContext context, HttpRequest req, HttpResponse res, ClaimsPrincipal user) => { });<\/code><\/pre>\n
\n\u63d0\u793a : \u6211\u4eec\u8fd8\u53ef\u4ee5\u4f7f\u7528 IHttpContextAccessor \u63a5\u53e3\u8bbf\u95ee\u6240\u6709\u8fd9\u4e9b\u5bf9\u8c61\uff0c\u5c31\u50cf\u6211\u4eec\u5728\u4ee5\u524d\u7684 ASP.NET Core \u7248\u672c\u4e2d\u6240\u505a\u7684\u90a3\u6837\u3002<\/p>\n
\n\u81ea\u5b9a\u4e49\u7ed1\u5b9a<\/p>\n
\n\u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\uff0c\u53c2\u6570\u7ed1\u5b9a\u7684\u9ed8\u8ba4\u5de5\u4f5c\u65b9\u5f0f\u4e0d\u8db3\u4ee5\u6ee1\u8db3\u6211\u4eec\u7684\u76ee\u7684\u3002\u5728\u6700\u5c0f\u7684 API \u4e2d\uff0c\u6211\u4eec\u4e0d\u652f\u6301 IModelBinderProvider \u548c IModelBinder \u63a5\u53e3\uff0c\u4f46\u6211\u4eec\u6709\u4e24\u79cd\u5b9e\u73b0\u81ea\u5b9a\u4e49\u6a21\u578b\u7ed1\u5b9a\u7684\u65b9\u6cd5\u3002<\/p>\n
\n\u91cd\u8981\u63d0\u793a : \u57fa\u4e8e\u63a7\u5236\u5668\u7684\u9879\u76ee\u4e2d\u7684 IModelBinderProvider \u548c IModelBinder \u63a5\u53e3\u5141\u8bb8\u6211\u4eec\u5b9a\u4e49\u8bf7\u6c42\u6570\u636e\u548c\u5e94\u7528\u7a0b\u5e8f\u6a21\u578b\u4e4b\u95f4\u7684\u6620\u5c04\u3002ASP.NET Core \u63d0\u4f9b\u7684\u9ed8\u8ba4\u6a21\u578b Binder \u652f\u6301\u5927\u591a\u6570\u5e38\u89c1\u6570\u636e\u7c7b\u578b\uff0c\u4f46\u5982\u6709\u5fc5\u8981\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u521b\u5efa\u81ea\u5df1\u7684\u63d0\u4f9b\u7a0b\u5e8f\u6765\u6269\u5c55\u7cfb\u7edf\u3002\u6211\u4eec\u53ef\u4ee5\u5728\u4ee5\u4e0b\u94fe\u63a5\u4e2d\u627e\u5230\u66f4\u591a\u4fe1\u606f\uff1ahttps:\/\/docs.microsoft.com\/aspnet\/core\/mvc\/advanced\/custom-model-binding<\/a>\u3002<\/p>\n
\n\u5982\u679c\u6211\u4eec\u60f3\u5c06\u6765\u81ea\u8def\u7531\u3001\u67e5\u8be2\u5b57\u7b26\u4e32\u6216\u6807\u5934\u7684\u53c2\u6570\u7ed1\u5b9a\u5230\u81ea\u5b9a\u4e49\u7c7b\u578b\uff0c\u6211\u4eec\u53ef\u4ee5\u5411\u8be5\u7c7b\u578b\u6dfb\u52a0\u9759\u6001 TryParse \u65b9\u6cd5\uff1a<\/p>\n\/\/ GET \/navigate?location=43.8427,7.8527\napp.MapGet("\/navigate", (Location location) => $"Location: \n {location.Latitude}, {location.Longitude}");\npublic class Location\n{\n public double Latitude { get; set; }\n public double Longitude { get; set; }\n public static bool TryParse(string? value, \n IFormatProvider? provider, out Location? location)\n {\n if (!string.IsNullOrWhiteSpace(value))\n {\n var values = value.Split(',', \n StringSplitOptions.RemoveEmptyEntries);\n if (values.Length == 2 && double.\n TryParse(values[0],\n NumberStyles.AllowDecimalPoint, \n CultureInfo.InvariantCulture, \n out var latitude) && double.\n TryParse(values[1], NumberStyles.\n AllowDecimalPoint, CultureInfo.\n InvariantCulture, out var longitude))\n {\n location = new Location \n { Latitude = latitude, \n Longitude = longitude };\n return true;\n }\n }\n location = null;\n return false;\n }\n}<\/code><\/pre>\n
\n\u5728 TryParse \u65b9\u6cd5\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u5c1d\u8bd5\u62c6\u5206\u8f93\u5165\u53c2\u6570\u5e76\u68c0\u67e5\u5b83\u662f\u5426\u5305\u542b\u4e24\u4e2a\u5341\u8fdb\u5236\u503c\uff1a\u5728\u672c\u4f8b\u4e2d\uff0c\u6211\u4eec\u89e3\u6790\u6570\u5b57\u4ee5\u6784\u5efa Location \u5bf9\u8c61\u5e76\u8fd4\u56de true\u3002\u5426\u5219\uff0c\u6211\u4eec\u5c06\u8fd4\u56de false\uff0c\u56e0\u4e3a\u65e0\u6cd5\u521d\u59cb\u5316 Location \u5bf9\u8c61\u3002<\/p>\n
\n\u91cd\u8981\u63d0\u793a : \u5f53\u6700\u5c0f API \u53d1\u73b0\u67d0\u4e2a\u7c7b\u578b\u5305\u542b\u9759\u6001 TryParse \u65b9\u6cd5\u65f6\uff0c\u5373\u4f7f\u5b83\u662f\u4e00\u4e2a\u590d\u6742\u7c7b\u578b\uff0c\u5b83\u4e5f\u4f1a\u6839\u636e\u8def\u7531\u6a21\u677f\u5047\u5b9a\u5b83\u662f\u5728\u8def\u7531\u6216\u67e5\u8be2\u5b57\u7b26\u4e32\u4e2d\u4f20\u9012\u7684\u3002\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528 [FromHeader] \u5c5e\u6027\u6765\u66f4\u6539\u7ed1\u5b9a\u6e90\u3002\u5728\u4efb\u4f55\u60c5\u51b5\u4e0b\uff0c\u90fd\u4e0d\u4f1a\u4e3a\u8bf7\u6c42\u6b63\u6587\u8c03\u7528 TryParse\u3002<\/p>\n
\n\u5982\u679c\u6211\u4eec\u9700\u8981\u5b8c\u5168\u63a7\u5236\u7ed1\u5b9a\u7684\u6267\u884c\u65b9\u5f0f\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u7c7b\u578b\u4e0a\u5b9e\u73b0\u9759\u6001 BindAsync \u65b9\u6cd5\u3002\u8fd9\u4e0d\u662f\u4e00\u4e2a\u975e\u5e38\u5e38\u89c1\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u4f46\u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\uff0c\u5b83\u53ef\u80fd\u5f88\u6709\u7528\uff1a<\/p>\n\/\/ POST \/navigate?lat=43.8427&lon=7.8527\napp.MapPost("\/navigate", (Location location) => \n $"Location: {location.Latitude}, {location.Longitude}");\npublic class Location\n{\n \/\/ ...\n public static ValueTask<Location?> BindAsync(HttpContext \n context, ParameterInfo parameter)\n {\n if (double.TryParse(context.Request.Query["lat"], \n NumberStyles.AllowDecimalPoint, CultureInfo.\n InvariantCulture, out var latitude)&& double.\n TryParse(context.Request.Query["lon"], \n NumberStyles.AllowDecimalPoint, CultureInfo.\n InvariantCulture, out var longitude))\n {\n var location = new Location \n { Latitude = latitude, Longitude = longitude };\n return ValueTask.\n FromResult<Location?>(location);\n }\n return ValueTask.FromResult<Location?>(null);\n }\n}<\/code><\/pre>\n
\n\u6b63\u5982\u6211\u4eec\u6240\u770b\u5230\u7684\uff0cBindAsync \u65b9\u6cd5\u5c06\u6574\u4e2a HttpContext \u4f5c\u4e3a\u53c2\u6570\uff0c\u56e0\u6b64\u6211\u4eec\u53ef\u4ee5\u8bfb\u53d6\u521b\u5efa\u4f20\u9012\u7ed9\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u7684\u5b9e\u9645 Location \u5bf9\u8c61\u6240\u9700\u7684\u6240\u6709\u4fe1\u606f\u3002\u5728\u6b64\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u8bfb\u53d6\u4e24\u4e2a\u67e5\u8be2\u5b57\u7b26\u4e32\u53c2\u6570\uff08lat \u548c lon\uff09\uff0c\u4f46\uff08\u5728 POST\u3001PUT \u6216 PATCH \u65b9\u6cd5\u7684\u60c5\u51b5\u4e0b\uff09\u6211\u4eec\u8fd8\u53ef\u4ee5\u8bfb\u53d6\u8bf7\u6c42\u7684\u6574\u4e2a\u6b63\u6587\u5e76\u624b\u52a8\u89e3\u6790\u5176\u5185\u5bb9\u3002\u4f8b\u5982\uff0c\u5982\u679c\u6211\u4eec\u9700\u8981\u5904\u7406\u683c\u5f0f\u4e0d\u662f JSON \u7684\u8bf7\u6c42\uff08\u5982\u524d\u6240\u8ff0\uff0cJSON \u662f\u9ed8\u8ba4\u652f\u6301\u7684\u552f\u4e00\u683c\u5f0f\uff09\uff0c\u8fd9\u53ef\u80fd\u5f88\u6709\u7528\u3002<\/p>\n
\n\u5982\u679c BindAsync \u65b9\u6cd5\u8fd4\u56de null\uff0c\u800c\u76f8\u5e94\u7684\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u53c2\u6570\u4e0d\u80fd\u91c7\u7528\u6b64\u503c\uff08\u5982\u524d\u9762\u7684\u793a\u4f8b\u6240\u793a\uff09\uff0c\u6211\u4eec\u5c06\u6536\u5230 HttpBadRequestException \u9519\u8bef\u3002\u50cf\u5f80\u5e38\u4e00\u6837\uff0c\u5c06\u5305\u88c5\u5728 400 Bad Request \u54cd\u5e94\u4e2d\u3002<\/p>\n
\n\u91cd\u8981\u63d0\u793a : \u6211\u4eec\u4e0d\u5e94\u8be5\u4f7f\u7528\u7c7b\u578b\u540c\u65f6\u5b9a\u4e49 TryParse \u548c BindAsync \u65b9\u6cd5;\u5982\u679c\u4e24\u8005\u90fd\u5b58\u5728\uff0c\u5219 BindAsync \u59cb\u7ec8\u5177\u6709\u4f18\u5148\u6743\uff08\u5373\uff0c\u6c38\u8fdc\u4e0d\u4f1a\u8c03\u7528 TryParse\uff09\u3002<\/p>\n
\n\u73b0\u5728\u6211\u4eec\u5df2\u7ecf\u4e86\u89e3\u4e86\u53c2\u6570\u7ed1\u5b9a\u5e76\u4e86\u89e3\u4e86\u5982\u4f55\u4f7f\u7528\u5b83\u5e76\u81ea\u5b9a\u4e49\u5176\u884c\u4e3a\uff0c\u8ba9\u6211\u4eec\u770b\u770b\u5982\u4f55\u5728\u6700\u5c0f\u7684 API \u4e2d\u4f7f\u7528\u54cd\u5e94\u3002<\/p>\n
\n\u63a2\u7d22\u54cd\u5e94<\/p>\n
\n\u4e0e\u57fa\u4e8e\u63a7\u5236\u5668\u7684\u9879\u76ee\u4e00\u6837\uff0c\u4f7f\u7528\u6700\u5c0f API \u7684\u8def\u7531\u5904\u7406\u7a0b\u5e8f\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u8fd4\u56de\u5b57\u7b26\u4e32\u6216\u7c7b\uff08\u540c\u6b65\u6216\u5f02\u6b65\uff09\uff1a<\/p>\n
\n\u5982\u679c\u6211\u4eec\u8fd4\u56de\u4e00\u4e2a\u5b57\u7b26\u4e32\uff08\u5982\u4e0a\u4e00\u8282\u7684\u793a\u4f8b\u6240\u793a\uff09\uff0c\u6846\u67b6\u4f1a\u5c06\u8be5\u5b57\u7b26\u4e32\u76f4\u63a5\u5199\u5165\u54cd\u5e94\uff0c\u5c06\u5176\u5185\u5bb9\u7c7b\u578b\u8bbe\u7f6e\u4e3a text\/plain\uff0c\u5e76\u5c06\u72b6\u6001\u4ee3\u7801\u8bbe\u7f6e\u4e3a 200 OK<\/p>\n
\n\u5982\u679c\u6211\u4eec\u4f7f\u7528\u7c7b\uff0c\u5219\u5bf9\u8c61\u5c06\u5e8f\u5217\u5316\u4e3a JSON \u683c\u5f0f\uff0c\u5e76\u4f7f\u7528 application\/json \u5185\u5bb9\u7c7b\u578b\u548c 200 OK \u72b6\u6001\u4ee3\u7801\u53d1\u9001\u5230\u54cd\u5e94<\/p>\n
\n\u4f46\u662f\uff0c\u5728\u5b9e\u9645\u5e94\u7528\u7a0b\u5e8f\u4e2d\uff0c\u6211\u4eec\u901a\u5e38\u9700\u8981\u63a7\u5236\u54cd\u5e94\u7c7b\u578b\u548c\u72b6\u6001\u4ee3\u7801\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u9759\u6001 Results \u7c7b\uff0c\u8be5\u7c7b\u5141\u8bb8\u6211\u4eec\u8fd4\u56de IResult \u63a5\u53e3\u7684\u5b9e\u4f8b\uff0c\u8be5\u5b9e\u4f8b\u5728\u6700\u5c0f\u7684 API \u4e2d\u7684\u4f5c\u7528\u7c7b\u4f3c\u4e8e IActionResult \u5bf9\u63a7\u5236\u5668\u7684\u4f5c\u7528\u3002\u4f8b\u5982\uff0c\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u5b83\u6765\u8fd4\u56de 201 Created \u54cd\u5e94\uff0c\u800c\u4e0d\u662f 400 Bad Request \u6216 404 Not Found \u6d88\u606f\u3002\u6211\u4eec\u6765\u770b\u770b\u4e00\u4e9b\u4f8b\u5b50\uff1a<\/p>\napp.MapGet("\/ok", () => Results.Ok(new Person("Donald", \n "Duck")));\napp.MapGet("\/notfound", () => Results.NotFound());\napp.MapPost("\/badrequest", () =>\n{\n \/\/ Creates a 400 response with a JSON body.\n return Results.BadRequest(new { ErrorMessage = "Unable to\n complete the request" });\n});\napp.MapGet("\/download", (string fileName) => \n Results.File(fileName));\nrecord class Person(string FirstName, string LastName);<\/code><\/pre>\n
\nResults \u7c7b\u7684\u6bcf\u4e2a\u65b9\u6cd5\u90fd\u8d1f\u8d23\u8bbe\u7f6e\u4e0e\u65b9\u6cd5\u672c\u8eab\u7684\u542b\u4e49\u76f8\u5bf9\u5e94\u7684\u54cd\u5e94\u7c7b\u578b\u548c\u72b6\u6001\u4ee3\u7801\uff08\u4f8b\u5982\uff0cResults.NotFound\uff08\uff09 \u65b9\u6cd5\u8fd4\u56de 404 Not Found \u54cd\u5e94\uff09\u3002\u8bf7\u6ce8\u610f\uff0c\u5373\u4f7f\u6211\u4eec\u901a\u5e38\u9700\u8981\u5728 200 OK \u54cd\u5e94\u7684\u60c5\u51b5\u4e0b\u8fd4\u56de\u4e00\u4e2a\u5bf9\u8c61\uff08\u4f7f\u7528 Results.Ok\uff08\uff09\uff09\uff0c\u5b83\u4e5f\u4e0d\u662f\u552f\u4e00\u5141\u8bb8\u8fd9\u6837\u505a\u7684\u65b9\u6cd5\u3002\u8bb8\u591a\u5176\u4ed6\u65b9\u6cd5\u5141\u8bb8\u6211\u4eec\u5305\u542b\u81ea\u5b9a\u4e49\u54cd\u5e94;\u5728\u6240\u6709\u8fd9\u4e9b\u60c5\u51b5\u4e0b\uff0c\u54cd\u5e94\u7c7b\u578b\u90fd\u5c06\u8bbe\u7f6e\u4e3a application\/json\uff0c\u5e76\u4e14\u5bf9\u8c61\u5c06\u81ea\u52a8\u8fdb\u884c JSON \u5e8f\u5217\u5316\u3002<\/p>\n
\n\u5f53\u524d\u7248\u672c\u7684 minimal API \u4e0d\u652f\u6301\u5185\u5bb9\u534f\u5546\u3002\u53ea\u6709\u5c11\u6570\u65b9\u6cd5\u5141\u8bb8\u6211\u4eec\u663e\u5f0f\u8bbe\u7f6e\u5185\u5bb9\u7c7b\u578b\uff0c\u5f53\u4f7f\u7528 Results.Bytes\uff08\uff09\u3001Results.Stream\uff08\uff09 \u548c Results.File\uff08\uff09 \u83b7\u53d6\u6587\u4ef6\u65f6\uff0c\u6216\u8005\u4f7f\u7528 Results.Text\uff08\uff09 \u548c Results.Content\uff08\uff09 \u65f6\u3002\u5728\u6240\u6709\u5176\u4ed6\u60c5\u51b5\u4e0b\uff0c\u5f53\u6211\u4eec\u5904\u7406\u590d\u6742\u5bf9\u8c61\u65f6\uff0c\u54cd\u5e94\u5c06\u91c7\u7528 JSON \u683c\u5f0f\u3002\u8fd9\u662f\u4e00\u4e2a\u7cbe\u786e\u7684\u8bbe\u8ba1\u9009\u62e9\uff0c\u56e0\u4e3a\u5927\u591a\u6570\u5f00\u53d1\u4eba\u5458\u5f88\u5c11\u9700\u8981\u652f\u6301\u5176\u4ed6\u5a92\u4f53\u7c7b\u578b\u3002\u901a\u8fc7\u4ec5\u652f\u6301 JSON \u800c\u4e0d\u6267\u884c\u5185\u5bb9\u534f\u5546\uff0c\u6700\u5c11\u7684 API \u53ef\u4ee5\u975e\u5e38\u9ad8\u6548\u3002<\/p>\n
\n\u4f46\u662f\uff0c\u8fd9\u79cd\u65b9\u6cd5\u5e76\u975e\u5728\u6240\u6709\u60c5\u51b5\u4e0b\u90fd\u8db3\u591f\u3002\u5728\u67d0\u4e9b\u60c5\u51b5\u4e0b\uff0c\u6211\u4eec\u53ef\u80fd\u9700\u8981\u521b\u5efa\u81ea\u5b9a\u4e49\u54cd\u5e94\u7c7b\u578b\uff0c\u4f8b\u5982\uff0c\u5982\u679c\u6211\u4eec\u8981\u8fd4\u56de HTML \u6216 XML \u54cd\u5e94\u800c\u4e0d\u662f\u6807\u51c6 JSON\u3002\u6211\u4eec\u53ef\u4ee5\u624b\u52a8\u4f7f\u7528 Results.Content\uff08\uff09 \u65b9\u6cd5\uff08\u5b83\u5141\u8bb8\u6211\u4eec\u5c06\u5185\u5bb9\u6307\u5b9a\u4e3a\u5177\u6709\u7279\u5b9a\u5185\u5bb9\u7c7b\u578b\u7684\u7b80\u5355\u5b57\u7b26\u4e32\uff09\uff0c\u4f46\u662f\uff0c\u5982\u679c\u6211\u4eec\u6709\u6b64\u8981\u6c42\uff0c\u6700\u597d\u5b9e\u73b0\u81ea\u5b9a\u4e49 IResult \u7c7b\u578b\uff0c\u4ee5\u4fbf\u53ef\u4ee5\u91cd\u7528\u89e3\u51b3\u65b9\u6848\u3002<\/p>\n
\n\u4f8b\u5982\uff0c\u5047\u8bbe\u6211\u4eec\u60f3\u7528 XML \u800c\u4e0d\u662f JSON \u6765\u5e8f\u5217\u5316\u5bf9\u8c61\u3002\u7136\u540e\uff0c\u6211\u4eec\u53ef\u4ee5\u5b9a\u4e49\u4e00\u4e2a\u5b9e\u73b0 IResult \u63a5\u53e3\u7684 XmlResult \u7c7b\uff1a<\/p>\npublic class XmlResult : IResult\n{\n private readonly object value;\n public XmlResult(object value)\n {\n this.value = value;\n }\n public Task ExecuteAsync(HttpContext httpContext)\n {\n using var writer = new StringWriter();\n\n var serializer = new XmlSerializer(value.GetType());\n serializer.Serialize(writer, value);\n var xml = writer.ToString();\n httpContext.Response.ContentType = MediaTypeNames.\n Application.Xml;\n httpContext.Response.ContentLength = Encoding.UTF8\n .GetByteCount(xml);\n return httpContext.Response.WriteAsync(xml);\n }\n}<\/code><\/pre>\n
\nIResult \u63a5\u53e3\u8981\u6c42\u6211\u4eec\u5b9e\u73b0 ExecuteAsync \u65b9\u6cd5\uff0c\u8be5\u65b9\u6cd5\u63a5\u6536\u5f53\u524d HttpContext \u4f5c\u4e3a\u53c2\u6570\u3002\u6211\u4eec\u4f7f\u7528 XmlSerializer \u7c7b\u5e8f\u5217\u5316\u8be5\u503c\uff0c\u7136\u540e\u5c06\u5176\u5199\u5165\u54cd\u5e94\uff0c\u5e76\u6307\u5b9a\u6b63\u786e\u7684\u54cd\u5e94\u7c7b\u578b\u3002<\/p>\n
\n\u73b0\u5728\uff0c\u6211\u4eec\u53ef\u4ee5\u76f4\u63a5\u5728\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u4e2d\u4f7f\u7528\u65b0\u7684 XmlResult \u7c7b\u578b\u3002\u4f46\u662f\uff0c\u6700\u4f73\u5b9e\u8df5\u5efa\u8bae\u6211\u4eec\u4e3a IResultExtensions \u63a5\u53e3\u521b\u5efa\u4e00\u4e2a\u6269\u5c55\u65b9\u6cd5\uff0c\u5982\u4e0b\u6240\u793a\uff1a<\/p>\npublic static class ResultExtensions\n{\n public static IResult Xml(this IResultExtensions \n resultExtensions, object value) => new XmlResult(value);\n}<\/code><\/pre>\n
\n\u8fd9\u6837\uff0c\u6211\u4eec\u5728 Results.Extensions \u5c5e\u6027\u4e0a\u5c31\u6709\u4e86\u4e00\u4e2a\u65b0\u7684 Xml \u65b9\u6cd5\uff1a<\/p>\napp.MapGet("\/xml", () => Results.Extensions.Xml(new City { Name = "Taggia" }));\npublic record class City\n{\n public string? Name { get; init; }\n}<\/code><\/pre>\n
\n\u8fd9\u79cd\u65b9\u6cd5\u7684\u597d\u5904\u662f\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u9700\u8981\u5904\u7406 XML \u7684\u4efb\u4f55\u5730\u65b9\u91cd\u7528\u5b83\uff0c\u800c\u4e0d\u5fc5\u624b\u52a8\u5904\u7406\u5e8f\u5217\u5316\u548c\u54cd\u5e94\u7c7b\u578b\uff08\u5c31\u50cf\u6211\u4eec\u5e94\u8be5\u4f7f\u7528 Result.Content\uff08\uff09 \u65b9\u6cd5\u6240\u505a\u7684\u90a3\u6837\uff09\u3002<\/p>\n
\n\u63d0\u793a : \u5982\u679c\u6211\u4eec\u60f3\u6267\u884c\u5185\u5bb9\u9a8c\u8bc1\uff0c\u6211\u4eec\u9700\u8981\u624b\u52a8\u68c0\u67e5 HttpRequest \u5bf9\u8c61\u7684 Accept \u6807\u5934\uff0c\u6211\u4eec\u53ef\u4ee5\u5c06\u5176\u4f20\u9012\u7ed9\u6211\u4eec\u7684\u5904\u7406\u7a0b\u5e8f\uff0c\u7136\u540e\u76f8\u5e94\u5730\u521b\u5efa\u6b63\u786e\u7684\u54cd\u5e94\u3002<\/p>\n
\n\u5728\u5206\u6790\u4e86\u5982\u4f55\u5728\u6700\u5c0f API \u4e2d\u6b63\u786e\u5904\u7406\u54cd\u5e94\u4e4b\u540e\uff0c\u6211\u4eec\u5c06\u5728\u4e0b\u4e00\u8282\u4e2d\u4e86\u89e3\u5982\u4f55\u63a7\u5236\u6570\u636e\u7684\u5e8f\u5217\u5316\u548c\u53cd\u5e8f\u5217\u5316\u65b9\u5f0f\u3002<\/p>\n
\n\u63a7\u5236\u5e8f\u5217\u5316<\/p>\n
\n\u5982\u524d\u51e0\u8282\u6240\u8ff0\uff0c\u6700\u5c0f API \u4ec5\u63d0\u4f9b\u5bf9 JSON \u683c\u5f0f\u7684\u5185\u7f6e\u652f\u6301\u3002\u5177\u4f53\u800c\u8a00\uff0c\u6846\u67b6\u4f7f\u7528 System.Text.Json \u8fdb\u884c\u5e8f\u5217\u5316\u548c\u53cd\u5e8f\u5217\u5316\u3002\u5728\u57fa\u4e8e\u63a7\u5236\u5668\u7684 API \u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u66f4\u6539\u6b64\u9ed8\u8ba4\u503c\u5e76\u6539\u7528 JSON.NET\u3002\u5f53\u4f7f\u7528\u6700\u5c11\u7684 API \u65f6\uff0c\u8fd9\u662f\u4e0d\u53ef\u80fd\u7684\uff1a\u6211\u4eec\u6839\u672c\u65e0\u6cd5\u66ff\u6362\u5e8f\u5217\u5316\u5668\u3002<\/p>\n
\n\u5185\u7f6e\u5e8f\u5217\u5316\u7a0b\u5e8f\u4f7f\u7528\u4ee5\u4e0b\u9009\u9879\uff1a<\/p>\n
\n\u5e8f\u5217\u5316\u671f\u95f4\u4e0d\u533a\u5206\u5927\u5c0f\u5199\u7684\u5c5e\u6027\u540d\u79f0<\/p>\n
\n\u9a7c\u5cf0\u5f0f\u5927\u5c0f\u5199\u5c5e\u6027\u547d\u540d\u7b56\u7565<\/p>\n
\n\u652f\u6301\u5e26\u5f15\u53f7\u7684\u6570\u5b57\uff08\u6570\u5b57\u5c5e\u6027\u7684 JSON \u5b57\u7b26\u4e32\uff09<\/p>\n
\n\u6ce8\u610f : \u6211\u4eec\u53ef\u4ee5\u5728\u4ee5\u4e0b\u94fe\u63a5\u4e2d\u627e\u5230\u6709\u5173 System.Text.Json \u547d\u540d\u7a7a\u95f4\u53ca\u5176\u63d0\u4f9b\u7684\u6240\u6709 API \u7684\u66f4\u591a\u4fe1\u606f\uff1ahttps:\/\/docs.microsoft.com\/dotnet\/api\/system.text.json<\/a>\u3002<\/p>\n
\n\u5728\u57fa\u4e8e\u63a7\u5236\u5668\u7684 API \u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u901a\u8fc7\u5728 AddControllers\uff08\uff09 \u4e4b\u540e\u6d41\u7545\u5730\u8c03\u7528 AddJsonOptions\uff08\uff09 \u6765\u81ea\u5b9a\u4e49\u8fd9\u4e9b\u8bbe\u7f6e\u3002\u5728\u6700\u5c0f\u7684 API \u4e2d\uff0c\u6211\u4eec\u4e0d\u80fd\u4f7f\u7528\u8fd9\u79cd\u65b9\u6cd5\uff0c\u56e0\u4e3a\u6211\u4eec\u6839\u672c\u6ca1\u6709\u63a7\u5236\u5668\uff0c\u56e0\u6b64\u6211\u4eec\u9700\u8981\u663e\u5f0f\u8c03\u7528 JsonOptions \u7684 Configure \u65b9\u6cd5\u3002\u90a3\u4e48\uff0c\u8ba9\u6211\u4eec\u8003\u8651\u4e00\u4e0b\u8fd9\u4e2a\u5904\u7406\u7a0b\u5e8f\uff1a<\/p>\napp.MapGet("\/product", () =>\n{\n var product = new Product("Apple", null, 0.42, 6);\n return Results.Ok(product); \n});\npublic record class Product(string Name, string? Description, double UnitPrice, int Quantity)\n{\n public double TotalPrice => UnitPrice * Quantity;\n}<\/code><\/pre>\n
\n\u4f7f\u7528\u9ed8\u8ba4\u7684 JSON \u9009\u9879\uff0c\u6211\u4eec\u5f97\u5230\u4ee5\u4e0b\u7ed3\u679c\uff1a<\/p>\n{\n "name": "Apple",\n "description": null,\n "unitPrice": 0.42,\n "quantity": 6,\n "totalPrice": 2.52\n}<\/code><\/pre>\n
\n\u73b0\u5728\uff0c\u8ba9\u6211\u4eec\u914d\u7f6e JsonOptions\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nbuilder.Services.Configure<Microsoft.AspNetCore.Http.Json.\nJsonOptions>(options =>\n{\n options.SerializerOptions.DefaultIgnoreCondition = \n JsonIgnoreCondition.WhenWritingNull;\n options.SerializerOptions.IgnoreReadOnlyProperties \n = true;\n});<\/code><\/pre>\n
\n\u518d\u6b21\u8c03\u7528 \/product \u7aef\u70b9\uff0c\u6211\u4eec\u73b0\u5728\u5c06\u83b7\u5f97\u4ee5\u4e0b\u5185\u5bb9\uff1a<\/p>\n{\n "name": "Apple",\n "unitPrice": 0.42,\n "quantity": 6\n}<\/code><\/pre>\n
\n\u6b63\u5982\u9884\u671f\u7684\u90a3\u6837\uff0cDescription \u5c5e\u6027\u5c1a\u672a\u5e8f\u5217\u5316\uff0c\u56e0\u4e3a\u5b83\u4e3a null\uff0c\u4ee5\u53ca TotalPrice\uff0c\u7531\u4e8e\u5b83\u662f\u53ea\u8bfb\u7684\uff0c\u56e0\u6b64\u672a\u5305\u542b\u5728\u54cd\u5e94\u4e2d\u3002<\/p>\n
\nJsonOptions \u7684\u53e6\u4e00\u4e2a\u5178\u578b\u7528\u4f8b\u662f\u5f53\u6211\u4eec\u60f3\u8981\u6dfb\u52a0\u5c06\u81ea\u52a8\u5e94\u7528\u4e8e\u6bcf\u4e2a\u5e8f\u5217\u5316\u6216\u53cd\u5e8f\u5217\u5316\u7684\u8f6c\u6362\u5668\u65f6\uff0c\u4f8b\u5982\uff0cJsonStrinEnumConverter \u7528\u4e8e\u5c06\u679a\u4e3e\u503c\u8f6c\u6362\u4e3a\u5b57\u7b26\u4e32\u6216\u4ece\u5b57\u7b26\u4e32\u8f6c\u6362\u3002<\/p>\n
\n\u91cd\u8981\u63d0\u793a : \u8bf7\u6ce8\u610f\uff0c\u6700\u5c0f API \u4f7f\u7528\u7684 JsonOptions \u7c7b\u662f Microsoft.AspNetCore.Http.Json \u547d\u540d\u7a7a\u95f4\u4e2d\u53ef\u7528\u7684\u7c7b\u3002\u4e0d\u8981\u5c06\u5176\u4e0e Microsoft.AspNetCore.Mvc \u547d\u540d\u7a7a\u95f4\u4e2d\u5b9a\u4e49\u7684\u540d\u79f0\u6df7\u6dc6;\u5bf9\u8c61\u7684\u540d\u79f0\u76f8\u540c\uff0c\u4f46\u540e\u8005\u4ec5\u5bf9\u63a7\u5236\u5668\u6709\u6548\uff0c\u56e0\u6b64\u5982\u679c\u5728\u6700\u5c0f API \u9879\u76ee\u4e2d\u8bbe\u7f6e\uff0c\u5219\u65e0\u6548\u3002<\/p>\n
\n\u7531\u4e8e\u4ec5\u652f\u6301 JSON\uff0c\u5982\u679c\u6211\u4eec\u6ca1\u6709\u663e\u5f0f\u6dfb\u52a0\u5bf9\u5176\u4ed6\u683c\u5f0f\u7684\u652f\u6301\uff0c\u5982\u524d\u9762\u90e8\u5206\u6240\u8ff0\uff08\u4f8b\u5982\uff0c\u5728\u81ea\u5b9a\u4e49\u7c7b\u578b\u4e0a\u4f7f\u7528 BindAsync \u65b9\u6cd5\uff09\uff0c\u5219\u6700\u5c0f API \u5c06\u5728\u6b63\u6587\u7ed1\u5b9a\u6e90\u4e0a\u81ea\u52a8\u6267\u884c\u4e00\u4e9b\u9a8c\u8bc1\u5e76\u5904\u7406\u4ee5\u4e0b\u60c5\u51b5\uff1a<\/p>\n<\/p>\n
\n\u8868 2.3 \u2013 \u6b63\u6587\u7ed1\u5b9a\u95ee\u9898\u7684\u54cd\u5e94\u72b6\u6001\u4ee3\u7801<\/p>\n
\n\u5728\u8fd9\u4e9b\u60c5\u51b5\u4e0b\uff0c\u7531\u4e8e\u4e3b\u4f53\u9a8c\u8bc1\u5931\u8d25\uff0c\u6211\u4eec\u7684\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u5c06\u6c38\u8fdc\u4e0d\u4f1a\u88ab\u8c03\u7528\uff0c\u6211\u4eec\u5c06\u76f4\u63a5\u83b7\u53d6\u4e0a\u8868\u4e2d\u663e\u793a\u7684\u54cd\u5e94\u72b6\u6001\u4ee3\u7801\u3002<\/p>\n
\n\u73b0\u5728\uff0c\u6211\u4eec\u5df2\u7ecf\u6db5\u76d6\u4e86\u5f00\u59cb\u5f00\u53d1\u6700\u5c0f API \u6240\u9700\u7684\u6240\u6709\u652f\u67f1\u3002\u4f46\u662f\uff0c\u8fd8\u6709\u4e00\u4ef6\u91cd\u8981\u7684\u4e8b\u60c5\u8981\u8c08\uff1a\u8bbe\u8ba1\u771f\u5b9e\u9879\u76ee\u7684\u6b63\u786e\u65b9\u6cd5\uff0c\u4ee5\u907f\u514d\u67b6\u6784\u4e2d\u7684\u5e38\u89c1\u9519\u8bef\u3002<\/p>\n
\n\u6784\u5efa\u4e00\u4e2a\u6700\u5c0f\u7684 API \u9879\u76ee<\/p>\n
\n\u5230\u76ee\u524d\u4e3a\u6b62\uff0c\u6211\u4eec\u5df2\u7ecf\u76f4\u63a5\u5728 Program.cs \u6587\u4ef6\u4e2d\u7f16\u5199\u4e86\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u3002\u8fd9\u662f\u4e00\u4e2a\u5b8c\u5168\u652f\u6301\u7684\u573a\u666f\uff1a\u4f7f\u7528\u6700\u5c11\u7684 API\uff0c\u6211\u4eec\u53ef\u4ee5\u5728\u8fd9\u4e2a\u6587\u4ef6\u4e2d\u7f16\u5199\u6240\u6709\u4ee3\u7801\u3002\u4e8b\u5b9e\u4e0a\uff0c\u51e0\u4e4e\u6240\u6709\u6837\u672c\u90fd\u663e\u793a\u4e86\u8fd9\u79cd\u89e3\u51b3\u65b9\u6848\u3002\u7136\u800c\uff0c\u867d\u7136\u8fd9\u662f\u5141\u8bb8\u7684\uff0c\u4f46\u6211\u4eec\u53ef\u4ee5\u5f88\u5bb9\u6613\u5730\u60f3\u8c61\u8fd9\u79cd\u65b9\u6cd5\u5982\u4f55\u5bfc\u81f4\u975e\u7ed3\u6784\u5316\u7684\u3001\u56e0\u6b64\u65e0\u6cd5\u7ef4\u62a4\u7684\u9879\u76ee\u3002\u5982\u679c\u7aef\u70b9\u8f83\u5c11\uff0c\u90a3\u5f88\u597d \u2014\u2014 \u5426\u5219\uff0c\u6700\u597d\u5c06\u6211\u4eec\u7684\u5904\u7406\u7a0b\u5e8f\u7ec4\u7ec7\u5728\u5355\u72ec\u7684\u6587\u4ef6\u4e2d\u3002<\/p>\n
\n\u5047\u8bbe Program.cs \u6587\u4ef6\u4e2d\u6709\u4ee5\u4e0b\u4ee3\u7801\uff0c\u56e0\u4e3a\u6211\u4eec\u5fc5\u987b\u5904\u7406 CRUD\u4f5c\uff1a<\/p>\napp.MapGet("\/api\/people", (PeopleService peopleService) => \n { });\napp.MapGet("\/api\/people\/{id:guid}", (Guid id, PeopleService \n peopleService) => { });\napp.MapPost("\/api\/people", (Person Person, PeopleService \n people) => { });\napp.MapPut("\/api\/people\/{id:guid}", (Guid id, Person \n Person, PeopleService people) => { });\napp.MapDelete("\/api\/people\/{id:guid}", (Guid id, \n PeopleService people) => { });<\/code><\/pre>\n
\n\u5f88\u5bb9\u6613\u60f3\u8c61\uff0c\u5982\u679c\u6211\u4eec\u5728\u8fd9\u91cc\u62e5\u6709\u6240\u6709\u5b9e\u73b0\uff08\u5373\u4f7f\u6211\u4eec\u4f7f\u7528 PeopleService \u6765\u63d0\u53d6\u4e1a\u52a1\u903b\u8f91\uff09\uff0c\u6b64\u6587\u4ef6\u5f88\u5bb9\u6613\u7206\u70b8\u3002\u56e0\u6b64\uff0c\u5728\u5b9e\u9645\u573a\u666f\u4e2d\uff0c\u5185\u8054 lambda \u65b9\u6cd5\u5e76\u4e0d\u662f\u6700\u4f73\u5b9e\u8df5\u3002\u6211\u4eec\u5e94\u8be5\u4f7f\u7528 \u8def\u7531 \u90e8\u5206\u4ecb\u7ecd\u7684\u5176\u4ed6\u65b9\u6cd5\u6765\u5b9a\u4e49\u5904\u7406\u7a0b\u5e8f\u3002\u56e0\u6b64\uff0c\u521b\u5efa\u4e00\u4e2a\u5916\u90e8\u7c7b\u6765\u4fdd\u5b58\u6240\u6709\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u662f\u4e00\u4e2a\u597d\u4e3b\u610f\uff1a<\/p>\npublic class PeopleHandler\n{\n public static void MapEndpoints(IEndpointRouteBuilder \n app)\n {\n app.MapGet("\/api\/people", GetList);\n app.MapGet("\/api\/people\/{id:guid}", Get);\n app.MapPost("\/api\/people", Insert);\n app.MapPut("\/api\/people\/{id:guid}", Update);\n app.MapDelete("\/api\/people\/{id:guid}", Delete);\n }\n\n private static IResult GetList(PeopleService \n peopleService) { \/* ... *\/ }\n private static IResult Get(Guid id, PeopleService \n peopleService) { \/* ... *\/ }\n private static IResult Insert(Person person, \n PeopleService people) { \/* ... *\/ }\n private static IResult Update(Guid id, Person \n person, PeopleService people) { \/* ... *\/ }\n private static IResult Delete(Guid id) { \/* ... *\/ }\n}<\/code><\/pre>\n
\n\u6211\u4eec\u5df2\u5c06\u6240\u6709\u7aef\u70b9\u5b9a\u4e49\u5206\u7ec4\u5230 PeopleHandler.MapEndpoints \u9759\u6001\u65b9\u6cd5\u4e2d\uff0c\u8be5\u65b9\u6cd5\u5c06 IEndpointRouteBuilder \u63a5\u53e3\u4f5c\u4e3a\u53c2\u6570\uff0c\u800c\u8be5\u63a5\u53e3\u53c8\u7531 WebApplication \u7c7b\u5b9e\u73b0\u3002\u7136\u540e\uff0c\u6211\u4eec\u6ca1\u6709\u4f7f\u7528 lambda \u8868\u8fbe\u5f0f\uff0c\u800c\u662f\u4e3a\u6bcf\u4e2a\u5904\u7406\u7a0b\u5e8f\u521b\u5efa\u4e86\u5355\u72ec\u7684\u65b9\u6cd5\uff0c\u4ee5\u4fbf\u4ee3\u7801\u66f4\u52a0\u7b80\u6d01\u3002\u8fd9\u6837\uff0c\u8981\u5728\u6211\u4eec\u7684\u6700\u5c0f API \u4e2d\u6ce8\u518c\u6240\u6709\u8fd9\u4e9b\u5904\u7406\u7a0b\u5e8f\uff0c\u6211\u4eec\u53ea\u9700\u8981\u5728 Program.cs \u4e2d\u7f16\u5199\u4ee5\u4e0b\u4ee3\u7801\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\n\/\/ ..\nvar app = builder.Build();\n\/\/ ..\nPeopleHandler.MapEndpoints(app);\napp.Run();<\/code><\/pre>\n
\n\u5c55\u671b\u672a\u6765<\/p>\n
\n\u521a\u624d\u5c55\u793a\u7684\u65b9\u6cd5\u4f7f\u6211\u4eec\u80fd\u591f\u66f4\u597d\u5730\u7ec4\u7ec7\u4e00\u4e2a\u6700\u5c0f\u7684 API \u9879\u76ee\uff0c\u4f46\u4ecd\u7136\u9700\u8981\u6211\u4eec\u4e3a\u8981\u5b9a\u4e49\u7684\u6bcf\u4e2a\u5904\u7406\u7a0b\u5e8f\u663e\u5f0f\u6dfb\u52a0\u4e00\u884c to Program.cs\u3002\u4f7f\u7528\u63a5\u53e3\u548c\u4e00\u4e9b\u53cd\u5c04\uff0c\u6211\u4eec\u53ef\u4ee5\u521b\u5efa\u4e00\u4e2a\u7b80\u5355\u4e14\u53ef\u91cd\u7528\u7684\u89e3\u51b3\u65b9\u6848\uff0c\u4ee5\u6700\u5c11\u7684 API \u7b80\u5316\u6211\u4eec\u7684\u5de5\u4f5c\u3002<\/p>\n
\n\u56e0\u6b64\uff0c\u8ba9\u6211\u4eec\u4ece\u5b9a\u4e49\u4ee5\u4e0b\u63a5\u53e3\u5f00\u59cb\uff1a<\/p>\npublic interface IEndpointRouteHandler\n{\n public void MapEndpoints(IEndpointRouteBuilder app);\n}<\/code><\/pre>\n
\n\u987e\u540d\u601d\u4e49\uff0c\u6211\u4eec\u9700\u8981\u8ba9\u6240\u6709\u7684\u5904\u7406\u7a0b\u5e8f\uff08\u5c31\u50cf\u4e4b\u524d\u7684 PeopleHandler \u4e00\u6837\uff09\u5b9e\u73b0\u5b83\uff1a<\/p>\npublic class PeopleHandler : IEndpointRouteHandler\n{\n public void MapEndpoints(IEndpointRouteBuilder app)\n {\n \/\/ ...\n }\n \/\/ ...\n}<\/code><\/pre>\n
\n\u6ce8\u610f : MapEndpoints \u65b9\u6cd5\u4e0d\u518d\u662f\u9759\u6001\u7684\uff0c\u56e0\u4e3a\u5b83\u73b0\u5728\u662f IEndpointRouteHandler \u63a5\u53e3\u7684\u5b9e\u73b0\u3002<\/p>\n
\n\u73b0\u5728\uff0c\u6211\u4eec\u9700\u8981\u4e00\u4e2a\u65b0\u7684\u6269\u5c55\u65b9\u6cd5\uff0c\u8be5\u65b9\u6cd5\u4f7f\u7528\u53cd\u5c04\u626b\u63cf\u7a0b\u5e8f\u96c6\u4e2d\u5b9e\u73b0\u6b64\u63a5\u53e3\u7684\u6240\u6709\u7c7b\uff0c\u5e76\u81ea\u52a8\u8c03\u7528\u5176 MapEndpoints \u65b9\u6cd5\uff1a<\/p>\npublic static class IEndpointRouteBuilderExtensions\n{\n public static void MapEndpoints(this\n IEndpointRouteBuilder app, Assembly assembly)\n {\n var endpointRouteHandlerInterfaceType = \n typeof(IEndpointRouteHandler);\n var endpointRouteHandlerTypes = \n assembly.GetTypes().Where(t =>\n t.IsClass && !t.IsAbstract && !t.IsGenericType\n && t.GetConstructor(Type.EmptyTypes) != null\n && endpointRouteHandlerInterfaceType\n .IsAssignableFrom(t));\n foreach (var endpointRouteHandlerType in \n endpointRouteHandlerTypes)\n {\n var instantiatedType = (IEndpointRouteHandler)\n Activator.CreateInstance\n (endpointRouteHandlerType)!;\n instantiatedType.MapEndpoints(app);\n }\n }\n}<\/code><\/pre>\n
\n\u63d0\u793a : \u5982\u679c\u60a8\u60f3\u66f4\u8be6\u7ec6\u5730\u4e86\u89e3\u53cd\u5c04\u53ca\u5176\u5728 .NET \u4e2d\u7684\u5de5\u4f5c\u539f\u7406\uff0c\u53ef\u4ee5\u5148\u6d4f\u89c8\u4ee5\u4e0b\u9875\u9762\uff1ahttps:\/\/docs.microsoft.com\/dotnet\/csharp\/programming-guide\/concepts\/reflection<\/a>\u3002<\/p>\n
\n\u5b8c\u6210\u6240\u6709\u8fd9\u4e9b\u90e8\u5206\u540e\uff0c\u6700\u540e\u8981\u505a\u7684\u662f\u5728 Run\uff08\uff09 \u65b9\u6cd5\u4e4b\u524d\u8c03\u7528 Program.cs \u6587\u4ef6\u4e2d\u7684\u6269\u5c55\u65b9\u6cd5\uff1a<\/p>\napp.MapEndpoints(Assembly.GetExecutingAssembly());\napp.Run();<\/code><\/pre>\n
\n\u8fd9\u6837\uff0c\u5f53\u6211\u4eec\u6dfb\u52a0\u65b0\u7684\u5904\u7406\u7a0b\u5e8f\u65f6\uff0c\u6211\u4eec\u5e94\u8be5\u53ea\u9700\u8981\u521b\u5efa\u4e00\u4e2a\u5b9e\u73b0 IEndpointRouteHandler \u63a5\u53e3\u7684\u65b0\u7c7b\u3002Program.cs \u4e2d\u65e0\u9700\u8fdb\u884c\u5176\u4ed6\u66f4\u6539\u5373\u53ef\u5c06\u65b0\u7ec8\u7aef\u8282\u70b9\u6dfb\u52a0\u5230\u8def\u7531\u5f15\u64ce\u3002<\/p>\n
\n\u5728\u5916\u90e8\u6587\u4ef6\u4e2d\u7f16\u5199\u8def\u7531\u5904\u7406\u7a0b\u5e8f\u5e76\u8003\u8651\u4e00\u79cd\u81ea\u52a8\u5316\u7ec8\u7aef\u8282\u70b9\u6ce8\u518c\u7684\u65b9\u6cd5\uff0c\u4ee5\u4fbfProgram.cs\u4e0d\u4f1a\u56e0\u6bcf\u4e2a\u529f\u80fd\u6dfb\u52a0\u800c\u589e\u957f\uff0c\u8fd9\u662f\u6784\u5efa\u6700\u5c0f API \u9879\u76ee\u7684\u6b63\u786e\u65b9\u6cd5\u3002<\/p>\n
\n\u603b\u7ed3<\/p>\n
\nASP.NET Core \u6700\u5c0f API \u4ee3\u8868\u4e86\u5728 .NET \u73af\u5883\u4e2d\u7f16\u5199 HTTP API \u7684\u4e00\u79cd\u65b0\u65b9\u6cd5\u3002\u5728\u672c\u7ae0\u4e2d\uff0c\u6211\u4eec\u4ecb\u7ecd\u4e86\u5f00\u59cb\u5f00\u53d1\u6700\u5c0f API \u6240\u9700\u7684\u6240\u6709\u652f\u67f1\u3001\u5982\u4f55\u6709\u6548\u5730\u5904\u7406\u5b83\u4eec\uff0c\u4ee5\u53ca\u5728\u51b3\u5b9a\u9075\u5faa\u6b64\u67b6\u6784\u65f6\u8981\u8003\u8651\u7684\u6700\u4f73\u5b9e\u8df5\u3002<\/p>\n
\n\u5728\u4e0b\u4e00\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u91cd\u70b9\u4ecb\u7ecd\u4e00\u4e9b\u9ad8\u7ea7\u6982\u5ff5\uff0c\u4f8b\u5982\u4f7f\u7528 Swagger \u8bb0\u5f55 API\u3001\u5b9a\u4e49\u6b63\u786e\u7684\u9519\u8bef\u5904\u7406\u7cfb\u7edf\u4ee5\u53ca\u5c06\u6700\u5c0f API \u4e0e\u5355\u9875\u5e94\u7528\u7a0b\u5e8f\u96c6\u6210\u3002<\/p>\n3 Working with Minimal APIs<\/h1>\n
\n\u5728\u672c\u7ae0\u4e2d\uff0c\u6211\u4eec\u5c06\u5c1d\u8bd5\u5e94\u7528\u65e9\u671f\u7248\u672c\u7684 .NET \u4e2d\u63d0\u4f9b\u7684\u4e00\u4e9b\u9ad8\u7ea7\u5f00\u53d1\u6280\u672f\u3002\u6211\u4eec\u5c06\u8ba8\u8bba\u56db\u4e2a\u5f7c\u6b64\u8131\u8282\u7684\u5e38\u89c1\u4e3b\u9898\u3002<\/p>\n
\n\u6211\u4eec\u5c06\u4ecb\u7ecd\u524d\u7aef\u63a5\u53e3\u548c\u914d\u7f6e\u7ba1\u7406\u7684\u751f\u4ea7\u529b\u4e3b\u9898\u548c\u6700\u4f73\u5b9e\u8df5\u3002<\/p>\n
\n\u6bcf\u4e2a\u5f00\u53d1\u4eba\u5458\u8fdf\u65e9\u90fd\u4f1a\u9047\u5230\u6211\u4eec\u5728\u672c\u7ae0\u4e2d\u63cf\u8ff0\u7684\u95ee\u9898\u3002\u7a0b\u5e8f\u5458\u5fc5\u987b\u4e3a API \u7f16\u5199\u6587\u6863\uff0c\u5fc5\u987b\u4f7f API \u4e0e JavaScript \u524d\u7aef\u901a\u4fe1\uff0c\u5fc5\u987b\u5904\u7406\u9519\u8bef\u5e76\u5c1d\u8bd5\u4fee\u590d\u5b83\u4eec\uff0c\u5e76\u4e14\u5fc5\u987b\u6839\u636e\u53c2\u6570\u914d\u7f6e\u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u6211\u4eec\u5c06\u5728\u672c\u7ae0\u4e2d\u8ba8\u8bba\u7684\u4e3b\u9898\u5982\u4e0b\uff1a<\/p>\n
\n\u2022 Supporting CORS
\n\u2022 Working with global API settings
\n\u2022 Error handling<\/p>\n
\n\u6280\u672f\u8981\u6c42<\/p>\n
\n\u5982\u524d\u51e0\u7ae0\u6240\u8ff0\uff0c\u6709\u5fc5\u8981\u63d0\u4f9b .NET 6 \u5f00\u53d1\u6846\u67b6;\u60a8\u8fd8\u9700\u8981\u4f7f\u7528 .NET \u5de5\u5177\u6765\u8fd0\u884c\u5185\u5b58\u4e2d\u7684 Web \u670d\u52a1\u5668\u3002<\/p>\n
\n\u4e3a\u4e86\u9a8c\u8bc1\u8de8\u57df\u8d44\u6e90\u5171\u4eab \uff08CORS\uff09 \u7684\u529f\u80fd\uff0c\u6211\u4eec\u5e94\u8be5\u5229\u7528\u9a7b\u7559\u5728\u4e0e\u6211\u4eec\u5c06\u6258\u7ba1 API \u7684 HTTP \u5730\u5740\u4e0d\u540c\u7684 HTTP \u5730\u5740\u4e0a\u7684\u524d\u7aef\u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u4e3a\u4e86\u6d4b\u8bd5\u6211\u4eec\u5c06\u5728\u672c\u7ae0\u4e2d\u63d0\u51fa\u7684 CORS \u793a\u4f8b\uff0c\u6211\u4eec\u5c06\u5229\u7528\u5185\u5b58\u4e2d\u7684 Web \u670d\u52a1\u5668\uff0c\u8fd9\u5c06\u5141\u8bb8\u6211\u4eec\u6258\u7ba1\u4e00\u4e2a\u7b80\u5355\u7684\u9759\u6001 HTML \u9875\u9762\u3002<\/p>\n
\n\u56e0\u6b64\uff0c\u4e3a\u4e86\u6258\u7ba1\u7f51\u9875\uff08HTML \u548c JavaScript\uff09\uff0c\u6211\u4eec\u5c06\u4f7f\u7528 LiveReloadServer\uff0c\u60a8\u53ef\u4ee5\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u5c06\u5176\u4f5c\u4e3a .NET \u5de5\u5177\u5b89\u88c5\uff1a<\/p>\ndotnet tool install -g LiveReloadServer<\/code><\/pre>\n
\n\u672c\u7ae0\u4e2d\u7684\u6240\u6709\u4ee3\u7801\u793a\u4f8b\u90fd\u53ef\u4ee5\u5728\u672c\u4e66\u7684 GitHub \u5b58\u50a8\u5e93\u4e2d\u627e\u5230\uff0c\u7f51\u5740\u4e3a https:\/\/github.com\/PacktPublishing\/Minimal-APIs-in-ASP.NET-Core-6\/tree\/main\/Chapter03<\/a>\u3002<\/p>\n
\n\u63a2\u7d22 Swagger<\/p>\n
\nSwagger \u5df2\u7ecf\u5728\u5f88\u5927\u7a0b\u5ea6\u4e0a\u8fdb\u5165\u4e86 .NET \u5f00\u53d1\u4eba\u5458\u7684\u751f\u6d3b;\u5b83\u5df2\u51fa\u73b0\u5728\u591a\u4e2a\u7248\u672c\u7684 Visual Studio \u7684\u9879\u76ee\u67b6\u4e0a\u3002<\/p>\n
\nSwagger \u662f\u57fa\u4e8e OpenAPI \u89c4\u8303\u7684\u5de5\u5177\uff0c\u5141\u8bb8\u60a8\u4f7f\u7528 Web \u5e94\u7528\u7a0b\u5e8f\u8bb0\u5f55 API\u3002\u6839\u636e https:\/\/oai.github.io\/Documentation\/introduction.xhtml<\/a> \u4e0a\u63d0\u4f9b\u7684\u5b98\u65b9\u6587\u6863\uff1a<\/p>\n
\n\u201cOpenAPI \u89c4\u8303\u5141\u8bb8\u63cf\u8ff0\u53ef\u901a\u8fc7 HTTP \u6216\u7c7b\u4f3c HTTP \u7684\u534f\u8bae\u8bbf\u95ee\u7684\u8fdc\u7a0b API\u3002API \u5b9a\u4e49\u4e24\u4e2a\u8f6f\u4ef6\u4e4b\u95f4\u5141\u8bb8\u7684\u4ea4\u4e92\uff0c\u5c31\u50cf\u7528\u6237\u754c\u9762\u5b9a\u4e49\u7528\u6237\u4e0e\u7a0b\u5e8f\u4ea4\u4e92\u7684\u65b9\u5f0f\u4e00\u6837\u3002<\/p>\n
\nAPI \u7531\u53ef\u80fd\u8c03\u7528\u7684\u65b9\u6cd5\u5217\u8868 \uff08\u53d1\u51fa\u7684\u8bf7\u6c42\uff09 \u3001\u5b83\u4eec\u7684\u53c2\u6570\u3001\u8fd4\u56de\u503c\u548c\u5b83\u4eec\u9700\u8981\u7684\u4efb\u4f55\u6570\u636e\u683c\u5f0f \uff08\u4ee5\u53ca\u5176\u4ed6\u5185\u5bb9\uff09 \u7ec4\u6210\u3002\u8fd9\u76f8\u5f53\u4e8e\u7528\u6237\u4e0e\u624b\u673a\u5e94\u7528\u7a0b\u5e8f\u7684\u4ea4\u4e92\u4ec5\u9650\u4e8e\u5e94\u7528\u7a0b\u5e8f\u7528\u6237\u754c\u9762\u4e2d\u7684\u6309\u94ae\u3001\u6ed1\u5757\u548c\u6587\u672c\u6846\u3002<\/p>\n
\nVisual Studio \u57fa\u67b6\u4e2d\u7684 Swagger<\/p>\n
\n\u7136\u540e\u6211\u4eec\u660e\u767d\uff0c\u6b63\u5982\u6211\u4eec\u5728 .NET \u4e16\u754c\u4e2d\u6240\u77e5\u9053\u7684\u90a3\u6837\uff0cSwagger \u53ea\u4e0d\u8fc7\u662f\u4e3a\u516c\u5f00\u57fa\u4e8e Web \u7684 API \u7684\u6240\u6709\u5e94\u7528\u7a0b\u5e8f\u5b9a\u4e49\u7684\u4e00\u7ec4\u89c4\u8303\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0301.jpg\")
<\/p>\n
\n\u901a\u8fc7\u9009\u62e9\u201c\u542f\u7528 OpenAPI \u652f\u6301\u201d\uff0cVisual Studio \u5c06\u6dfb\u52a0\u4e00\u4e2a\u540d\u4e3a Swashbuckle.AspNetCore \u7684 NuGet \u5305\uff0c\u5e76\u81ea\u52a8\u5728 Program.cs \u6587\u4ef6\u4e2d\u5bf9\u5176\u8fdb\u884c\u914d\u7f6e\u3002<\/p>\n
\n\u6211\u4eec\u663e\u793a\u4e86\u968f\u65b0\u9879\u76ee\u6dfb\u52a0\u7684\u51e0\u884c\u3002\u6709\u4e86\u8fd9\u51e0\u6761\u4fe1\u606f\uff0cWeb \u5e94\u7528\u7a0b\u5e8f\u4ec5\u9488\u5bf9\u5f00\u53d1\u73af\u5883\u542f\u7528\uff0c\u8fd9\u5141\u8bb8\u5f00\u53d1\u4eba\u5458\u5728\u4e0d\u751f\u6210\u5ba2\u6237\u7aef\u6216\u4f7f\u7528\u5e94\u7528\u7a0b\u5e8f\u5916\u90e8\u5de5\u5177\u7684\u60c5\u51b5\u4e0b\u6d4b\u8bd5 API\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nbuilder.Services.AddEndpointsApiExplorer();\nbuilder.Services.AddSwaggerGen();\nvar app = builder.Build();\nif (app.Environment.IsDevelopment())\n{\n app.UseSwagger();\n app.UseSwaggerUI();\n}<\/code><\/pre>\n
\nSwagger \u751f\u6210\u7684\u56fe\u5f62\u90e8\u5206\u5927\u5927\u63d0\u9ad8\u4e86\u751f\u4ea7\u529b\uff0c\u5e76\u5141\u8bb8\u5f00\u53d1\u4eba\u5458\u4e0e\u5c06\u4e0e\u5e94\u7528\u7a0b\u5e8f\u4ea4\u4e92\u7684\u4eba\u5458\u5171\u4eab\u4fe1\u606f\uff0c\u65e0\u8bba\u662f\u524d\u7aef\u5e94\u7528\u7a0b\u5e8f\u8fd8\u662f\u673a\u5668\u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u6ce8\u610f : \u6211\u4eec\u63d0\u9192\u60a8\uff0c\u5f3a\u70c8\u5efa\u8bae\u4e0d\u8981\u5728\u751f\u4ea7\u73af\u5883\u4e2d\u542f\u7528 Swagger\uff0c\u56e0\u4e3a\u654f\u611f\u4fe1\u606f\u53ef\u80fd\u4f1a\u5728 Web \u6216\u5e94\u7528\u7a0b\u5e8f\u6240\u5728\u7684\u7f51\u7edc\u4e0a\u516c\u5f00\u66b4\u9732\u3002<\/p>\n
\n\u6211\u4eec\u5df2\u7ecf\u4e86\u89e3\u4e86\u5982\u4f55\u5c06 Swagger \u5f15\u5165\u6211\u4eec\u7684 API \u5e94\u7528\u7a0b\u5e8f;\u6b64\u529f\u80fd\u5141\u8bb8\u6211\u4eec\u8bb0\u5f55\u6211\u4eec\u7684 API\uff0c\u5e76\u5141\u8bb8\u7528\u6237\u751f\u6210\u5ba2\u6237\u7aef\u6765\u8c03\u7528\u6211\u4eec\u7684\u5e94\u7528\u7a0b\u5e8f\u3002\u8ba9\u6211\u4eec\u770b\u770b\u6211\u4eec\u5fc5\u987b\u9009\u62e9\u54ea\u4e9b\u9009\u9879\u6765\u5feb\u901f\u5c06\u5e94\u7528\u7a0b\u5e8f\u4e0e OpenAPI \u4e2d\u63cf\u8ff0\u7684 API \u8fde\u63a5\u8d77\u6765\u3002<\/p>\n
\nOpenAPI \u751f\u6210\u5668<\/p>\n
\n\u4f7f\u7528 Swagger\uff0c\u5c24\u5176\u662f OpenAPI \u6807\u51c6\uff0c\u60a8\u53ef\u4ee5\u81ea\u52a8\u751f\u6210\u5ba2\u6237\u7aef\u4ee5\u8fde\u63a5\u5230 Web \u5e94\u7528\u7a0b\u5e8f\u3002\u53ef\u4ee5\u4e3a\u591a\u79cd\u8bed\u8a00\u751f\u6210\u5ba2\u6237\u7aef\uff0c\u4e5f\u53ef\u4ee5\u4e3a\u5f00\u53d1\u5de5\u5177\u751f\u6210\u5ba2\u6237\u7aef\u3002\u6211\u4eec\u77e5\u9053\u7f16\u5199\u5ba2\u6237\u7aef\u6765\u8bbf\u95ee Web API \u662f\u591a\u4e48\u4e4f\u5473\u548c\u91cd\u590d\u3002Open API Generator \u5e2e\u52a9\u6211\u4eec\u81ea\u52a8\u751f\u6210\u4ee3\u7801\uff0c\u68c0\u67e5 Swagger \u548c OpenAPI \u5236\u4f5c\u7684 API \u6587\u6863\uff0c\u5e76\u81ea\u52a8\u751f\u6210\u4ee3\u7801\u4ee5\u4e0e API \u4ea4\u4e92\u3002\u7b80\u5355\u3001\u8f7b\u677e\uff0c\u6700\u91cd\u8981\u7684\u662f\uff0c\u5feb\u901f\u3002<\/p>\n
\n@openapitools\/openapi-generator-cli npm \u5305\u662f OpenAPI \u751f\u6210\u5668\u7684\u4e00\u4e2a\u975e\u5e38\u77e5\u540d\u7684\u5305\u5305\u88c5\u5668\uff0c\u60a8\u53ef\u4ee5\u5728 https:\/\/openapi-generator.tech\/<\/a> \u4e2d\u627e\u5230\u5b83\u3002<\/p>\n
\n\u4f7f\u7528\u6b64\u5de5\u5177\uff0c\u60a8\u53ef\u4ee5\u4e3a\u7f16\u7a0b\u8bed\u8a00\u751f\u6210\u5ba2\u6237\u7aef\u4ee5\u53ca JMeter \u548c K6 \u7b49\u8d1f\u8f7d\u6d4b\u8bd5\u5de5\u5177\u3002<\/p>\n
\n\u65e0\u9700\u5728\u8ba1\u7b97\u673a\u4e0a\u5b89\u88c5\u8be5\u5de5\u5177\uff0c\u4f46\u5982\u679c\u53ef\u4ee5\u4ece\u8ba1\u7b97\u673a\u8bbf\u95ee\u5e94\u7528\u7a0b\u5e8f\u7684 URL\uff0c\u5219\u53ef\u4ee5\u4f7f\u7528 Docker \u6620\u50cf\uff0c\u5982\u4ee5\u4e0b\u547d\u4ee4\u6240\u8ff0\uff1a<\/p>\ndocker run --rm \\\n\n -v ${PWD}:\/local openapitools\/openapi-generator-cli generate \\\n\n -i \/local\/petstore.yaml \\\n\n -g go \\\n\n -o \/local\/out\/go<\/code><\/pre>\n
\n\u8be5\u547d\u4ee4\u5141\u8bb8\u60a8\u4f7f\u7528\u6302\u8f7d\u5728 Docker \u5377\u4e0a\u7684 petstore.yaml \u6587\u4ef6\u4e2d\u627e\u5230\u7684 OpenAPI \u5b9a\u4e49\u751f\u6210 Go \u5ba2\u6237\u7aef\u3002<\/p>\n
\n\u73b0\u5728\uff0c\u8ba9\u6211\u4eec\u8be6\u7ec6\u4ecb\u7ecd\u5982\u4f55\u5728 .NET 6 \u9879\u76ee\u4e2d\u5229\u7528 Swagger \u5e76\u4f7f\u7528\u6700\u5c11\u7684 API\u3002<\/p>\n
\n\u5728\u6700\u5c11\u7684 API \u4e2d\u4f7f\u7528Swagger<\/p>\n
\n\u5728 Web API ASP.NET\uff0c\u5982\u4ee5\u4e0b\u4ee3\u7801\u6458\u5f55\u6240\u793a\uff0c\u6211\u4eec\u770b\u5230\u4e00\u4e2a\u4f7f\u7528\u5e26\u6709\u4e09\u659c\u6760 \uff08\uff09 \u7684 C# \u8bed\u8a00\u6ce8\u91ca\u8bb0\u5f55\u7684\u65b9\u6cd5\u3002<\/p>\n
\n\u5229\u7528 documentation \u90e8\u5206\u5411 API \u63cf\u8ff0\u6dfb\u52a0\u66f4\u591a\u4fe1\u606f\u3002\u6b64\u5916\uff0cProducesResponseType \u6ce8\u91ca\u53ef\u5e2e\u52a9 Swagger \u8bc6\u522b\u5ba2\u6237\u7aef\u5728\u65b9\u6cd5\u8c03\u7528\u540e\u5fc5\u987b\u5904\u7406\u7684\u53ef\u80fd\u4ee3\u7801\uff1a<\/p>\n\/\/\/ <summary>\n\/\/\/ Creates a Contact.\n\/\/\/ <\/summary>\n\/\/\/ <param name="contact"><\/param>\n\/\/\/ <returns>A newly created Contact<\/returns>\n\/\/\/ <response code="201">Returns the newly created contact<\/response>\n\/\/\/ <response code="400">If the contact is null<\/response>\n[HttpPost]\n[ProducesResponseType(StatusCodes.Status201Created)]\n[ProducesResponseType(StatusCodes.Status400BadRequest)]\npublic async Task<IActionResult> Create(Contact contactItem)\n{\n _context.Contacts.Add(contactItem);\n await _context.SaveChangesAsync();\n return CreatedAtAction(nameof(Get), new { id = \n contactItem.Id }, contactItem);\n}<\/code><\/pre>\n
\n\u9664\u4e86\u5355\u4e2a\u65b9\u6cd5\u7684\u6ce8\u91ca\u5916\uff0c\u8be5\u8bed\u8a00\u7684\u6587\u6863\u8fd8\u6307\u793a Swagger \u4e3a\u90a3\u4e9b\u968f\u540e\u5fc5\u987b\u4f7f\u7528 API \u5e94\u7528\u7a0b\u5e8f\u7684\u4eba\u63d0\u4f9b\u66f4\u591a\u4fe1\u606f\u3002\u5bf9\u53c2\u6570\u65b9\u6cd5\u7684\u63cf\u8ff0\u603b\u662f\u53d7\u5230\u90a3\u4e9b\u5fc5\u987b\u8fdb\u884c\u63a5\u53e3\u7684\u4eba\u7684\u6b22\u8fce;\u9057\u61be\u7684\u662f\uff0c\u65e0\u6cd5\u5728\u6700\u5c0f API \u4e2d\u5229\u7528\u6b64\u529f\u80fd\u3002<\/p>\n
\n\u8ba9\u6211\u4eec\u6309\u987a\u5e8f\u6765\u770b\u770b\u5982\u4f55\u5728\u5355\u4e2a\u65b9\u6cd5\u4e0a\u5f00\u59cb\u4f7f\u7528 Swagger\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nbuilder.Services.AddEndpointsApiExplorer();\nbuilder.Services.AddSwaggerGen(c =>\n{\n c.SwaggerDoc("v1", new() \n { \n Title = builder.Environment.ApplicationName,\n Version = "v1", Contact = new() \n { Name = "PacktAuthor", Email = "authors@packtpub.com",\n Url = new Uri("https:\/\/www.packtpub.com\/") },\n Description = "PacktPub Minimal API - Swagger",\n License = new Microsoft.OpenApi.Models.\n OpenApiLicense(),\n TermsOfService = new("https:\/\/www.packtpub.com\/")\n});\n});\nvar app = builder.Build();\nif (app.Environment.IsDevelopment())\n{\n app.UseSwagger();\n app.UseSwaggerUI();\n}<\/code><\/pre>\n
\n\u5728\u7b2c\u4e00\u4e2a\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u914d\u7f6e\u4e86 Swagger \u548c\u5e38\u89c4 Swagger \u4fe1\u606f\u3002\u6211\u4eec\u6dfb\u52a0\u4e86\u4e30\u5bcc Swagger UI \u7684\u5176\u4ed6\u4fe1\u606f\u3002\u552f\u4e00\u7684\u5fc5\u586b\u4fe1\u606f\u662f\u6807\u9898\uff0c\u800c\u7248\u672c\u3001\u8054\u7cfb\u4eba\u3001\u63cf\u8ff0\u3001\u8bb8\u53ef\u8bc1\u548c\u670d\u52a1\u6761\u6b3e\u662f\u53ef\u9009\u7684\u3002<\/p>\n
\nUseSwaggerUI\uff08\uff09 \u65b9\u6cd5\u81ea\u52a8\u914d\u7f6e\u653e\u7f6e UI \u548c\u63cf\u8ff0 OpenAPI \u683c\u5f0f API \u7684 JSON \u6587\u4ef6\u7684\u4f4d\u7f6e\u3002<\/p>\n
\n\u8fd9\u662f\u56fe\u5f62\u7ea7\u522b\u7684\u7ed3\u679c\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0302.jpg\")
<\/p>\n
\n\u6211\u4eec\u53ef\u4ee5\u7acb\u5373\u770b\u5230 OpenAPI \u5408\u7ea6\u4fe1\u606f\u5df2\u7ecf\u653e\u5728 \/swagger\/v1\/swagger.json \u8def\u5f84\u4e0b\u3002<\/p>\n
\n\u8054\u7cfb\u4fe1\u606f\u5df2\u586b\u5145\uff0c\u4f46\u672a\u62a5\u544a\u4efb\u4f55\u4f5c\uff0c\u56e0\u4e3a\u6211\u4eec\u5c1a\u672a\u8f93\u5165\u4efb\u4f55\u4f5c\u3002API \u5e94\u8be5\u6709\u7248\u672c\u63a7\u5236\u5417\uff1f\u5728\u53f3\u4e0a\u89d2\uff0c\u6211\u4eec\u53ef\u4ee5\u4e3a\u6bcf\u4e2a\u7248\u672c\u9009\u62e9\u53ef\u7528\u7684\u4f5c\u3002<\/p>\n
\n\u6211\u4eec\u53ef\u4ee5\u81ea\u5b9a\u4e49 Swagger URL \u5e76\u5c06\u6587\u6863\u63d2\u5165\u5230\u65b0\u8def\u5f84\u4e0a;\u91cd\u8981\u7684\u662f\u91cd\u65b0\u5b9a\u4e49 SwaggerEndpoint\uff0c\u5982\u4e0b\u6240\u793a\uff1a<\/p>\napp.UseSwaggerUI(c => c.SwaggerEndpoint("\/swagger\/v1\/swagger.json", $"{builder.Environment.ApplicationName} v1"));<\/code><\/pre>\n
\n\u73b0\u5728\uff0c\u6211\u4eec\u7ee7\u7eed\u6dfb\u52a0\u63cf\u8ff0\u4e1a\u52a1\u903b\u8f91\u7684\u7ec8\u7aef\u8282\u70b9\u3002<\/p>\n
\n\u5b9a\u4e49 RouteHandlerBuilder \u975e\u5e38\u91cd\u8981\uff0c\u56e0\u4e3a\u5b83\u5141\u8bb8\u6211\u4eec\u63cf\u8ff0\u6211\u4eec\u5728\u4ee3\u7801\u4e2d\u7f16\u5199\u7684\u7aef\u70b9\u7684\u6240\u6709\u5c5e\u6027\u3002<\/p>\n
\n\u5fc5\u987b\u5c3d\u53ef\u80fd\u4e30\u5bcc Swagger \u7684 UI;\u6211\u4eec\u6700\u591a\u53ea\u80fd\u63cf\u8ff0\u6700\u5c0f API \u5141\u8bb8\u6211\u4eec\u6307\u5b9a\u7684\u5185\u5bb9\u3002\u9057\u61be\u7684\u662f\uff0c\u5e76\u975e\u6240\u6709\u529f\u80fd\u90fd\u53ef\u7528\uff0c\u5c31\u50cf ASP.NET Web API \u4e00\u6837\u3002<\/p>\n
\n\u5728\u6700\u5c11\u7684 API \u4e2d\u8fdb\u884c\u7248\u672c\u63a7\u5236<\/p>\n
\n\u6700\u5c0f API \u4e2d\u7684\u7248\u672c\u63a7\u5236\u4e0d\u5728\u6846\u67b6\u529f\u80fd\u4e2d\u5904\u7406;\u56e0\u6b64\uff0c\u5373\u4f7f\u662f Swagger \u4e5f\u65e0\u6cd5\u5904\u7406 UI \u7aef API \u7248\u672c\u63a7\u5236\u3002\u56e0\u6b64\uff0c\u6211\u4eec\u89c2\u5bdf\u5230\uff0c\u5f53\u6211\u4eec\u8f6c\u5230\u56fe 3.2 \u6240\u793a\u7684 Select a definition \u90e8\u5206\u65f6\uff0c\u53ea\u6709\u5f53\u524d\u7248\u672c API \u7684\u4e00\u4e2a\u6761\u76ee\u53ef\u89c1\u3002<\/p>\n
\nSwagger \u529f\u80fd<\/p>\n
\n\u6211\u4eec\u521a\u521a\u610f\u8bc6\u5230\u5e76\u975e\u6240\u6709\u529f\u80fd\u5728 Swagger \u4e2d\u90fd\u53ef\u7528;\u73b0\u5728\u8ba9\u6211\u4eec\u6765\u63a2\u7d22\u4e00\u4e0b\u53ef\u7528\u7684\u5185\u5bb9\u3002\u4e3a\u4e86\u63cf\u8ff0\u7ec8\u7aef\u8282\u70b9\u7684\u53ef\u80fd\u8f93\u51fa\u503c\uff0c\u6211\u4eec\u53ef\u4ee5\u8c03\u7528\u53ef\u4ee5\u5728\u5904\u7406\u7a0b\u5e8f\u4e4b\u540e\u8c03\u7528\u7684\u51fd\u6570\uff0c\u4f8b\u5982 Produces \u6216 WithTags \u51fd\u6570\uff0c\u6211\u4eec\u73b0\u5728\u5c06\u63a2\u8ba8\u8fd9\u4e9b\u51fd\u6570\u3002<\/p>\n
\nProduces \u51fd\u6570\u4f7f\u7528\u5ba2\u6237\u7aef\u5e94\u8be5\u80fd\u591f\u7ba1\u7406\u7684\u6240\u6709\u53ef\u80fd\u7684\u54cd\u5e94\u6765\u88c5\u9970\u7ec8\u7aef\u8282\u70b9\u3002\u6211\u4eec\u53ef\u4ee5\u6dfb\u52a0\u4f5c ID \u7684\u540d\u79f0;\u6b64\u4fe1\u606f\u4e0d\u4f1a\u663e\u793a\u5728 Swagger \u5c4f\u5e55\u4e2d\uff0c\u4f46\u5b83\u5c06\u662f\u5ba2\u6237\u7aef\u521b\u5efa\u8c03\u7528\u7ec8\u7ed3\u70b9\u7684\u65b9\u6cd5\u65f6\u4f7f\u7528\u7684\u540d\u79f0\u3002OperationId \u662f\u5904\u7406\u7a0b\u5e8f\u53ef\u7528\u7684\u4f5c\u7684\u552f\u4e00\u540d\u79f0\u3002<\/p>\n
\n\u8981\u4ece API \u63cf\u8ff0\u4e2d\u6392\u9664\u7ec8\u7aef\u8282\u70b9\uff0c\u60a8\u9700\u8981\u8c03\u7528 ExcludeFromDescription\uff08\uff09\u3002\u6b64\u51fd\u6570\u5f88\u5c11\u4f7f\u7528\uff0c\u4f46\u5728\u60a8\u4e0d\u60f3\u5c06\u7aef\u70b9\u516c\u5f00\u7ed9\u6b63\u5728\u5f00\u53d1\u524d\u7aef\u7684\u7a0b\u5e8f\u5458\u7684\u60c5\u51b5\u4e0b\uff0c\u5b83\u975e\u5e38\u6709\u7528\uff0c\u56e0\u4e3a\u8be5\u7279\u5b9a\u7aef\u70b9\u7531\u673a\u5668\u5e94\u7528\u7a0b\u5e8f\u4f7f\u7528\u3002<\/p>\n
\n\u6700\u540e\uff0c\u6211\u4eec\u53ef\u4ee5\u6dfb\u52a0\u548c\u6807\u8bb0\u5404\u79cd\u7ec8\u7aef\u8282\u70b9\uff0c\u5e76\u5bf9\u5176\u8fdb\u884c\u7ec6\u5206\u4ee5\u66f4\u597d\u5730\u7ba1\u7406\u5ba2\u6237\u7aef\uff1a<\/p>\napp.MapGet("\/sampleresponse", () =>\n {\n return Results.Ok(new ResponseData("My Response"));\n })\n .Produces<ResponseData>(StatusCodes.Status200OK)\n .WithTags("Sample")\n .WithName("SampleResponseOperation"); \/\/ operation ids to \n Open API\napp.MapGet("\/sampleresponseskipped", () =>\n{\n return Results.Ok(new ResponseData("My Response Skipped"));\n})\n .ExcludeFromDescription();\napp.MapGet("\/{id}", (int id) => Results.Ok(id));\napp.MapPost("\/", (ResponseData data) => Results.Ok(data))\n .Accepts<ResponseData>(MediaTypeNames.Application.Json);<\/code><\/pre>\n
\n\u8fd9\u662f Swagger \u7684\u56fe\u5f62\u7ed3\u679c;\u6b63\u5982\u6211\u4e4b\u524d\u6240\u9884\u6599\u7684\u90a3\u6837\uff0cWeb \u5ba2\u6237\u7aef\u4e0d\u4f1a\u663e\u793a\u6807\u7b7e\u548c\u4f5c ID\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0303.jpg\")
<\/p>\n
\n\u56fe 3.3 \u2013 Swagger UI \u65b9\u6cd5<\/p>\n
\n\u53e6\u4e00\u65b9\u9762\uff0c\u7ec8\u7aef\u8282\u70b9\u63cf\u8ff0\u975e\u5e38\u6709\u7528\u3002\u8fd9\u5f88\u5bb9\u6613\u5b9e\u73b0\uff1a\u53ea\u9700\u5728\u65b9\u6cd5\u4e2d\u63d2\u5165 C# \u6ce8\u91ca\uff08\u53ea\u9700\u5728\u65b9\u6cd5\u4e2d\u63d2\u5165\u4e09\u4e2a\u659c\u6760 \uff0c \u5373\u53ef\uff09\u3002Minimal API \u6ca1\u6709\u6211\u4eec\u5728\u57fa\u4e8e Web \u7684\u63a7\u5236\u5668\u4e2d\u4e60\u60ef\u7684\u65b9\u6cd5\uff0c\u56e0\u6b64\u5b83\u4eec\u672c\u8eab\u4e0d\u53d7\u652f\u6301\u3002<\/p>\n
\nSwagger \u4e0d\u4ec5\u4ec5\u662f\u6211\u4eec\u4e60\u60ef\u770b\u5230\u7684 GUI\u3002\u9996\u5148\uff0cSwagger \u662f\u652f\u6301 OpenAPI \u89c4\u8303\u7684 JSON \u6587\u4ef6\uff0c\u6700\u65b0\u7248\u672c\u4e3a 3.1.0\u3002<\/p>\n
\n\u5728\u4ee5\u4e0b\u4ee3\u7801\u6bb5\u4e2d\uff0c\u6211\u4eec\u663e\u793a\u4e86\u5305\u542b\u6211\u4eec\u5728 API \u4e2d\u63d2\u5165\u7684\u7b2c\u4e00\u4e2a\u7ec8\u7aef\u8282\u70b9\u7684\u63cf\u8ff0\u7684\u90e8\u5206\u3002\u6211\u4eec\u53ef\u4ee5\u63a8\u65ad tag \u548c\u4f5c ID;\u6b64\u4fe1\u606f\u5c06\u7531\u5c06\u4e0e API \u4ea4\u4e92\u7684\u4eba\u5458\u4f7f\u7528\uff1a<\/p>\n"paths": {\n "\/sampleresponse": {\n "get": {\n "tags": [\n "Sample"\n ],\n "operationId": "SampleResponseOperation",\n "responses": {\n "200": {\n "description": "Success",\n "content": {\n "application\/json": {\n "schema": {\n "$ref": "#\/components\/schemas\/ResponseData"\n }\n }\n }\n }\n }\n }\n },<\/code><\/pre>\n
\n\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u4e86\u89e3\u4e86\u5982\u4f55\u914d\u7f6e Swagger \u4ee5\u53ca\u5f53\u524d\u5c1a\u4e0d\u652f\u6301\u7684\u5185\u5bb9\u3002<\/p>\n
\n\u5728\u63a5\u4e0b\u6765\u7684\u7ae0\u8282\u4e2d\uff0c\u6211\u4eec\u8fd8\u5c06\u4e86\u89e3\u5982\u4f55\u914d\u7f6e OpenAPI\uff0c\u5305\u62ec OpenID Connect \u6807\u51c6\u548c\u901a\u8fc7 API \u5bc6\u94a5\u8fdb\u884c\u8eab\u4efd\u9a8c\u8bc1\u3002<\/p>\n
\n\u5728 Swagger UI \u7684\u524d\u9762\u7684\u4ee3\u7801\u7247\u6bb5\u4e2d\uff0cSwagger \u4f7f\u6240\u6d89\u53ca\u5bf9\u8c61\u7684\u793a\u610f\u56fe\u53ef\u7528\uff0c\u5305\u62ec\u5165\u7ad9\u5230\u5404\u4e2a\u7aef\u70b9\u548c\u4ece\u5b83\u4eec\u51fa\u7ad9\u7684\u793a\u610f\u56fe\u3002<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0304.jpg\")
<\/p>\n
\n\u56fe 3.4 \u2013 \u8f93\u5165\u548c\u8f93\u51fa\u6570\u636e\u67b6\u6784<\/p>\n
\n\u6211\u4eec\u5c06\u5728\u7b2c 6 \u7ae0 \u63a2\u7d22\u9a8c\u8bc1\u548c\u6620\u5c04 \u4e2d\u5b66\u4e60\u5982\u4f55\u5904\u7406\u8fd9\u4e9b\u5bf9\u8c61\u4ee5\u53ca\u5982\u4f55\u9a8c\u8bc1\u548c\u5b9a\u4e49\u5b83\u4eec\u3002<\/p>\n
\nSwagger OperationFilter<\/p>\n
\n\u4f5c\u7b5b\u9009\u5668\u5141\u8bb8\u60a8\u5411 Swagger \u663e\u793a\u7684\u6240\u6709\u4f5c\u6dfb\u52a0\u884c\u4e3a\u3002\u5728\u4ee5\u4e0b\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u5c06\u5411\u60a8\u5c55\u793a\u5982\u4f55\u5411\u7279\u5b9a\u8c03\u7528\u6dfb\u52a0 HTTP \u6807\u5934\uff0c\u5e76\u6309 OperationId \u5bf9\u5176\u8fdb\u884c\u7b5b\u9009\u3002<\/p>\n
\n\u5728\u5b9a\u4e49\u4f5c\u7b5b\u9009\u6761\u4ef6\u65f6\uff0c\u60a8\u8fd8\u53ef\u4ee5\u6839\u636e\u8def\u7531\u3001\u6807\u7b7e\u548c\u4f5c ID \u8bbe\u7f6e\u7b5b\u9009\u6761\u4ef6\uff1a<\/p>\npublic class CorrelationIdOperationFilter : IOperationFilter\n{\n private readonly IWebHostEnvironment environment;\n public CorrelationIdOperationFilter(IWebHostEnvironment \n environment)\n {\n this.environment = environment;\n }\n \/\/\/ <summary>\n \/\/\/ Apply header in parameter Swagger.\n \/\/\/ We add default value in parameter for developer \n environment\n \/\/\/ <\/summary>\n \/\/\/ <param name="operation"><\/param>\n \/\/\/ <param name="context"><\/param>\n public void Apply(OpenApiOperation operation, \n OperationFilterContext context)\n {\n if (operation.Parameters == null)\n {\n operation.Parameters = new \n List<OpenApiParameter>();\n }\n if (operation.OperationId == \n "SampleResponseOperation")\n {\n operation.Parameters.Add(new OpenApiParameter\n {\n Name = "x-correlation-id",\n In = ParameterLocation.Header,\n Required = false,\n Schema = new OpenApiSchema { Type = \n "String", Default = new OpenApiString("42") }\n });\n }\n }\n}<\/code><\/pre>\n
\n\u8981\u5b9a\u4e49\u4f5c\u8fc7\u6ee4\u5668\uff0c\u5fc5\u987b\u5b9e\u73b0 IOperationFilter \u63a5\u53e3\u3002<\/p>\n
\n\u5728\u6784\u9020\u51fd\u6570\u4e2d\uff0c\u60a8\u53ef\u4ee5\u5b9a\u4e49\u4e4b\u524d\u5728 dependency inject \u5f15\u64ce\u4e2d\u6ce8\u518c\u7684\u6240\u6709\u63a5\u53e3\u6216\u5bf9\u8c61\u3002<\/p>\n
\n\u7136\u540e\uff0c\u7b5b\u9009\u5668\u7531\u4e00\u4e2a\u540d\u4e3a Apply \u7684\u65b9\u6cd5\u7ec4\u6210\uff0c\u8be5\u65b9\u6cd5\u63d0\u4f9b\u4e24\u4e2a\u5bf9\u8c61\uff1a<\/p>\n
\n\u2022 OperationFilterContext: The filter context that allows you to read ApiDescription, where you can find the URL of the current endpoint<\/p>\n
\n\u6700\u540e\uff0c\u8981\u5728 Swagger \u4e2d\u542f\u7528\u4f5c\u7b5b\u9009\u5668\uff0c\u6211\u4eec\u9700\u8981\u5728 SwaggerGen \u65b9\u6cd5\u4e2d\u6ce8\u518c\u5b83\u3002<\/p>\n
\n\u5728\u6b64\u65b9\u6cd5\u4e2d\uff0c\u6211\u4eec\u5e94\u8be5\u6dfb\u52a0\u8fc7\u6ee4\u5668\uff0c\u5982\u4e0b\u6240\u793a\uff1a<\/p>\nbuilder.Services.AddSwaggerGen(c =>\n{\n \u2026 removed for brevity\n c.OperationFilter<CorrelationIdOperationFilter>();\n});<\/code><\/pre>\n
\n\u4e0b\u9762\u662f UI \u7ea7\u522b\u7684\u7ed3\u679c;\u5728\u7ec8\u7aef\u8282\u70b9\u4e2d\uff0c\u5e76\u4e14\u4ec5\u9488\u5bf9\u7279\u5b9a\u7684\u4f5c ID\uff0c\u6211\u4eec\u5c06\u6709\u4e00\u4e2a\u5e26\u6709 default \u53c2\u6570\u7684\u65b0 mandatory \u6807\u5934\uff0c\u5728\u5f00\u53d1\u4e2d\uff0c\u4e0d\u5fc5\u63d2\u5165\u8be5\u53c2\u6570\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0305.jpg\")
<\/p>\n
\n\u56fe 3.5 \u2013 API \u5bc6\u94a5\u90e8\u5206<\/p>\n
\n\u5f53\u6211\u4eec\u6709\u4e00\u4e2a\u9700\u8981\u8bbe\u7f6e\u7684 API \u5bc6\u94a5\u5e76\u4e14\u6211\u4eec\u4e0d\u60f3\u5728\u6bcf\u6b21\u8c03\u7528\u65f6\u90fd\u63d2\u5165\u5b83\u65f6\uff0c\u8fd9\u4e2a\u6848\u4f8b\u7814\u7a76\u5bf9\u6211\u4eec\u6709\u5f88\u5927\u5e2e\u52a9\u3002<\/p>\n
\n\u751f\u4ea7\u4e2d\u7684\u4f5c\u8fc7\u6ee4\u5668<\/p>\n
\n\u7531\u4e8e\u4e0d\u5e94\u5728\u751f\u4ea7\u73af\u5883\u4e2d\u542f\u7528 Swagger\uff0c\u56e0\u6b64\u8fc7\u6ee4\u5668\u53ca\u5176\u9ed8\u8ba4\u503c\u4e0d\u4f1a\u9020\u6210\u5e94\u7528\u7a0b\u5e8f\u5b89\u5168\u95ee\u9898\u3002<\/p>\n
\n\u5efa\u8bae\u60a8\u5728\u751f\u4ea7\u73af\u5883\u4e2d\u5173\u95ed Swagger\u3002<\/p>\n
\n\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u5f04\u6e05\u695a\u4e86\u5982\u4f55\u542f\u7528\u63cf\u8ff0 API \u5e76\u5141\u8bb8\u6211\u4eec\u6d4b\u8bd5\u5b83\u7684 UI \u5de5\u5177\u3002\u5728\u4e0b\u4e00\u8282\u4e2d\uff0c\u6211\u4eec\u5c06\u4e86\u89e3\u5982\u4f55\u901a\u8fc7 CORS \u542f\u7528\u5355\u9875\u5e94\u7528\u7a0b\u5e8f \uff08SPA\uff09 \u4e0e\u540e\u7aef\u4e4b\u95f4\u7684\u8c03\u7528\u3002<\/p>\n
\n\u542f\u7528 CORS<\/p>\n
\nCORS \u662f\u4e00\u79cd\u5b89\u5168\u673a\u5236\uff0c\u5982\u679c HTTP\/S \u8bf7\u6c42\u6765\u81ea\u4e0e\u6258\u7ba1\u5e94\u7528\u7a0b\u5e8f\u7684\u57df\u4e0d\u540c\u7684\u57df\uff0c\u5219 HTTP\/S \u8bf7\u6c42\u5c06\u88ab\u963b\u6b62\u3002\u6709\u5173\u8be6\u7ec6\u4fe1\u606f\uff0c\u8bf7\u53c2\u9605 Microsoft \u6587\u6863\u6216 Mozilla \u5f00\u53d1\u4eba\u5458\u7f51\u7ad9\u3002<\/p>\n
\n\u6d4f\u89c8\u5668\u4f1a\u963b\u6b62\u7f51\u9875\u5411\u63d0\u4f9b\u8be5\u7f51\u9875\u7684\u57df\u4ee5\u5916\u7684\u57df\u53d1\u51fa\u8bf7\u6c42\u3002\u7f51\u9875\u3001SPA \u6216\u670d\u52a1\u5668\u7aef\u7f51\u9875\u53ef\u4ee5\u5411\u6258\u7ba1\u5728\u4e0d\u540c\u6e90\u4e2d\u7684\u591a\u4e2a\u540e\u7aef API \u53d1\u51fa HTTP \u8bf7\u6c42\u3002<\/p>\n
\n\u6b64\u9650\u5236\u79f0\u4e3a\u540c\u6e90\u7b56\u7565\u3002\u540c\u6e90\u7b56\u7565\u53ef\u9632\u6b62\u6076\u610f\u7ad9\u70b9\u4ece\u5176\u4ed6\u7ad9\u70b9\u8bfb\u53d6\u6570\u636e\u3002\u6d4f\u89c8\u5668\u4e0d\u4f1a\u963b\u6b62 HTTP \u8bf7\u6c42\uff0c\u4f46\u4f1a\u963b\u6b62\u54cd\u5e94\u6570\u636e\u3002<\/p>\n
\n\u56e0\u6b64\uff0c\u6211\u4eec\u7406\u89e3\u5fc5\u987b\u8c28\u614e\u8bc4\u4f30\u4e0e\u5b89\u5168\u76f8\u5173\u7684 CORS \u8d44\u683c\u3002<\/p>\n
\n\u6700\u5e38\u89c1\u7684\u60c5\u51b5\u662f\u5728 Web \u670d\u52a1\u5668\u4e0a\u53d1\u5e03\u7684 SPA\uff0c\u8fd9\u4e9b SPA \u7684 Web \u5730\u5740\u4e0e\u6258\u7ba1\u6700\u5c0f API \u7684 Web \u670d\u52a1\u5668\u4e0d\u540c\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0306.jpg\")
<\/p>\n
\n\u56fe 3.6 \u2013 SPA \u548c\u6700\u5c0f API<\/p>\n
\n\u7c7b\u4f3c\u7684\u573a\u666f\u662f\u5fae\u670d\u52a1\uff0c\u5b83\u4eec\u9700\u8981\u76f8\u4e92\u901a\u4fe1\u3002\u6bcf\u4e2a\u5fae\u670d\u52a1\u5c06\u9a7b\u7559\u5728\u4e00\u4e2a\u4e0e\u5176\u4ed6\u5fae\u670d\u52a1\u4e0d\u540c\u7684\u7279\u5b9a Web \u5730\u5740\u4e0a\u3002<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0307.jpg\")
<\/p>\n
\n\u56fe 3.7 \u2013 \u5fae\u670d\u52a1\u548c\u6700\u5c11\u7684 API<\/p>\n
\n\u56e0\u6b64\uff0c\u5728\u6240\u6709\u8fd9\u4e9b\u60c5\u51b5\u4e0b\uff0c\u90fd\u4f1a\u9047\u5230 CORS \u95ee\u9898\u3002<\/p>\n
\n\u73b0\u5728\uff0c\u6211\u4eec\u4e86\u89e3\u4e86\u53ef\u80fd\u53d1\u751f CORS \u8bf7\u6c42\u7684\u60c5\u51b5\u3002\u73b0\u5728\u8ba9\u6211\u4eec\u770b\u770b\u6b63\u786e\u7684 HTTP \u8bf7\u6c42\u6d41\u662f\u4ec0\u4e48\uff0c\u4ee5\u53ca\u6d4f\u89c8\u5668\u5982\u4f55\u5904\u7406\u8bf7\u6c42\u3002<\/p>\n
\n\u6765\u81ea HTTP \u8bf7\u6c42\u7684 CORS \u6d41<\/p>\n
\n\u5f53\u8c03\u7528\u79bb\u5f00\u6d4f\u89c8\u5668\u524d\u5f80\u6258\u7ba1\u524d\u7aef\u7684\u5730\u5740\u4ee5\u5916\u7684\u5176\u4ed6\u5730\u5740\u65f6\uff0c\u4f1a\u53d1\u751f\u4ec0\u4e48\u60c5\u51b5\uff1f<\/p>\n
\nHTTP \u8c03\u7528\u88ab\u6267\u884c\uff0c\u5e76\u4e00\u76f4\u8fdb\u5165\u540e\u7aef\u4ee3\u7801\uff0c\u540e\u7aef\u4ee3\u7801\u6b63\u786e\u6267\u884c\u3002<\/p>\n
\n\u5305\u542b\u6b63\u786e\u6570\u636e\u7684\u54cd\u5e94\u88ab\u6d4f\u89c8\u5668\u963b\u6b62\u3002\u8fd9\u5c31\u662f\u4e3a\u4ec0\u4e48\u5f53\u6211\u4eec\u4f7f\u7528 Postman\u3001Fiddler \u6216\u4efb\u4f55 HTTP \u5ba2\u6237\u7aef\u6267\u884c\u8c03\u7528\u65f6\uff0c\u54cd\u5e94\u4f1a\u6b63\u786e\u5230\u8fbe\u6211\u4eec\u3002<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0308.jpg\")
<\/p>\n
\n\u56fe 3.8 \u2013 CORS \u6d41\u7a0b<\/p>\n
\n\u5728\u4e0b\u56fe\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u770b\u5230\u6d4f\u89c8\u5668\u4f7f\u7528 OPTIONS \u65b9\u6cd5\u8fdb\u884c\u4e86\u7b2c\u4e00\u6b21\u8c03\u7528\uff0c\u540e\u7aef\u4ee5 204 \u72b6\u6001\u7801\u6b63\u786e\u54cd\u5e94\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0309.jpg\")
<\/p>\n
\n\u56fe 3.9 \u2013 CORS \u8c03\u7528\u7684\u7b2c\u4e00\u4e2a\u8bf7\u6c42\uff08204 No Content \u7ed3\u679c\uff09<\/p>\n
\n\u5728\u6d4f\u89c8\u5668\u8fdb\u884c\u7684\u7b2c\u4e8c\u6b21\u8c03\u7528\u4e2d\uff0c\u4f1a\u53d1\u751f\u9519\u8bef;strict-origin-when-cross-origin \u503c\u663e\u793a\u5728 Referrer Policy \u4e2d\uff0c\u8be5\u503c\u8868\u793a\u6d4f\u89c8\u5668\u62d2\u7edd\u63a5\u53d7\u6765\u81ea\u540e\u7aef\u7684\u6570\u636e\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0310.jpg\")
<\/p>\n
\n\u56fe 3.10 \u2013 CORS \u8c03\u7528\u7684\u7b2c\u4e8c\u4e2a\u8bf7\u6c42\uff08\u88ab\u6d4f\u89c8\u5668\u963b\u6b62\uff09<\/p>\n
\n\u542f\u7528 CORS \u540e\uff0c\u5728\u5bf9 OPTIONS \u65b9\u6cd5\u8c03\u7528\u7684\u54cd\u5e94\u4e2d\uff0c\u5c06\u63d2\u5165\u4e09\u4e2a\u6807\u5934\uff0c\u8fd9\u4e9b\u6807\u5934\u5177\u6709\u540e\u7aef\u613f\u610f\u9075\u5faa\u7684\u7279\u5f81\uff1a<\/p>\n![](\"\/images\/masteringminimalapsinaspnetcore\/0311.jpg\")
<\/p>\n
\n\u56fe 3.11 \u2013 \u8bf7\u6c42 CORS \u8c03\u7528\uff08\u542f\u7528 CORS\uff09<\/p>\n
\n\u5728\u672c\u4f8b\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u770b\u5230\u6dfb\u52a0\u4e86\u4e09\u4e2a\u6807\u5934\uff0c\u5206\u522b\u5b9a\u4e49 Access-Control-Allow-Headers\u3001Access-Control-Allow-Methods \u548c Access-Control-Allow-Origin\u3002<\/p>\n
\n\u5177\u6709\u6b64\u4fe1\u606f\u7684\u6d4f\u89c8\u5668\u53ef\u4ee5\u63a5\u53d7\u6216\u963b\u6b62\u5bf9\u6b64 API \u7684\u54cd\u5e94\u3002<\/p>\n
\n\u4f7f\u7528\u7b56\u7565\u8bbe\u7f6e CORS<\/p>\n
\n\u5728 .NET 6 \u5e94\u7528\u7a0b\u5e8f\u4e2d\u53ef\u4ee5\u4f7f\u7528\u8bb8\u591a\u914d\u7f6e\u6765\u6fc0\u6d3b CORS\u3002\u6211\u4eec\u53ef\u4ee5\u5b9a\u4e49\u6388\u6743\u7b56\u7565\uff0c\u5728\u5176\u4e2d\u53ef\u4ee5\u914d\u7f6e\u56db\u4e2a\u53ef\u7528\u8bbe\u7f6e\u3002\u8fd8\u53ef\u4ee5\u901a\u8fc7\u6dfb\u52a0\u6269\u5c55\u65b9\u6cd5\u6216\u6ce8\u91ca\u6765\u6fc0\u6d3b CORS\u3002<\/p>\n
\n\u4f46\u662f\uff0c\u8ba9\u6211\u4eec\u6309\u987a\u5e8f\u8fdb\u884c\u5427\u3002<\/p>\n
\norsPolicyBuilder \u7c7b\u5141\u8bb8\u6211\u4eec\u5b9a\u4e49 CORS \u63a5\u53d7\u7b56\u7565\u4e2d\u5141\u8bb8\u6216\u4e0d\u5141\u8bb8\u7684\u5185\u5bb9\u3002<\/p>\n
\n\u56e0\u6b64\uff0c\u6211\u4eec\u53ef\u4ee5\u8bbe\u7f6e\u4e0d\u540c\u7684\u65b9\u6cd5\uff0c\u4f8b\u5982\uff1a<\/p>\n
\n\u2022 AllowAnyMethod
\n\u2022 AllowAnyOrigin
\n\u2022 AllowCredentials<\/p>\n
\n\u867d\u7136\u524d\u4e09\u79cd\u65b9\u6cd5\u662f\u63cf\u8ff0\u6027\u7684\uff0c\u5e76\u5141\u8bb8\u6211\u4eec\u5206\u522b\u542f\u7528\u4e0e HTTP \u8c03\u7528\u7684\u6807\u5934\u3001\u65b9\u6cd5\u548c\u6765\u6e90\u76f8\u5173\u7684\u4efb\u4f55\u8bbe\u7f6e\uff0c\u4f46 AllowCredentials \u5141\u8bb8\u6211\u4eec\u5c06 Cookie \u4e0e\u8eab\u4efd\u9a8c\u8bc1\u51ed\u636e\u4e00\u8d77\u5305\u542b\u3002<\/p>\n
\nCORS \u7b56\u7565\u5efa\u8bae<\/p>\n
\n\u6211\u4eec\u5efa\u8bae\u60a8\u4e0d\u8981\u4f7f\u7528 AllowAny \u65b9\u6cd5\uff0c\u800c\u662f\u7b5b\u9009\u6389\u5fc5\u8981\u7684\u4fe1\u606f\u4ee5\u63d0\u9ad8\u5b89\u5168\u6027\u3002\u4f5c\u4e3a\u6700\u4f73\u5b9e\u8df5\uff0c\u5728\u542f\u7528 CORS \u65f6\uff0c\u6211\u4eec\u5efa\u8bae\u4f7f\u7528\u4ee5\u4e0b\u65b9\u6cd5\uff1a<\/p>\n
\n\u2022 WithHeaders
\n\u2022 WithOrigins<\/p>\n
\n\u4e3a\u4e86\u6a21\u62df CORS \u7684\u573a\u666f\uff0c\u6211\u4eec\u521b\u5efa\u4e86\u4e00\u4e2a\u5177\u6709\u4e09\u4e2a\u4e0d\u540c\u6309\u94ae\u7684\u7b80\u5355\u524d\u7aef\u5e94\u7528\u7a0b\u5e8f\u3002\u6bcf\u4e2a\u6309\u94ae\u90fd\u5141\u8bb8\u60a8\u5728\u6700\u5c0f API \u4e2d\u6d4b\u8bd5 CORS \u7684\u4e00\u79cd\u53ef\u80fd\u914d\u7f6e\u3002\u6211\u4eec\u5c06\u7528\u51e0\u884c\u6765\u89e3\u91ca\u8fd9\u4e9b\u914d\u7f6e\u3002<\/p>\n
\n\u4e3a\u4e86\u542f\u7528 CORS \u65b9\u6848\uff0c\u6211\u4eec\u521b\u5efa\u4e86\u4e00\u4e2a\u5355\u9875\u5e94\u7528\u7a0b\u5e8f\uff0c\u8be5\u5e94\u7528\u7a0b\u5e8f\u53ef\u4ee5\u5728\u5185\u5b58\u4e2d\u7684 Web \u670d\u52a1\u5668\u4e0a\u542f\u52a8\u3002\u6211\u4eec\u4f7f\u7528\u4e86 LiveReloadServer\uff0c\u8fd9\u662f\u4e00\u4e2a\u53ef\u4ee5\u4f7f\u7528 .NET CLI \u5b89\u88c5\u7684\u5de5\u5177\u3002\u6211\u4eec\u5728\u672c\u7ae0\u7684\u5f00\u5934\u8ba8\u8bba\u8fc7\u5b83\uff0c\u73b0\u5728\u662f\u65f6\u5019\u4f7f\u7528\u5b83\u4e86\u3002<\/p>\n
\n\u5b89\u88c5\u540e\uff0c\u60a8\u9700\u8981\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u542f\u52a8 SPA\uff1a<\/p>\nlivereloadserver "{BasePath}\\Chapter03\\2-CorsSample\\Frontend"<\/code><\/pre>\n
\n\u6b64\u5904\uff0cBasePath \u662f\u60a8\u8981\u4e0b\u8f7d GitHub \u4e0a\u53ef\u7528\u793a\u4f8b\u7684\u6587\u4ef6\u5939\u3002<\/p>\n
\n\u7136\u540e\uff0c\u60a8\u5fc5\u987b\u4f7f\u7528\u4ee5\u4e0b\u547d\u4ee4\u901a\u8fc7 Visual Studio \u6216 Visual Studio Code \u6216\u901a\u8fc7 .NET CLI \u542f\u52a8\u5e94\u7528\u7a0b\u5e8f\u540e\u7aef\uff1a<\/p>\ndotnet run .\\Backend\\CorsSample.csproj<\/code><\/pre>\n
\n\u6211\u4eec\u5df2\u7ecf\u60f3\u51fa\u4e86\u5982\u4f55\u5f00\u59cb\u4e00\u4e2a\u7a81\u51fa CORS \u95ee\u9898\u7684\u793a\u4f8b;\u73b0\u5728\u6211\u4eec\u9700\u8981\u914d\u7f6e\u670d\u52a1\u5668\u4ee5\u63a5\u53d7\u8bf7\u6c42\u5e76\u901a\u77e5\u6d4f\u89c8\u5668\u5b83\u77e5\u9053\u8bf7\u6c42\u6765\u81ea\u4e0d\u540c\u7684\u6765\u6e90\u3002<\/p>\n
\n\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u8ba8\u8bba\u7b56\u7565\u914d\u7f6e\u3002\u6211\u4eec\u5c06\u4e86\u89e3\u9ed8\u8ba4\u7b56\u7565\u7684\u7279\u5f81\u4ee5\u53ca\u5982\u4f55\u521b\u5efa\u81ea\u5b9a\u4e49\u7b56\u7565\u3002<\/p>\n
\n\u914d\u7f6e\u9ed8\u8ba4\u7b56\u7565<\/p>\n
\n\u8981\u914d\u7f6e\u5355\u4e2a CORS \u542f\u7528\u7b56\u7565\uff0c\u60a8\u9700\u8981\u5728 Program.cs \u6587\u4ef6\u4e2d\u5b9a\u4e49\u884c\u4e3a\u5e76\u6dfb\u52a0\u6240\u9700\u7684\u914d\u7f6e\u3002\u8ba9\u6211\u4eec\u5b9e\u73b0\u4e00\u4e2a\u7b56\u7565\u5e76\u5c06\u5176\u5b9a\u4e49\u4e3a Default\u3002<\/p>\n
\n\u7136\u540e\uff0c\u8981\u4e3a\u6574\u4e2a\u5e94\u7528\u7a0b\u5e8f\u542f\u7528\u7b56\u7565\uff0c\u53ea\u9700\u6dfb\u52a0 app.UseCors\uff08\uff09;\u5728\u5b9a\u4e49\u5904\u7406\u7a0b\u5e8f\u4e4b\u524d\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nvar corsPolicy = new CorsPolicyBuilder("http:\/\/localhost:5200")\n .AllowAnyHeader()\n .AllowAnyMethod()\n .Build();\nbuilder.Services.AddCors(c => c.AddDefaultPolicy(corsPolicy));\nvar app = builder.Build();\napp.UseCors();\napp.MapGet("\/api\/cors", () =>\n{\n return Results.Ok(new { CorsResultJson = true });\n});\napp.Run();<\/code><\/pre>\n
\n\u914d\u7f6e\u81ea\u5b9a\u4e49\u7b56\u7565<\/p>\n
\n\u6211\u4eec\u53ef\u4ee5\u5728\u4e00\u4e2a\u5e94\u7528\u7a0b\u5e8f\u4e2d\u521b\u5efa\u591a\u4e2a\u7b56\u7565;\u6bcf\u4e2a\u7b56\u7565\u53ef\u80fd\u6709\u81ea\u5df1\u7684\u914d\u7f6e\uff0c\u5e76\u4e14\u6bcf\u4e2a\u7b56\u7565\u53ef\u80fd\u4e0e\u4e00\u4e2a\u6216\u591a\u4e2a\u7ec8\u7aef\u8282\u70b9\u5173\u8054\u3002<\/p>\n
\n\u5bf9\u4e8e\u5fae\u670d\u52a1\uff0c\u62e5\u6709\u591a\u4e2a\u7b56\u7565\u6709\u52a9\u4e8e\u7cbe\u786e\u5206\u6bb5\u6765\u81ea\u4e0d\u540c\u6765\u6e90\u7684\u8bbf\u95ee\u3002<\/p>\n
\n\u8981\u914d\u7f6e\u65b0\u7b56\u7565\uff0c\u5fc5\u987b\u6dfb\u52a0\u8be5\u7b56\u7565\u5e76\u4e3a\u5176\u547d\u540d;\u6b64\u540d\u79f0\u5c06\u6388\u4e88\u5bf9\u7b56\u7565\u7684\u8bbf\u95ee\u6743\u9650\uff0c\u5e76\u5141\u8bb8\u5b83\u4e0e\u7ec8\u7aef\u8282\u70b9\u5173\u8054\u3002<\/p>\n
\n\u5982\u524d\u9762\u7684\u793a\u4f8b\u6240\u793a\uff0c\u81ea\u5b9a\u4e49\u7b56\u7565\u88ab\u5206\u914d\u7ed9\u6574\u4e2a\u5e94\u7528\u7a0b\u5e8f\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nvar corsPolicy = new CorsPolicyBuilder("http:\/\/localhost:5200")\n .AllowAnyHeader()\n .AllowAnyMethod()\n .Build();\nbuilder.Services.AddCors(options => options.AddPolicy("MyCustomPolicy", corsPolicy));\nvar app = builder.Build();\napp.UseCors("MyCustomPolicy");\napp.MapGet("\/api\/cors", () =>\n{\n return Results.Ok(new { CorsResultJson = true });\n});\napp.Run();<\/code><\/pre>\n
\n\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u4e86\u89e3\u5982\u4f55\u5c06\u5355\u4e2a\u7b56\u7565\u5e94\u7528\u4e8e\u7279\u5b9a\u7ec8\u7aef\u8282\u70b9;\u4e3a\u6b64\uff0c\u6709\u4e24\u79cd\u65b9\u6cd5\u53ef\u4f9b\u9009\u62e9\u3002\u7b2c\u4e00\u79cd\u662f\u901a\u8fc7 IEndpointConventionBuilder \u63a5\u53e3\u7684\u6269\u5c55\u65b9\u6cd5\u3002\u7b2c\u4e8c\u79cd\u65b9\u6cd5\u662f\u6dfb\u52a0 EnableCors \u6ce8\u91ca\uff0c\u540e\u8ddf\u8981\u4e3a\u8be5\u65b9\u6cd5\u542f\u7528\u7684\u7b56\u7565\u7684\u540d\u79f0\u3002<\/p>\n
\n\u4f7f\u7528\u6269\u5c55\u8bbe\u7f6e CORS<\/p>\n
\n\u5fc5\u987b\u4f7f\u7528 RequireCors \u65b9\u6cd5\uff0c\u540e\u8ddf\u7b56\u7565\u7684\u540d\u79f0\u3002<\/p>\n
\n\u4f7f\u7528\u6b64\u65b9\u6cd5\uff0c\u53ef\u4ee5\u4e3a\u7ec8\u7aef\u8282\u70b9\u542f\u7528\u4e00\u4e2a\u6216\u591a\u4e2a\u7b56\u7565\uff1a<\/p>\napp.MapGet("\/api\/cors\/extension", () =>\n{\n return Results.Ok(new { CorsResultJson = true });\n})\n.RequireCors("MyCustomPolicy");<\/code><\/pre>\n
\n\u4f7f\u7528\u6ce8\u91ca\u8bbe\u7f6e CORS<\/p>\n
\n\u7b2c\u4e8c\u79cd\u65b9\u6cd5\u662f\u6dfb\u52a0 EnableCors \u6ce8\u91ca\uff0c\u540e\u8ddf\u8981\u4e3a\u8be5\u65b9\u6cd5\u542f\u7528\u7684\u7b56\u7565\u7684\u540d\u79f0\uff1a<\/p>\napp.MapGet("\/api\/cors\/annotation", [EnableCors("MyCustomPolicy")] () =>\n{\n return Results.Ok(new { CorsResultJson = true });\n});<\/code><\/pre>\n
\n\u5173\u4e8e\u63a7\u5236\u5668\u7f16\u7a0b\uff0c\u5f88\u5feb\u5c31\u4f1a\u53d1\u73b0\u4e0d\u53ef\u80fd\u5c06\u7b56\u7565\u5e94\u7528\u4e8e\u7279\u5b9a\u63a7\u5236\u5668\u7684\u6240\u6709\u65b9\u6cd5\u3002\u4e5f\u65e0\u6cd5\u5bf9\u63a7\u5236\u5668\u8fdb\u884c\u5206\u7ec4\u5e76\u542f\u7528\u7b56\u7565\u3002\u56e0\u6b64\uff0c\u6709\u5fc5\u8981\u5c06\u5355\u4e2a\u7b56\u7565\u5e94\u7528\u4e8e\u65b9\u6cd5\u6216\u6574\u4e2a\u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u4e86\u89e3\u4e86\u5982\u4f55\u4e3a\u6258\u7ba1\u5728\u4e0d\u540c\u57df\u4e0a\u7684\u5e94\u7528\u7a0b\u5e8f\u914d\u7f6e\u6d4f\u89c8\u5668\u4fdd\u62a4\u3002<\/p>\n
\n\u5728\u4e0b\u4e00\u8282\u4e2d\uff0c\u6211\u4eec\u5c06\u5f00\u59cb\u914d\u7f6e\u6211\u4eec\u7684\u5e94\u7528\u7a0b\u5e8f\u3002<\/p>\n
\n\u4f7f\u7528\u5168\u5c40 API \u8bbe\u7f6e<\/p>\n
\n\u6211\u4eec\u521a\u521a\u5b9a\u4e49\u4e86\u5982\u4f55\u5728 ASP.NET \u5e94\u7528\u7a0b\u5e8f\u4e2d\u4f7f\u7528 options \u6a21\u5f0f\u52a0\u8f7d\u6570\u636e\u3002\u5728\u672c\u8282\u4e2d\uff0c\u6211\u4eec\u60f3\u63cf\u8ff0\u5982\u4f55\u914d\u7f6e\u5e94\u7528\u7a0b\u5e8f\u5e76\u5229\u7528\u6211\u4eec\u5728\u4e0a\u4e00\u8282\u4e2d\u770b\u5230\u7684\u6240\u6709\u5185\u5bb9\u3002<\/p>\n
\n\u968f\u7740 .NET Core \u7684\u8bde\u751f\uff0c\u8be5\u6807\u51c6\u5df2\u4ece Web.config \u6587\u4ef6\u79fb\u81f3 appsettings.json \u6587\u4ef6\u3002\u8fd8\u53ef\u4ee5\u4ece\u5176\u4ed6\u6765\u6e90\u8bfb\u53d6\u914d\u7f6e\uff0c\u4f8b\u5982\u5176\u4ed6\u6587\u4ef6\u683c\u5f0f\uff0c\u5982\u65e7.ini\u6587\u4ef6\u6216\u4f4d\u7f6e\u6587\u4ef6\u3002<\/p>\n
\n\u5728\u6700\u5c0f API \u4e2d\uff0c\u9009\u9879\u6a21\u5f0f\u529f\u80fd\u4fdd\u6301\u4e0d\u53d8\uff0c\u4f46\u5728\u63a5\u4e0b\u6765\u7684\u51e0\u6bb5\u4e2d\uff0c\u6211\u4eec\u5c06\u770b\u5230\u5982\u4f55\u91cd\u7528\u63a5\u53e3\u6216 appsettings.json \u6587\u4ef6\u7ed3\u6784\u3002<\/p>\n
\n.NET 6 \u4e2d\u7684\u914d\u7f6e<\/p>\n
\n\u4ece .NET \u63d0\u4f9b\u7684\u5bf9\u8c61\u662f IConfiguration\uff0c\u5b83\u5141\u8bb8\u6211\u4eec\u8bfb\u53d6 appsettings \u6587\u4ef6\u4e2d\u7684\u4e00\u4e9b\u7279\u5b9a\u914d\u7f6e\u3002<\/p>\n
\n\u4f46\u662f\uff0c\u5982\u524d\u6240\u8ff0\uff0c\u6b64\u63a5\u53e3\u7684\u4f5c\u7528\u4e0d\u4ec5\u4ec5\u662f\u8bbf\u95ee\u6587\u4ef6\u8fdb\u884c\u8bfb\u53d6\u3002<\/p>\n
\n\u4ee5\u4e0b\u6458\u5f55\u81ea\u5b98\u65b9\u6587\u6863\u6709\u52a9\u4e8e\u6211\u4eec\u4e86\u89e3\u63a5\u53e3\u5982\u4f55\u6210\u4e3a\u5141\u8bb8\u6211\u4eec\u8bbf\u95ee\u63d2\u5165\u5404\u79cd\u670d\u52a1\u4e2d\u7684\u6570\u636e\u7684\u901a\u7528\u63a5\u5165\u70b9\uff1a<\/p>\n
\nASP.NET Core \u4e2d\u7684\u914d\u7f6e\u662f\u4f7f\u7528\u4e00\u4e2a\u6216\u591a\u4e2a\u914d\u7f6e\u63d0\u4f9b\u7a0b\u5e8f\u6267\u884c\u7684\u3002\u914d\u7f6e\u63d0\u4f9b\u7a0b\u5e8f\u4f7f\u7528\u5404\u79cd\u914d\u7f6e\u6e90\u4ece\u952e\u503c\u5bf9\u4e2d\u8bfb\u53d6\u914d\u7f6e\u6570\u636e\u3002<\/p>\n
\n\u4ee5\u4e0b\u662f\u914d\u7f6e\u6e90\u7684\u5217\u8868\uff1a<\/p>\n
\n\u2022 Environment variables
\n\u2022 Azure Key Vault
\n\u2022 Azure App Configuration
\n\u2022 Command-line arguments
\n\u2022 Custom providers, installed or created
\n\u2022 Directory files
\n\u2022 In-memory .NET objects<\/p>\n
\n\u6211\u4eec\u5c06\u5728\u4e0b\u4e00\u7ae0\u4e2d\u770b\u5230\u7684 IConfiguration \u548c IOptions \u63a5\u53e3\u65e8\u5728\u4ece\u5404\u79cd\u63d0\u4f9b\u7a0b\u5e8f\u8bfb\u53d6\u6570\u636e\u3002\u8fd9\u4e9b\u63a5\u53e3\u4e0d\u9002\u5408\u5728\u7a0b\u5e8f\u8fd0\u884c\u65f6\u8bfb\u53d6\u548c\u7f16\u8f91\u914d\u7f6e\u6587\u4ef6\u3002<\/p>\n
\nIConfiguration \u63a5\u53e3\u53ef\u901a\u8fc7 builder \u5bf9\u8c61 builder \u83b7\u5f97\u3002Configuration\uff0c\u5b83\u63d0\u4f9b\u8bfb\u53d6\u503c\u3001\u5bf9\u8c61\u6216\u8fde\u63a5\u5b57\u7b26\u4e32\u6240\u9700\u7684\u6240\u6709\u65b9\u6cd5\u3002<\/p>\n
\n\u5728\u67e5\u770b\u4e86\u6211\u4eec\u5c06\u7528\u4e8e\u914d\u7f6e\u5e94\u7528\u7a0b\u5e8f\u7684\u6700\u91cd\u8981\u7684\u63a5\u53e3\u4e4b\u4e00\u4e4b\u540e\uff0c\u6211\u4eec\u60f3\u8981\u5b9a\u4e49\u826f\u597d\u7684\u5f00\u53d1\u5b9e\u8df5\u5e76\u4e3a\u4efb\u4f55\u5f00\u53d1\u4eba\u5458\u4f7f\u7528\u4e00\u4e2a\u57fa\u672c\u6784\u5efa\u5757\uff1a\u5373\u7c7b\u3002\u5c06\u914d\u7f6e\u590d\u5236\u5230\u7c7b\u4e2d\u5c06\u4f7f\u6211\u4eec\u80fd\u591f\u66f4\u597d\u5730\u4eab\u53d7\u4ee3\u7801\u4e2d\u4efb\u4f55\u4f4d\u7f6e\u7684\u5185\u5bb9\u3002<\/p>\n
\n\u6211\u4eec\u5b9a\u4e49\u5305\u542b\u5c5e\u6027\u7684\u7c7b\u548c\u5bf9\u5e94\u7684 appsettings \u6587\u4ef6\u7684\u7c7b\uff1a<\/p>\npublic class MyCustomObject\n{\n public string? CustomProperty { get; init; }\n}\npublic class MyCustomStartupObject\n{\n public string? CustomProperty { get; init; }\n}<\/code><\/pre>\n
\n\u5728\u8fd9\u91cc\uff0c\u6211\u4eec\u8fd4\u56de\u6211\u4eec\u521a\u521a\u770b\u5230\u7684 C# \u7c7b\u7684\u76f8\u5e94 JSON\uff1a<\/p>\n
\nappsettings.json\u5b9a\u4e49<\/p>\n{\n "MyCustomObject": {\n "CustomProperty": "PropertyValue"\n },\n "MyCustomStartupObject": {\n "CustomProperty": "PropertyValue"\n },\n "ConnectionStrings": {\n "Default": "MyConnectionstringValueInAppsettings"\n }\n}<\/code><\/pre>\n
\n\u63a5\u4e0b\u6765\uff0c\u6211\u4eec\u5c06\u6267\u884c\u51e0\u9879\u4f5c\u3002<\/p>\n
\n\u6211\u4eec\u6267\u884c\u7684\u7b2c\u4e00\u4e2a\u4f5c\u5c06\u521b\u5efa\u4e00\u4e2a startupConfig \u5bf9\u8c61\u7684\u5b9e\u4f8b\uff0c\u8be5\u5b9e\u4f8b\u5c06\u4e3a MyCustomStartupObject \u7c7b\u578b\u3002\u4e3a\u4e86\u586b\u5145\u6b64\u5bf9\u8c61\u7684\u5b9e\u4f8b\uff0c\u901a\u8fc7 IConfiguration\uff0c\u6211\u4eec\u5c06\u4ece\u540d\u4e3a MyCustomStartupObject \u7684\u90e8\u5206\u8bfb\u53d6\u6570\u636e\uff1a<\/p>\nvar startupConfig = builder.Configuration.GetSection(nameof(MyCustomStartupObject)).Get<MyCustomStartupObject>();<\/code><\/pre>\n
\n\u7136\u540e\uff0c\u65b0\u521b\u5efa\u7684\u5bf9\u8c61\u53ef\u4ee5\u5728\u6700\u5c0f API \u7684\u5404\u79cd\u5904\u7406\u7a0b\u5e8f\u4e2d\u4f7f\u7528\u3002<\/p>\n
\n\u76f8\u53cd\uff0c\u5728\u7b2c\u4e8c\u4e2a\u4f5c\u4e2d\uff0c\u6211\u4eec\u4f7f\u7528\u4f9d\u8d56\u9879\u6ce8\u5165\u5f15\u64ce\u6765\u8bf7\u6c42 IConfiguration \u5bf9\u8c61\u7684\u5b9e\u4f8b\uff1a<\/p>\napp.MapGet("\/read\/configurations", (IConfiguration configuration) =>\n{\n var customObject = configuration.\n GetSection(nameof(MyCustomObject)).Get<MyCustomObject>();<\/code><\/pre>\nGet<T>()<\/code> method.
\n\u4f7f\u7528 IConfiguration \u5bf9\u8c61\uff0c\u6211\u4eec\u5c06\u68c0\u7d22\u6570\u636e\uff0c\u7c7b\u4f3c\u4e8e\u521a\u624d\u63cf\u8ff0\u7684\u4f5c\u3002\u6211\u4eec\u9009\u62e9 GetSection\uff08nameof\uff08MyCustomObject\uff09\uff09 \u90e8\u5206\uff0c\u5e76\u4f7f\u7528Get<T>()<\/code>\u65b9\u6cd5\u952e\u5165\u5bf9\u8c61\u3002<\/p>\n
\n\u6700\u540e\uff0c\u5728\u6700\u540e\u4e24\u4e2a\u793a\u4f8b\u4e2d\uff0c\u6211\u4eec\u8bfb\u53d6\u4e86\u4e00\u4e2a\u952e\uff0c\u8be5\u952e\u4f4d\u4e8e appsettings \u6587\u4ef6\u7684\u6839\u7ea7\u522b\uff1a<\/p>\nMyCustomValue = configuration.GetValue<string>("MyCustomValue"),\nConnectionString = configuration.GetConnectionString("Default"),<\/code><\/pre>\nconfiguration.GetValue<T>(\u201cJsonRootKey\u201d)<\/code> method extracts the value of a key and converts it into an object; this method is used to read strings or numbers from a root-level property.
\nconfiguration.GetValue<T>(\u201cJsonRootKey\u201d)<\/code> \u65b9\u6cd5\u63d0\u53d6\u952e\u7684\u503c\u5e76\u5c06\u5176\u8f6c\u6362\u4e3a\u5bf9\u8c61;\u6b64\u65b9\u6cd5\u7528\u4e8e\u4ece\u6839\u7ea7\u522b\u5c5e\u6027\u4e2d\u8bfb\u53d6\u5b57\u7b26\u4e32\u6216\u6570\u5b57\u3002<\/p>\n
\n\u5728\u4e0b\u4e00\u884c\u4e2d\uff0c\u6211\u4eec\u53ef\u4ee5\u770b\u5230\u5982\u4f55\u5229\u7528 IConfiguration \u65b9\u6cd5\u6765\u8bfb\u53d6 ConnectionString\u3002<\/p>\n
\n\u5728 appsettings \u6587\u4ef6\u4e2d\uff0c\u8fde\u63a5\u5b57\u7b26\u4e32\u653e\u7f6e\u5728\u7279\u5b9a\u90e8\u5206 ConnectionStrings \u4e2d\uff0c\u8be5\u90e8\u5206\u5141\u8bb8\u4f60\u547d\u540d\u548c\u8bfb\u53d6\u5b57\u7b26\u4e32\u3002\u53ef\u4ee5\u5728\u6b64\u90e8\u5206\u4e2d\u653e\u7f6e\u591a\u4e2a\u8fde\u63a5\u5b57\u7b26\u4e32\uff0c\u4ee5\u4fbf\u5728\u4e0d\u540c\u7684\u5bf9\u8c61\u4e2d\u5229\u7528\u5b83\u3002<\/p>\n
\n\u5728 Azure \u5e94\u7528\u670d\u52a1\u7684\u914d\u7f6e\u63d0\u4f9b\u7a0b\u5e8f\u4e2d\uff0c\u5e94\u8f93\u5165\u8fde\u63a5\u5b57\u7b26\u4e32\uff0c\u5e76\u5e26\u6709\u4e00\u4e2a\u524d\u7f00\uff0c\u8be5\u524d\u7f00\u4e5f\u6307\u793a\u4f60\u5c1d\u8bd5\u4f7f\u7528\u7684 SQL \u63d0\u4f9b\u7a0b\u5e8f\uff0c\u5982\u4ee5\u4e0b\u94fe\u63a5\u6240\u8ff0\uff1ahttps:\/\/docs.microsoft.com\/azure\/app-service\/configure-common#configure-connection-strings<\/a>\u3002<\/p>\n
\n\u5728\u8fd0\u884c\u65f6\uff0c\u8fde\u63a5\u5b57\u7b26\u4e32\u53ef\u7528\u4f5c\u73af\u5883\u53d8\u91cf\uff0c\u524d\u7f00\u4e3a\u4ee5\u4e0b\u8fde\u63a5\u7c7b\u578b\uff1a<\/p>\n
\n\u2022 MySQL: MYSQLCONNSTR<\/em>
\n\u2022 SQLAzure: SQLAZURECONNSTR
\n\u2022 Custom: CUSTOMCONNSTR<\/em>
\n\u2022 PostgreSQL: POSTGRESQLCONNSTR_<\/p>\n
\n\u4e3a\u4e86\u5b8c\u6574\u8d77\u89c1\uff0c\u6211\u4eec\u5c06\u8fd4\u56de\u521a\u624d\u63cf\u8ff0\u7684\u6574\u4e2a\u4ee3\u7801\uff0c\u4ee5\u4fbf\u66f4\u597d\u5730\u4e86\u89e3\u5982\u4f55\u5728\u4ee3\u7801\u4e2d\u5229\u7528 IConfiguration \u5bf9\u8c61\uff1a<\/p>\nvar builder = WebApplication.CreateBuilder(args);\nvar startupConfig = builder.Configuration.GetSection(nameof(MyCustomStartupObject)).Get<MyCustomStartupObject>();\napp.MapGet("\/read\/configurations", (IConfiguration configuration) =>\n{\n var customObject = configuration.GetSection\n (nameof(MyCustomObject)).Get<MyCustomObject>();\n return Results.Ok(new\n {\n MyCustomValue = configuration.GetValue\n <string>("MyCustomValue"),\n ConnectionString = configuration.\n GetConnectionString("Default"),\n CustomObject = customObject,\n StartupObject = startupConfig\n });\n})\n.WithName("ReadConfigurations");<\/code><\/pre>\n
\n\u6211\u4eec\u5df2\u7ecf\u4e86\u89e3\u4e86\u5982\u4f55\u5229\u7528\u5e26\u6709\u8fde\u63a5\u5b57\u7b26\u4e32\u7684 appsettings \u6587\u4ef6\uff0c\u4f46\u901a\u5e38\uff0c\u6bcf\u4e2a\u73af\u5883\u90fd\u6709\u8bb8\u591a\u4e0d\u540c\u7684\u6587\u4ef6\u3002\u8ba9\u6211\u4eec\u770b\u770b\u5982\u4f55\u4e3a\u6bcf\u4e2a\u73af\u5883\u5229\u7528\u4e00\u4e2a\u6587\u4ef6\u3002<\/p>\n
\nappsettings \u6587\u4ef6\u4e2d\u7684\u4f18\u5148\u7ea7<\/p>\n
\n\u53ef\u4ee5\u6839\u636e\u5e94\u7528\u7a0b\u5e8f\u6240\u5728\u7684\u73af\u5883\u6765\u7ba1\u7406 appsettings \u6587\u4ef6\u3002\u5728\u8fd9\u79cd\u60c5\u51b5\u4e0b\uff0c\u505a\u6cd5\u662f\u5c06\u8be5\u73af\u5883\u7684\u5173\u952e\u4fe1\u606f\u653e\u5728 appsettings.{ENVIRONMENT}.json\u6587\u4ef6\u3002<\/p>\n
\n\u6839\u6587\u4ef6\uff08\u5373 appsettings.json\uff09\u5e94\u4ec5\u7528\u4e8e\u751f\u4ea7\u73af\u5883\u3002<\/p>\n
\n\u4f8b\u5982\uff0c\u5982\u679c\u6211\u4eec\u5728\u4e24\u4e2a\u6587\u4ef6\u4e2d\u4e3a \u201cPriority\u201d \u952e\u521b\u5efa\u8fd9\u4e9b\u793a\u4f8b\uff0c\u6211\u4eec\u4f1a\u5f97\u5230\u4ec0\u4e48\uff1f<\/p>\n"Priority": "Root"<\/code><\/pre>\n"Priority": "Dev"<\/code><\/pre>\n
\n\u5982\u679c\u662f Development \u73af\u5883\uff0c\u5219 key \u7684\u503c\u5c06\u5bfc\u81f4 Dev\uff0c\u800c\u5728 Production \u73af\u5883\u4e2d\uff0c\u8be5\u503c\u5c06\u5bfc\u81f4 Root\u3002<\/p>\n
\n\u5982\u679c\u73af\u5883\u4e0d\u662f\u751f\u4ea7\u6216\u5f00\u53d1\uff0c\u4f1a\u53d1\u751f\u4ec0\u4e48\u60c5\u51b5\uff1f\u4f8b\u5982\uff0c\u5982\u679c\u5b83\u88ab\u79f0\u4e3a Stage\uff1f\u5728\u672c\u4f8b\u4e2d\uff0c\u672a\u6307\u5b9a\u4efb\u4f55 appsettings.Stage.json\u6587\u4ef6\u4e2d\uff0c\u8bfb\u53d6\u503c\u5c06\u662f\u5176\u4e2d\u4e00\u4e2aappsettings.json\u6587\u4ef6\u7684\u503c\uff0c\u56e0\u6b64\u662f Root\u3002<\/p>\n
\n\u4f46\u662f\uff0c\u5982\u679c\u6211\u4eec\u6307\u5b9a appsettings.Stage.json\u6587\u4ef6\u4e2d\uff0c\u5c06\u4ece\u8be5\u6587\u4ef6\u4e2d\u8bfb\u53d6\u8be5\u503c\u3002<\/p>\n
\n\u63a5\u4e0b\u6765\uff0c\u8ba9\u6211\u4eec\u8bbf\u95ee Options \u6a21\u5f0f\u3002\u6846\u67b6\u63d0\u4f9b\u4e86\u4e00\u4e9b\u5bf9\u8c61\uff0c\u7528\u4e8e\u5728\u542f\u52a8\u65f6\u6216\u7cfb\u7edf\u90e8\u95e8\u8fdb\u884c\u66f4\u6539\u65f6\u52a0\u8f7d\u914d\u7f6e\u4fe1\u606f\u3002\u8ba9\u6211\u4eec\u6765\u770b\u770b\u5982\u4f55\u4f5c\u3002<\/p>\n
\n\u9009\u9879\u6a21\u5f0f<\/p>\n
\n\u9009\u9879\u6a21\u5f0f\u4f7f\u7528\u7c7b\u63d0\u4f9b\u5bf9\u76f8\u5173\u8bbe\u7f6e\u7ec4\u7684\u5f3a\u7c7b\u578b\u8bbf\u95ee\uff0c\u5373\uff0c\u5f53\u914d\u7f6e\u8bbe\u7f6e\u6309\u65b9\u6848\u9694\u79bb\u5230\u5355\u72ec\u7684\u7c7b\u4e2d\u65f6\u3002<\/p>\n
\n\u9009\u9879\u6a21\u5f0f\u5c06\u4f7f\u7528\u4e0d\u540c\u7684\u63a5\u53e3\u548c\u4e0d\u540c\u7684\u529f\u80fd\u5b9e\u73b0\u3002\u6bcf\u4e2a\u754c\u9762\uff08\u8bf7\u53c2\u9605\u4ee5\u4e0b\u5c0f\u8282\uff09\u90fd\u6709\u81ea\u5df1\u7684\u529f\u80fd\uff0c\u53ef\u4ee5\u5e2e\u52a9\u6211\u4eec\u5b9e\u73b0\u67d0\u4e9b\u76ee\u6807\u3002<\/p>\n
\n\u4f46\u8ba9\u6211\u4eec\u6309\u987a\u5e8f\u5f00\u59cb\u3002\u6211\u4eec\u4e3a\u6bcf\u79cd\u7c7b\u578b\u7684\u63a5\u53e3\u5b9a\u4e49\u4e00\u4e2a\u5bf9\u8c61\uff08\u6211\u4eec\u5c06\u8fd9\u6837\u505a\u4ee5\u66f4\u597d\u5730\u8868\u793a\u793a\u4f8b\uff09\uff0c\u4f46\u540c\u4e00\u4e2a\u7c7b\u53ef\u7528\u4e8e\u5728\u914d\u7f6e\u6587\u4ef6\u4e2d\u6ce8\u518c\u66f4\u591a\u9009\u9879\u3002\u4fdd\u6301\u6587\u4ef6\u7684\u7ed3\u6784\u76f8\u540c\u975e\u5e38\u91cd\u8981\uff1a<\/p>\npublic class OptionBasic\n{\n public string? Value { get; init; }\n}\n public class OptionSnapshot\n {\n public string? Value { get; init; }\n }\n public class OptionMonitor\n {\n public string? Value { get; init; }\n }\n public class OptionCustomName\n {\n public string? Value { get; init; }\n }<\/code><\/pre>\n
\n\u6bcf\u4e2a\u9009\u9879\u90fd\u901a\u8fc7 Configure \u65b9\u6cd5\u5728\u4f9d\u8d56\u9879\u6ce8\u5165\u5f15\u64ce\u4e2d\u6ce8\u518c\uff0c\u8be5\u65b9\u6cd5\u8fd8\u9700\u8981\u6ce8\u518c\u65b9\u6cd5\u7b7e\u540d\u4e2d\u5b58\u5728\u7684 T \u7c7b\u578b\u3002\u5982\u4f60\u6240\u89c1\uff0c\u5728\u6ce8\u518c\u9636\u6bb5\uff0c\u6211\u4eec\u58f0\u660e\u4e86\u7c7b\u578b\u548c\u6587\u4ef6\u90e8\u5206\uff0c\u7528\u4e8e\u68c0\u7d22\u4fe1\u606f\uff0c\u4ec5\u6b64\u800c\u5df2\uff1a<\/p>\nbuilder.Services.Configure<OptionBasic>(builder.Configuration.GetSection("OptionBasic"));\nbuilder.Services.Configure<OptionMonitor>(builder.Configuration.GetSection("OptionMonitor"));\nbuilder.Services.Configure<OptionSnapshot>(builder.Configuration.GetSection("OptionSnapshot"));\nbuilder.Services.Configure<OptionCustomName>("CustomName1", builder.Configuration.GetSection("CustomName1"));\nbuilder.Services.Configure<OptionCustomName>("CustomName2", builder.Configuration.GetSection("CustomName2"));<\/code><\/pre>\n
\n\u6211\u4eec\u5c1a\u672a\u5b9a\u4e49\u5e94\u8be5\u5982\u4f55\u8bfb\u53d6\u5bf9\u8c61\u3001\u8bfb\u53d6\u9891\u7387\u4ee5\u53ca\u4f7f\u7528\u4ec0\u4e48\u7c7b\u578b\u7684\u63a5\u53e3\u3002<\/p>\n
\n\u552f\u4e00\u66f4\u6539\u7684\u662f\u53c2\u6570\uff0c\u5982\u524d\u9762\u4ee3\u7801\u6bb5\u7684\u6700\u540e\u4e24\u4e2a\u793a\u4f8b\u6240\u793a\u3002\u6b64\u53c2\u6570\u5141\u8bb8\u60a8\u5411\u9009\u9879\u7c7b\u578b\u6dfb\u52a0\u540d\u79f0\u3002\u8be5\u540d\u79f0\u5fc5\u987b\u4e0e\u65b9\u6cd5\u7b7e\u540d\u4e2d\u4f7f\u7528\u7684\u7c7b\u578b\u5339\u914d\u3002\u6b64\u529f\u80fd\u79f0\u4e3a named options\u3002<\/p>\n
\n\u4e0d\u540c\u7684\u9009\u9879\u63a5\u53e3<\/p>\n
\n\u4e0d\u540c\u7684\u754c\u9762\u53ef\u4ee5\u5229\u7528\u60a8\u521a\u521a\u5b9a\u4e49\u7684\u8bb0\u5f55\u3002\u6709\u4e9b\u652f\u6301\u547d\u540d\u9009\u9879\uff0c\u6709\u4e9b\u5219\u4e0d\u652f\u6301\uff1a<\/p>\nIOptions<TOptions><\/code>:
\nIs registered as a singleton and can be injected into any service lifetime
\n\u6ce8\u518c\u4e3a\u5355\u4e00\u5b9e\u4f8b\uff0c\u53ef\u4ee5\u6ce8\u5165\u5230\u4efb\u4f55\u670d\u52a1\u751f\u547d\u5468\u671f\u4e2d
\nDoes not support the following:
\n\u4e0d\u652f\u6301\u4ee5\u4e0b\u5185\u5bb9\uff1a
\nReading of configuration data after the app has started
\n\u5728\u5e94\u7528\u7a0b\u5e8f\u542f\u52a8\u540e\u8bfb\u53d6\u914d\u7f6e\u6570\u636e
\nNamed options
\n\u547d\u540d\u9009\u9879<\/p>\nIOptionsSnapshot<TOptions><\/code>:
\nIs useful in scenarios where options should be recomputed on every request
\n\u5728\u5e94\u5728\u6bcf\u4e2a\u8bf7\u6c42\u4e0a\u91cd\u65b0\u8ba1\u7b97\u9009\u9879\u7684\u60c5\u51b5\u4e0b\u975e\u5e38\u6709\u7528
\nIs registered as scoped and therefore cannot be injected into a singleton service
\n\u6ce8\u518c\u4e3a scoped\uff0c\u56e0\u6b64\u4e0d\u80fd\u6ce8\u5165\u5230\u5355\u4e00\u5b9e\u4f8b\u670d\u52a1
\nSupports named options
\n\u652f\u6301\u547d\u540d\u9009\u9879<\/p>\nIOptionsMonitor<TOptions><\/code>:
\nIs used to retrieve options and manage options notifications for TOptions instances
\n\u7528\u4e8e\u68c0\u7d22\u9009\u9879\u548c\u7ba1\u7406 TOptions \u5b9e\u4f8b\u7684\u9009\u9879\u901a\u77e5
\nIs registered as a singleton and can be injected into any service lifetime
\n\u6ce8\u518c\u4e3a\u5355\u4e00\u5b9e\u4f8b\uff0c\u53ef\u4ee5\u6ce8\u5165\u5230\u4efb\u4f55\u670d\u52a1\u751f\u547d\u5468\u671f\u4e2d
\nSupports the following:
\n\u652f\u6301\u4ee5\u4e0b\u529f\u80fd\uff1a
\nChange notifications
\n\u66f4\u6539\u901a\u77e5
\nNamed options
\n\u547d\u540d\u9009\u9879
\nReloadable configuration
\n\u53ef\u91cd\u65b0\u52a0\u8f7d\u914d\u7f6e
\nSelective options invalidation (IOptionsMonitorCache<TOptions><\/code>)
\n\u9009\u62e9\u6027\u9009\u9879\u5931\u6548 \uff08IOptionsMonitorCache<TOptions><\/code>)<\/p>\nIOptionsFactory<TOptions><\/code>, which is responsible for creating new instances of options. It has a single Create method. The default implementation takes all registered IConfigureOptions<TOptions> <\/code>and IPostConfigureOptions
\n\u6211\u4eec\u60f3\u5411\u60a8\u4ecb\u7ecd\u4e00\u4e0b IOptionsFactory<TOptions><\/code> \u7684\u4f7f\u7528\uff0c\u5b83\u8d1f\u8d23\u521b\u5efa\u65b0\u7684\u9009\u9879\u5b9e\u4f8b\u3002\u5b83\u53ea\u6709\u4e00\u4e2a Create \u65b9\u6cd5\u3002\u9ed8\u8ba4\u5b9e\u73b0\u91c7\u7528\u6240\u6709\u5df2\u6ce8\u518c\u7684 IConfigureOptions<TOptions> <\/code>\u548c IPostConfigureOptions<TOptions><\/code>\u5e76\u9996\u5148\u6267\u884c\u6240\u6709\u914d\u7f6e\uff0c\u7136\u540e\u6267\u884c\u540e\u914d\u7f6e \uff08https:\/\/docs.microsoft.com\/aspnet\/core\/fundamentals\/configuration\/options#options-interfaces<\/a>\uff09\u3002<\/p>\n
\nConfigure \u65b9\u6cd5\u4e5f\u53ef\u4ee5\u540e\u8ddf\u914d\u7f6e\u7ba1\u9053\u4e2d\u7684\u53e6\u4e00\u4e2a\u65b9\u6cd5\u3002\u6b64\u65b9\u6cd5\u79f0\u4e3a PostConfigure\uff0c\u65e8\u5728\u5728\u6bcf\u6b21\u914d\u7f6e\u6216\u91cd\u65b0\u8bfb\u53d6\u914d\u7f6e\u65f6\u4fee\u6539\u914d\u7f6e\u3002\u4ee5\u4e0b\u662f\u5982\u4f55\u8bb0\u5f55\u6b64\u884c\u4e3a\u7684\u793a\u4f8b\uff1a<\/p>\nbuilder.Services.PostConfigure<MyConfigOptions>(myOptions =>\n{\n myOptions.Key1 = "my_new_value_post_configuration";\n});<\/code><\/pre>\n
\n\u628a\u5b83\u4eec\u653e\u5728\u4e00\u8d77<\/p>\n
\n\u5728\u5b9a\u4e49\u4e86\u8fd9\u4e9b\u4f17\u591a\u63a5\u53e3\u7684\u7406\u8bba\u4e4b\u540e\uff0c\u6211\u4eec\u4ecd\u7136\u9700\u8981\u901a\u8fc7\u4e00\u4e2a\u5177\u4f53\u7684\u4f8b\u5b50\u6765\u4e86\u89e3 IOptions \u7684\u5de5\u4f5c\u539f\u7406\u3002<\/p>\n
\n\u8ba9\u6211\u4eec\u770b\u770b\u521a\u624d\u63cf\u8ff0\u7684\u4e09\u4e2a\u63a5\u53e3\u7684\u7528\u6cd5\u4ee5\u53ca IOptionsFactory \u7684\u7528\u6cd5\uff0c\u5b83\u4e0e Create \u65b9\u6cd5\u548c\u547d\u540d\u9009\u9879\u51fd\u6570\u4e00\u8d77\u68c0\u7d22\u5bf9\u8c61\u7684\u6b63\u786e\u5b9e\u4f8b\uff1a<\/p>\napp.MapGet("\/read\/options", (IOptions<OptionBasic> optionsBasic,\n IOptionsMonitor<OptionMonitor> optionsMonitor,\n IOptionsSnapshot<OptionSnapshot> optionsSnapshot,\n IOptionsFactory<OptionCustomName> optionsFactory) =>\n{\n return Results.Ok(new\n {\n Basic = optionsBasic.Value,\n Monitor = optionsMonitor.CurrentValue,\n Snapshot = optionsSnapshot.Value,\n Custom1 = optionsFactory.Create("CustomName1"),\n Custom2 = optionsFactory.Create("CustomName2")\n });\n})\n.WithName("ReadOptions");<\/code><\/pre>\n
\n\u5728\u524d\u9762\u7684\u4ee3\u7801\u7247\u6bb5\u4e2d\uff0c\u6211\u4eec\u5e0c\u671b\u63d0\u8bf7\u6ce8\u610f\u53ef\u7528\u4e0d\u540c\u63a5\u53e3\u7684\u4f7f\u7528\u3002<\/p>\n
\n\u4e0a\u4e00\u4e2a\u4ee3\u7801\u6bb5\u4e2d\u4f7f\u7528\u7684\u6bcf\u4e2a\u63a5\u53e3\u90fd\u6709\u4e00\u4e2a\u7279\u5b9a\u7684\u751f\u547d\u5468\u671f\uff0c\u7528\u4e8e\u63cf\u8ff0\u5176\u884c\u4e3a\u3002\u6700\u540e\uff0c\u6b63\u5982\u6211\u4eec\u5728\u524d\u9762\u7684\u6bb5\u843d\u4e2d\u5df2\u7ecf\u63cf\u8ff0\u7684\u90a3\u6837\uff0c\u6bcf\u4e2a\u63a5\u53e3\u5728\u65b9\u6cd5\u4e0a\u7565\u6709\u4e0d\u540c\u3002<\/p>\n
\n\u64cd\u4f5c\u548c\u9a8c\u8bc1<\/p>\n
\n\u6700\u540e\u4f46\u5e76\u975e\u6700\u4e0d\u91cd\u8981\u7684\u4e00\u70b9\u662f\u914d\u7f6e\u4e2d\u5b58\u5728\u7684\u6570\u636e\u7684\u9a8c\u8bc1\u529f\u80fd\u3002\u5f53\u5fc5\u987b\u53d1\u5e03\u5e94\u7528\u7a0b\u5e8f\u7684\u56e2\u961f\u4ecd\u7136\u6267\u884c\u81f3\u5c11\u9700\u8981\u7531\u4ee3\u7801\u9a8c\u8bc1\u7684\u624b\u52a8\u6216\u7cbe\u7ec6\u4f5c\u65f6\uff0c\u8fd9\u975e\u5e38\u6709\u7528\u3002<\/p>\n
\n\u5728 .NET Core \u51fa\u73b0\u4e4b\u524d\uff0c\u5e94\u7528\u7a0b\u5e8f\u7ecf\u5e38\u7531\u4e8e\u914d\u7f6e\u4e0d\u6b63\u786e\u800c\u65e0\u6cd5\u542f\u52a8\u3002\u73b0\u5728\uff0c\u501f\u52a9\u6b64\u529f\u80fd\uff0c\u6211\u4eec\u53ef\u4ee5\u9a8c\u8bc1\u914d\u7f6e\u4e2d\u7684\u6570\u636e\u5e76\u5f15\u53d1\u9519\u8bef\u3002<\/p>\n
\n\u4e0b\u9762\u662f\u4e00\u4e2a\u793a\u4f8b\uff1a<\/p>\n
\n\u5e26\u9a8c\u8bc1\u7684 Register \u9009\u9879<\/p>\nbuilder.Services.AddOptions<ConfigWithValidation>().Bind(builder.Configuration.GetSection(nameof(ConfigWithValidation)))\n.ValidateDataAnnotations();\napp.MapGet("\/read\/options", (IOptions<ConfigWithValidation> optionsValidation) =>\n{\n return Results.Ok(new\n {\n Validation = optionsValidation.Value\n });\n})\n.WithName("ReadOptions");<\/code><\/pre>\n
\n\u8fd9\u662f\u660e\u786e\u62a5\u544a\u9519\u8bef\u7684\u914d\u7f6e\u6587\u4ef6\uff1a<\/p>\n
\n\u7528\u4e8e\u914d\u7f6e\u9a8c\u8bc1\u7684 Appsettings \u90e8\u5206<\/p>\n"ConfigWithValidation": {\n "Email": "andrea.tosato@hotmail.it",\n "NumericRange": 1001\n }<\/code><\/pre>\n
\n\u4e0b\u9762\u662f\u5305\u542b\u9a8c\u8bc1\u903b\u8f91\u7684\u7c7b\uff1a<\/p>\npublic class ConfigWithValidation\n{\n [RegularExpression(@"^([\\w\\.\\-]+)@([\\w\\-]+)((\\.(\\w)\n {2,})+)$")]\n public string? Email { get; set; }\n [Range(0, 1000, ErrorMessage = "Value for {0} must be \n between {1} and {2}.")]\n public int NumericRange { get; set; }\n}<\/code><\/pre>\n