исправление ошибок

using System;
using System.Collections.Generic;
 
namespace Demo
{
    // Состояние игры
    public enum GameResult { Win = 1, Lose = -1, Draw = 0, Pending = 2 };
 
    /// <summary>
    /// Вот  карта
    /// </summary>
    public class Card
    {
        public string ID { get; set; }
        public string Suit { get; set; }
        public int Value { get; set; }
 
        public Card(string id, string suit, int value)
        {
            ID = id;
            Suit = suit;
            Value = value;
            
        }
    }
 
    /// <summary>
    /// колода может быть просто стопкой карт
    /// </summary>
    public class Deck : Stack<Card>
    {
        public Deck(IEnumerable<Card> collection) : base(collection) { }
        public Deck() : base(52) { }
 
 
        public Card this[int index]
        {
            get
            {
                Card item;
 
                if (index >= 0 && index <= this.Count - 1)
                {
                    item = this.ToArray()[index];
                }
                else
                {
 
                    item = null;
 
 
                }
                return item;
            }
        }
 
        public double Value
        {
            get
            {
 
                return BlackJackRules.HandValue(this);
            }
        }
    }
 
    /// <summary>
    /// то что представляет игроков (Player & Dealer)
    /// </summary>
 
 
    public class Member
    {
        public Deck Hand;
 
        public Member()
        {
            Hand = new Deck();
        }
    }
    /// <summary>
    /// представление правил игры
    /// </summary>
    public static class BlackJackRules
    {
        //значение карт
        public static string[] ids = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "A", "J", "K", "Q" };
 
 
        // Масти карты
        public static string[] suits = { "C", "D", "H", "S" };
 
        /// <summary>
        /// возвращает новую колоду
        /// </summary>
        public static Deck NewDeck
        {
            get
            {
                Deck d = new Deck();
                int value;
 
                foreach (string suit in suits)
                {
                    foreach (string id in ids)
                    {
                        value = Int32.TryParse(id, out value) ? value : id == "A" ? 1 : 10;
                        d.Push(new Card(id, suit, value));
                    }
                }
                return d;
            }
        }
        /// <summary>
        /// возврвщвет перетасованую колоду
        /// </summary>
 
        public static Deck ShuffledDeck
        {
            get
            {
                return new Deck(NewDeck.OrderBy(Card => System.Guid.NewGuid()).ToArray());
            }
        }
 
        /// <summary>
        /// вычесляет значение руки.
        /// В руке находитса всего пара карт так мы можем представить колоду.
        /// Сравнил два итога для тузов и вернул то которое ближе или равно 21
        /// </summary>
        /// <param name="deck"></param>
        /// <returns></returns>
        public static double HandValue(Deck deck)
        {
            //Туз = 1
            int val1 = deck.Sum(c => c.ValueType);
 
            //Туз = 11
            double aces = deck.Count(c => c.Suit == "A");
            double val2 = aces > 0 ? val1 + (10 * aces) : val1;
 
            return new double[] { val1, val2 }
                .Select(handVal => new
                {
                    handVal,
                    weight = Math.Abs(handVal - 21) + (handVal > 21 ? 100 :
                    0)
                })
                    .OrderBy(n => n.weight)
                        .First().handVal;
 
        }
 
        // Еще пара правил
 
        /// <summary>
        /// Проверяет может ли дилер побить имеющююся руку
        /// </summary>
        /// <param name="deck"></param>
        /// <param name="standLimit"></param>
        /// <returns></returns>
        public static bool CanDealerHit(Deck deck, int standLimit)
        {
            return deck.Value < standLimit;
        }
 
        /// <summary>
        /// Нет смысла бить выше 21
        /// </summary>
        /// <param name="deck"></param>
        /// <returns></returns>
 
        public static bool CanPlayerHit(Deck deck)
        {
            return deck.Value < 21;
        }
 
        /// <summary>
        /// возвращает статистику игры win, lose or draw
        /// </summary>
        /// <param name="player"></param>
        /// <param name="dealer"></param>
        /// <returns></returns>
 
