02.net6 常用第三方类库介绍

海纳百川程序员

已于 2024-02-06 13:13:11 修改

阅读量490

点赞数

分类专栏： Net6-第三方框架/类库介绍文章标签： .net microsoft

于 2023-07-21 10:20:19 首次发布

本文链接：https://blog.csdn.net/qq_42574478/article/details/131845858

版权

Net6-第三方框架/类库介绍专栏收录该内容

3 篇文章 0 订阅

订阅专栏

常见的 .NET 6 的第三方类库

在 .NET 6 中，有许多常用的第三方类库可以用来增强和扩展你的应用程序。以下是一些常见的 .NET 6 的第三方类库：

Entity Framework Core (EF Core)
EF Core 是一个轻量级、可扩展和跨数据库的对象关系映射 (ORM) 框架，用于在应用程序中访问和操作数据库。
AutoMapper
AutoMapper 是一个对象映射库，用于简化对象之间的转换和映射操作。
Serilog
Serilog 是一个强大的日志库，提供了丰富的日志记录功能和灵活的配置选项。
Newtonsoft.Json (Json.NET)
Newtonsoft.Json 是一个用于处理 JSON 数据的流行库，提供了序列化、反序列化和转换 JSON 的功能。
Dapper
Dapper 是一个简单高效的 ORM 库，与原生 SQL 语句交互，提供了快速的数据库访问性能。
Polly
Polly 是一个强大的库，用于处理应用程序中的故障和超时情况，包括断路器模式、重试策略等。
IdentityServer4
IdentityServer4 是一个用于实现身份验证和授权的开源框架，可用于构建安全的单页应用 (SPA) 和 Web API。
Hangfire
Hangfire 是一个简单易用的后台任务调度库，可用于在应用程序中执行延迟任务、周期性任务等。
AutoMapper.Extensions.Microsoft.DependencyInjection
AutoMapper.Extensions.Microsoft.DependencyInjection 是 AutoMapper 的扩展库，用于在 ASP.NET Core 中集成和配置 AutoMapper。
FluentValidation
FluentValidation 是一个功能强大的验证库，用于执行输入数据的验证和校验规则。

当然，根据你的具体需求，还有更多的第三方类库可供选择。你可以通过 NuGet 包管理器或在项目中直接引用这些类库，来丰富和增强你的 .NET 6 应用程序的功能。记得在项目中使用之前，要查阅它们的官方文档以便正确地使用和配置。

AutoMapper的使用

AutoMapper 是一个用于对象之间的映射和转换的库，它可以帮助简化和自动化对象之间的转换过程。

要使用 AutoMapper，需要进行以下步骤：

步骤1：安装 AutoMapper 包

在应用程序的项目中，需要安装 AutoMapper 包。可以通过 NuGet 包管理器或手动下载并将其添加到项目中。

步骤2：创建映射配置

在应用程序中，需要创建映射配置，指定源类型和目标类型之间的映射关系。可以使用 MapperConfiguration 类来创建映射配置。

以下是一个示例：

using AutoMapper;

class Program
{
    static void Main(string[] args)
    {
        var config = new MapperConfiguration(cfg =>
        {
            cfg.CreateMap<SourceClass, DestinationClass>();
        });

        // 创建映射实例
        IMapper mapper = config.CreateMapper();

        // 使用 mapper 进行对象映射
        var source = new SourceClass { Id = 1, Name = "John" };
        var destination = mapper.Map<DestinationClass>(source);
    }
}

上面的示例中，通过 CreateMap<SourceClass, DestinationClass>() 指定了 SourceClass 和 DestinationClass 之间的映射关系。

步骤3：进行对象映射

在应用程序的代码中，可以通过创建 IMapper 实例来执行对象之间的映射。

使用 mapper.Map(source) 方法，可以将源对象映射到目标类型，并返回一个新的目标对象。

以下是一些常见的对象映射示例：

// 单个对象映射
var source = new SourceClass { Id = 1, Name = "John" };
var destination = mapper.Map<DestinationClass>(source);

// 集合对象映射
var sourceList = new List<SourceClass>
{
    new SourceClass { Id = 1, Name = "John" },
    new SourceClass { Id = 2, Name = "Alice" }
};

var destinationList = mapper.Map<List<DestinationClass>>(sourceList);

