WPF依赖注入

已于 2025-04-07 12:07:15 修改
阅读量1k 收藏 15
点赞数 21
文章标签： log4j java 开发语言
于 2025-04-07 07:28:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ly1h1/article/details/147033935
版权

一、IOC 在 WPF 中的原理

控制反转（IOC）是一种设计原则，它将对象的创建和依赖关系的管理从对象本身转移到外部容器（IOC 容器）。在传统的编程方式中，一个对象如果需要使用另一个对象（即存在依赖关系），通常会在自身内部通过 new 关键字等方式直接创建被依赖的对象，这就导致了对象之间的紧密耦合。而在 IOC 模式下，由 IOC 容器负责创建对象，并在对象需要时将其依赖的对象注入进去。这样，对象只需要关注自身的业务逻辑，而不需要关心依赖对象的创建过程，从而实现了对象之间依赖关系的解耦。

 

在 WPF 应用中，这种解耦可以使视图、视图模型和其他组件之间的关系更加清晰和灵活，便于代码的维护和扩展。例如，视图模型依赖于数据访问服务来获取数据，通过 IOC，数据访问服务的具体实现可以由 IOC 容器注入到视图模型中，而不是视图模型自己去创建数据访问服务的实例。

二、IOC 在 WPF 中的作用

  1. 降低耦合度：使得组件之间的依赖关系更加松散，一个组件的变化不会轻易影响到其他组件。比如，当数据访问层的实现从数据库 A 切换到数据库 B 时，只需要在 IOC 容器中修改数据访问服务的注册配置，而使用该数据访问服务的业务逻辑组件无需进行修改。
  2. 提高可维护性：由于组件之间的耦合度降低，当需要修改或替换某个组件的依赖时，只需要在 IOC 容器中进行配置修改，而无需在大量的组件代码中查找和修改与依赖创建相关的代码。
  3. 增强可测试性：在进行单元测试时，可以方便地使用模拟对象或测试替身替换实际的依赖对象。例如，在测试视图模型时，可以注入一个模拟的数据访问服务，返回预设的数据，使单元测试更加独立和简单，不受实际依赖对象的影响。
  4. 实现依赖注入：可以在对象创建时将其依赖的对象自动注入，简化对象的初始化过程。对象在设计时只需要定义好依赖关系（通常通过构造函数、属性或方法参数来体现），IOC 容器会负责在合适的时机将依赖对象传递给它。

三、IOC 在 WPF 中的优劣势

  1. 优势
    1. 灵活性高：可以根据不同的需求或环境，动态地切换依赖对象的实现。例如，在开发环境中使用模拟的服务进行测试，而在生产环境中切换到实际的服务实现。
    2. 代码复用性好：由于依赖关系的解耦，组件可以更容易地在不同的项目或模块中复用。一个组件只依赖于抽象的接口或抽象类，只要提供符合接口定义的实现，就可以在不同的上下文中使用该组件。
    3. 易于扩展：添加新的功能或依赖时，对现有代码的影响较小，只需要在 IOC 容器中进行相应的配置。例如，添加一个新的日志服务，只需要在 IOC 容器中注册该日志服务的实现，并在需要使用日志服务的组件中注入它，而不需要对其他组件进行大规模的修改。
  2. 劣势
    1. 学习成本较高：理解和使用 IOC 需要一定的学习成本，尤其是对于初学者来说，需要掌握相关的概念（如依赖注入、控制反转）和技术（如如何配置 IOC 容器、如何进行依赖注入）。
    2. 配置复杂：在大型项目中，IOC 容器的配置可能会变得复杂，需要仔细管理和维护，否则可能会导致难以调试的问题。例如，当存在大量的依赖关系和不同的对象生命周期管理时，配置不当可能会导致对象创建错误或依赖关系混乱。

