重构代码以避免反模式

我有一个 BusinessLayer 项目，其中包含以下代码。域对象是FixedBankAccount（它实现了IBankAccount）。

1. 存储库被制作为域对象的公共属性，并被制作为接口成员。如何重构它以使存储库不再是接口成员?

2. 域对象（FixedBankAccount）直接使用存储库来存储数据。这是否违反单一责任原则？如何纠正呢？

注意：存储库模式是使用 LINQ to SQL 实现的。

EDIT

下面给出的代码是更好的方法吗？https://codereview.stackexchange.com/questions/13148/is-it-good-code-to-satisfy-single-responsibility-principle

CODE

public interface IBankAccount
{
    RepositoryLayer.IRepository<RepositoryLayer.BankAccount> AccountRepository { get; set; }
    int BankAccountID { get; set; }
    void FreezeAccount();
}

public class FixedBankAccount : IBankAccount
{
    private RepositoryLayer.IRepository<RepositoryLayer.BankAccount> accountRepository;
    public RepositoryLayer.IRepository<RepositoryLayer.BankAccount> AccountRepository
    {
        get
        {
            return accountRepository;
        }
        set
        {
            accountRepository = value;
        }
    }

    public int BankAccountID { get; set; }

    public void FreezeAccount()
    {
        ChangeAccountStatus();
    }

    private void SendEmail()
    {

    }

    private void ChangeAccountStatus()
    {
        RepositoryLayer.BankAccount bankAccEntity = new RepositoryLayer.BankAccount();
        bankAccEntity.BankAccountID = this.BankAccountID;

        accountRepository.UpdateChangesByAttach(bankAccEntity);
        bankAccEntity.Status = "Frozen";
        accountRepository.SubmitChanges();
    }
}

public class BankAccountService
{
    RepositoryLayer.IRepository<RepositoryLayer.BankAccount> accountRepository;
    ApplicationServiceForBank.IBankAccountFactory bankFactory;

    public BankAccountService(RepositoryLayer.IRepository<RepositoryLayer.BankAccount> repo, IBankAccountFactory bankFact)
    {
        accountRepository = repo;
        bankFactory = bankFact;
    }

    public void FreezeAllAccountsForUser(int userId)
    {
        IEnumerable<RepositoryLayer.BankAccount> accountsForUser = accountRepository.FindAll(p => p.BankUser.UserID == userId);
        foreach (RepositoryLayer.BankAccount repositroyAccount in accountsForUser)
        {
            DomainObjectsForBank.IBankAccount acc = null;
            acc = bankFactory.CreateAccount(repositroyAccount);
            if (acc != null)
            {
                acc.BankAccountID = repositroyAccount.BankAccountID;
                acc.accountRepository = this.accountRepository;
                acc.FreezeAccount();
            }
        }
    }
}

public interface IBankAccountFactory
{
     DomainObjectsForBank.IBankAccount CreateAccount(RepositoryLayer.BankAccount repositroyAccount);
}

public class MySimpleBankAccountFactory : IBankAccountFactory
{
    public DomainObjectsForBank.IBankAccount CreateAccount(RepositoryLayer.BankAccount repositroyAccount)
    {
        DomainObjectsForBank.IBankAccount acc = null;

        if (String.Equals(repositroyAccount.AccountType, "Fixed"))
        {
            acc = new DomainObjectsForBank.FixedBankAccount();
        }

        if (String.Equals(repositroyAccount.AccountType, "Savings"))
        {
            acc = new DomainObjectsForBank.SavingsBankAccount();
        }

        return acc;
    }
}

阅读：

1. DDD - 实体状态转换

2. https://codereview.stackexchange.com/questions/13148/is-it-good-code-to-satisfy-single-responsibility-principle

3. 使用“单一职责原则”强制我的容器拥有公共设置器

4. https://softwareengineering.stackexchange.com/questions/150760/single-responsibility-principle-how-can-i-avoid-code-fragmentation

我不会说这是一种反模式，因为反模式首先应该是一种模式（一种可识别的、广泛的做事方式），而且我不知道有任何“存储库” -领域-对象”模式。

然而，在我看来，这肯定是不好的做法，因为您的 BankAccount 域对象混合了 3 个职责：

• 作为域对象，其自然且合法的责任是冻结自身并更改其状态。

• 更新并将更改提交到持久存储的责任（使用 accountRepository）。

• 有责任决定如何发送消息（在这种情况下为电子邮件）并发送。

结果，您的 Domain 对象与太多事物紧密耦合，使其僵化且脆弱。它可能会因为太多的原因而改变，甚至可能被破坏。

所以没有反模式，但违反了单一责任原则一定。

最后两个职责应该转移到单独的对象。提交更改更应该属于管理业务事务（工作单元）的对象，并且知道结束事务和刷新事物的正确时间。第二个可以放置在基础设施层的电子邮件服务中。理想情况下，执行全局冻结操作的对象不应该知道消息传递机制（通过邮件或其他方式），而应该注入它，这样可以提供更大的灵活性。