通过执行上述步骤，你就可以使用 AutoMapper 进行对象之间的映射和转换了。根据你的需求，还可以进一步配置映射规则，处理复杂的映射需求，例如字段名称不匹配、嵌套对象等。了解 AutoMapper 的更多功能和用法，可以查阅 AutoMapper 的官方文档。
在 ASP.NET Core 中使用 AutoMapper 与在其他.NET 应用中使用基本相同，只需稍作配置即可在 ASP.NET Core 中集成 AutoMapper。

以下是在 ASP.NET Core 中使用 AutoMapper 的步骤：

步骤1：安装 AutoMapper 包

在 ASP.NET Core 项目的项目文件（.csproj）中，添加对 AutoMapper 包的引用。可以通过 NuGet 包管理器或手动编辑项目文件来添加引用。

步骤2：配置 AutoMapper

在 ASP.NET Core 项目的 Startup.cs 文件中的 ConfigureServices 方法中配置 AutoMapper。

以下是一个示例：

using AutoMapper;

public class Startup
{
    // ...

    public void ConfigureServices(IServiceCollection services)
    {
        // 添加 AutoMapper 服务
        services.AddAutoMapper(typeof(Startup));

        // 配置 AutoMapper 映射配置
        var mapperConfig = new MapperConfiguration(config =>
        {
            config.CreateMap<SourceClass, DestinationClass>();
        });

        // 添加 IMapper 实例到 DI 容器
        IMapper mapper = mapperConfig.CreateMapper();
        services.AddSingleton(mapper);

        // ...
    }

    // ...
}

步骤3：进行对象映射

在 ASP.NET Core 项目的控制器或其他适当的位置，通过依赖注入的方式使用 IMapper 进行对象映射。

以下是一个示例：

using AutoMapper;

public class MyController : ControllerBase
{
    private readonly IMapper _mapper;

    public MyController(IMapper mapper)
    {
        _mapper = mapper;
    }

    public IActionResult MyAction()
    {
        var source = new SourceClass { Id = 1, Name = "John" };

        var destination = _mapper.Map<DestinationClass>(source);

        // 执行其他操作

        return Ok();
    }
}

在上述示例中，通过构造函数注入 IMapper 实例，并在 MyAction 方法中使用该实例进行对象映射操作。

通过以上步骤，你就可以在 ASP.NET Core 项目中使用 AutoMapper 来进行对象映射和转换了。记得在项目中使用之前，查阅 AutoMapper 的官方文档以了解更多功能和用法。

FluentValidation的使用

FluentValidation 是一个功能强大的验证库，用于执行输入数据的验证和校验规则。在 WPF 中使用 FluentValidation，你可以按照以下步骤进行配置和集成：

步骤1：安装 FluentValidation 包

在 WPF 项目中，使用 NuGet 包管理器或手动添加对 FluentValidation 包的引用。

步骤2：创建验证规则

在你的 WPF 项目中，需要创建验证规则，用于定义输入数据的验证逻辑。

以下是一个示例：

using FluentValidation;

public class PersonValidator : AbstractValidator<Person>
{
    public PersonValidator()
    {
        RuleFor(x => x.FirstName)
            .NotEmpty().WithMessage("First Name is required")
            .Length(2, 50).WithMessage("First Name must be between 2 and 50 characters");

        RuleFor(x => x.LastName)
            .NotEmpty().WithMessage("Last Name is required")
            .Length(2, 50).WithMessage("Last Name must be between 2 and 50 characters");

        RuleFor(x => x.Age)
            .InclusiveBetween(18, 120).WithMessage("Age must be between 18 and 120");
    }
}

上述示例中，通过创建一个名为 PersonValidator 的验证器类，并继承自 AbstractValidator。然后，通过使用 FluentValidation 提供的方法，可以定义针对每个属性的验证规则，例如 NotEmpty()、Length()、InclusiveBetween() 等。

步骤3：执行验证

在你的 WPF 代码中，可以通过实例化验证器并调用其 Validate() 方法来执行验证操作。

以下是一个示例：

public class PersonViewModel : INotifyPropertyChanged
{
    private readonly PersonValidator _validator;
    private Person _person;

    public PersonViewModel()
    {
        _person = new Person();
        _validator = new PersonValidator();
    }

    public Person Person
    {
        get { return _person; }
        set
        {
            _person = value;
            OnPropertyChanged(nameof(Person));
        }
    }

