扩展和使用CardLib

  前面介绍了事件的定义和使用，现在就可以在Ch13CardLib中使用它们了。在库中需要添加一个LastCardDrawn事件，当使用GetCard获得Deck对象中的最后一个Card对象时，就将引发该事件。这个事件允许订阅者（subscriber）自动重新洗牌，减少需要在客户端完成的处理。这个事件将使用EventHandler委托类型，并传递一个Deck对象的应用作为事件源，这样无论处理程序在什么地方，都可以访问Shuffle()方法。在Deck.cs中添加以下代码以定义并引发事件（这段代码包含在Ch13CardLib\Deck.cs文件中）：

  1.     namespace Ch13CardLib
  2.     {
  3.         public event EventHandler LastCardDrawn;
  5.         ...
  7.         public Card GetCard(int cardNum)
  8.         {
  9.             if(cardNum >= 0 && cardNum <= 51)
  10.             {
  11.                 if((cardNum == 51) && (LastCardDrawn != null))
  12.                     LastCardDrawn(this, EventArgs.Empty);
  13.                 return cards[cardNum];
  14.             }
  15.             else
  16.                 throw new CardOutOfRangeException((Cards)cards.Clone());
  17.         }
  18.     }

  这是把事件添加到Deck类定义需要的所有代码。

