4

我最近创建了一个解决方案，并认为我会尝试使用 DryIoC 容器来处理依赖注入。现在，与我使用的许多其他 DI 解决方案一样，对象重用的默认范围是瞬态的。然而，这似乎给我正在使用的存储库模式的实现带来了问题，因为如果引用的类实现 IDisposable，则 DryIoC（和许多其他解决方案）无法将绑定注册为瞬态。结果，我暂时求助于使用Reuse.Singleton注册我的存储库。这对我来说绝对是一种代码味道，所以我希望有人可以就如何避免这种情况提出一些建议——例如，我可能在创建存储库方面做得很差。

这是我用来创建 IoC 容器的代码：

private static Container ConstructNewContainer()
{
    var container = new Container(Rules.Default);
    container.Register(Made.Of(() => SettingsFactory.CreateSettings()));    
    container.Register<IRepository<tblMailMessage>, MailMessageRepository>(Reuse.Singleton);
    container.Register<IRepository<ProcessedMailMessages>, ProcessedMailMessageRepository>(Reuse.Singleton);
    container.Register<IParser, EmailParser>();
    container.Register<IMonitor, DatabaseMonitor>();
    return container;
}

...以及一个示例存储库实现：

public interface IRepository<T>
{
    void Insert(T objectToInsert);

    void Delete(int id);

    void Update(T objectToUpdate);

    void Save();

    T GetById(long id);

    IEnumerable<T> Get();

    T Last();

    bool Exists(int id);
}

public class MailMessageRepository : IRepository<tblMailMessage>, IDisposable
{
    private bool _disposed;
    private readonly CoreDataModel _model;

    public MailMessageRepository()
    {
        _model = new CoreDataModel();
    }

    public void Delete(int id)
    {
        var objectToDelete = _model.tblMailMessages.Find(id);
        if (objectToDelete != null) _model.tblMailMessages.Remove(objectToDelete);
    }

    public void Update(tblMailMessage objectToUpdate) => _model.Entry(objectToUpdate).State = EntityState.Modified;

    public void Save() => _model.SaveChanges();

    public IEnumerable<tblMailMessage> Get() => _model.tblMailMessages.ToList();

    public tblMailMessage Last() => _model.tblMailMessages.OrderByDescending(x => x.DateSubmitted).FirstOrDefault();

    public bool Exists(int id) => _model.tblMailMessages.SingleOrDefault(x => x.MailMessageID == id) != null;

    public void Insert(tblMailMessage objectToInsert) => _model.tblMailMessages.Add(objectToInsert);

    public tblMailMessage GetById(long id) => _model.tblMailMessages.SingleOrDefault(x => x.MailMessageID == id);

    #region Dispose

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (!disposing)
            {
                _model.Dispose();
            }
        }

        _disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    #endregion
}
4

2 回答 2

4

此处的文档解释了为什么一次性瞬态是问题以及为什么以这种方式选择 DryIoc 默认行为。基本上，行为是告知您问题，而不是默默地解决问题。

关于其他容器，对特定的一次性瞬态处理没有强烈的偏好。这是与Autofac、StructureMap 和其他容器开发人员参与的Microsoft.Extensions.DependencyInjection相关的讨论。

顺便说一句，DryIoc 错误消息包含如何选择问题的提示。

于 2017-09-28T05:34:24.973 回答
4

根据文档，您有 3 个选项：

  1. 不允许注册一次性临时服务。默认的 DryIoc 行为。

     container.Register<X>(); // will throw exception

  2. 允许注册一次性瞬态，但将处置服务的责任委托给容器用户。

     container.Register<X>(setup: Setup.With(allowDisposableTransient: true));

 // or allow globally for all container registrations:
 var container = new Container(rules => rules.WithoutThrowOnRegisteringDisposableTransient());

 container.Register<X>(); // works, but dispose is up to User

  3. 在其所有者重用范围（如果有）中跟踪（存储）一次性瞬态依赖关系，或在当前开放范围（如果有）中跟踪已解决的一次性瞬态。

     container.Register<X>(setup: Setup.With(trackDisposableTransient: true));

 // or track globally for all container registrations:
 var container = new Container(rules => rules.WithTrackingDisposableTransients());

 // will be tracked in XUser parent in singleton scope and disposed with container as all singletons
 container.Register<XUser>(Reuse.Singleton);
 container.Register<X>();  

 // or tracking in open scope
 using (var scope = container.OpenScope())
     scope.Resolve<X>; // will be disposed on exiting of using block

正如您在上面看到的，默认行为期望您在使用临时生活方式时明确处置。

但他们忽略了第四个选项，即寻找另一个 DI 容器。我从来没有使用过 DryIoC，但这似乎太担心你不必使用其他容器了。通常，选择正确的生命周期决定了何时处置实例。

于 2017-09-26T12:26:03.340 回答