四、IOC 在 WPF 中的写法要求

  1. 定义接口或抽象类：首先要明确组件之间的依赖关系，定义好接口或抽象类，作为依赖的契约。接口或抽象类应该清晰地定义出所提供的功能和行为，例如定义一个 ICustomerService 接口，其中声明获取客户信息、保存客户信息等方法。
  2. 实现具体类：针对每个接口或抽象类，编写具体的实现类，实现接口中定义的方法或属性。例如，实现 ICustomerService 接口的 SqlCustomerService 类，在其中实现从数据库中获取和保存客户信息的具体逻辑。
  3. 创建 IOC 容器：编写一个简单的 IOC 容器类，用于管理对象的注册和解析。通常使用字典来存储接口和实现类的映射关系。容器类应该提供注册接口和实现类映射关系的方法（如 Register 方法），以及根据接口解析出对应实现类实例的方法（如 Resolve 方法）。
  4. 注册映射关系：在 IOC 容器中，将接口和对应的实现类进行注册，建立它们之间的映射关系。可以使用泛型方法来实现注册，例如 Register<TInterface, TImplementation>()，其中 TInterface 是接口类型，TImplementation 是实现类类型。
  5. 进行依赖注入：在需要使用依赖对象的组件中，通过构造函数、属性或方法注入依赖对象。在创建组件实例时，从 IOC 容器中获取相应的依赖对象并进行注入。例如，在视图模型的构造函数中接收依赖的服务对象，或者通过属性设置依赖对象。

五、IOC 在 WPF 中的应用场景

  1. 业务逻辑层与数据访问层的解耦：在 WPF 应用中，业务逻辑层通常依赖数据访问层来获取和存储数据。通过 IOC，可以将数据访问层的具体实现（如数据库访问类）注入到业务逻辑层中，使业务逻辑层与具体的数据访问技术（如 SQL Server、MySQL 等）解耦。这样，当需要更换数据库或数据访问方式时，只需要在 IOC 容器中修改数据访问服务的注册配置，而业务逻辑组件无需修改。
  2. 视图模型与服务的注入：视图模型（ViewModel）通常需要依赖一些服务（如网络服务、日志服务、消息推送服务等）来完成其功能。使用 IOC 可以将这些服务注入到视图模型中，提高视图模型的可测试性和可维护性。例如，在视图模型中注入日志服务，以便在处理业务逻辑时记录相关信息，而在测试视图模型时可以注入模拟的日志服务，避免实际的日志输出影响测试结果。
  3. 多语言支持：可以将不同语言的资源文件加载逻辑封装成服务，通过 IOC 注入到视图中，实现多语言的切换和支持。例如，创建一个 ILanguageService 接口，实现类负责根据用户设置加载相应语言的资源文件，并将其注入到视图中，从而实现视图的多语言显示。
  4. 插件式架构：当应用程序需要实现插件式架构时，IOC 可以帮助管理插件的依赖关系。插件可以通过接口来定义其功能，然后在 IOC 容器中注册插件的实现，使得主应用程序能够方便地加载和使用插件。主应用程序可以依赖于插件接口，而不需要关心插件的具体实现，从而实现插件的动态插拔和扩展。

六、5 个 IOC 容器示例代码及解析

示例 1：构造函数注入简单服务

 

csharp

using System;using System.Collections.Generic;using System.Windows;

// 定义IOC容器类class SimpleIocContainer{

    // 使用字典存储接口和对应的创建实例的委托

    private readonly Dictionary<Type, Func<object>> _registrations = new Dictionary<Type, Func<object>>();

 

    // 注册接口和实现类的映射关系

    public void Register<TInterface, TImplementation>() where TImplementation : TInterface

    {

        // 将创建TImplementation实例的委托存入字典，键为TInterface的Type对象

        _registrations[typeof(TInterface)] = () => Activator.CreateInstance<TImplementation>();

    }

 

    // 根据接口解析出对应的实现类实例

    public TInterface Resolve<TInterface>()

    {

        if (_registrations.TryGetValue(typeof(TInterface), out var factory))

        {

            // 如果字典中存在对应的创建委托，则调用委托创建实例并返回

            return (TInterface)factory();

        }

        throw new Exception($"Type {typeof(TInterface)} is not registered.");

    }}

// 定义服务接口interface IMessageService{

    string GetMessage();}

// 实现服务接口class ConsoleMessageService : IMessageService{

    public string GetMessage()

    {

        return "Hello from ConsoleMessageService!";

    }}