    public void Save()
    {
        ValidationResult result = _validator.Validate(Person);

        if (result.IsValid)
        {
            // 执行保存操作
        }
        else
        {
            // 处理验证错误
            foreach (var error in result.Errors)
            {
                // 显示或处理错误信息
                Console.WriteLine(error.ErrorMessage);
            }
        }
    }

    // ...
}

在上述示例中，通过创建一个名为 PersonViewModel 的视图模型类，并在 Save() 方法中调用 _validator.Validate() 方法执行验证操作。如果验证结果有效（即没有错误），则可以执行保存操作。否则，可以遍历验证结果中的错误信息，并进行相应的错误处理。

通过以上步骤，你就可以在 WPF 应用程序中使用 FluentValidation 执行输入数据的验证操作了。请注意，这只是一个基本的示例，你可以根据自己的需求和业务逻辑来定义更复杂的验证规则和验证操作。记得在项目中使用之前，查阅 FluentValidation 的官方文档以了解更多功能和用法。
在 ASP.NET Core 中使用 FluentValidation 可以轻松地执行输入数据的验证。下面是在 ASP.NET Core 中使用 FluentValidation 的步骤：

步骤1：安装 FluentValidation 包

在 ASP.NET Core 项目中，使用 NuGet 包管理器或手动添加对 FluentValidation 包的引用。

步骤2：创建验证规则

在应用程序中创建验证规则，用于定义输入数据的验证逻辑。

以下是一个示例：

using FluentValidation;

public class PersonValidator : AbstractValidator<PersonDto>
{
    public PersonValidator()
    {
        RuleFor(x => x.FirstName)
            .NotEmpty().WithMessage("First Name is required")
            .Length(2, 50).WithMessage("First Name must be between 2 and 50 characters");

        RuleFor(x => x.LastName)
            .NotEmpty().WithMessage("Last Name is required")
            .Length(2, 50).WithMessage("Last Name must be between 2 and 50 characters");

        RuleFor(x => x.Age)
            .InclusiveBetween(18, 120).WithMessage("Age must be between 18 and 120");
    }
}

在上述示例中，我们创建了一个名为 PersonValidator 的验证器类，并继承自 AbstractValidator。然后，我们使用 FluentValidation 提供的方法定义了针对 PersonDto 对象中每个属性的验证规则。

步骤3：注册验证器

在 ASP.NET Core 的 Startup.cs 文件中的 ConfigureServices 方法中注册验证器。

以下是一个示例：

using FluentValidation.AspNetCore;

public class Startup
{
    // ...

    public void ConfigureServices(IServiceCollection services)
    {
        // 注册验证器
        services.AddControllers()
            .AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining<PersonValidator>());

        // ...
    }

    // ...
}

在上述示例中，我们使用 AddFluentValidation() 方法来注册验证器，并通过 RegisterValidatorsFromAssemblyContaining() 方法指定验证器所在的程序集。

步骤4：执行验证

在你的控制器或其他合适的位置，使用 FluentValidation 执行验证操作。可以通过属性注入方式获取验证器实例，并在适当的地方调用其 Validate() 方法。

以下是一个示例：

using FluentValidation;

[ApiController]
[Route("api/[controller]")]
public class PersonController : ControllerBase
{
    private readonly IValidator<PersonDto> _validator;

    public PersonController(IValidator<PersonDto> validator)
    {
        _validator = validator;
    }

    [HttpPost]
    public IActionResult CreatePerson(PersonDto person)
    {
        ValidationResult result = _validator.Validate(person);

        if (result.IsValid)
        {
            // 执行创建人员操作
            return Ok("Person created successfully!");
        }
        else
        {
            // 处理验证错误
            return BadRequest(result.Errors);
        }
    }
}

在上述示例中，我们在控制器中使用属性注入获取验证器实例，并调用其 Validate() 方法来执行验证操作。如果验证结果有效（即没有错误），可以执行相应的操作。否则，可以返回验证错误信息。

通过以上步骤，你就可以在 ASP.NET Core 应用程序中使用 FluentValidation 执行输入数据的验证操作了。请注意，这只是一个基本的示例，你可以根据自己的需求定义更复杂的验证规则和验证操作。确保在项目中使用之前，查阅 FluentValidation 的官方文档以了解更多功能和用法。

Polly的使用