        public static GameResult GetResult(Member player, Member dealer)
        {
            GameResult res = GameResult.Win;
 
            double playerValue = HandValue(player.Hand);
            double dealerValue = HandValue(dealer.Hand);
 
            // игрок может быть победителем если...
            if(playerValue <=21)
            {
                //и
                if(playerValue !=dealerValue)
                {
                    double closestValue = new double[]{playerValue, dealerValue}
                        .Select(handVal => new {handVal, weight = Math.Abs(handVal-21) + (handVal >21
                            ? 100 : 0)})
                            .OrderBy(n=>n.weight)
                            .First().handVal;
 
                    res = playerValue == closestValue ? GameResult.Win : GameResult.Lose;
                }
                else
                {
                    res = GameResult.Draw;
                }
            }
            else 
            {
                res = GameResult.Lose;
            }
            return res;
 
    }
 
        public class BlackJack
        {
            public Member Dealer = new Member();
            public Member Player = new Member();
            public GameResult Result { get; set; }
 
            public Deck MainDeck;
 
            public int StandLimit { get; set; }
 
            public BlackJack(int dealerStandLimit)
            {
                // настроика игры Black Jack
 
                Result = GameResult.Pending;
 
                StandLimit = dealerStandLimit;
 
                // Положить новую перетасованую колоду на стол
                MainDeck = BlackJackRules.ShuffledDeck;
 
                // Очистить руку Player & Dealer.
                Dealer.Hand.Clear();
                Player.Hand.Clear();
 
                // Выдать первые 2 карты Player & Dealer
                for (int i = 0; ++i < 3; )
                {
                    Dealer.Hand.Push(MainDeck.Pop());
                    Player.Hand.Push(MainDeck.Pop());
 
                }
            }
            /// <summary>
            /// позволяет игроку отбить. Дилер автомотически отбивает когда игрок бездействует.
            /// </summary>
 
            public void Hit()
            {
                if (BlackJackRules.CanPlayerHit(Player.Hand) && Result == GameResult.Pending)
                {
                    Player.Hand.Push(MainDeck.Pop());
                }
            }
 
            /// <summary>
            /// Когда игрок закончил брать карты позваляет дилеру брать карты пока лимит не будет исчерпан.
            /// Затем продолжить и установить результат игры.
            /// </summary>
            public void Stand()
            {
                if (Result == GameResult.Pending)
                {
                    while (BlackJackRules.CanDealerHit(Dealer.Hand, StandLimit))
                    {
                        Dealer.Hand.Push(MainDeck.Pop());
                    }
 
                    Result = BlackJackRules.GetResult(Player, Dealer);
                }
            }
        }
 
        public class Program
        {
            public static void ShowStats(BlackJack bj)
            {
                foreach (Card c in bj.Dealer.Hand)
                {
                    Console.WriteLine(string.Format("{0}{1}", c.ID, c.Suit));
 
                }
                Console.WriteLine(bj.Dealer.Hand.Value);
 
                Console.WriteLine(Environment.NewLine);
 
                foreach (Card c in bj.Player.Hand)
                {
                    Console.WriteLine(string.Format("{0}{1}", c.ID, c.Suit));
                }
 
                Console.WriteLine(bj.Player.Hand.Value);
 
                Console.WriteLine(Environment.NewLine);
 
            }
            public static void Main()
            {
                string input = "";
 
                BlackJack bj = new BlackJack(17);
 
                ShowStats(bj);
 
                while (bj.Result == GameResult.Pending)
                {
                    input = Console.ReadLine();
 
                    if (input.ToLower() == "h")
                    {
                        bj.Hit();
                        ShowStats(bj);
                    }
                    else
                    {
                        bj.Stand();
                        ShowStats(bj);
                    }
 
                }
 
                Console.WriteLine(bj.Result);
                Console.ReadLine();
            }
        }
    }
}

using System.Linq;