// 视图模型类，通过构造函数注入服务class MainViewModel{

    // 保存注入的IMessageService实例

    private readonly IMessageService _messageService;

 

    // 构造函数接收IMessageService实例作为参数，实现依赖注入

    public MainViewModel(IMessageService messageService)

    {

        _messageService = messageService;

    }

 

    // 视图模型的方法，调用注入的服务获取消息

    public string GetViewModelMessage()

    {

        return _messageService.GetMessage();

    }}

// 主窗口类public partial class MainWindow : Window{

    public MainWindow()

    {

        InitializeComponent();

 

        // 创建IOC容器实例

        var container = new SimpleIocContainer();

        // 注册IMessageService接口和ConsoleMessageService实现类的映射关系

        container.Register<IMessageService, ConsoleMessageService>();

 

        // 从IOC容器中解析出MainViewModel实例，此时会自动注入已注册的IMessageService实例

        var viewModel = container.Resolve<MainViewModel>();

        // 设置窗口的数据上下文为视图模型实例

        DataContext = viewModel;

    }}

 

解析：此示例展示了最基本的构造函数注入方式。SimpleIocContainer 类实现了简单的 IOC 容器功能，通过 Register 方法注册接口和实现类的映射，Resolve 方法根据接口解析实例。IMessageService 定义了服务接口，ConsoleMessageService 是其实现类。MainViewModel 通过构造函数接收 IMessageService 实例，实现依赖注入。在主窗口中，创建 IOC 容器，注册映射关系，解析出视图模型并设置为数据上下文，从而实现了从容器中获取依赖并注入到视图模型的过程。

 

示例 2：属性注入服务

 

csharp

using System;using System.Collections.Generic;using System.Windows;

class SimpleIocContainer{

    private readonly Dictionary<Type, Func<object>> _registrations = new Dictionary<Type, Func<object>>();

 

    public void Register<TInterface, TImplementation>() where TImplementation : TInterface

    {

        _registrations[typeof(TInterface)] = () => Activator.CreateInstance<TImplementation>();

    }

 

    public TInterface Resolve<TInterface>()

    {

        if (_registrations.TryGetValue(typeof(TInterface), out var factory))

        {

            return (TInterface)factory();

        }

        throw new Exception($"Type {typeof(TInterface)} is not registered.");

    }}

interface ILogger{

    void Log(string message);}

class FileLogger : ILogger{

    public void Log(string message)

    {

        Console.WriteLine($"Logging to file: {message}");

    }}

class OrderViewModel{

    // 定义可读写的属性来接收注入的ILogger实例

    public ILogger Logger { get; set; }

 

    public void PlaceOrder()

    {

        // 在方法中使用注入的Logger实例记录日志

        Logger.Log("Order placed successfully.");

    }}

public partial class MainWindow : Window{

    public MainWindow()

    {

        InitializeComponent();

 

        var container = new SimpleIocContainer();

        container.Register<ILogger, FileLogger>();

 

        var viewModel = container.Resolve<OrderViewModel>();

        // 从IOC容器中解析出ILogger实例，并赋值给视图模型的Logger属性，实现属性注入

        viewModel.Logger = container.Resolve<ILogger>();

 

        DataContext = viewModel;

    }}

 

解析：该示例使用属性注入方式。OrderViewModel 定义了一个 Logger 属性用于接收 ILogger 实例。在主窗口中，创建 IOC 容器并注册 ILogger 接口和 FileLogger 实现类的映射关系。解析出 OrderViewModel 实例后，再从容器中解析出 ILogger 实例并赋值给视图模型的 Logger 属性，从而实现了属性注入。视图模型的 PlaceOrder 方法中使用注入的 Logger 实例记录日志。

 

示例 3：方法注入服务

 

csharp

using System;using System.Collections.Generic;using System.Windows;

class SimpleIocContainer{

    private readonly Dictionary<Type, Func<object>> _registrations = new Dictionary<Type, Func<object>>();

 

    public void Register<TInterface, TImplementation>() where TImplementation : TInterface

    {

        _registrations[typeof(TInterface)] = () => Activator.CreateInstance<TImplementation>();

    }

 

    public TInterface Resolve<TInterface>()

