C# 检查颜色是否已从数组列表C中使用#

您好，我想检查我的数组中的特定颜色是否已被使用 它不会再使用了。我正在使用数组中当前随机的颜色，所以有时它会得到相同的颜色

// Add random block color
            Color[] colors = new Color[] { Color.Red, Color.Blue, Color.Green, Color.Purple, Color.Black, Color.Aqua };
            Random ra = new Random();
            int rnum = ra.Next(0, 5);
            p.block.brush_color = new SolidBrush(Color.FromArgb(100, colors[rnum]));
// Add new generated process to list
            processes.Add(p);

---

我怎样才能做到这一点呢？

考虑到所有的评论，比如：

Color[] colors = new Color[] { Color.Red, Color.Blue, Color.Green, Color.Purple, Color.Black, Color.Aqua };
List<Color> randomColors = new List<Color>();
var random = new Random();

//fill the queue with a bunch of colors, careful to take fewer than exist
do
{
    var index = random.Next(colors.Length);
    var newColor = colors[index];
    if (!randomColors.Contains(newColor))
    {
        randomColors.Add(newColor);
    }
} while (randomColors.Count < colors.Length - 2);

foreach (var color in randomColors)
{
    Trace.WriteLine(color.ToString());
}

p.block.brush_color = GetNextColoredBrush();

Color[]colors=新颜色[]{Color.Red，Color.Blue，Color.Green，Color.紫色，Color.Black，Color.Aqua}；
List randomColors=新列表（）；
var random=新的random（）；
//用一堆颜色填充队列，小心地使用少于现有颜色的颜色
做
{
var索引=random.Next（colors.Length）；
var newColor=颜色[索引]；
如果（！randomColor.Contains（newColor））
{
随机颜色。添加（新颜色）；
}
}而（randomColors.Count

---

如果您有多种颜色，您可能希望有一个

HashSet

，用于跟踪您使用的颜色（而不是一次又一次地（大量地）遍历列表）。

考虑到所有的注释，类似于：

Color[] colors = new Color[] { Color.Red, Color.Blue, Color.Green, Color.Purple, Color.Black, Color.Aqua };
List<Color> randomColors = new List<Color>();
var random = new Random();

//fill the queue with a bunch of colors, careful to take fewer than exist
do
{
    var index = random.Next(colors.Length);
    var newColor = colors[index];
    if (!randomColors.Contains(newColor))
    {
        randomColors.Add(newColor);
    }
} while (randomColors.Count < colors.Length - 2);

foreach (var color in randomColors)
{
    Trace.WriteLine(color.ToString());
}

p.block.brush_color = GetNextColoredBrush();

Color[]colors=新颜色[]{Color.Red，Color.Blue，Color.Green，Color.紫色，Color.Black，Color.Aqua}；
List randomColors=新列表（）；
var random=新的random（）；
//用一堆颜色填充队列，小心地使用少于现有颜色的颜色
做
{
var索引=random.Next（colors.Length）；
var newColor=颜色[索引]；
如果（！randomColor.Contains（newColor））
{
随机颜色。添加（新颜色）；
}
}而（randomColors.Count

---

如果您有多种颜色，您可能希望使用一个

哈希集来跟踪您使用的颜色（而不是一次又一次地（大量地）遍历列表）。
处理此问题的一种方法是将数组中的项洗牌，然后按顺序选择项。通常认为的最佳算法是：

private static Color[] colors =
{
    Color.Red, Color.Blue, Color.Green, Color.Purple, Color.Black, Color.Aqua
};

private static Random random = new Random();

private static void ShuffleColors()
{
    for (int index = 0; index < colors.Length; index++)
    {
        var randomIndex = index + random.Next(colors.Length - index);
        var temp = colors[randomIndex];
        colors[randomIndex] = colors[index];
        colors[index] = temp;
    }
}

现在，我们可以在循环中调用此方法，以查看输出的外观：

private static void Main()
{
    // Output our random colors. Note that even though we
    // only we only have 6 colors, they are consistently 
    // output in a random order (but with no duplicates).
    for (int i = 0; i < 20; i++)
    {
        Console.WriteLine(GetNextColoredBrush().Color.ToKnownColor());
    }


    GetKeyFromUser("\nDone! Press any key to exit...");
}

但是，您可能会注意到，我稍微更改了输出，以便它输出一个
KnownColor
。如果要维护原始代码，应修改
getnextcolordbrush
方法中返回值的行：

return new SolidBrush(Color.FromArgb(100, colors[nextIndex++]));

处理此问题的一种方法是将数组中的项洗牌，然后按顺序选择这些项。通常认为的最佳算法是：

private static Color[] colors =
{
    Color.Red, Color.Blue, Color.Green, Color.Purple, Color.Black, Color.Aqua
};

private static Random random = new Random();

private static void ShuffleColors()
{
    for (int index = 0; index < colors.Length; index++)
    {
        var randomIndex = index + random.Next(colors.Length - index);
        var temp = colors[randomIndex];
        colors[randomIndex] = colors[index];
        colors[index] = temp;
    }
}

现在，我们可以在循环中调用此方法，以查看输出的外观：

private static void Main()
{
    // Output our random colors. Note that even though we
    // only we only have 6 colors, they are consistently 
    // output in a random order (but with no duplicates).
    for (int i = 0; i < 20; i++)
    {
        Console.WriteLine(GetNextColoredBrush().Color.ToKnownColor());
    }


    GetKeyFromUser("\nDone! Press any key to exit...");
}