Polly 是一个.NET 库，用于实现和处理重试、断路器、超时、回退和其他策略的功能。它提供了一种简单而强大的方式来处理常见的容错和恢复逻辑。

在 ASP.NET Core 中使用 Polly，可以按照以下步骤进行配置和集成：

步骤1：安装 Polly 包

在 ASP.NET Core 项目中，使用 NuGet 包管理器或手动添加对 Polly 包的引用。

步骤2：配置 Polly 策略

在应用程序中配置 Polly 策略，以定义重试、熔断、超时等容错策略。

以下是一个示例：

using Polly;
using Polly.Timeout;

public class MyService
{
private readonly IHttpClientFactory _httpClientFactory;

public MyService(IHttpClientFactory httpClientFactory)
{
    _httpClientFactory = httpClientFactory;
}

public async Task<string> GetData()
{
    // 创建 HttpClient 实例
    var httpClient = _httpClientFactory.CreateClient();

    // 定义 Polly 重试策略
    var retryPolicy = Policy
        .Handle<HttpRequestException>() // 需要处理的异常
        .OrTransientHttpStatusCode() // 处理的 HTTP 状态码
        .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

    // 定义 Polly 超时策略
    var timeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(5));

    var response = await Policy.WrapAsync(retryPolicy, timeoutPolicy)
        .ExecuteAsync(() => httpClient.GetAsync("https://api.example.com/data"));

    return await response.Content.ReadAsStringAsync();
}

}
在上述示例中，我们使用 Polly 来定义了一个简单的重试和超时策略。使用 Policy.Handle() 方法指定了要处理的异常（例如 HttpRequestException），并使用 WaitAndRetryAsync() 方法定义了重试频率和次数。然后使用 Policy.TimeoutAsync() 方法定义了超时时间。

步骤3：注册 Polly 策略

在 ASP.NET Core 的 Startup.cs 文件中的 ConfigureServices 方法中，注册 Polly 策略。

以下是一个示例：

using Polly;

public class Startup
{
    // ...

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHttpClient();

        services.AddSingleton<TimeoutPolicy<HttpResponseMessage>>((serviceProvider) =>
        {
            return Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(5));
        });

        // ...
    }

    // ...
}

在上述示例中，我们使用 AddHttpClient() 方法注册 HttpClient，并使用 services.AddSingleton() 方法注册了超时策略。

步骤4：应用 Polly 策略到控制器或服务中

在控制器或服务中，通过构造函数注入 Polly 策略的实例，并在适当的地方应用策略。

以下是一个示例：

public class MyController : Controller
{
    private readonly IHttpClientFactory _httpClientFactory;
    private readonly TimeoutPolicy<HttpResponseMessage> _timeoutPolicy;

    public MyController(IHttpClientFactory httpClientFactory, TimeoutPolicy<HttpResponseMessage> timeoutPolicy)
    {
        _httpClientFactory = httpClientFactory;
        _timeoutPolicy = timeoutPolicy;
    }

    public async Task<IActionResult> Index()
    {
        var httpClient = _httpClientFactory.CreateClient();

        var response = await _timeoutPolicy.ExecuteAsync(() => httpClient.GetAsync("https://api.example.com/data"));

        var content = await response.Content.ReadAsStringAsync();

        return View(content);
    }
}

在上述示例中，我们通过构造函数注入了超时策略的实例，并在 Index() 方法中使用 _timeoutPolicy.ExecuteAsync() 方法应用超时策略。

通过以上步骤，你就可以在 ASP.NET Core 应用程序中使用 Polly 来实现容错和恢复策略了。请注意，这只是一个基本的示例，你可以根据自己的需求定义更复杂的策略和操作。确保在项目中使用之前，查阅 Polly 的官方文档以了解更多功能和用法。

Hangfire的使用

Hangfire 是一个开源的 .NET 库，用于在 ASP.NET 或 .NET Core 应用程序中实现后台任务调度和管理。它提供了一种简单而强大的方式来处理延迟任务、定时任务和后台处理任务。

以下是在 ASP.NET Core 中使用 Hangfire 的基本步骤：

步骤1：安装 Hangfire 包

在 ASP.NET Core 项目中，使用 NuGet 包管理器或手动添加对 Hangfire 包的引用。

步骤2：配置 Hangfire

