C# 删除嵌套的if语句

嗨，我正在写一篇文章，我现在正在做的部分很快变得臃肿起来。如何删除这个嵌套的if语句，但仍然具有相同的行为

最好生成的代码简洁明了，并且不需要额外的本地标志。下面的代码现在看起来可能没那么糟糕，但我正计划编写更多的方法，直到T16，您可以想象这些嵌套的if语句会变得多么糟糕

using ContainerExpressions.Containers;
using System;

namespace ContainerExpressions.Expressions.Core
{
    internal static class Compose
    {
        public static Response<T> Evaluate<T>(Func<Response<T>> func) => func();

        public static Response<TResult> Evaluate<T1, TResult>(Func<Response<T1>> func1, Func<T1, Response<TResult>> funcResult)
        {
            var response = new Response<TResult>();

            var result = func1();
            if (result)
            {
                response = response.WithValue(funcResult(result));
            }

            return response;
        }

        public static Response<TResult> Evaluate<T1, T2, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<TResult>> funcResult)
        {
            var response = new Response<TResult>();

            var result1 = func1();
            if (result1)
            {
                var result2 = func2(result1);
                if (result2)
                {
                    response = response.WithValue(funcResult(result2));
                }
            }

            return response;
        }

        public static Response<TResult> Evaluate<T1, T2, T3, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<T3>> func3, Func<T3, Response<TResult>> funcResult)
        {
            var response = new Response<TResult>();

            var result1 = func1();
            if (result1)
            {
                var result2 = func2(result1);
                if (result2)
                {
                    var result3 = func3(result2);
                    if (result3)
                    {
                        response = response.WithValue(funcResult(result3));
                    }
                }
            }

            return response;
        }
    }
}

使用ContainerExpressions.Containers；
使用制度；
命名空间ContainerExpressions.Expressions.Core
{
内部静态类组合
{
公共静态响应评估（Func Func）=>Func（）；
公共静态响应评估（Func func1，Func funcResult）
{
var响应=新响应（）；
var result=func1（）；
如果（结果）
{
response=response.WithValue（funcResult（result））；
}
返回响应；
}
公共静态响应评估（Func func1、Func func2、Func funcResult）
{
var响应=新响应（）；
var result1=func1（）；
如果（结果1）
{
var result2=func2（result1）；
如果（结果2）
{
response=response.WithValue（funcResult（result2））；
}
}
返回响应；
}
公共静态响应求值（Func func1、Func func2、Func func3、Func funcResult）
{
var响应=新响应（）；
var result1=func1（）；
如果（结果1）
{
var result2=func2（result1）；
如果（结果2）
{
var result3=func3（result2）；
如果（结果3）
{
response=response.WithValue（funcResult（result3））；
}
}
}
返回响应；
}
}
}

我最终创建的代码 在这里重新提出建议后，我将代码膨胀降低，现在看起来如下所示：

using ContainerExpressions.Containers;
using System;
using System.Runtime.CompilerServices;

namespace ContainerExpressions.Expressions.Core
{
    internal static class Compose
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Response<TResult> Evaluate<T1, TResult>(Func<Response<T1>> func1, Func<T1, Response<TResult>> funcResult)
        {
            var result = func1();
            return result ? funcResult(result) : Response.Create<TResult>();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Response<TResult> Evaluate<T1, T2, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<TResult>> funcResult)
        {
            var result = func1();
            return result ? Evaluate(() => func2(result), funcResult) : Response.Create<TResult>();
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Response<TResult> Evaluate<T1, T2, T3, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<T3>> func3, Func<T3, Response<TResult>> funcResult)
        {
            var result = func1();
            return result ? Evaluate(() => func2(result), func3, funcResult) : Response.Create<TResult>();
        }
    }
}

使用ContainerExpressions.Containers；
使用制度；
使用System.Runtime.CompilerServices；
命名空间ContainerExpressions.Expressions.Core
{
内部静态类组合
{
[MethodImpl（MethodImplOptions.AggressiveInline）]
公共静态响应评估（Func func1，Func funcResult）
{
var result=func1（）；
返回结果？funcResult（result）：Response.Create（）；
}
[MethodImpl（MethodImplOptions.AggressiveInline）]
公共静态响应评估（Func func1、Func func2、Func funcResult）
{
var result=func1（）；
返回结果？Evaluate（（）=>func2（result），funcResult）：Response.Create（）；
}
[MethodImpl（MethodImplOptions.AggressiveInline）]
公共静态响应求值（Func func1、Func func2、Func func3、Func funcResult）
{
var result=func1（）；
返回结果？求值（（）=>func2（result）、func3、funcResult）：Response.Create（）；
}
}
}

