C#下Tuple的替代方案（静态实现）及B.func扩展填充A.c的技术问询

嘿，我来帮你捋清楚这个问题！你现在需要调整B.func(int generator)方法，让它在返回int类型的A.b值的同时，还能填充已存在于内存中的string类型A.c，但原方法的返回值类型限制了没法直接返回两个值，还要用静态类相关的方案替代Tuple，我给你几个靠谱的实现思路：

方案1：使用out参数（最直接无额外类） #

这是最简单的方式，不需要额外的容器类，直接给B.func加一个out参数来传递A.c的目标值，同时在方法内部完成A.b和A.c的填充：

// 假设你的A是静态类（或包含静态字段的类）
public static class A
{
    public static int b;
    public static string c;
}

// 假设Values是存储目标值的类/结构
public static class Values
{
    public static int b = 1; // 示例目标值
    public static string c = "target_c_value"; // 示例目标值
}

public static class B
{
    public static int func(int generator, out string cValue)
    {
        // 原有逻辑：当Values.b等于传入的generator时，A.b赋值为2
        int bResult = Values.b == generator ? 2 : 0; // 0为示例默认值
        A.b = bResult;

        // 从Values获取c的目标值，赋值给out参数同时填充A.c
        cValue = Values.c;
        A.c = cValue;

        return bResult;
    }
}

// 调用方式
string cResult;
int bResult = B.func(1, out cResult);
// 此时A.b和A.c都已被正确填充，同时你也能拿到两个返回值的本地副本

优点：代码简洁，无额外类开销，线程安全，符合C#常规写法。

方案2：自定义静态结果类（符合你要求的静态类方向） #

如果你更倾向于用静态类来承载多返回值，可以创建一个静态的结果持有类，用来暂存单次调用的结果（注意：单线程场景适用，多线程需加锁）：

// 静态结果类，用来暂存B.func的返回结果
public static class FuncResult
{
    public static int BValue { get; private set; }
    public static string CValue { get; private set; }

    // 内部方法，仅允许B类设置值
    internal static void SetResult(int bVal, string cVal)
    {
        BValue = bVal;
        CValue = cVal;
    }
}

public static class A
{
    public static int b;
    public static string c;
}

public static class Values
{
    public static int b = 1;
    public static string c = "target_c_value";
}

public static class B
{
    public static int func(int generator)
    {
        int bResult = Values.b == generator ? 2 : 0;
        string cResult = Values.c;

        // 设置静态结果类的值
        FuncResult.SetResult(bResult, cResult);

        // 填充A的静态字段
        A.b = bResult;
        A.c = cResult;

        return bResult;
    }
}

// 调用方式
int bResult = B.func(1);
string cResult = FuncResult.CValue;
// A.b和A.c已完成填充，同时可从静态类获取c的值

注意：静态类的字段是全局共享的，如果多线程同时调用B.func，会出现结果覆盖的问题，所以单线程场景用这个方案更合适。

方案3：使用ref参数（直接修改已有内存中的A.c） #

既然A.c已经存在于内存中，你可以直接把它作为ref参数传入方法，让方法内部直接修改它的值，不需要额外返回：

public static class A
{
    public static int b;
    public static string c;
}

public static class Values
{
    public static int b = 1;
    public static string c = "target_c_value";
}

public static class B
{
    public static int func(int generator, ref string cTarget)
    {
        int bResult = Values.b == generator ? 2 : 0;
        A.b = bResult;

        // 直接修改传入的ref参数（也就是A.c）的值
        cTarget = Values.c;

        return bResult;
    }
}

// 调用方式
int bResult = B.func(1, ref A.c);
// 此时A.b和A.c都已被正确填充，无需额外获取c的值

优点：直接操作已有变量的内存引用，无额外对象创建，效率最高，线程安全。

内容的提问来源于stack exchange，提问作者Devin Andres Salemi