在应用程序的 Startup.cs 文件中的 ConfigureServices 方法中，配置 Hangfire。

以下是一个示例：

using Hangfire;

public class Startup
{
    // ...

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddHangfire(config =>
        {
            config.UseSqlServerStorage(Configuration.GetConnectionString("HangfireConnection"));
        });

        // ...
    }

    public void Configure(IApplicationBuilder app, IHostingEnvironment env, IBackgroundJobClient backgroundJobClient, IRecurringJobManager recurringJobManager)
    {
        // ...
        
        app.UseHangfireDashboard(); 
        
        // 创建 Hangfire 作业
        var jobOptions = new BackgroundJobOptions { 
            QueueName = "my_queue", // 可选项：为作业指定队列
            Priority = 1 // 可选项：为作业指定优先级
        };
        backgroundJobClient.Enqueue(() => Console.WriteLine("Hello Hangfire!"), jobOptions);

        // 创建定期执行的 Hangfire 作业
        recurringJobManager.AddOrUpdate("SendEmailJob", () => SendEmail(), Cron.Daily);

        // ...
    }
}

在上述示例中：

ConfigureServices 方法中，我们使用 AddHangfire() 方法来配置 Hangfire，并指定使用 SQL Server 存储来存储后台任务数据。你可以选择其他支持的存储提供程序。

Configure 方法中，我们使用 UseHangfireDashboard() 方法启用 Hangfire 的仪表板，从而可以监视和管理后台作业。在这个方法中，我们还通过 backgroundJobClient.Enqueue() 方法创建了一个简单的后台作业，并附加了一些可选的选项，如队列名称和优先级。我们还使用 recurringJobManager.AddOrUpdate() 方法创建了一个定期执行的后台作业，它会每天执行一次。

步骤3：创建后台任务

在适当的位置创建后台任务。你可以使用 Hangfire 提供的不同方法创建不同类型的后台任务，例如延迟任务、定时任务和后台处理任务。

以下是一个示例：

public class BackgroundTask
{
    public void RunTask()
    {
        // 执行后台任务的逻辑
        Console.WriteLine("Background Task is running...");
    }

    public void SendEmail()
    {
        // 发送邮件的逻辑
        Console.WriteLine("Send Email Job is running...");
    }
}

在上述示例中，我们创建了一个名为 BackgroundTask 的后台任务类，其中包含了 RunTask() 和 SendEmail() 方法来执行具体的后台任务逻辑。

通过以上步骤，你就可以在 ASP.NET Core 应用程序中使用 Hangfire 来执行后台任务了。请注意，这只是一个基本的示例，你可以根据自己的需求定义更复杂的后台任务和逻辑。确保在项目中使用之前，查阅 Hangfire 的官方文档以了解更多功能和用法。

Newtonsoft.Json使用

Newtonsoft.Json是一个用于.NET平台的开源JSON序列化和反序列化库。它提供了一种简单且高效的方式来处理JSON数据。

要使用Newtonsoft.Json，在你的项目中，你需要首先引入Newtonsoft.Json库。你可以通过NuGet包管理器来安装它，或者手动下载该库并添加对应的引用。

一旦你引入了Newtonsoft.Json库，你就可以开始使用它来序列化和反序列化JSON数据。

下面是一个简单的示例，展示如何使用Newtonsoft.Json进行序列化和反序列化操作：

using Newtonsoft.Json;

// 序列化对象为JSON字符串
string jsonString = JsonConvert.SerializeObject(yourObject);

// 反序列化JSON字符串为对象
YourObject deserializedObject = JsonConvert.DeserializeObject<YourObject>(jsonString);

在上述示例中，你需要将yourObject替换为你想要进行序列化的对象，并使用JsonConvert.SerializeObject方法将其转换为JSON字符串。然后，你可以使用JsonConvert.DeserializeObject(jsonString)方法将JSON字符串转换回对象。

你还可以使用其他一些选项来自定义JSON序列化和反序列化的行为。例如，你可以使用JsonProperty属性来指定对象属性在JSON中的名称，或者使用JsonConverter来实现自定义的序列化和反序列化逻辑。Newtonsoft.Json提供了灵活的配置选项，以满足各种需求。

希望这个简单的例子能帮助你开始使用Newtonsoft.Json库。如果你需要更多关于该库的详细信息，你可以查阅官方文档或者参考相关教程和示例代码。

