c# - 使用 Dependency Resolver 是一种不好的做法吗？

Question

我将在这里编一个例子来说明我的观点。请考虑以下类(class):

public class MovieController : Controller
{
    private readonly IMovieService _movieService;
    private readonly IUserService _userService;

    public MovieController(IMovieService movieService, IUserService userService)
    {
        _movieService = movieService;
        _userService = userService;
    }

    public ViewModel GetMovies()
    {
        return View("Movies", _movieService.GetMovies());
    }

    public ViewModel GetAuthors()
    {
        return View("Authors", _userService.GetAuthors());
    }
}

在上面的示例中，每当创建 MovieController 时，它都会创建这两个服务。每个服务都需要在构造函数中使用它的服务和存储库。所以，实际上，每次调用 MovieController 时我可能会创建一些类。出于这个原因，我想实现延迟加载，因为我相信它会提高性能。为此，请考虑下一节课:

public class MovieController : Controller
{
    private readonly IMovieService _movieService;
    private readonly IUserService _userService;

    private MovieService 
    {
        get 
        {
            if (_movieService == null) _movieService = new MovieService();
            return _movieService;
        }
    }

    private UserService 
    {
        get 
        {
            if (_userService == null) _userService = new UserService();
            return _userService;
        }
    }

    public MovieController() { }

    public ViewModel GetMovies()
    {
        return View("Movies", MovieService.GetMovies());
    }

    public ViewModel GetAuthors()
    {
        return View("Authors", UserService.GetAuthors());
    }
}

上面例子的问题是我丢了DI。现在我明白了 DI 的好处，我非常想保留它，因此，我想到了以下示例:

public class MovieController : Controller
{
    private readonly IMovieService _movieService;
    private readonly IUserService _userService;

    private MovieService 
    {
        get 
        {
            if (_movieService == null) _movieService = DependencyResolver.Current.GetService(typeof(IMovieService));
            return _movieService;
        }
    }

    private UserService 
    {
        get 
        {
            if (_userService == null) _userService = DependencyResolver.Current.GetService(typeof(IUserService));
            return _userService;
        }
    }

    public MovieController() { }

    public ViewModel GetMovies()
    {
        return View("Movies", MovieService.GetMovies());
    }

    public ViewModel GetAuthors()
    {
        return View("Authors", UserService.GetAuthors());
    }
}

我在这个问题中的第三个例子是不好的做法吗？如果是这样，为什么？我这样做是在降低性能还是有其他原因导致这被认为是不好的做法？

Answer 1

以这种方式使用依赖解析器意味着您正在使用 the service locator anti-pattern .

您是否认为创建 MovieService 和 UserService 会出现性能问题？您是否在这些类的构造函数中做了一些重要的事情？如果是这样，那么你可能不应该这样做。在构造函数中，您几乎应该总是只接受依赖项并将它们存储在私有(private)字段中。

如果出于某种原因，你仍然想要延迟加载，那么你可以创建这样的东西:

public class LazyMovieService : IMovieService
{
    private readonly Lazy<IMovieService> lazyInstance;

    public LazyMovieService(Func<IMovieService> instanceFactory)
    {
        lazyInstance = new Lazy<IMovieService>(instanceFactory);
    }
    public string[] GetMovies()
    {
        return lazyInstance.Value.GetMovies();
    }
}

此类允许您在代码中使用第一个代码示例，同时仍然能够延迟加载您的服务。

在Composition Root ，您只需执行以下操作:

var controller =
    new MovieController(
        new LazyMovieService(() => new MyOriginalMovieService(...)),
        ...);