不如像这样重用其他方法：

internal static class Compose
{
    public static Response<T> Evaluate<T>(Func<Response<T>> func) => func();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Response<TResult> Evaluate<T1, TResult>(Func<Response<T1>> func1, Func<T1, Response<TResult>> funcResult)
    {
        var response = new Response<TResult>();

        var result = func1();
        if (result)
        {
            response = response.WithValue(funcResult(result));
        }

        return response;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Response<TResult> Evaluate<T1, T2, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<TResult>> funcResult)
    {
        return func1() ? Evaluate(func2, funcResult) : new Response<TResult>();
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static Response<TResult> Evaluate<T1, T2, T3, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<T3>> func3, Func<T3, Response<TResult>> funcResult)
    {
        return func1() ? Evaluate(func2, func3, funcResult) : new Response<TResult>();
    }
}

public static Response<T> Evaluate<T>(Func<Response<T>> func) => func();

public static Response<TResult> Evaluate<T1, TResult>(Func<Response<T1>> func1, Func<T1, Response<TResult>> funcResult)
{
    var response = new Response<TResult>();
    return func1() ? response.WithValue(funcResult(result)) : response;
}

public static Response<TResult> Evaluate<T1, T2, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<TResult>> funcResult)
{
    var response = new Response<TResult>();
    return func1() ? Evaluate(func2, funcResult) ? : response;
}

public static Response<TResult> Evaluate<T1, T2, T3, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<T3>> func3, Func<T3, Response<TResult>> funcResult)
{
    var response = new Response<TResult>();
    return func1() ? Evaluate(func2, func3, funcResult) : response;
}

内部静态类组合
{
公共静态响应评估（Func Func）=>Func（）；
[MethodImpl（MethodImplOptions.AggressiveInline）]
公共静态响应评估（Func func1，Func funcResult）
{
var响应=新响应（）；
var result=func1（）；
如果（结果）
{
response=response.WithValue（funcResult（result））；
}
返回响应；
}
[MethodImpl（MethodImplOptions.AggressiveInline）]
公共静态响应评估（Func func1、Func func2、Func funcResult）
{
返回func1（）？求值（func2，funcResult）：新响应（）；
}
[MethodImpl（MethodImplOptions.AggressiveInline）]
公共静态响应求值（Func func1、Func func2、Func func3、Func funcResult）
{
返回func1（）？求值（func2，func3，funcResult）：新响应（）；
}
}

如果您的代码始终按照所示的部分运行，您可以重构它以提前返回。我以您的

评估（…）

为例：

public static Response<TResult> Evaluate<T1, T2, T3, TResult>(Func<Response<T1>> func1, Func<T1, Response<T2>> func2, Func<T2, Response<T3>> func3, Func<T3, Response<TResult>> funcResult)
{
    var response = new Response<TResult>();

    if (!func1()) return response;
    if (!func2(true)) return response;
    if (!func3(true)) return response;
    return response.WithValue(funcResult(true));
}

---

我投票结束这个问题，因为它属于你的链接，指向一个不正确的网站。很好，如果这个问题不属于这个网站，我会移动它。嘿，Simon，我考虑过了，它满足了我所有的语法梦想，但我担心这种方法的额外函数调用。对于exmaple，如果您要在何处组合16个函数，则需要进行16个额外的函数调用（因为每个求值都会调用比它小的函数）。如果这是一个问题，您可以直接内联方法，这将删除性能方面。这可以使用

[MethodImpl（MethodImplOptions.AggressiveInline）]来完成

attribute，但是JIT编译器可能会在合适的情况下决定内联您的方法。谢谢，我以前没有用过，但听起来不错。我来试一试。那个属性会出现在那个compose类中的每个方法之上吗？虽然我很欣赏你们的来源，但你们在这里展示的代码和我的示例不一样。func的结果不是布尔值。它们是一种类型，可以隐式转换为任何T，也可以转换为boo。可以更清晰地声明为

return func1（）？评估（func2，funcResult）：新响应（）除第一个之外的所有！哦，我没有意识到那个重要的部分；）但是你展示的代码根本就没有编译？因为
if（result）
只在
result
是
bool
@RenéVogt时才编译，所以我喜欢你和Simon的答案的组合，我打算将这两种方法结合在一起。@user1515024啊，好的，看来我今天工作太久了，没有考虑cast操作符。