随机选择设置位的有效方法

我当前的业余项目是为带有法国套牌的纸牌游戏（52张纸牌，从2到A）提供蒙特卡洛模拟。

为了尽可能快地进行仿真，我在某些位置使用多张卡表示为位掩码。这是一些（简化的）代码：

public struct Card
{
    public enum CardColor : byte { Diamonds = 0, Hearts = 1, Spades = 2, Clubs = 3 }
    public enum CardValue : byte { Two = 0, Three = 1, Four = 2, Five = 3, Six = 4, Seven = 5, Eight = 6, Nine = 7, Ten = 8, Jack = 9, Queen = 10, King = 11, Ace = 12 }

    public CardColor Color { get; private set; }
    public CardValue Value { get; private set; }

    // ID provides a unique value for each card, ranging from 0 to 51, from 2Diamonds to AceClubs
    public byte ID { get { return (byte)(((byte)this.Value * 4) + (byte)this.Color); } }

    // --- Constructors ---
    public Card(CardColor color, CardValue value)
    {
        this.Color = color;
        this.Value = value;
    }
    public Card(byte id)
    {
        this.Color = (CardColor)(id % 4);
        this.Value = (CardValue)((id - (byte)this.Color) / 4);
    }
}

将多张卡作为位掩码的结构：

 public struct CardPool
 {
    private const ulong FULL_POOL = 4503599627370495;

    internal ulong Pool { get; private set; } // Holds all cards as set bit at Card.ID position

    public int Count()
    {
        ulong i = this.Pool;
        i = i - ((i >> 1) & 0x5555555555555555);
        i = (i & 0x3333333333333333) + ((i >> 2) & 0x3333333333333333);
        return (int)((((i + (i >> 4)) & 0xF0F0F0F0F0F0F0F) * 0x101010101010101) >> 56);
    }

    public CardPool Clone()
    {
        return new CardPool() { Pool = this.Pool };
    }

    public void Add(Card card)
    {
        Add(card.ID);
    }
    public void Add(byte cardID)
    {
        this.Pool = this.Pool | ((ulong)1 << cardID);
    }

    public void Remove(Card card)
    {
        Remove(card.ID);
    }
    public void Remove(byte cardID)
    {
        this.Pool = this.Pool & ~((ulong)1 << cardID);
    }

    public bool Contains(Card card)
    {
        ulong mask = ((ulong)1 << card.ID);
        return (this.Pool & mask) == mask;
    }

    // --- Constructor ---
    public CardPool(bool filled)
    {
        if (filled)
            this.Pool = FULL_POOL;
        else
            this.Pool = 0;
    }

}

我想从第二个结构CardPool中随机绘制一张或多张卡，但我无法想象如何在不迭代池中单个位的情况下做到这一点。有什么已知的算法可以执行此操作吗？如果没有，您是否有快速执行此操作的想法？

更新：该结构并非旨在提取所有卡片。它经常被克隆，克隆数组是没有选择的。我真的想到了绘制一张或多张卡的位操作。

Update2：我编写了一个类，将这些卡保存为列表以进行比较。

public class CardPoolClass
{
    private List<Card> Cards;
    public void Add(Card card)
    {
        this.Cards.Add(card);
    }

    public CardPoolClass Clone()
    {
        return new CardPoolClass(this.Cards);
    }

    public CardPoolClass()
    {
        this.Cards = new List<Card> { };
    }
    public CardPoolClass(List<Card> cards)
    {
        this.Cards = cards.ToList();
    }
}

比较整个平台的1.000.000克隆操作：-结构：17毫秒-类：73毫秒

承认：差异不像我想的那么大。但是考虑到我还放弃了对预先计算的值的轻松查找，因此产生了很大的不同。当然，用此类绘制一张随机卡片会更快，但是我必须计算一个索引才能进行查找，而这只是将问题转移到另一个地方。

我重复我的第一个问题：是否有一种已知的算法可以从整数值中选择一个随机置位，还是有人想过要比迭代所有位更快地做到这一点？

关于将类与List或Array一起使用的讨论无济于事，这不是我的问题，如果可以更好地使用类，我可以自行阐述。

Update3，查找代码：

删除代码：这可能会引起误解，因为它不是指性能受线程主题影响的段落。