Serilog的使用

Serilog是一个.NET平台上的全功能日志记录库，它提供了强大的日志记录功能和灵活的配置选项。它能够帮助你在应用程序中快速、方便地进行日志记录。

要使用Serilog，你首先需要在你的项目中引入Serilog库。你可以通过NuGet包管理器来安装它，或者手动下载该库并添加对应的引用。

一旦你引入了Serilog库，你可以开始配置和使用它来记录日志。

下面是一个简单的示例，展示如何使用Serilog进行日志记录：

using Serilog;

// 配置Serilog日志记录器
Log.Logger = new LoggerConfiguration()
    .WriteTo.Console() // 输出到控制台
    .WriteTo.File("log.txt") // 输出到文件
    .CreateLogger();

// 日志记录
Log.Information("这是一条信息日志");
Log.Debug("这是一条调试日志");
Log.Warning("这是一条警告日志");
Log.Error("这是一条错误日志");

// 关闭日志记录器
Log.CloseAndFlush();

在上述示例中，我们使用LoggerConfiguration配置器来定义日志记录的行为。通过.WriteTo方法，我们可以指定日志的输出目标，例如控制台或文件。.CreateLogger()方法用于创建日志记录器实例。

然后，我们可以使用Log.Information、Log.Debug、Log.Warning和Log.Error等方法来记录不同级别的日志。

最后，我们使用Log.CloseAndFlush方法关闭日志记录器。这个方法会将缓冲中的日志写入到文件或其他输出目标，并释放资源。

当然，Serilog还提供了许多其他配置选项和功能。例如，你可以配置日志格式、选择不同的输出目标（如数据库或日志服务器）、配置筛选条件等等。你可以参考官方文档或其他教程来学习更多关于Serilog的用法和功能。

希望这个简单的示例能帮助你开始使用Serilog进行日志记录。如果你有其他疑问或需要更多帮助，请随时提问。

log4net使用

log4net 是一个成熟的日志记录框架，用于在.NET 应用程序中实现灵活和高效的日志记录。

要使用 log4net，需要进行以下步骤：

步骤1：安装 log4net 包

在应用程序的项目中，需要安装 log4net 包。可以通过 NuGet 包管理器或手动下载并将其添加到项目中。

步骤2：配置 log4net

在应用程序的配置文件（如 app.config 或 web.config）中，添加 log4net 的配置信息。配置信息通常包括日志记录器的输出目标（如文件、数据库或控制台），日志级别、日志格式等。

以下是一个简单的 log4net 配置示例：

<configuration>
  <configSections>
    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
  </configSections>

  <log4net>
    <appender name="FileAppender" type="log4net.Appender.FileAppender">
      <param name="File" value="log.txt" />
      <layout type="log4net.Layout.SimpleLayout" />
    </appender>

    <root>
      <level value="DEBUG" />
      <appender-ref ref="FileAppender" />
    </root>
  </log4net>
</configuration>

这个配置将将日志记录到名为 “log.txt” 的文件中，并指定了日志级别为 DEBUG。

步骤3：初始化 log4net

在应用程序的入口点（如 Main 方法）中，需要调用 log4net.Config.XmlConfigurator.Configure() 方法，初始化 log4net。

以下是一个示例：

using log4net;
using log4net.Config;

class Program
{
    private static readonly ILog log = LogManager.GetLogger(typeof(Program));

    static void Main(string[] args)
    {
        XmlConfigurator.Configure(); // 初始化 log4net

        log.Debug("Debug message");
        log.Info("Info message");
        log.Warn("Warning message");
        log.Error("Error message");
        log.Fatal("Fatal message");
    }
}

在上面的示例中，GetLogger(typeof(Program)) 将日志记录器与当前类关联起来。

步骤4：使用 log4net 记录日志

在应用程序的代码中，可以通过调用 ILog 接口的方法来记录日志。常用的方法有 Debug()、Info()、Warn()、Error() 和 Fatal()。

通过执行上述步骤，你就可以在应用程序中使用 log4net 进行日志记录了。根据你的配置，日志将会写入指定的目标（文件、数据库等）。

Quartz.net的使用

# nuget控制台
Install-Package Quartz
或者
 <ItemGroup>
   <PackageReference Include="Quartz" Version="3.8.0" />
 </ItemGroup>
 
