C# 条件语句的组合

我有两套3个条件。 设a，b，c为一组条件，x，y，z为另一组条件。我需要评估以下内容

if(a && x)
..... 
else if(a && y) 
..... 
else if(a && z)
.....

以同样的方式，3个条件与b和3个条件与c

在不填写所有组合的情况下，评估条件的最佳方法是什么

更新：

我正在做一个团结的游戏。条件a、b、c检查球员的x位置与球的位置相比是否在一定范围内，条件x、y、z对y位置执行相同的操作。根据正确的条件（从ax、ay、az、bx、by、bz、cx、cy、cz组合中），选择一个动画状态（共9个）。所以每种情况都会产生不同的结果

更新：

---

最后，我创建了两个函数来计算这两组条件，每个函数都返回一个枚举，在该枚举上按位或操作以获得最终状态。

我的第一个想法是至少先测试第一组条件，然后再测试第二组条件。虽然这不是一个可以避免编写所有九条if语句的答案，但您将平均减少被检查的if语句的数量

if (a) 
{
    if (x) { }
    else if (y) { }
    else if (z) { }
}
else if (b)
{
    if (x) { }
    else if (y) { }
    else if (z) { }
}
else if (c)
{
    if (x) { }
    else if (y) { }
    else if (z) { }
}

---

我的第一个想法是至少先测试第一组条件，然后再测试第二组条件。虽然这不是一个可以避免编写所有九条if语句的答案，但您将平均减少被检查的if语句的数量

if (a) 
{
    if (x) { }
    else if (y) { }
    else if (z) { }
}
else if (b)
{
    if (x) { }
    else if (y) { }
    else if (z) { }
}
else if (c)
{
    if (x) { }
    else if (y) { }
    else if (z) { }
}

---

这是一种使用Linq表达式的方法，Linq表达式是一种动态定义表达式的方法，您可以对表达式执行多个操作。为了演示，我在这里使用了一个伪条件表达式，它将数字作为参数。首先在方法中或直接在代码中定义每个条件。然后将所有这些放入数组，每个条件设置为一个数组。然后是执行表达式的两个foreach

int num = 20;

        ConditionalExpression[] firstSet = { ExpressionA(num), ExpressionB(num), ExpressionC(num) };
        ConditionalExpression[] secondSet = { ExpressionX(num), ExpressionY(num), ExpressionZ(num) };

        foreach(var firstSetExpression in firstSet)
            foreach (var secondSetExpression in secondSet)
            {
                var result1 = Expression.Lambda<Func<bool>>(firstSetExpression.Test).Compile();
                var result2 = Expression.Lambda<Func<bool>>(secondSetExpression.Test).Compile();

                if (result1.Invoke() && result2.Invoke())
                { 
                    // do your thing here 
                }
            }

这甚至可以在许多方面进行优化，但只是为了让您开始

更新：这是另一种不喜欢在运行时编译的方法。使用代理：

Func<int, bool>[] firstSet = new Func<int,bool> [] { ExpressionA(), ExpressionA(), ExpressionA() };
            Func<int, bool>[] secondSet = new Func<int, bool>[] { ExpressionA(), ExpressionA(), ExpressionA() };

            foreach(var firstSetExpression in firstSet)
                foreach (var secondSetExpression in secondSet)
                {
                    if (firstSetExpression.Invoke(20) && secondSetExpression.Invoke(20))
                    { 
                        // do your thing here 
                    }
                }
...
...
...

private static Func<int, bool> ExpressionA()
        {
             return (x) => x > 10;
        }

Func[]firstSet=new Func[]{ExpressionA（），ExpressionA（），ExpressionA（）}；
Func[]secondSet=new Func[]{ExpressionA（），ExpressionA（），ExpressionA（）}；
foreach（firstSet中的var firstSetExpression）
foreach（secondSet中的var secondSetExpression）
{
if（firstSetExpression.Invoke（20）和&secondSetExpression.Invoke（20））
{ 
//在这里做你的事
}
}
...
...
...
私有静态函数表达式（）
{
返回（x）=>x>10；
}