    {

        if (_registrations.TryGetValue(typeof(TInterface), out var factory))

        {

            return (TInterface)factory();

        }

        throw new Exception($"Type {typeof(TInterface)} is not registered.");

    }}

interface IEmailSender{

    void SendEmail(string to, string subject, string body);}

class SmtpEmailSender : IEmailSender{

    public void SendEmail(string to, string subject, string body)

    {

        Console.WriteLine($"Sending email to {to}: {subject} - {body}");

    }}

class CustomerViewModel{

    private IEmailSender _emailSender;

 

    // 定义方法用于接收注入的IEmailSender实例

    public void SetEmailSender(IEmailSender emailSender)

    {

        _emailSender = emailSender;

    }

 

    public void SendWelcomeEmail(string customerEmail)

    {

        // 在方法中使用注入的IEmailSender实例发送邮件

        _emailSender.SendEmail(customerEmail, "Welcome", "Thank you for choosing us!");

    }}

public partial class MainWindow : Window{

    public MainWindow()

    {

        InitializeComponent();

 

        var container = new SimpleIocContainer();

        container.Register<IEmailSender, SmtpEmailSender>();

 

        var viewModel = container.Resolve<CustomerViewModel>();

        // 从IOC容器中解析出IEmailSender实例，并调用视图模型的SetEmailSender方法进行注入

        viewModel.SetEmailSender(container.Resolve<IEmailSender>());

 

        DataContext = viewModel;

    }}

 

解析：此示例采用方法注入。CustomerViewModel 定义了 SetEmailSender 方法用于接收 IEmailSender 实例。在主窗口中，创建 IOC 容器并注册 IEmailSender 接口和 SmtpEmailSender 实现类的映射关系。解析出 CustomerViewModel 实例后，从容器中解析出 IEmailSender 实例并调用视图模型的 SetEmailSender 方法，实现方法注入。视图模型的 SendWelcomeEmail 方法中使用注入的 IEmailSender 实例发送欢迎邮件。

 

 

案例4

csharp

using System;using System.Collections.Generic;using System.Windows;

class SimpleIocContainer{

    private readonly Dictionary<Type, Func<object>> _registrations = new Dictionary<Type, Func<object>>();

 

    public void Register<TInterface, TImplementation>() where TImplementation : TInterface

    {

        _registrations[typeof(TInterface)] = () => Activator.CreateInstance<TImplementation>();

    }

 

    public TInterface Resolve<TInterface>()

    {

        if (_registrations.TryGetValue(typeof(TInterface), out var factory))

        {

            return (TInterface)factory();

        }

        throw new Exception($"Type {typeof(TInterface)} is not registered.");

    }}

interface IDataAccess{

    string GetData();}

class SqlDataAccess : IDataAccess{

    public string GetData()

    {

        return "Data retrieved from SQL database.";

    }}

interface IBusinessLogic{

    string ProcessData();}

class BusinessLogic : IBusinessLogic{

    // 保存注入的IDataAccess实例

    private readonly IDataAccess _dataAccess;

 

    // 构造函数接收IDataAccess实例作为参数，实现第一层依赖注入

    public BusinessLogic(IDataAccess dataAccess)

    {

        _dataAccess = dataAccess;

    }

 

    // 业务逻辑方法，调用注入的IDataAccess实例获取数据并处理

    public string ProcessData()

    {

        return $"Processed: {_dataAccess.GetData()}";

    }}

class MainViewModel{

    // 保存注入的IBusinessLogic实例

    private readonly IBusinessLogic _businessLogic;

 

    // 构造函数接收IBusinessLogic实例作为参数，实现第二层依赖注入

    public MainViewModel(IBusinessLogic businessLogic)

    {

        _businessLogic = businessLogic;

    }

 

    // 视图模型的方法，调用注入的IBusinessLogic实例获取处理后的数据

    public string GetViewModelData()

    {

        return _businessLogic.ProcessData();

    }}

public partial class MainWindow : Window{

    public MainWindow()

