сброс цикла по алфавиту

for( int  i= 0; i <= 999; i++ ) 
{
   if(i == 193)
   {
      i = 200;
   }
   else if(i == 202) 
   {
      i = 300;
   } 
}

string alfavit = "0123456789";
        for (int a = 0; a < alfavit.Length; a++)
        {
            for (int b = 0; b < alfavit.Length; b++)
            {
                for (int c = 0; c < alfavit.Length; c++)
                {
                    for (int d = 0; d < alfavit.Length; d++)
                    {
                        string mystroka = alfavit[a].ToString() + alfavit[b].ToString() + alfavit[c].ToString() + alfavit[d].ToString();
                        Console.WriteLine(mystroka);
                    }
                }
            }
        }
        Console.ReadKey();

0012
0100
...
...
0234
0300

Не пойму, для чего вам 4 цикла. Попробуйте это:

for (int i = 0; i <= 9999;)
{       
    Console.WriteLine(i.ToString("D4"));
    switch(i)
    {
        case 12:
            i = 100;
            break;
        case 193:
            i= 200;
            break;
        case 202:
            i=300;
            break;
        default:
            i++;
            break;
    }
}

Как видите, никаких if нет, инкремент счетчику присваиваем внутри цикла. Для вывода используем форматирование целых чисел.

Вывод:

0000
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0100
0101
0102
0103
....

Вариант со словарём переходов:

var jumps = new Dictionary<int, int> { [12]=100, [194]=200, [203]=300 };
for (int i = 0; i < 10000; i = jumps.TryGetValue(i, out var j) ? j : i + 1)
    Console.WriteLine($"{i:D4}");

или, без введения переменной j:

var jumps = new Dictionary<int, int> { [12]=100, [194]=200, [203]=300 };
for (int i = 0; i < 10000; i = jumps.ContainsKey(i) ? jumps[i] : i + 1)
    Console.WriteLine($"{i:D4}");

var numbers = new Range { 
    {1, 2}, 
    {5, 9}, 
};
foreach(var i in numbers)
    Console.WriteLine($"{i:D4}");

Результат вызова

0001
0002
0005
0006
0007
0008
0009

Простая реализация.

public class Range : List<int>
{
    public void Add(int from, int to)
    {
        AddRange(Enumerable.Range(from, to - from + 1));
    }
}

Вторая версия. Улучшено потребление памяти.

public class Range : IEnumerable<int>
{
    private List<IEnumerable<int>> intervals = new List<IEnumerable<int>>();
    public Range Add(int from, int to)
    {
        intervals.Add(Enumerable.Range(from, to - from + 1));
        return this;
    }
    public IEnumerator<int> GetEnumerator()
    {
        foreach(var interval in intervals)
            foreach(var i in interval)
                yield return i;
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Код можно вызывать и цепочкой

var numbers = new Range()
    .Add(1, 2)
    .Add(5, 9);
//...

Я бы сделал как-то так:

IEnumerable<int> Range(int from, int to) => Enumerable.Range(from, to - from + 1);
IEnumerable<T> Concat<T>(IEnumerable<IEnumerable<T>> sequences)
{
    foreach (var seq in sequences)
        foreach (var item in seq)
            yield return item;
}
var ranges = new[]
{
    Range(0, 12),
    Range(100, 193),
    Range(200, 202),
    Range(300, 999)
};
foreach (var i in Concat(ranges))
    Console.WriteLine($"{i:D4}");

Заметьте, что функцию Concat можно записать более простым, но, возможно, менее понятным для новичков способом:

IEnumerable<T> Concat<T>(IEnumerable<IEnumerable<T>> ll) => ll.SelectMany(l => l);

В C# 7.3 появится Range, и можно будет писать просто

var ranges = new[] { 0..12,  100..193, 200..202, 300..999 };