# 必须会的类和接口
IJob
ILogProvider
LogProvider
StdSchedulerFactory
IScheduler
IJobDetail
JobBuilder
ITrigger
TriggerBuilder

JobDataMap

ITriggerListener
IJobListener
ISchedulerListener

HelloJob.cs

using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    public class HelloJob : IJob
    {

        public async Task Execute(IJobExecutionContext context)
        {
            await Task.Run(() =>
            {
                Console.WriteLine("greet"+DateTime.Now.ToString());
                Console.WriteLine(context.JobDetail.JobDataMap.GetString("student1"));

                Console.WriteLine("trigger:" + context.Trigger.JobDataMap.GetString("student1"));

                Console.WriteLine("merge:" + context.MergedJobDataMap.GetString("student1"));

            });
        }
    }
}

ConsoleLogProvider.cs

using Quartz.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    public class ConsoleLogProvider : ILogProvider
    {
        public Logger GetLogger(string name)
        {
            return (level, func, exception, parameters) =>
            {
                if (level >= LogLevel.Info && func != null)
                {
                    Console.WriteLine("[" + DateTime.Now.ToLongTimeString() + "] [" + level + "] " + func(), parameters);
                }
                return true;
            };
        }

        public IDisposable OpenMappedContext(string key, object value, bool destructure = false)
        {
            throw new NotImplementedException();
        }

        public IDisposable OpenNestedContext(string message)
        {
            throw new NotImplementedException();
        }
    }
}

Program.cs

using Microsoft.Extensions.DependencyInjection;
using Quartz;
using Quartz.Impl;
using Quartz.Logging;
using System.Security.Authentication.ExtendedProtection;

    public class Program
    {
        static async Task Main(string[] args)
        {
            LogProvider.SetCurrentLogProvider(new ConsoleLogProvider());

            StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
            IScheduler scheduler   = await stdSchedulerFactory.GetScheduler();

            await scheduler.Start();
            //scheduler.ListenerManager.AddJobListener(new MyJobListener());


            IJobDetail jobDetail = JobBuilder.Create<HelloJob>()
                .WithIdentity("helloJob","group1")
                .WithDescription("this is a hello job")
                .Build();

            jobDetail.JobDataMap.Add("student1","张三");
            jobDetail.JobDataMap.Add("student2","李四");
            jobDetail.JobDataMap.Add("student3","王五");

            ITrigger trigger=TriggerBuilder.Create()
                .WithIdentity("helloTrigger","group1")
                .WithDescription("this is a hello trigger")
                //.StartAt(DateTimeOffset.Now.AddSeconds(5))
                .StartNow()
                .WithSimpleSchedule(x=>x.WithIntervalInSeconds(5).RepeatForever())
                .WithCronSchedule("5/10 * * * * ?") //从5秒开始每隔10执行一次
                .Build();

            trigger.JobDataMap.Add("student1", "张三");
            trigger.JobDataMap.Add("student2", "李四");
            trigger.JobDataMap.Add("student3", "王五");

            await scheduler.ScheduleJob(jobDetail, trigger);

            await Task.Delay(TimeSpan.FromSeconds(60));
            await scheduler.Shutdown();

            Console.WriteLine("Press any key to close the application");
            Console.ReadKey();            
        }
    }
}

监听器和日志

using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    public class MyJobListener : IJobListener
    {
        public string Name => "MyJobListener";

        public async Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken cancellationToken = default)
        {
            await Task.Run(() => {
                Console.WriteLine("JobExecutionVetoed");
            });
        }

        public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default)
        {
            throw new NotImplementedException();
        }

        public Task JobWasExecuted(IJobExecutionContext context, JobExecutionException? jobException, CancellationToken cancellationToken = default)
        {
            throw new NotImplementedException();
        }
    }
}

海纳百川程序员

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
02.net6 常用第三方类库介绍

在 .NET 6 中，有许多常用的第三方类库可以用来增强和扩展你的应用程序。以下是一些常见的 .NET 6 的第三方类库：EF Core 是一个轻量级、可扩展和跨数据库的对象关系映射 (ORM) 框架，用于在应用程序中访问和操作数据库。AutoMapperAutoMapper 是一个对象映射库，用于简化对象之间的转换和映射操作。SerilogSerilog 是一个强大的日志库，提供了丰富的日志记录功能和灵活的配置选项。
复制链接

扫一扫