Elegant technique to move items from one array to another

Question

Context: A card game; I want to deal out cards from a deck to each player in the game, in a clean way.

This is what I had in mind:

public static CardGame.IGame DealAll(this CardGame.IGame objThis, CardGame.Card[] cards)
    {
        if (objThis.Players.Length > 0)
        {
            for (int i = 0; i < cards.Length; i++)
            {
                objThis.Deck.MoveTo(cards[i], objThis.CurrentPlayer.Hand);

                objThis.AdvancePlayer();
            }
        }

        return objThis;
    }

public static Card[] MoveTo(this Card[] objThis, Card card, Card[] cards)
    {
        List<Card> lstCards = cards.ToList();
        List<Card> lstThis = objThis.ToList();

        lstThis.Remove(card);
        lstCards.Add(card);

        objThis = lstThis.ToArray();
        cards = lstCards.ToArray();

        return cards;
    }

Surely you can see the reference problems. Using the ref keyword leads to some not-so-nice looking code, but it may be unavoidable. Any suggestions?

I would prefer a solution that is flexible enough to handle other "card-passing" situations (a player playing a card to the pile, moving cards from the pile to a "trash" deck, etc.).

Answer 1

Well, one simple way is not to use arrays in the first place. Use lists from the start and you don't need to reallocated etc - just remove from the deck and add to the hand. You might want to consider using a Queue<T> for the deck though.

The more functional way would be to use immutable collections and ref parameters, but that's not terribly practical without some good immutable collection classes behind you. (They're available, but not built into the framework.)

Why are you passing the array of cards into the method though? Shouldn't it just deal everything from the deck? At that point it's easier to write:

foreach (Card card in deck)
{
    CurrentPlayer.Hand.Add(card);
    AdvancePlayer();
}
deck.Clear();

(I'm not sure why you're using extension methods here, btw. This looks like something which would be more appropriate as an instance method.)

Answer 2

This is a bad case for Arrays, I think, which usually aren't designed to be repeatedly added to and removed from. Also, I would not make this an extension method, since it has no relevance outside of a few selected places in your application.

Consider just sticking with a List instead and having a class method which is responsible for doing the moving.

public class CardDealer {
...
  private List<Card> _deck;

  // Put the card [c] into [hand], and remove it from the deck.
  public void Deal(List<Card> hand, Card c) {
    _deck.Remove(c);
    hand.Add(c);
  }
}

Commenters have suggested a deck of cards may better modeled as a Queue, which is a legitimate point depending on whether you can only take cards from the top of the deck or not. If that is indeed the case, consider this:

public class CardDealer {
...
  private Queue<Card> _deck;

  // Put the top card of the deck into the specified hand.
  public void Deal(List<Card> hand) {
    // Deck is a Queue now. No need to specify which card to take.
    Card c = _deck.Dequeue(); 
    hand.Add(c);
  }
}

Answer 3

Maybe something like this?

interface ICardPile
{
    ICollection<Card> Cards
    {
        get;
    }
}

interface IOrderedCardPile : ICardPile // FIXME Better name.
{
}

class Deck : ICardPile
{
    private Stack<Card> _cards = new Stack<Card>();

    ICollection<Card> Cards
    {
        get
        {
            return _cards;
        }
    }

    public Deck()
    {
        // TODO Fill deck.
    }

    public void DealCardsTo(IEnumerable<ICardPile> piles, int cardCount)
    {
        for(int i = 0; i < cardCount; ++i)
        {
            foreach(var pile in piles)
                Cards.MoveSomeTo(piles, 1);
        }
    }
}

class Hand : IOrderedCardPile
{
    private HashSet<Card> _cards = new HashSet<Card>();

    ICollection<Card> Cards
    {
        get
        {
            return _cards;
        }
    }
}

---

// Extension methods
static void MoveSomeTo(this ICardPile pile, ICardPile other, int count)
{
    // Removes cards from the end of pile and puts them at the end of other.

    foreach(Card card in pile.Cards.Reverse().Take(count))
    {
        other.Add(card);
    }

    pile.Cards = pile.Cards.Take(count);
}

static void MoveCardTo(this IOrderedCardPile pile, ICardPile other, Card card)
{
    // Removes card from pile and puts it at the end of other.
    pile.Remove(card);
    other.Add(card);
}

---

// Examples
Deck deck;
DiscardPile discard;
var hands = new Hand[4];

deck.DealCardsTo(hands, 7);

// Discard all aces.
forach(var hand in hands)
{
    foreach(var card in hand.Cards.Where(card => card.Number == Card.SomeEnum.Ace))
        hand.MoveCardTo(discard, card);
}