---

祝你好运。

这是一种使用Linq表达式的方法，Linq表达式是一种动态定义表达式的方法，您可以在其中对表达式执行多个操作。为了演示，我在这里使用了一个伪条件表达式，它将数字作为参数。首先在方法中或直接在代码中定义每个条件。然后将所有这些放入数组，每个条件设置为一个数组。然后是执行表达式的两个foreach

int num = 20;

        ConditionalExpression[] firstSet = { ExpressionA(num), ExpressionB(num), ExpressionC(num) };
        ConditionalExpression[] secondSet = { ExpressionX(num), ExpressionY(num), ExpressionZ(num) };

        foreach(var firstSetExpression in firstSet)
            foreach (var secondSetExpression in secondSet)
            {
                var result1 = Expression.Lambda<Func<bool>>(firstSetExpression.Test).Compile();
                var result2 = Expression.Lambda<Func<bool>>(secondSetExpression.Test).Compile();

                if (result1.Invoke() && result2.Invoke())
                { 
                    // do your thing here 
                }
            }

这甚至可以在许多方面进行优化，但只是为了让您开始

更新：这是另一种不喜欢在运行时编译的方法。使用代理：

Func<int, bool>[] firstSet = new Func<int,bool> [] { ExpressionA(), ExpressionA(), ExpressionA() };
            Func<int, bool>[] secondSet = new Func<int, bool>[] { ExpressionA(), ExpressionA(), ExpressionA() };

            foreach(var firstSetExpression in firstSet)
                foreach (var secondSetExpression in secondSet)
                {
                    if (firstSetExpression.Invoke(20) && secondSetExpression.Invoke(20))
                    { 
                        // do your thing here 
                    }
                }
...
...
...

private static Func<int, bool> ExpressionA()
        {
             return (x) => x > 10;
        }

Func[]firstSet=new Func[]{ExpressionA（），ExpressionA（），ExpressionA（）}；
Func[]secondSet=new Func[]{ExpressionA（），ExpressionA（），ExpressionA（）}；
foreach（firstSet中的var firstSetExpression）
foreach（secondSet中的var secondSetExpression）
{
if（firstSetExpression.Invoke（20）和&secondSetExpression.Invoke（20））
{ 
//在这里做你的事
}
}
...
...
...
私有静态函数表达式（）
{
返回（x）=>x>10；
}

祝你好运

生成所有可能的组合。因为你处理的是布尔人，所以每个人都有两个选择。然后，2个布尔值的最简单可能组合将得到2 x 2=4个组合。一般来说，K=2^n，其中n表示处理的布尔数

如果我是你，我会坚持使用

Tuple

和嵌套

（var I=0；I<2；I++）

循环（需要n个参数n个循环）

然后，我将提供一个

Tuple

列表，该列表将谓词与回调配对，当谓词等于true时应触发回调

其余的可以通过Linq实现。类似于

possibleCombinationsList.Select（tripleOfBooleans=>PredicateSandCallbackList.Single（predicateAndCallback=>predicateAndCallback.Item1（tripleOfBooleans）==true））.Sinle（）.Item2（）

玩得开心

生成所有可能的组合。因为你处理的是布尔人，所以每个人都有两个选择。然后，2个布尔值的最简单可能组合将得到2 x 2=4个组合。一般来说，K=2^n，其中n表示处理的布尔数

如果我是你，我会坚持使用

Tuple

和嵌套

（var I=0；I<2；I++）

循环（需要n个参数n个循环）

然后，我将提供一个

Tuple

列表，该列表将谓词与回调配对，当谓词等于true时应触发回调

其余的可以通过Linq实现。类似于

possibleCombinationsList.Select（tripleOfBooleans=>PredicateSandCallbackList.Single（predicateAndCallback=>predicateAndCallback.Item1（tripleOfBooleans）==true））.Sinle（）.Item2（）

---

玩得开心。

对于

a

、

b

和

c

，条件是否总是按顺序循环通过

x

、

y

、

z

？我在想一些涉及lambda表达式数组的笨拙的事情。比

if