Current code to generate array filled with unique ints crashes

Question

(this is a library)
The function GetUniqueInt is being called with (5, 5) as the variables.
Currently the code will stall unity to a complete halt, or crash my PC with a memory overflow error.
Does anyone have any ideas as to how I could prevent it from crashing or what is making it crash?

using UnityEngine;

namespace MajorSolution
{
    public static class MajorMath
    {
        public static int[] GetUniqueInt(int intCount, int intLength)
        {
            int[] returnValue = new int[intCount];
            int[] temp = new int[intLength];
            for (int a = 0; a < intCount; a++)
            {
                string create = new string("create".ToCharArray());
                switch (create)
                {
                    case "create":
                        returnValue[a] = GetRandomInt(intCount);
                        goto case "check";
                    case "check":
                        bool alreadyTaken = false;
                        for (int c = 0; c < returnValue.Length - 1; c++)
                        {
                            if (returnValue[a] == returnValue[c])
                            {
                                // Already Taken!
                                alreadyTaken = true;
                            }
                        }
                        if (!alreadyTaken)
                        {
                            break;
                        }
                        else
                        {
                            goto case "create";
                        }
                    }
                }
            Debug.Log(returnValue);
            return returnValue;
        }

        public static int GetRandomInt(int intCount)
        {
            int[] storage = new int[intCount];
            int returnValue = 0;
            for (int i = 0; i < intCount; i++)
            {
                storage[i] = (Mathf.FloorToInt(Random.Range(0, 9)) * (int)Mathf.Pow(10,i));
                returnValue += storage[i];
            }
            return returnValue;
        }
    }
}

Answer 1

Edit I just realized I did not exactly answer the question of why it is bringing the PC to a halt because you have an infinite loop in the code.

The problem is occurring in the following lines of code, notice what is happening.

case "create":
    returnValue[a] = GetRandomInt(intCount);
    goto case "check";

In the above block of code you are generating a number and putting it in the returnValue array. Now you jump into your "check" block

case "check":
    bool alreadyTaken = false;
    for (int c = 0; c < returnValue.Length - 1; c++)
    {
        if (returnValue[a] == returnValue[c])
        {
            // Already Taken!
            alreadyTaken = true;
        }
    }

In this block of code you are looping over the entire returnValue array including the value you just inserted in it. Basically you are looping over the array asking if a value that you just put in the array is in the array.

Without knowing exactly what you are trying to do with these methods, I will just make a simple fix suggestion with some minor cleanup

public static int[] GetUniqueInt(int count, int length)
{
    var returnValue = new int[count];
    var values = new HashSet<int>(); // Used to track what numbers we have generated
    for (int i = 0; i < count; ++i)
    {
        // Generate the number and check to be sure we haven't seen it yet
        var number = GetRandomInt(length);
        while(values.Contains(number)) // This checks if the number we just generated exists in the HashSet of seen numbers
        {
            // We get here if the HashSet contains the number. If we have
            // seen the number then we need to generate a different one
            number = GetRandomInt(length);
        }

        // When we reach this point, it means that we have generated a new unique number
        // Add the number to the return array and also add it to the list of seen numbers             
        returnValue[a] = number;
        values.Add(number); // Adds the number to the HashSet
    }
    Debug.Log(returnValue);
    return returnValue;
}

I did end up removing the using of intLength but from your posted code it was only used to declare a temp array which itself was never used. Based on that, I just removed it entirely.

Based on your comment I updated the fix to use intLength. I made one other minor change. I removed int from the variable names of count and length. Hungarian notation is a lot less common in C# code. Personally, I feel like the code is cleaner and easier to read without the Hungarian notation. The key is to use good variable names that express the intent or make it easier to follow. In this case count is the count (read total number) of numbers you want returned and length is the length of the number. You could consider maybe even renaming that to numberOfDigits to make it clearer that the idea is you are going to create a random number with that number of digits in it.