Elegante Technik, um Objekte von einem Array zum anderen zu bewegen

Question

Kontext: Ein Kartenspiel; Ich möchte jedem Spieler im Spiel Karten von einem Deck auf saubere Art und Weise austeilen.

Dies ist, was ich im Sinn hatte:

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; 
    } 

Sicherlich können Sie die Referenz Probleme sehen. Die Verwendung des Schlüsselworts ref führt zu etwas nicht so gut aussehenden Code, aber es kann unvermeidlich sein. Irgendwelche Vorschläge?

Ich würde eine Lösung bevorzugen, die flexibel genug ist, um andere "Kartenpass" -Situationen zu bewältigen (ein Spieler spielt eine Karte auf den Stapel, zieht Karten vom Stapel auf ein "Müll" -Deck usw.).

Answer 1

Nun, eine einfache Möglichkeit besteht nicht darin, Arrays zu verwenden. Benutze Listen von Anfang an und du musst sie nicht neu zuweisen - entferne sie einfach vom Deck und füge sie der Hand hinzu. Vielleicht möchten Sie einen Queue<T> für das Deck verwenden.

Der funktionalere Weg wäre, unveränderliche Sammlungen und Ref-Parameter zu verwenden, aber das ist nicht besonders praktisch ohne einige gute unveränderliche Sammlungsklassen hinter Ihnen. (Sie sind verfügbar, aber nicht in das Framework integriert.)

Warum übergeben Sie das Kartenfeld in die Methode? Sollte es nicht einfach alles vom Deck aus erledigen? An diesem Punkt ist es einfacher zu schreiben: (.. Ich bin mir nicht sicher, warum Sie Erweiterungsmethoden hier verwenden, btw Das ist etwas aussieht, die besser geeignet als eine Instanz Methode wäre)

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

Answer 2

Das ist ein schlechter Fall für Arrays, denke ich, die normalerweise nicht dazu gedacht sind, wiederholt hinzugefügt und entfernt zu werden. Außerdem würde ich dies nicht zu einer Erweiterungsmethode machen, da es außerhalb einiger ausgewählter Orte in Ihrer Anwendung keine Relevanz hat.

Denken Sie nur daran, mit einer Liste zu bleiben und eine Klassenmethode zu haben, die für das Verschieben verantwortlich ist.

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); 
    } 
} 

Commen hat ein Kartenspiel kann besser als Queue, nach dem Vorbild vorgeschlagen, die ein legitimer Punkt ist abhängig davon, ob Sie nur Karten oben von dem Deck oder nicht stattfinden können. Wenn das tatsächlich der Fall ist, denken Sie darüber nach:

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

Vielleicht so etwas?

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); 
}