C# 已到达方法结尾，但编译器跳回

只是为了好玩，我试着做改变的问题-或多或少。我的问题是，我得到了双倍的结果，通过使用调试器，我发现编译器会再次跳回该方法，即使它应该完成

private static void Main(string[] args)
{
string temp = Console.ReadLine();
int input;

if (int.TryParse(temp, out input))
{
    if(input == 0)
    {
        System.Environment.Exit(Environment.ExitCode);
    }
    else
    {
        ChangeMaking(input);
    }
}
else
{
    Console.WriteLine("Not a number.");
}
}

private static int ChangeMakingHelper(int input, int euro)
{
    return input / euro;
}

static int[] euro = { 1, 2, 5, 10, 20, 50, 100, 200, 500 };
static int counter = 0;
static List<int[]> result = new List<int[]>();
static int[] tempResult = new int[euro.Length];

private static void ChangeMaking(int input)
{
    for (int i = euro.Length -1; i >= 0; i--)
    {
        if(euro[i] <= input)
        {
            tempResult[i] = ChangeMakingHelper(input, euro[i]);
            input = input - euro[i];
            if((input % euro[i] != 0))
            {
                ChangeMaking(input % euro[i]);
            }
        }
    }
    result.Add(tempResult);
}

---

我对输入11的预期行为是一个数组，其中的值

{1,0,0,1,0,0,0}

，我得到的值增加了一倍。

问题是，您正在使用静态变量在函数调用之间传递数据。不要那样做。改为使用返回值

public static void Main()
{
    var result = ChangeMaking(11);
    Console.WriteLine(string.Join(", ", result));
}

private static int ChangeMakingHelper(int input, int euro)
{
    return input / euro;
}

static readonly int[] euro = { 1, 2, 5, 10, 20, 50, 100, 200, 500 };

private static int[] ChangeMaking(int input)
{
    var result = new int[euro.Length];
    for (int i = euro.Length -1; i >= 0; i--)
    {
        if (euro[i] <= input)
        {
            result[i] += ChangeMakingHelper(input, euro[i]);
            input = input - euro[i];
            if (input % euro[i] != 0)
            {
                var tempResult = ChangeMaking(input % euro[i]);
                // Transfer the results to the local result array
                for(int j = 0; j < result.Length; j++)
                    result[j] += tempResult[j];
            }
            // Also add a break statement here so you don't add the lower values twice!
            break;
        }
    }
    return result;
}

publicstaticvoidmain（）
{
var结果=改变（11）；
Console.WriteLine（string.Join（“，”，result））；
}
专用静态int ChangeMakingHelper（int输入，int欧元）
{
返回输入/欧元；
}
静态只读int[]欧元={1,2,5,10,20,50,100,200,500}；
私有静态int[]变更（int输入）
{
var结果=新整数[欧元长度]；
对于（整数i=euro.Length-1；i>=0；i--）
{
if（欧元[i]如果输入是11，那么
ChangeMaking
调用两次，以11和1作为参数。当我在.Net FIDLE上运行它时，它运行良好：。您如何调用
ChangeMaking
？哦，我想我明白了…您的问题是
结果中有两个数组？您使用的是递归，所以您看到的是堆栈展开。基本上是w现在的情况是，您正在递归到
ChangeMaking
，因为该方法在末尾向列表中添加了一个静态数组，每次递归时，您都会向列表中添加一个全新的副本。在11作为输入的情况下，您递归一次，调用
ChangeMaking
两次，然后追加两次数组。这两次相同，因为AY是引用类型，即使值是值类型。在更快的内存中是有效的？我只能考虑使用迭代方法，但这是我第一次自然地认为递归方法是正确的。如果我没有错的话，递归使用的内存比迭代方法多。两者都有（更快和更少的内存）。此外，如果您的输入非常大，并且您使用递归方法，则可能会遇到堆栈溢出问题。我不会说这两种方法是对的还是错的。如果性能非常关键，我会使用迭代方法。如果您不打算每秒运行此函数数千次，而递归方法会产生更多的错误相信你，那么递归的方法是好的。
public static void Main()
{
    var result = ChangeMaking(11);
    Console.WriteLine(string.Join(", ", result));
}

private static int ChangeMakingHelper(int input, int euro)
{
    return input / euro;
}

static readonly int[] euro = { 1, 2, 5, 10, 20, 50, 100, 200, 500 };

private static int[] ChangeMaking(int input)
{
    var result = new int[euro.Length];
    for (int i = euro.Length -1; i >= 0; i--)
    {
        if (euro[i] <= input)
        {
            result[i] += ChangeMakingHelper(input, euro[i]);
            input = input - euro[i];
            if (input % euro[i] != 0)
            {
                var tempResult = ChangeMaking(input % euro[i]);
                // Transfer the results to the local result array
                for(int j = 0; j < result.Length; j++)
                    result[j] += tempResult[j];
            }
            // Also add a break statement here so you don't add the lower values twice!
            break;
        }
    }
    return result;
}