Linq 实体框架数据循环

我有一个Account对象，它有许多与之相关的事务

在一种方法中，我获取特定帐户的所有事务

    var transactionlines = (from p in Context.account_transaction
                                  .Include("account_transaction_line")
                                //  .Include("Account")
                                  .Include("account.z_account_type")
                                  .Include("account.institution")
                                  .Include("third_party")
                                  .Include("third_party.z_third_party_type")
                                  .Include("z_account_transaction_type")
                                  .Include("account_transaction_line.transaction_sub_category")
                                  .Include("account_transaction_line.transaction_sub_category.transaction_category")
                                  .Include("z_account_transaction_entry_type")
                                  .Include("account_transaction_line.cost_centre")
                            where p.account_id == accountId
                                  && p.deleted == null

                            select p).ToList();

这意味着返回一个事务列表及其相关对象。然后，我将每个对象传递给转换器，转换器将它们转换为数据传输对象，然后再将这些对象传递回我的主应用程序

 public TransactionDto TranslateTransaction(account_transaction source)
        {
            LogUserActivity("in TranslateTransaction");

            var result = new TransactionDto
            {
                Id = source.id,
                Version = source.version,
                AccountId = source.account_id,
               // Account = TranslateAccount(source.account, false),
                ThirdPartyId = source.third_party_id,
                ThirdParty = TranslateThirdParty(source.third_party),
                Amount = source.transaction_amount,
                EntryTypeId = source.account_transaction_entry_type_id,
                EntryType = new ReferenceItemDto
                {
                    Id = source.account_transaction_entry_type_id,
                    Description = source.z_account_transaction_entry_type.description,
                    Deleted = source.z_account_transaction_entry_type.deleted != null

                },
                Notes = source.notes,
                TransactionDate = source.transaction_date,
                TransactionTypeId = source.account_transaction_type_id,
                TransactionType = new ReferenceItemDto
                {
                    Id = source.z_account_transaction_type.id,
                    Description = source.z_account_transaction_type.description,
                    Deleted = source.z_account_transaction_type.deleted != null
                }
            };
... return my object
}

问题是：

账户有交易，因此交易属于账户。似乎我的翻译人员被称为太多了，并因此重新加载了大量数据

当我加载我的事务对象时，它的“account”属性有一个“transactions”属性，它有一个与该帐户关联的所有事务的列表。每个交易都有一个帐户属性。。。这些帐户权限同样有所有交易的列表。。。就这样一直持续下去

有没有办法将加载限制在一个级别或某个级别

我有这套：

Context.Configuration.LazyLoadingEnabled = false;

我希望我的“包括”将是所有加载。。。不加载“未包含”相关数据

根据要求，以下是我的TranslateAccount方法：

public AccountDto TranslateAccount(account p, bool includeCardsInterestRateDataAndBalance)
{
    LogUserActivity("in TranslateAccount");
    if (p == null)
        return null;

    var result =
        new AccountDto
        {
            Id = p.id,
            Description = p.description,
            PortfolioId = p.institution.account_portfolio_id,
            AccountNumber = p.account_number,
            Institution = TranslateInstitution(p.institution),
            AccountType = new ReferenceItemDto
            {
                Id = p.account_type_id,
                Description = p.z_account_type.description
            },
            AccountTypeId = p.account_type_id,
            InstitutionId = p.institution_id,
            MinimumBalance = p.min_balance,
            OpeningBalance = p.opening_balance,
            OpeningDate = p.opening_date
        };

    if (includeCardsInterestRateDataAndBalance)
    {
        // Add the assigned cards collection
        foreach (var card in p.account_card)
        {
            result.Cards.Add(new AccountCardDto
                {
                    Id = card.id,
                    AccountId = card.account_id,
                    Active = card.active,
                    CardHolderName = card.card_holder_name,
                    CardNumber = card.card_number,
                    ExpiryDate = card.expiry
                });
        }

        // Populate the current interest rate
        result.CurrentRate = GetCurrentInterestRate(result.Id);

        // Add all rates to the account
        foreach (var rate in p.account_rate)
        {
            result.Rates.Add(
                new AccountRateDto
                    {
                        Id = rate.id,
                        Description = rate.description,
                        Deleted = rate.deleted != null,
                        AccountId = rate.account_id,
                        EndDate = rate.end_date,
                        Rate = rate.rate,
                        StartDate = rate.start_date
                    });
        }
        result.CurrentBalance = CurrentBalance(result.Id);
    }
    LogUserActivity("out TranslateAccount");
    return result;

}

---

实体框架上下文维护已从数据库中取出的数据缓存。无论启用/禁用延迟加载，您都可以调用

Transaction.Account.Transactions[0].Account.Transactions[0]…

，而无需从数据库加载任何其他内容

---

问题不在于实体框架对象的周期性，而在于翻译对象的逻辑中的某个地方。

你能将

TranslateAccount

的内容发布到原始帖子中吗？我就是这么想的。我就是不明白为什么我的“帐户”模型有一个与之关联的事务列表。我宁愿不要这个。。。。这段关系似乎有两个方向。一个“账户有许多与之相关的交易”，因此关系。我能不能阻止它成为“账户”模式的一部分？我只希望“事务属于帐户”关系正常工作。您不能阻止它成为模型的一部分（实体框架始终创建双向导航属性），但可以使用实体框架设计器将Account.Transactions属性的可访问性更改为Private。这将阻止它在任何地方出现。