CardLib的扑克牌游戏客户程序

  在开发了CardLib库后，就可以使用它了。在结束讲述C#和.NET Framework中OOP技术的这个部分前，我们将编写扑克牌应用程序的基本代码，其中将使用我们熟悉的扑克牌类。

  与前面的章节一样，我们将在Ch13CardLib解决方案中添加一个客户控制台应用程序，添加一个Ch13CardLib项目的引用，使其成为启动项目。这个应用程序称为Ch13CardClient。

  首先在Ch13CardClient的一个新文件Player.cs中创建一个新类Player，相应代码可在本章下载代码的Ch13CardClient\Player.cs文件中找到。这个类包含两个自动属性：Name（字符串）和PlayerHand（Cards类型）。这些属性有私有的set访问器。但是PlayHand属性仍可以对其内容进行写入访问，这样就可以修改玩家手中的扑克牌。

  我们还把默认的构造函数设置为私有，以隐藏它，并提供了一个公共的非默认构造函数，该函数接受Player实例中属性Name的初始值。

  最后提供一个bool类型的方法HasWon()。如果玩家手中的扑克牌花色都相同（一个简单的取胜条件，但并没有什么意义），该方法就返回true。

  Player.cs的代码如下所示：

  1.     using System;
  2.     using System.Collections.Generic;
  3.     using System.Linq;
  4.     using System.Text;
  5.     using System.Threading.Tasks;
  6.     using Ch13CardLib;
  8.     namespace Ch13CardClient
  9.     {
  10.         public class Player
  11.         {
  12.             public string Name{ get; private set; }
  13.             public Cards PlayHand { get; private set; }
  15.             private Player()
  16.             {
  17.             }
  19.             public Player(string name)
  20.             {
  21.                 Name = name;
  22.                 PlayHand = new Cards();
  23.             }
  25.             public bool HasWon()
  26.             {
  27.                 bool won = true;
  28.                 Suit match = PlayHand[0].suit;
  29.                 for(int i = 1; i < PlayHand.Count; i++)
  30.                 {
  31.                     won &= PlayHand[i].suit == match;
  32.                 }
  33.                 return won;
  34.             }
  35.         }
  36.     }

  接着定义一个处理扑克牌游戏的类Game，这个类在Ch13CardClient项目的Game.cs文件中。

  这个类有4个私有成员字段：

  1.     • playDeck --- Deck类型的变量，包含要使用的一副扑克牌
  2.     • currentCard --- 一个int值，用作下一张要翻开的扑克牌的指针
  3.     • players --- 一个Player对象数组，表示游戏玩家
  4.     • discardedCards --- Cards集合，表示玩家扔掉的扑克牌，但还没有放回整副牌中。

  这个类的默认构造函数初始化了存储在playDeck中的Deck，并洗牌，把currentCard指针变量设置为0（playDeck中的第一张牌），并关联了playDeck.LastCardDrawn事件的处理程序Reshuffle()。这个处理程序将洗牌，初始化discardedCards集合，并将currentCard重置为0，准备从新的一副牌中读取扑克牌。

  Game类还包含两个实用方法：SetPlayers()可以设置游戏的玩家（Player对象数组），DealHands()给玩家发牌（每个玩家有7张牌）。玩家的数量限制为2～7人，确保每个玩家有足够多的牌。

  最后，PlayGame()方法包含游戏逻辑。在分析了Program.cs中的代码后介绍这个方法，Game.cs的剩余代码如下所示（这段代码包含在Ch13CardClient\Game.cs文件中）：

  1.     using System;
  2.     using System.Collentions.Generic;
  3.     using System.Linq;
  4.     using System.Text;
  5.     using System.Threading.Tasks;
  6.     using Ch13CardLib;
  8.     namespace Ch13CardClient
  9.     {
  10.         public class Game
  11.         {
  12.             private int currentCard;
  13.             private Deck playDeck;
  14.             private Player[] players;
  15.             private Cards discardedCards;
  17.             public Game()
  18.             {
  19.                 currentCard = 0;
  20.                 playDeck = new Deck(true);
  21.                 playDeck.LastCardDrawn += Reshuffle;
  22.                 playDeck.Shuffle();
  23.                 discardedCards = new Cards();
  24.             }
  26.             private void Reshuffle(object source, EventArgs args)
  27.             {
  28.                 Console.WriteLine("Discarded cards reshuffled into deck.");
  29.                 ((Deck)source).Shuffle();
  30.                 discardedCards.Clear();
  31.                 currentCard = 0;
  32.             }
  34.             public void SetPlayers(Player[] newPlayers)
  35.             {
  36.                 if(newPlayers.Length > 7)
  37.                     throw new ArgumentException(
  38.                         "A maximum of 7 players may play this game.");
  40.                 if(newPlayers.Length < 2)
  41.                     throw new ArgumentException(
  42.                         "A minimum of 2 players may play this game.");
  44.                 players = newPlayers;
  45.             }
  47.             private void DealHands()
  48.             {
  49.                 for(int p = 0; p < players.Length; p++)
  50.                 {
  51.                     for(int c = 0; c < 7; c++)
  52.                     {
  53.                         players[p].PlayHand.Add(playDeck.GetCard(currentCard++));
  54.                     }
  55.                 }
  56.             }
  58.             public int PlayGame()
  59.             {
  60.                 // Code to follow.
  61.             }
  62.         }
  63.     }

  Program.cs中包含Main()方法，它初始化并运行游戏。这个方法执行以下步骤：

  1.     （1）显示引导画面。
  2.     （2）提示用户输入玩家数（2～7）。
  3.     （3）根据玩家数建立一个Player对象数组。
  4.     （4）给每个玩家取名，用于初始化数组中的一个PLayer对象。
  5.     （5）创建一个Game对象，使用SetPlayers()方法指定玩家。
  6.     （6）使用PlayGame()方法启动游戏。
  7.     （7）PlayGame()的int返回值用于显示一条获胜消息（返回的值是Player对象数组中获胜的玩家的索引）。

  这个方法的代码（为清晰起见，加了一些注释）如下所示（这段代码包含在Ch13CardClient\Program.cs文件中）：

  1.     static void Main(string[] args)
  2.     {
  3.         // Display introduction.
  4.         Console.WriteLine("KarliCards: a new and exciting card game.");
  5.         Console.WriteLine("To win you must have 7 cards of the same suit in" +
  6.             " your hand.");
  7.         Console.WriteLine();
  9.         // Prompt for number of players.
  10.         bool inputOK = false;
  11.         int choice = -1;
  13.         do
  14.         {
  15.             Console.WriteLine("How many players(2-7) ");
  16.             string input = Console.ReadLine();
  18.             try
  19.             {
  20.                 // Attempt to convert input into a valid number of players.
  21.                 choice = Convert.ToInt32(input);
  22.                 if((choice >= 2) && (choice <= 7))
  23.                     inputOK = true;
  24.             }
  25.             catch
  26.             {
  27.                 // Ignore failed conversions, just continue prompting.
  28.             }
  30.         }while(inputOK == false);
  32.         // Initialize array of Player objects.
  33.         Player[] players = new Player[choice];
  35.         // Get player names.
  36.         for(int p = 0; p < players.Length; p++)
  37.         {
  38.             Console.WriteLine("Player {0}, enter your name:", p + 1);
  39.             string palyerName = Console.ReadLine();
  40.             players[p] = new Player(playerName);
  41.         }
  43.         // Start game.
  44.         Game newGame = new Game();
  45.         newGame.SetPlayers(players);
  46.         int whoWon = newGame.PlayGame();
  48.         // Display winning player.
  49.         Console.WriteLine("{0} has won the game!", players[whoWon].Name);
  50.         Console.ReadKey();
  51.     }

  接着分析一下应用程序的主体PlayGame()。由于篇幅所限，这里不准备详细讲解这个方法，而只是加注了一些注释，使其更容易理解。实际上，这些代码都不复杂，仅是较多而已。

  每个玩家都可以查看手中的牌和桌面上的那张牌，或者翻开一张新牌。在拾取一张牌后，玩家必须扔掉一张牌，如果他们拾取了桌面上的那张牌，就必须用另一张牌替换桌面上的那张牌，或者把扔掉的那张牌放在桌面上那张牌的上面（把扔掉的那张牌添加到discardedCards集合中）。

  在分析这段代码时，一个关键问题在于Card对象的处理方式。必须清楚，这些对象定义为引用类型，而不是值类型（使用结构）。给定的Card对象似乎同时存在于多个地方，因为引用可以存在于Deck对象、Player对象的hand字段、discardedCards集合和playCard对象（桌面上的当前牌）中。这样便于跟踪扑克牌，特别是可以用于从一副牌中拾取一张新牌。如果牌不在任何玩家的手中，也不在discardedCards集合中，才能接受该牌。

  代码如下所示：

  1.     public int PlayGame()
  2.     {
  3.         // Only play if players exist.
  4.         if(players == null)
  5.             return -1;
  7.         // Deal initial hands.
  8.         DealHands();
  10.                // Initialize game vars, including an initial card to place on the
  11.                // table: playCard.
  12.                bool GameWon = false;
  13.                int currentPlayer;
  14.                Card playCard = playDeck.GetCard(currentCard++);
  15.                discardedCards.Add(playCard);
  17.                // Main game loop, continues until GameWon == true.
  18.                do
  19.                {
  20.                    Console.WriteLine("Press T to take card in play or D to " +
  21.                        "draw:");
  22.                    string input = Console.ReadLine();
  23.                    if(input.ToLower() == "t")
  24.                    {
  25.                        // Add card from table to player hand.
  26.                        Console.WriteLine("Drawn: {0}", playCard);
  28.                        // Remove from discarded cards if possible(if deck
  29.                        // is reshuffled it won't be there any more)
  30.                        if(discardedCards.Contains(playCard))
  31.                        {
  32.                            discardedCards.Remove(playCard);
  33.                        }
  34.                        players[currentPlayer].PlayHand.Add(playCard);
  35.                        inputOK = true;
  36.                    }
  37.                    if(input.ToLower() == "d")
  38.                    {
  39.                        // Add new card from deck to player hand.
  40.                        Card newCard;
  42.                        // Only add card if it isn't already in a player hand
  43.                        // or in the discard pile
  44.                        bool cardIsAvailable;
  45.                        do
  46.                        {
  47.                            newCard = playDeck.GetCard(currentCard++);
  48.                            // Check if card is in discard pile
  49.                            cardIsAvailable = !discardedCards.Contains(newCard);
  50.                            if(cardIsAvailable)
  51.                            {
  52.                                // Loop through all player hands to see if newCard
  53.                                // is already in a hand.
  54.                                foreach(Player testPlayer in players)
  55.                                {
  56.                                    if(testPlayer.PlayHand.Contains(newCard))
  57.                                    {
  58.                                        cardIsAvailable = false;
  59.                                        break;
  60.                                    }
  61.                                }
  62.                            }
  63.                        }while(!cardIsAvailable);
  64.                        // Add the card found to player hand.
  65.                        Console.WriteLine("Drawn: {0}", newCard);
  66.                        players[currentPlayer].PlayHand.Add(newCard);
  67.                        inputOK = true;
  68.                    }
  69.                }while(inputOK == false);
  71.                // Display new hand with cards numbered.
  72.                Console.WriteLine("New hand:");
  73.                for(int i = 0; i < players[currentPlayer].PlayHand.Count; i++)
  74.                {
  75.                   Console.WriteLine("{0}: {1}", i+1, 
  76.                       players[currentPlayer].PlayHand[i]);
  77.                }
  79.                // Prompt player for a card to discard.
  80.                inputOK = false;
  81.                int choice = -1;
  82.                do
  83.                {
  84.                    Console.WriteLine("Choose card to discard:");
  85.                    string input = Console.ReadLine();
  86.                    try
  87.                    {
  88.                         // Attempt to convert input into a valid card number.
  89.                         choice = Convert.ToInt32(input);
  90.                         if((choice > 0) && (choice <= 8))
  91.                             inputOK = true;
  92.                     }
  93.                     catch
  94.                     {
  95.                         // Ignore failed conversions, just continue prompting.
  96.                     }
  97.                 }while(inputOK == false);
  99.                 // Place reference to removed card in playCard (place the card
  100.                 // on the table), then remove card from player hand and add
  101.                 // to discarded card pile.
  102.                 playCard = players[currentPlayer].PlayHand[choice - 1];
  103.                 players[currentPlayer].PlayHand.RemoveAt(choice - 1);
  104.                 discardedCards.Add(playCard);
  105.                 Console.WriteLine("Discarding: {0}", playCard);
  107.                 // Space out text for players
  108.                 Console.WriteLine();
  110.                 // Check to see if player has won the game, and exit the player
  111.                 // loop if so.
  112.                 GameWon = players[currentPlayer].HasWon();
  113.                 if(GameWon == true)
  114.                     break;
  116.             }
  117.         } while(GameWon == false);
  119.         // End game, noting the winning palyer.
  120.         return currentPlayer;
  121.     }

  玩这个游戏，确保花一些时间去仔细研究它。应尝试在Reshuffle()方法中设置一个断点，由7个玩家来玩这个游戏。如果在拾取了扑克牌后，马上扔掉它，不需要太长的时间就要重新洗牌了，因为7个玩家玩这个游戏时，就只富余3张牌。这样就可以注意3张牌何时重新翻开，验证程序是否正常执行。