但是，您可能会注意到，我稍微更改了输出，以便它输出一个
KnownColor
。如果要维护原始代码，应修改
getnextcolordbrush
方法中返回值的行：

return new SolidBrush(Color.FromArgb(100, colors[nextIndex++]));

你可以采取多种方法

方法1：洗牌列表
基于鲁弗斯的联系

static void Main(string[] args)
{
    List<Color> ColorList = new List<Color>() { Colors.Red, Colors.Blue, Colors.Green, Colors.Pink };

    Shuffle(ColorList);

    while (ColorList.Count > 0)
    {
        Console.WriteLine(ColorList[0]);    // Equivalent of using the color.
        ColorList.RemoveAt(0);              // Remove from the list once used.
    }

    Console.ReadLine();
}

static void Shuffle<T>(IList<T> list)
{
    Random rng = new Random();

    int n = list.Count;
    while (n > 1)
    {
        n--;
        int k = rng.Next(n + 1);
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
    }
}

这里，每个参数的范围是
0-255

现在，这个方法会给你很多颜色，你不可能用完。我在增量之间设置了16个限制，这样你就不会得到太多相似的颜色

private static List<Color> GetLotsOfColors(int gap)
{
    gap = gap < 16 ? 16 : gap;

    List<Color> ColorList = new List<Color>();
    for (int r = 0; r < 256; r += gap)
    {
        for (int g = 0; g < 256; g += gap)
        {
            for (int b = 0; b < 256; b += gap)
            {
                for (int a = 0; a < 256; a += gap)
                {
                    ColorList.Add(Color.FromArgb((byte)a, (byte)r, (byte)g, (byte)b));
                }
            }
        }
    }
    return ColorList;
}

private static List GetLotsOfColors（int-gap）
{
间隙=间隙<16？16：间隙；
List ColorList=新列表（）；
对于（int r=0；r<256；r+=gap）
{
对于（int g=0；g<256；g+=gap）
{
对于（int b=0；b<256；b+=gap）
{
对于（int a=0；a<256；a+=gap）
{
Add（Color.FromArgb（（字节）a，（字节）r，（字节）g，（字节）b））；
}
}
}
}
返回颜色列表；
}

现在，您可以使用前面的Shuffle（）

方法对它们进行洗牌，然后逐个获取它们。

您可以采取多种方法

方法1：洗牌列表 基于鲁弗斯的联系

static void Main(string[] args)
{
    List<Color> ColorList = new List<Color>() { Colors.Red, Colors.Blue, Colors.Green, Colors.Pink };

    Shuffle(ColorList);

    while (ColorList.Count > 0)
    {
        Console.WriteLine(ColorList[0]);    // Equivalent of using the color.
        ColorList.RemoveAt(0);              // Remove from the list once used.
    }

    Console.ReadLine();
}

static void Shuffle<T>(IList<T> list)
{
    Random rng = new Random();

    int n = list.Count;
    while (n > 1)
    {
        n--;
        int k = rng.Next(n + 1);
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
    }
}

这里，每个参数的范围是

0-255

现在，这个方法会给你很多颜色，你不可能用完。我在增量之间设置了16个限制，这样你就不会得到太多相似的颜色

private static List<Color> GetLotsOfColors(int gap)
{
    gap = gap < 16 ? 16 : gap;

    List<Color> ColorList = new List<Color>();
    for (int r = 0; r < 256; r += gap)
    {
        for (int g = 0; g < 256; g += gap)
        {
            for (int b = 0; b < 256; b += gap)
            {
                for (int a = 0; a < 256; a += gap)
                {
                    ColorList.Add(Color.FromArgb((byte)a, (byte)r, (byte)g, (byte)b));
                }
            }
        }
    }
    return ColorList;
}

private static List GetLotsOfColors（int-gap）
{
间隙=间隙<16？16：间隙；
List ColorList=新列表（）；
对于（int r=0；r<256；r+=gap）
{
对于（int g=0；g<256；g+=gap）
{
对于（int b=0；b<256；b+=gap）
{
对于（int a=0；a<256；a+=gap）
{
Add（Color.FromArgb（（字节）a，（字节）r，（字节）g，（字节）b））；
}
}
}
}
返回颜色列表；
}

---

现在，您可以使用前面的

Shuffle（）

方法对它们进行洗牌，然后逐个获得它们。

您将永远无法获得水色。请参见使用颜色列表，并在使用颜色列表时将其从列表中删除。列表长度将每次减少一个。我怎么做，先生？你能给我看一些示例代码吗？我建议使用

队列

-按随机顺序添加它们，然后根据需要退出队列。使用所有颜色后，你想做什么？我想你真正想要的是一种洗牌的方式。然后你可以按顺序从列表中选取项目，当你到达最后一个项目时，再将它们洗牌。你将永远不会得到浅绿色。请参见使用颜色列表，并在使用颜色列表时将其从列表中删除。列表长度将每次减少一个。我怎么做，先生？你能给我看一些示例代码吗？我建议使用

队列

-按随机顺序添加它们，然后根据需要退出队列。使用所有颜色后，你想做什么？我想你真正想要的是一种洗牌的方式。然后你可以按顺序从列表中提取项目，当你到达最后一个项目时，再将它们洗牌。先生，我怎样才能在我的代码中插入这些项目呢？我最多只能使用6种颜色。可能吗