Entity Framework 循环数据

Question

我有一个 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();

这意味着向我返回交易列表及其相关对象。然后我将每个对象传递给 Translator，Translator 将它们转换为数据传输对象，然后将其传递回我的主应用程序。

 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
}

问题是：

一个账户有交易，因此一个交易属于一个账户。看来我的翻译人员被称为太多了，因此重新加载了很多数据。

当我加载我的交易对象时，它的“帐户”属性有一个“交易”属性，其中包含与该帐户关联的所有交易的列表。然后，每笔交易都有一个帐户属性...这些帐户属性再次列出所有交易...等等。

有没有办法可以将加载限制在一个级别或其他什么？

我有这一套：

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;

}

Answer 1

实体框架上下文维护已从数据库中提取的数据的缓存。无论是否启用/禁用延迟加载，您都可以根据需要调用Transaction.Account.Transactions[0].Account.Transactions[0]...，而无需从数据库中加载任何其他内容。

问题不在于实体框架对象的循环性质，而在于翻译对象的逻辑。