    {

        InitializeComponent();

 

        var container = new SimpleIocContainer();

        // 注册IDataAccess接口和SqlDataAccess实现类的映射关系

        container.Register<IDataAccess, SqlDataAccess>();

        // 注册IBusinessLogic接口和BusinessLogic实现类的映射关系

        container.Register<IBusinessLogic, BusinessLogic>();

 

        // 从IOC容器中解析出MainViewModel实例，此时会自动按照依赖关系

        // 先解析出BusinessLogic实例，而BusinessLogic实例的创建又会依赖于

        // 已注册的SqlDataAccess实例，从而实现多层依赖注入

        var viewModel = container.Resolve<MainViewModel>();

        DataContext = viewModel;

    }}

 

解析：此示例展示了多层依赖注入的情况。BusinessLogic 类依赖于 IDataAccess 接口，通过构造函数注入 IDataAccess 实例来获取数据并进行处理。MainViewModel 类又依赖于 IBusinessLogic 接口，同样通过构造函数注入 IBusinessLogic 实例。在主窗口中，先在 IOC 容器中分别注册 IDataAccess 与 SqlDataAccess、IBusinessLogic 与 BusinessLogic 的映射关系。当解析 MainViewModel 实例时，IOC 容器会按照依赖关系，先创建 BusinessLogic 实例，而创建 BusinessLogic 实例时又会去解析并注入 SqlDataAccess 实例，从而实现了多层依赖的正确注入和使用。

 

示例 5：单例模式在 IOC 中的应用

 

csharp

using System;using System.Collections.Generic;using System.Windows;

class SimpleIocContainer{

    // 存储接口和对应的创建实例的委托

    private readonly Dictionary<Type, Func<object>> _registrations = new Dictionary<Type, Func<object>>();

    // 存储单例对象，键为接口的Type对象，值为单例实例

    private readonly Dictionary<Type, object> _singletons = new Dictionary<Type, object>();

 

    // 注册普通的接口和实现类的映射关系

    public void Register<TInterface, TImplementation>() where TImplementation : TInterface

    {

        _registrations[typeof(TInterface)] = () => Activator.CreateInstance<TImplementation>();

    }

 

    // 注册单例模式的接口和实现类的映射关系

    public void RegisterSingleton<TInterface, TImplementation>() where TImplementation : TInterface

    {

        _registrations[typeof(TInterface)] = () =>

        {

            // 如果单例字典中不存在该接口对应的实例，则创建一个新的实例并存储

            if (!_singletons.ContainsKey(typeof(TInterface)))

            {

                _singletons[typeof(TInterface)] = Activator.CreateInstance<TImplementation>();

            }

            // 返回已存储的单例实例

            return _singletons[typeof(TInterface)];

        };

    }

 

    // 根据接口解析出对应的实现类实例

    public TInterface Resolve<TInterface>()

    {

        if (_registrations.TryGetValue(typeof(TInterface), out var factory))

        {

            return (TInterface)factory();

        }

        throw new Exception($"Type {typeof(TInterface)} is not registered.");

    }}

interface IConfigurationService{

    string GetConfigurationValue(string key);}

class AppConfigurationService : IConfigurationService{

    public string GetConfigurationValue(string key)

    {

        return $"Value for {key} from configuration.";

    }}

class SettingsViewModel{

    // 保存注入的IConfigurationService实例

    private readonly IConfigurationService _configurationService;

 

    // 构造函数接收IConfigurationService实例作为参数，实现依赖注入

    public SettingsViewModel(IConfigurationService configurationService)

    {

        _configurationService = configurationService;

    }

 

    // 视图模型的方法，调用注入的IConfigurationService实例获取配置值

    public string GetSettingValue(string key)

    {

        return _configurationService.GetConfigurationValue(key);

    }}

public partial class MainWindow : Window{

    public MainWindow()

    {

        InitializeComponent();

 

        var container = new SimpleIocContainer();

        // 注册IConfigurationService接口和AppConfigurationService实现类为单例模式

        container.RegisterSingleton<IConfigurationService, AppConfigurationService>();

 

        // 从IOC容器中解析出SettingsViewModel实例，此时会注入已注册为单例的

        // IConfigurationService实例，保证整个应用中该服务只有一个实例

        var viewModel = container.Resolve<SettingsViewModel>();

        DataContext = viewModel;

    }}

