c# - 我有 5 个法规，我需要确保 3 个法规被 3 个不同的人占用

Question

这是我的第一篇文章，所以如果我在某些问题上失败，我深表歉意，但我会尽量说清楚，以便您可以关注我。

我正在创建一个程序来检查合作伙伴(来 self 工作的公司)是否具有有效的法规(高级合作伙伴、认证合作伙伴和解决方案合作伙伴)。为了确认这一点，我检查他们的技术人员是否拥有有效的认证，以及认证合作伙伴和解决方案合作伙伴的一切运行是否正常。

因此，对于高级合作伙伴，我必须检查他们是否具备所需的 5 项法规，但 3 个人必须接受 3 项不同的法规。

所以每个合作伙伴法规都有一个我创建的规则并且它工作正常，因为它只检查这 5 个法规。所以对于 Premiun 合作伙伴，我需要在规则验证之后做一些工作。

public async Task<bool> ValidateThirdPartyTypeRuleAsync(Partner partner, SpecializationExecutionThirdPartyType thirdPartyType)
{

    try
    {
        if (!string.IsNullOrEmpty(thirdPartyType.CRPValidationRule))
        {
            //Check if rule is valid
            using (var rule = new Evaluate(typeof(Partner), thirdPartyType.CRPValidationRule))
            {
                if (partner == null)
                {
                    throw new ArgumentNullException("Partner", "Partner cannot be null for ValidateThirdTypeRule execution");
                }

                //Run rule with partner
                var result = await rule.RunAsync(partner);

                if ((bool)result == true && partner.ThirdPartyType == "PPP")
                {
                    //Gets a list of technicians with valid satatutes for "PPP"
                    List<Technician> ValidTechnicianList = partner.Technicians.FindAll(s => 
                    s.StatutesHistory.Exists(a => (new int[] { 6, 11, 12, 8, 9 }).Contains(a.StatuteID) && a.Active)).ToList();

                    //Returns if partner is valid for the statute
                    if (ValidTechnicianList.Count() >= 3)
                    {
                            return true;
                    }
                    else
                    {
                        return false;
                    }
                }

                //Returns if partner is valid for his statute
                return (bool)result;
            }
      }
  }

所以您可以想象，这个“Count>=3”没有完成这项工作，因为如果 1 名技术人员作为 5 名需要的认证而其他 2 名技术人员只有一个并且相同，它将返回“True”。

这是高级合作伙伴的规则:

Technicians.Where(a => a.StatutesHistory.Exists(b => new int[] {6, 11}.Contains(b.StatuteID) && b.Active == true)).Count() >= 1 && 
Technicians.Where(a => a.StatutesHistory.Exists(b => new int[] {12}.Contains(b.StatuteID) && b.Active == true)).Count() >= 1 &&  
Technicians.Where(a => a.StatutesHistory.Exists(b => new int[] {8}.Contains(b.StatuteID) && b.Active == true)).Count() >= 1 &&  
Technicians.Where(a => a.StatutesHistory.Exists(b => new int[] {9, 25}.Contains(b.StatuteID) && b.Active == true)).Count() >= 1 &&  
Technicians.Where(a => a.StatutesHistory.Exists(b => new int[] {5, 26}.Contains(b.StatuteID) && b.Active == true)).Count() >= 1

提前致谢并保持良好的工作

Answer 1

好的，首先，抱歉，我之前的回答显然是错误的。您在这里需要的是一种从不同数量的集合中生成笛卡尔积的方法。

Eric Lippert有一篇关于这个主题的精彩文章和一个非常优雅的解决方案，您可以在以下文章中找到:Computing a Cartesian Product with LINQ .

//Eric Lippert's implementation
static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this 
    IEnumerable<IEnumerable<T>> sequences)
{
    var emptyProduct =
        new[] { Enumerable.Empty<T>() };

    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

现在，您的问题很容易解决:

 var requiredDistinct = new[] { 6, 11, 12 };
 var distinctStatutes = 
    technicians.Select(t => t.StatuteIds)
               .CartesianProduct()
               .Select(p => p.Distinct())
               .Where(p => requiredDistinct.All(
                  requiredId => p.Contains(requiredId)));

1. 我们计算所有法规 ID 的笛卡尔积。
2. 我们过滤掉对每个产品调用 Distinct 的重复 ID。
3. 然后，我们过滤掉所有未满足所有必需法规的产品。

现在我们的条件只有且仅当:

if (distincStatues.Count() >= requiredDistinct.Length)
{ 
    //condition met
}