这是一种优雅的方式来检查是否存在具有相同子项的物品

我有这个项目：

public partial class PACK
{
    public int PACK_IDE { get; set; }
    public string PACK_DESCR { get; set; }
    public Nullable<System.DateTime> PACK_DATE_CREATED { get; set; }
    public Nullable<System.DateTime> PACK_DATE_MODIFIED { get; set; }
    public Nullable<System.DateTime> PACK_DATE_LAST_CALC { get; set; }
    public decimal PACK_COST { get; set; }
    public int PACK_QTY_POSS { get; set; }
    public string PACK_NOTE { get; set; }
    public int PACK_QTY_SOLD { get; set; }
    public decimal PACK_AVRG_SELL_PRICE { get; set; }
    public Nullable<int> PACK_DESTINATION { get; set; }
    public virtual ICollection<INVENTORY_PACK> INVENTORY_PACK { get; set; }
}

如你所见，它包含一个库存包列表，形状如下：

public partial class INVENTORY_PACK
{
    public int INVENT_PACK_IDE { get; set; }
    public int INVENT_IDE { get; set; }
    public int PACK_IDE { get; set; }
    public int QTY { get; set; }
    public virtual INVENTORY INVENTORY { get; set; }
    public virtual PACK PACK { get; set; }
}

最后，库存项目，它有两个重要的字段，现在很重要：

public partial class INVENTORY
{
    public int INVENT_IDE { get; set; }
    public Nullable<int> CARD_IDE { get; set; }
    public Nullable<int> INVENT_NB_IN_STOCK { get; set; }
    public Nullable<int> INVENT_NB_QT_SOLD { get; set; }
    public string INVENT_ITEM_STATE { get; set; }
    public virtual CARD CARD { get; set; }
    public virtual ICollection<INVENTORY_PACK> INVENTORY_PACK { get; set; }
}

当我实际保存或创建一个新包时，我需要找到一种方法来检查实际包是否存在，该包基于INVENT_ITEM_STATE和CARD_IDE以及INVENTORY_PACK中的QTY具有完全相同的库存项。如果这三个值相同，那么我们可以考虑生同样的孩子。我基本上需要搜索任何包（使用Linq或任何Linq-to-Sql调用），其中的子级与我现在拥有的相同，但我真的不知道如何做到这一点，除了大量令人震惊的for/foreach循环。

编辑

根据要求，这里有一个我一直在努力做的例子

internal void CreatePack(PackInfo _pack)
{
    using (TransactionScope scope = TransactionUtils.CreateTransactionScope())
    {
        try
        {
            var packQry = from pa in mDb.PACK
                          select pa;
            if (!packQry.Any())
            {
                PACK packToAdd = DataConverter.PackInfoToPACKData(_pack);
                mDb.PACK.Add(packToAdd);
                mDb.SaveChanges();
                int packID = mDb.PACK.Max(_x => _x.PACK_IDE);
                foreach (INVENTORY_PACK inventoryPack in packToAdd.INVENTORY_PACK)
                {
                    inventoryPack.PACK_IDE = packID;
                    mDb.SaveChanges();
                }
            }
            else
            {
                List<PACK> listPacks = new List<PACK>();
                foreach (var inventoryPackInfo in _pack.mListInventoryPackInPack)
                {
                    packQry = from pa in mDb.PACK
                              where pa.INVENTORY_PACK.Any(_item =>
                                      _item.INVENTORY.INVENT_IDE ==
                                      inventoryPackInfo.mInventoryItem.mInventoryID)
                              where pa.INVENTORY_PACK.Any(
                                      _item =>
                                      _item.INVENTORY.INVENT_ITEM_STATE ==
                                      inventoryPackInfo.mInventoryItem.mItemState)
                              where pa.INVENTORY_PACK.Any(_item => _item.QTY == inventoryPackInfo.mQuantity)
                              select pa;
                    if (packQry.Any())
                    {
                        listPacks.AddRange(packQry);
                    }
                }
                if (_pack.mListInventoryPackInPack.Count == 1)
                {
                }
                IDictionary<PACK, int> counts = new Dictionary<PACK, int>();
                foreach (var pack in listPacks)
                {
                    if (!counts.ContainsKey(pack))
                    {
                        counts.Add(pack, 1);
                    }
                    else
                    {
                        counts[pack]++;
                    }
                }
            }
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
        scope.Complete();
    }
}

示例

我想我需要澄清我的需要。下面是一个例子。

假设我有1个包含2个INVENTORY_PACK的PACK：1是INVENTORY项，其中INVENT_IDE 1234，CARD_IDE 4321，QTY是1，而INVENT_ITEM_STATE是PERFECT。第二个对象是INVENT_IDE 4567、CARD_IDE 7654、QTY是2和INVENT_ITEM_STATE PERFECT。

我需要检查包，看看是否已经有一个包包含，确切地说在所选参数中有两个项目。所以有很多可能性：

• 如果我们有另一个现有的PACK，它具有相同的项目和相同数量的项目（在本例中为2）、数量和IDS，则我们有一个完全匹配，并且我们认为PACK已经存在
• 如果有一个PACK包含相同的项目，但有另一个项目（本例为3个或更多项目），是否认为是另一个包；那么我们就没有对手了
• 如果任何包裹只有其中一项，则我们没有匹配项