1

我有以下服务类：

public class JobService {
  private UserService us;

  public JobService (UserService us) {
    this.us = us;
  }

  public void addJob(Job job) {
    // needs to make a call to user service to update some user info
    // similar dependency to the deleteUser method
  }
}

public class UserService {
  private JobService js;
  public UserService(JobService js) {
    this.js = js;
  }

  public void deleteUser(User u) {
    using (TransactionScope scope = new TransactionScope()) {
      List<IJob> jobs = jobService.findAllByUser(u.Id);
      foreach (IJob job in jobs) {
        js.deleteJob(job);
      }
      userDao.delete(user);
      scope.Complete();
    }
  }
}

这些服务类中的每一个都由 IoC 容器实例化，并且没有功能问题，但是对我来说，这种方法存在潜在的设计缺陷，我想知道是否有更有意义的替代方法。

4

4 回答 4

7

正如有人已经指出的那样，问题不在于 DI 容器的限制，而在于您的设计。

我看到了你有一个单独的UserService和一个JobService包含相互引用的原因。这是因为两者都UserService 包含JobService一些需要其他服务作为参考的逻辑（添加作业需要添加用户等）。但是，我认为您不应该从另一项服务中引用一项服务。相反，您应该在服务后面有另一个抽象层，这些服务将用于公共逻辑。因此，服务将包含不能（不应该）重用的逻辑，而助手将包含共享逻辑。

例如：

    public class UserHelper{
      //add all your common methods here
    }
    public class JobService {
      private UserHelper us;

      public JobService (UserHelper us) {
        this.us = us;
      }

      public void addJob(Job job) {
 // calls helper class
      }
    }

    public class UserService {

      public UserService(UserHelper js) {
        this.js = js;
      }

      public void deleteUser(User u) {
        // calls helper class
      }
    }

这样，循环引用就不会有任何问题，并且您将拥有一个包含需要由不同服务重用的逻辑的地方。

此外，我更喜欢拥有彼此完全隔离的服务。

于 2012-12-26T16:34:55.043 回答
2

您遇到的问题实际上与您的 DI 容器的限制无关，但这是一个普遍的问题。即使没有任何容器，也无法创建这些类型：

var job = new JobService([what goes here???]);
var user = new UserService(job);

因此，一般的答案是将依赖项之一提升为属性。这将打破依赖循环：

var job = new JobService();
var user = new UserService(job);

// Use property injection
job.User = user;

但是，请防止使用比严格需要更多的属性。这些依赖循环应该是非常少见的，这使得将类型连接在一起或验证 DI 配置的正确性变得更加困难。构造函数注入使这更容易。

于 2012-12-26T16:22:33.370 回答
1

这在 Autofac 中不起作用。请参阅文档的循环依赖部分。

构造函数/构造函数依赖关系 不支持具有循环构造函数依赖关系的两种类型。当您尝试解析以这种方式注册的类型时，您将遇到异常。

您可能会使用关系类型( Func<>, Lazy<>) 来打破循环。

您的代码有点过于通用，无法提出适当的解决方案，但无论您使用什么 IoC 容器，您都应该考虑更改依赖关系的方向。

public class JobService {
  private UserService us;

  public JobService (UserService us) {
    this.us = us;
  }

  public void addJob(Job job) {
    // needs to make a call to user service to update some user info
  }
}

public class UserService {
  private JobService js;
  public UserService(Func<JobService> jsFactory) {
    this.js = jsFactory(this);
  }

  public void deleteUser(User u) {
    // needs to call the job service to delete all the user's jobs
  }
}

或者，在您的示例中，您可以移动deleteUser并创建一个方法，删除作业服务上的所有作业，而不是使用 id 来引用用户。这通过使用 id 打破了依赖关系。

另一种选择是将作业服务作为参数传递给deleteUser.

于 2012-12-26T15:51:41.997 回答
1

您可以使用事件解耦服务。当一个动作被执行时，不是调用另一个服务的依赖方法，而是引发一个事件。然后，集成商可以通过事件连接服务。一个服务甚至不知道另一个服务的存在。

public class JobService
{
    public event Action<User, Job> JobAdded;

    public void AddJob(User user, Job job)
    {
        //TODO: Add job.
        // Fire event
        if (JobAdded != null) JobAdded(user, job);
    }

    internal void DeleteJobs(int userID)
    {
        //TODO: Delete jobs
    }
}

public class UserService
{
    public event Action<User> UserDeleted;

    public void DeleteUser(User u)
    {
        //TODO: Delete User.
        // Fire event
        if (UserDeleted != null) UserDeleted(u);
    }

    public void UpdateUser(User user, Job job)
    {
        //TODO: Update user
    }
}

集成商连接服务

public static class Services
{
    public static JobService JobService { get; private set; }
    public static UserService UserService { get; private set; }

    static Services( )
    {
        JobService = new JobService();
        UserService = new UserService();

        JobService.JobAdded += JobService_JobAdded;
        UserService.UserDeleted += UserService_UserDeleted;
    }

    private static void UserService_UserDeleted(User user)
    {
        JobService.DeleteJobs(user.ID);
    }

    private static void JobService_JobAdded(User user, Job job)
    {
        UserService.UpdateUser(user, job);
    }
}

（注意：我稍微简化了事件引发。这样不是线程安全的。但您可以假设事件是提前订阅的，以后不会更改。）

于 2012-12-26T17:03:36.987 回答