C# 利用Autofac批量接口注入依赖的问题小结

首先我们需要明确“依赖注入”和“Autofac”的概念。

依赖注入是一种设计模式，它可以使代码更加灵活，易于扩展和测试。在依赖注入中，对象之间的依赖关系不是在对象内部被创建，而是通过外部容器提供的依赖注入机制来实现的。这样，整个系统可以视为由各个松散耦合的模块组成，每个模块都可以独立开发和测试。

Autofac是一个开源的.NET依赖注入框架，可以将依赖注入集成到应用程序中，并可用于一些常见的开发任务。

现在，让我们来详细讲解“C#结合Autofac实现批量接口注入依赖”的完整攻略：

1. 创建接口和实现类

首先，我们需要创建接口和实现类。在这里，我们创建一个接口IAnimal和两个实现类Dog和Cat。代码如下：

public interface IAnimal
{
    void Speak();
}

public class Dog : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("I'm a dog.");
    }
}

public class Cat : IAnimal
{
    public void Speak()
    {
        Console.WriteLine("I'm a cat.");
    }
}

1. 创建类容器

然后，我们需要创建一个Autofac容器来管理类的依赖关系，并将依赖注入到需要它们的类中。我们将使用ContainerBuilder类来创建和配置容器。代码如下：

var builder = new ContainerBuilder();
builder.RegisterType<Dog>().As<IAnimal>();
builder.RegisterType<Cat>().As<IAnimal>();
var container = builder.Build();

这里，我们用builder.RegisterType()方法来注册我们的实现类，并用builder.Build()方法来构建容器。

1. 自动注入

在创建容器之后，我们可以将需要使用依赖注入的类注入到容器中。当需要使用这些类时，我们可以通过容器自动将它们注入到需要它们的类中。代码如下：

class Program
{
    static void Main(string[] args)
    {
        using (var scope = container.BeginLifetimeScope())
        {
            //构建一个被注入的类AnimalService
            var service = scope.Resolve<AnimalService>();
            service.PetSpeak();
        }
        Console.ReadKey();
    }
}

public class AnimalService
{
    public ICollection<IAnimal> Animals { get; set; }

    public AnimalService(ICollection<IAnimal> animals)
    {
        Animals = animals;
    }

    public void PetSpeak()
    {
        foreach (var animal in Animals)
        {
            animal.Speak();
        }
    }
}

在这里，我们创建了一个AnimalService类，它有一个ICollection类型的Animals属性，并且在它的构造函数中通过依赖注入接收ICollection参数。在程序的主函数中，我们创建了一个scope变量，它表示我们要在容器中创建一个生命周期范围，并使用scope.Resolve()方法创建一个AnimalService的实例。这时，容器会自动将实现IAnimal接口的类（在这里是Dog和Cat）注入AnimalService构造函数中的ICollection型参数。

然后，我们使用service.PetSpeak()方法调用AnimalService对象中Animals集合中的所有动物的Speak()方法。

示例1

using System;
using System.Collections.Generic;
using Autofac;

namespace AutofacTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<Dog>().As<IAnimal>();
            builder.RegisterType<Cat>().As<IAnimal>();
            builder.RegisterType<AnimalService>();
            var container = builder.Build();

            using var scope = container.BeginLifetimeScope();
            var service = scope.Resolve<AnimalService>();
            service.PetSpeak();

            Console.ReadKey();
        }
    }

    public class AnimalService
    {
        public AnimalService(ICollection<IAnimal> animals)
        {
            Animals = animals;
        }

        public ICollection<IAnimal> Animals { get; }

        public void PetSpeak()
        {
            Console.WriteLine("All Animals Speak:");
            foreach (var animal in Animals)
            {
                animal.Speak();
            }
        }
    }

    public interface IAnimal
    {
        void Speak();
    }

    public class Dog : IAnimal
    {
        public void Speak()
        {
            Console.WriteLine("I'm a dog.");
        }
    }

    public class Cat : IAnimal
    {
        public void Speak()
        {
            Console.WriteLine("I'm a cat.");
        }
    }
}

我们创建了AnimalService类，并将需要使用依赖注入的IAnimal类型的类注入到AnimalService的构造函数中。最后，在主函数中使用AnimalService对象调用PetSpeak()方法，获取到所有动物对应的Speak()方法。

示例2

using System;
using System.Collections.Generic;
using Autofac;

namespace AutofacTest
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var builder = new ContainerBuilder();
            builder.RegisterAssemblyTypes(typeof(Program).Assembly)
                .Where(t => t.Name.EndsWith("Service"))
                .AsImplementedInterfaces()
                .InstancePerLifetimeScope();
            builder.RegisterType<MovieService>().As<IMovieService>();
            var container = builder.Build();

            using var scope = container.BeginLifetimeScope();
            var movieService = scope.Resolve<IMovieService>();
            movieService.DisplayTodaysMovies();
            movieService.AddNewMovie("Despicable Me 4");
            movieService.DisplayTodaysMovies();

            Console.ReadKey();
        }
    }

    public interface IMovieService
    {
        void AddNewMovie(string name);
        void DisplayTodaysMovies();
    }

    public class MovieService : IMovieService
    {
        public List<string> TodaysMovies { get; set; }

        public MovieService()
        {
            TodaysMovies = new List<string>();
        }

        public void AddNewMovie(string name)
        {
            TodaysMovies.Add(name);
        }

        public void DisplayTodaysMovies()
        {
            Console.WriteLine("Today's Movies:");
            Console.WriteLine("--------------------");
            foreach (var movie in TodaysMovies)
            {
                Console.WriteLine(movie);
            }
            Console.WriteLine("--------------------");
        }
    }

    public interface IUserService
    {
        void DisplayUserDetails();
    }

    public class UserService : IUserService
    {
        private IMovieService MovieService { get; set; }
        public UserService(IMovieService movieService)
        {
            MovieService = movieService;
        }

        public void DisplayUserDetails()
        {
            Console.WriteLine("Current User Details: ");
            Console.WriteLine("------------------------");
            MovieService.DisplayTodaysMovies();
            Console.WriteLine("------------------------");
        }
    }

}

我们定义了2个接口：IMovieService和IUserService。MovieService 可以添加新电影，还可以列出今天上映的电影。UserService负责显示用户的详细信息，但它需要依赖于MovieService。在实现UserService时，我们将IMovieService传递给构造函数，并使用它调用MovieService的DisplayTodaysMovies()方法。因此，当我们创建UserService对象时，容器会自动将IMovieService的实现类MovieService注入到它的构造函数中。最后，在主函数中，我们创建UserService对象，并使用它来显示用户详细信息。