Generate String Combinations I have created an algorithm that can generate all possible combinations of a string given its length, and character set (it uses a custom numeral system to do this). How could I improve its performance and readability?

using System;
using System.Text;

public class Program
{
    public static void Main(string[] args)
    {       
        Bruteforce brute = new Bruteforce(9, new Range(0, Helpers.Chars.Length - 1));
        brute.PrintResults();

        Console.ReadKey(true);
    }
}

public class Bruteforce
{
    private int _Length;
    private Range _Range;

    public int Length
    {
        get
        {
            return _Length;
        }
    }

    public Range Range
    {
        get
        {
            return _Range;
        }
    }

    public Bruteforce(int length, Range range)
    {
        _Length = length;
        _Range = range;
    }

    public Bruteforce(int length, int min, int max)
    {
        _Length = length;
        _Range = new Range(min, max);
    }


    public void PrintResults()
    {
        int num = this.Range.Max;
        int[] arr = new int[this.Length];
        for (int c = 0; c &lt; arr.Length; c++) arr[c] = this.Range.Min;
        while (true)
        {
            arr[0]++;
            if (arr[0] &gt; this.Range.Max)
            {
                for (int i = 1; i &lt; arr.Length; i++)
                {
                    if (arr[i - 1] &gt; this.Range.Max)
                    {
                        arr[i - 1] = this.Range.Min;
                        arr[i]++;
                    }
                }
            }

            int num2 = arr[0];
            for (int i = 1; i &lt; arr.Length; i++) num2 += arr[i];

            Console.WriteLine(Helpers.ArrayToString(arr));

            if (num2 == this.Range.Max * arr.Length) break;
        }
    }

    private void PrintArray(int[] arr)
    {
        for (int i = 0; i &lt; arr.Length; i++)
        {
            if (i == arr.Length - 1)
            {
                Console.WriteLine(arr[i]);
            }
            else
            {
                Console.Write(arr[i] + ", ");
            }
        }
    }
}

public class Helpers
{
    public static char[] Chars = new char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };
    public static string ArrayToString(int[] arr)
    {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i &lt; arr.Length; i++)
        {
            if (arr[i] &gt;= 0)
            {
                builder.Append(Helpers.Chars[arr[i]]);
            }
            else
            {
                throw new Exception();
            }
        }
        return builder.ToString();
    }
}

public class Range
{
    private int _Max, _Min;

    public int Max
    {
        get
        {
            return _Max;
        }
    }

    public int Min
    {
        get
        {
            return _Min;
        }
    }

    public Range(int min, int max)
    {
        _Max = max;
        _Min = min;
    }
}
string.Join(string, IEnumerable&lt;T&gt;)

Your method ArrayToString can be replaced with a single line :

public static string ArrayToString(int[] arr)
{
    return string.Join("", arr.Select(x =&gt; Chars[x]));
}


Your method PrintArray is never used but I assume it's just there for testing purpose.

Code style

Auto properties

You can use auto-properties to avoid explicitly creating a backing field for your variables :


private int _Length;

public int Length
{
    get
    {
        return _Length;
    }
}



Can be simplified to a single property :

public int Length { get; }


You can do the same for all of your properties.

Redundant this qualifier

You don't have to write this. everywhere e.g this.Range.Max as there are no variables with the same names there, the compiler will guess that you are referring to the container class.