.net core 如何Framework-dependent deployments

.NET Core Framework-Dependent Deployments

Introduction

In .NET Core, there are two types of deployments: self-contained and framework-dependent. Framework-dependent deployments (FDD) allow you to deploy your application without including the runtime, as it relies on the presence of the .NET Core runtime installed on the target machine. This type of deployment is useful when you have multiple applications that share the same runtime.

In this article, we will explore how to do a framework-dependent deployment in .NET Core. We will discuss the concepts and then provide code examples along with clear explanations.

Prerequisites

To follow along with the examples in this article, you will need the following:

• .NET Core SDK installed on your machine
• A text editor or an integrated development environment (IDE) such as Visual Studio Code

Creating a .NET Core Application

Let's start by creating a simple .NET Core console application. Open your terminal or command prompt and execute the following command:

dotnet new console -n MyApplication

This will create a new folder named "MyApplication" with a basic .NET Core console application structure.

Framework-Dependent Deployment

To perform a framework-dependent deployment, you need to publish your application. Publishing is the process of preparing your application for deployment by creating a self-contained folder that contains all the necessary files.

To publish your application, run the following command:

dotnet publish -c Release -r <runtime>

Replace <runtime> with the target runtime you want to publish for. For example, if you want to publish for Windows x64, use win-x64. If you are unsure about the available runtimes, you can check the official Microsoft documentation.

Project Dependencies

Before we proceed with the publishing, let's briefly discuss project dependencies. When you create a new .NET Core application, a MyApplication.csproj file is also created. This file contains all the information about your project, including the dependencies.

For a framework-dependent deployment, the MyApplication.csproj file should have the following section:

<PropertyGroup>
  <OutputType>Exe</OutputType>
  <TargetFramework>netcoreapp3.1</TargetFramework>
</PropertyGroup>

Make sure the <TargetFramework> element specifies the target .NET Core version you want to use.

Publishing the Application

Now, let's publish our application using framework-dependent deployment. Open your terminal or command prompt and navigate to the root folder of your project. Then, execute the following command:

dotnet publish -c Release -r <runtime>

Replace <runtime> with the target runtime, as discussed earlier.

This command will create a publish folder within your project directory. Inside the publish folder, you will find the published files.

Running the Published Application

To run the published application, navigate to the publish folder and execute the following command:

dotnet MyApplication.dll

Replace MyApplication with the name of your application.

Code Example

Here is a simple code example that you can use in your .NET Core application:

using System;

namespace MyApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, .NET Core!");
        }
    }
}

Save this code in a file named Program.cs within the MyApplication folder.

Gantt Chart

The following is a Gantt chart to visualize the steps involved in the framework-dependent deployment process:

gantt
    dateFormat  YYYY-MM-DD
    title Framework-Dependent Deployment

    section Create Application
    Create Project    :done,    2022-01-01, 1d
    Add Code          :done,    2022-01-02, 1d

    section Publish Application
    Publish           :done,    2022-01-03, 1d
    Run Published App :done,    2022-01-04, 1d

Sequence Diagram

The following is a sequence diagram to illustrate the flow of framework-dependent deployment:

sequenceDiagram
    participant Developer
    participant Compiler
    participant Runtime
    participant TargetMachine

    Developer->>Compiler: Build Application
    Compiler->>Developer: Build Successful
    Developer->>Runtime: Run Application
    Runtime->>TargetMachine: Execute Application
    TargetMachine->>Runtime: Application Output
    Runtime->>Developer: Application Output

Conclusion

In this article, we have explored how to do a framework-dependent deployment in .NET Core. We started by creating a .NET Core application, discussed project dependencies, and then covered the publishing process. We also provided a code example along with a Gantt chart and a sequence diagram to illustrate the steps involved in the deployment process.

Framework-dependent deployments allow you to deploy your application without including the runtime, which can be useful in scenarios where multiple applications share the same runtime. By following the steps outlined in this article, you can successfully perform a framework-dependent deployment in .NET Core.