Как мне сгенерировать эту конкретную последовательность чисел?

Question

Очевидно, что в .net нет предопределенного списка.

Я бы хотел использовать несколько стандартных цветов, например, что-то вроде красного, зеленого, синего, желтого ... то есть типичные цвета, состоящие из компонентов 00 и FF, за которыми следуют цвета с дополнительными компонентами 7F, ...

Есть ли способ получить эти "стандартные" цвета, или я должен написать IEnumerable<Color> сам?

Редактировать: это возможный вывод для значений RGB.

Обратите внимание, что порядок множеств имеет значение в том смысле, что перечисление 00 / FF должно быть завершено до добавления 80, а перечисление 00/80 / FF должно быть завершено до добавления 40 / B0, и так далее. Порядок в наборе не имеет значения (т. Е. 00 FF 00 может предшествовать 00 00 FF).

00 00 00 // start out with 00 and FF components
00 00 FF
00 FF 00
FF 00 00
FF FF 00
FF 00 FF
00 FF FF
FF FF FF
00 00 80 // ok, now add 80
00 80 00
...
80 80 80
FF 00 80
FF 80 00
FF 80 80
80 FF 00
80 FF 80
FF FF 80
...
// now add 40 and B0

Answer 1

Класс Colors имеет ряд предопределенных цветов ARGB, как и структура Color.Они содержат такие вещи, как Yellow, White, Green и т. Д. *

Если вы хотите, чтобы пользователь определял системные цвета, вы можете использовать класс SystemColors, который имееттакие вещи, как ActiveBorder, WindowText и т.д ...

---

Обновление:

В платформе нет ничего, что сортировало бы цвета по значениям ARGB как таковым, посколькуЭто действительно имеет смысл

Вы можете использовать Linq для сортировки списка цветов по их компонентам (OrderBy метод расширения).

Answer 2

Это достаточно быстрый способ генерации последовательности:

public static IEnumerable<Color> StandardColors ()
{
    int r = 0;
    int g = 0;
    int b = 0;
    int inc = 0x100;

    yield return Color.FromArgb (0, 0, 0);

    while (true) {
        if (((r | g | b) & inc) != 0) {
            int outR = r == 0 ? 0 : r - 1;
            int outG = g == 0 ? 0 : g - 1;
            int outB = b == 0 ? 0 : b - 1;
            yield return Color.FromArgb (outR, outG, outB);
        }

        r += inc;
        if (r > 256) {
            r = 0;
            g += inc;

            if (g > 256) {
                g = 0;
                b += inc;

                if (b > 256) {
                    b = 0;
                    inc >>= 1;

                    if (inc <= 1) {
                        break;
                    }
                }
            }
        }
    }
}

Это, безусловно, можно улучшить.Например, следует избегать наличия отдельной переменной outR / G / B, а приращение должно быть через 2 * inc, начиная с нечетного (основанного на inc) значения, чтобы избежать необходимости проверять, было ли это значение уже сгенерировано ранее.

С помощью этого теста

static void Main (string[] args)
{
    var colors = StandardColorEnumerator.StandardColors ().Take (15)
        .Concat (StandardColorEnumerator.StandardColors ().Skip (1000).Take (10));
    foreach (var color in colors) {
        Console.WriteLine (color.B + "\t" + color.G + "\t" + color.R);
    }

    Console.ReadKey (true);
}

генерируется следующий вывод:

0       0       0
0       0       255
0       255     0
0       255     255
255     0       0
255     0       255
255     255     0
255     255     255
0       0       127
0       127     0
0       127     127
0       127     255
0       255     127
127     0       0
127     0       127

15      47      191
15      47      207
15      47      223
15      47      239
15      47      255
15      63      0
15      63      15
15      63      31
15      63      47
15      63      63

Answer 3

AFAIK «Стандартные» цвета не равны цветам со значением RGB на основе описанного вами шаблона. Например, фиолетовый цвет имеет значение # B803FF RGB (где у аналогичной фуксии # FF00FF).

Answer 4

Возможно, класс SystemColors - то, что вам нужно.