解析：该示例演示了在 IOC 容器中实现单例模式。SimpleIocContainer 类增加了一个 _singletons 字典用于存储单例对象。RegisterSingleton 方法实现了单例注册逻辑，当解析接口对应的实例时，如果单例字典中不存在该实例，则创建一个新的实例并存储，以后每次请求该接口的实例时都返回已存储的单例实例。IConfigurationService 定义了配置服务接口，AppConfigurationService 是其实现类。SettingsViewModel 通过构造函数注入 IConfigurationService 实例。在主窗口中，注册 IConfigurationService 与 AppConfigurationService 的单例映射关系，解析 SettingsViewModel 实例时会注入单例的配置服务实例，确保在整个应用中该配置服务只有一个实例，避免了重复创建和资源浪费，同时也方便在不同组件中共享相同的配置信息。

 

 

观无
关注
WPF实现依赖注入
weixin_52505520的博客
03-21 2529
一、修改App.xaml 删除启动的Uri(StartupUri=“MainWindow.xaml”) 二、修改App.xaml.cs 1、集成Microsoft.Extensions.DependencyInjection 2、重写OnStartUp方法 var services = new ServiceCollection(); services.AddSingleton<MainWindow>(); servic
wpf通过依赖注入查询多个数据库显示到页面
sasafs的博客
06-25 480
C#依赖注入
WPF/C#：在WPF中如何实现依赖注入
mingupup的博客
07-11 1289
本文通过 WPF Gallery 这个项目学习依赖注入的相关概念与如何在WPF中进行依赖注入。依赖注入（Dependency Injection，简称DI）是一种设计模式，用于实现控制反转（Inversion of Control，简称IoC）原则。依赖注入的主要目的是将对象的创建和对象之间的依赖关系的管理从对象内部转移到外部容器或框架中，从而提高代码的可维护性、可测试性和灵活性。依赖注入的核心概念依赖：一个对象需要另一个对象来完成其工作，那么前者就依赖于后者。
WPF使用依赖注入
xunmeng2002的专栏
08-22 1345
在使用依赖注入后，我发现在App里面完成一些初始化内容更合适，包括MainWindow也通过容器生成，需要注意的是，记得把App.xaml中的 StartupUri更改为 Startup，并把值改为自定义的启动函数，在启动函数里面调用MainWindow的Show方法。现在依赖注入在.Net里面已经普及，自己常写一些简单的demo倒是无所谓，但偶尔写一点正式的工程，也免不了要使用一下，于是总结了一下在WPF里面使用依赖注入。
WPF添加依赖注入
nightingale1985的博客
04-03 2530
本文记录下WPF程序如何使用依赖注入。代码是在之前WPF使用MVVM模式开发的代码基础上修改的，MVVM的内容见下面链接。 WPF使用MVVM模式开发 废话不多说，直接上代码： nuget添加Microsoft.Extensions.DependencyInjection包 修改App.xaml.cs文件如下： public App() { Services = ConfigureServices(); //this.Init
WPF Prism 依赖注入
u013255730的博客
10-03 3099
WPF Prism Services依赖注入 安装Prism.Unity，当前最新版为7.2* RegisterTypes中的写法与ASP.netcore中的依赖注入方式相似 App.xaml.cs // App.xaml.cs using Prism.Ioc; using Prism.Wpf.NetCore.Views; using System.Windows; using Prism.Modularity; using Prism.Wpf.NetCore.Services; namespace P
WPF 依赖注入之 Microsoft.Extensions.DependencyInjection
dotNET跨平台
01-09 1518
WPF 依赖注入之 Microsoft.Extensions.DependencyInjection独立观察员 2023 年 1 月 8 日NuGet 包：添加业务需要的接口及实现类：在 App 中声明服务提供者对象，以及添加服务等：核心代码：/// <summary> /// App.xaml 的交互逻辑 /// </summary> public partial cla...
WPF 手撸插件 八 依赖注入
bjxingch的博客
09-09 652
Autofac
C# WPF MVVM中依赖注入
weixin_42774407的博客
06-07 926
C# WPF MVVM依赖注入
wpf 依赖注入
12-25
在Windows Presentation Foundation (WPF) 中，依赖注入(Dependency Injection，简称DI)是一种设计模式，用于管理应用程序中组件之间的交互和依赖关系。它的核心思想是让组件自身声明需要的依赖项，而不是直接创建...
WPF PRISM开发入门二(Unity依赖注入容器使用)-附件资源
03-02
WPF PRISM开发入门二(Unity依赖注入容器使用)-附件资源
【WPF】Prism学习（六）
weixin_45125631的博客
11-18 1498
Prism是一个流行的.NET框架，用于构建基于MVVM模式的应用程序，它支持依赖注入，这有助于构建可维护和可测试的应用程序，并减少对静态和循环引用的依赖。：Prism框架提供了几种不同的DI容器实现，这些容器实现了Prism的IoC（控制反转）抽象。
Spring Boot 项目日志系统全攻略：Logback、Log4j2、Log4j与SLF4J整合指南
qq_42763903的博客
04-07 786
SLF4J：日志门面框架（必须）Logback：默认实现（Spring Boot官方推荐）Log4j2：高性能替代方案Log4j：旧版实现（不推荐新项目使用）📌最佳实践：无论使用哪种实现，都应该通过SLF4J API进行日志记录，保持代码与具体实现的解耦。新项目推荐组合传统项目组合必须避免：直接使用Log4j 1.x核心原则代码中始终使用SLF4J API合理选择日志级别生产环境使用异步日志建立完善的日志监控体系通过合理配置日志系统，可以显著提升应用的可靠性和可维护性。
【Code】《代码整洁之道》笔记-Chapter9-单元测试
江湖人称菠萝包
04-10 849
过去十年以来，编程专业领域进步很大。1997年时，没人听说过测试驱动开发。对于我们之中的大多数人来说，单元测试是那种用来确保程序“可运行”的用过即扔的短代码。我们辛勤地编写类和方法，再弄出一些特殊代码来测试它们。通常这些代码会是一种简单的驱动式程序，让我们能够手工与自己编写的程序交互。我记得在20世纪90年代曾为一套嵌入式实时系统编写过C++程序。想法很简单；到达指定毫秒数时，在一个新线程中执行Command的execute方法。问题在于如何测试它。我随便写了个简单的驱动式程序，聆听来自键盘的动作。
请你回答一下单元测试、集成测试、系统测试、验收测试、回归测试这几步中最重要的是哪一步？
zhanghaiou07657的博客
04-07 555
public OrderService(Repository repo) { // 依赖注入。如同建筑地基决定楼宇高度，单元测试的质量直接影响整个系统的可靠性上限。在软件测试的不同阶段中，每个环节都有其不可替代的价值，但若从工程效率和缺陷防控的全局视角来看，相较系统测试的"黑盒"特性，单元测试提供更细粒度的故障定位能力。是质量金字塔的基石，其重要性最为关键。单元测试强制代码解耦，使系统天然具备可维护性。据统计，拥有完善单元测试的团队部署频率提升。单元测试的广泛覆盖，为上层测试提供稳定底座。
算法刷题记录——LeetCode篇(1.8) [第71~80题](持续更新)
最新发布
weixin_42826353的博客
04-10 831
LeetCode71-80个人刷题总结。
第四十三篇 会计数据仓库建模实战指南- 维度建模在财务系统的深度应用
qq_39991788的博客
04-07 788
关账后仍有数据变更请求。财务数据仓库实施计划。
C++：了解string类的重要函数
2301_81791624的博客
04-08 907
对于常用的一些string的函数，掌握上面的足以应对遇到的绝大部分情况了，并且我们可以看出封装了一个这样的字符串类后，我们以后再使用字符串就可以更加简洁更加方便了。后面会写一篇文章来进行对一些重要函数的模拟实现来帮助大家更加深入的了解这些函数的底层封装。
JavaMath类+设计一个小计算器
Eugene__Chen的博客
04-07 437
(✪ω✪) 曼波来啦！Java的Math类就像哆啦A梦的数学口袋呢~ 准备好接收知识能量了吗？(๑˃̵ᴗ˂̵)و。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值