Класс колода карт - C#

using System;
using System.Collections.Generic;
using System.Text;
 
namespace sstud
{ // Общий закрытый класс Suit (масть карты) 
  public sealed class Suit 
 { 
// Статически  определяет все допустимые значения масти 
   public static readonly Suit DIAMONDS = new Suit((char) 4);  // ♦ 
   public static readonly Suit HEARTS = new Suit((char) 3);    //♥ 
   public static readonly Suit SPADES = new Suit((char) 6);    //в™* 
   public static readonly Suit CLUBS = new Suit((char) 5);     //в™Ј 
 
// Помогает выполнить итерации по перечислимым значениям 
public static readonly Suit[ ] SUIT = new Suit[ ]{DIAMONDS, HEARTS, SPADES, CLUBS}; 
// Переменная экземпляра display для хранения отображаемого значения  
   private readonly char display; 
    
// He позволить создавать экземпляры вне объектов 
   private Suit(char display)                        // конструктор 
  { 
    this.display = display; 
  } 
    
  // ToString() – переопределяющий возвратить значение масти
   public override System.String ToString() // ToString() – м-д класса String 
  { 
    return System.Convert.ToString(display); 
  } 
 } 
 
/*****************************************************************************************************/
 
// Общий закрытый класс Rank (достоинство карты
public sealed class Rank 
 { 
   public static readonly Rank SIX = new Rank(6, "6"); 
   public static readonly Rank SEVEN = new Rank(7, "7"); 
   public static readonly Rank EIGHT = new Rank(8, "8"); 
   public static readonly Rank NINE = new Rank(9, "9"); 
   public static readonly Rank TEN = new Rank(10, "10"); 
   public static readonly Rank JACK = new Rank(11, "J");            // валет 
   public static readonly Rank QUEEN = new Rank(12, "Q");           // дама  
   public static readonly Rank KING = new Rank(13, "K");            // король 
   public static readonly Rank ACE = new Rank(14, "A");             // туз 
// Общий статический Rank (достоинство карты)  
 public static readonly Rank[ ] RANK = new Rank[ ]{          SIX, SEVEN, 
EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE}; 
   
   private readonly int rank; 
// Переменная экземпляра rank для хранения отображаемого значения 
   private System.String display; 
   
   private Rank(int rank, System.String display)                      // конструктор 
  { 
    this.rank = rank; 
     this.display = display; 
   } 
   
   public int getRank()                             // возврат достоинства карты 
  { 
    return rank; 
  } 
                                                   // ToString() – переопределяющий  
    public override System.String ToString() 
  { 
    return display; 
  } 
 } 
/*****************************************************************************************************/
public class Card                                                                                                                  // Листинг 1с
{  private Rank rank; 
  private Suit suit; 
     
/* создание новой карты - при этом используются только те константы, 
которые были инициализированы */ 
  public Card(Suit suit, Rank rank)                 // конструктор – создается карта 
 {
   this.suit = suit;                   
   this.rank = rank;                
 } 
  
  virtual public Suit Suit                           // свойство – получить значение масти карты 
 { 
   get    {  return suit;   } 
 } 
  virtual public Rank Rank                 // свойство – получить значение достоинства карты 
 { 
   get  {  return rank;  } 
 } 
   
  public virtual System.String display()                   // строковое представление карты 
 {             
   return rank.ToString() + suit.ToString(); 
 } 
} 
/*****************************************************************************************************/
public class Deck                                                                                                 
 { 
  private System.Collections.ArrayList deck;             // динамический массив 
   
  public Deck() 
 {        
  buildCards();                    
 } 
 
  public virtual Card get_Renamed(int index) 
 { 
   if (index < deck.Count)               // Count – это свойство класса ArrayList 
  {                               // deck[index] – это элемент массива 
    return (Card) deck[index]; 
 
  } 
   return null; 
 } 
   
  public virtual void  replace(int index, Card card)                     // перестановка карт 
 { 
  deck[index] = card; 
 } 
   
  public virtual int size() 
 { 
   return deck.Count;              // Count – это свойство класса ArrayList 
 } 
   
  public virtual Card removeFromFront()                      // метод – извлечение карты 
 { 
   if (deck.Count > 0)              // Count – это свойство класса ArrayList 
  { 
   System.Object tempObject; 
   tempObject = deck[0]; 
   deck.RemoveAt(0);                // RemoveAt – это м-д класса ArrayList 
    Card card = (Card) tempObject; 
    return card; 
  } 
   return null; 
 } 
   
  public virtual void  returnToBack(Card card)   // метод – возврат карты 
 { 
  deck.Add(card);                           // Add – это м-д класса ArrayList 
 } 
  private void  buildCards()              
  {                               // создание колоды карт 
// объект deck класса ArrayList()- динамический массив 
  deck = new System.Collections.ArrayList();    
   
   for (int i = 0; i < Suit.SUIT.Length; i++)                
  { 
    for (int j = 0; j < Rank.RANK.Length; j++)  
   {      // Add – это м-д класса ArrayList              
  deck.Add(new Card(Suit.SUIT[i], Rank.RANK[j])); 
   } 
  } 
  } 
 } 
/*****************************************************************************************************/
 public class Dealer                                                                                                            //Листинг 3а
  { 
  private Deck deck;                          // прямой доступ к колоде закрыт 
 
public Dealer(Deck d) 
 { 
  deck = d; 
 } 
 
public virtual void  shuffle()             // этот метод перетасовывает карты 
 { 
   // расположить карты случайным образом 
   int num_cards = deck.size();                         
   for (int i = 0; i < num_cards; i++) 
  {                                              // NextDouble() – м-д класса Random 
      int index = (int)(SupportClass.Random.NextDouble() * num_cards);
    Card card_i = (Card) deck.get_Renamed(i); 
    Card card_index = (Card) deck.get_Renamed(index);  
    deck.replace(i, card_index);                       
    deck.replace(index, card_i); 
  } 
 } 
 public virtual Card dealCard()                 // метод раздачи карт не используетс
 { 
   if (deck.size() > 0) 
  { 
    return deck.removeFromFront(); 
  } 
   return null; 
 } 
public class SupportClass 
{ 
   // обеспечивается доступ к статической переменной Random 
   static public System.Random Random = new System.Random(); 
}  
} 
 
/*****************************************************************************************************/
public class CardDriver 
 { 
  public static void  Main( String[ ] args) 
 { 
    Deck   deck   =  new Deck(); // объект  deck - колода карт  
    Dealer dealer = new Dealer(deck);  // колода карт передается дилеру 
    Console.WriteLine("\n Упорядоченной колоды карт");  
    printDeck(deck); // распечатать упорядоченную колоду карт
   
    dealer.shuffle();           // перетасовать колоду карт 
   
    Console.WriteLine("\n Перетасованной колоды карт");   
    printDeck(deck); // распечатать перетасованную  колоды карт 
    Console.ReadLine(); 
 } 
   
  public static void  printDeck(Deck deck) // метод – печать массива карт 
 { 
             for (int i = 0; i < 4; i++) // четыре масти  
  { 
    for (int j = 0; j < 9; j++) // карты 9-ти достоинств от 6 до туза
   { 
     Card card = deck.removeFromFront(); 
     deck.returnToBack(card);                       
     Console.Write(card.display() + "\t ");      
   } 
    Console.WriteLine(" "); 
  } 
 } 
 } 
}