Return to Answer

• Player is a simple enum:

    enum Player {
        X,
        O
    }
  

• IBoard represents a board with an indexer by row and column and Size.

    interface IBoard
    {
        int Size { get; }
        Player? this [int row, int column] { get; set; }
    }
  

  (really, you don't need anything else in IBoard)

• IBoardAnalyzer has a single method that scans the board to find the winner, similarly to yours:

    interface IBoardAnalyzer
    {
        Player? DetermineWinner (IBoard board);
    }
  

• All the actual heavy-lifting for scanning the board lives in BoardExtensions that can enumerate board rows, columns and diagonals. There is also an über-method called SelectAllLines that returns a sequence of all “lines” (rows, columns and diagonals) on the board. Note that BoardExtensions does no analysis; it only provides convenience methods for extracting data out of Board.

    static class BoardExtensions
    {
        public enum DiagonalKind {
            Primary,
            Secondary
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllLines (this IBoard board)
        {
            return board.SelectAllDiagonals ()
                .Concat (board.SelectAllRows ())
                .Concat (board.SelectAllColumns ());
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllRows (this IBoard board)
        {
            return from row in board.SelectIndices ()
                   select board.SelectRow (row);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllColumns (this IBoard board)
        {
            return from column in board.SelectIndices ()
                   select board.SelectColumn (column);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllDiagonals (this IBoard board)
        {
            return from kind in new [] { DiagonalKind.Primary, DiagonalKind.Secondary }
                   select board.SelectDiagonal (kind);
        }
  
        public static IEnumerable<Player?> SelectRow (this IBoard board, int row)
        {
            return from column in board.SelectIndices ()
                   select board [row, column];
        }
  
        public static IEnumerable<Player?> SelectColumn (this IBoard board, int column)
        {
            return from row in board.SelectIndices ()
                   select board [row, column];
        }
  
        public static IEnumerable<Player?> SelectDiagonal (this IBoard board, DiagonalKind kind)
        {
            return from index in board.SelectIndices ()
                   let row = index
                   let column = (kind == DiagonalKind.Primary)
                       ? index
                       : board.Size - 1 - index
                   select board [row, column];
        }
  
        public static IEnumerable<int> SelectIndices (this IBoard board)
        {
            return Enumerable.Range (0, board.Size);
        }
    }
  

• The implementation for BoardAnalyzer uses BoardExtensions to find the winner, but in itself is trivial:

    class BoardAnalyzer : IBoardAnalyzer
    {
        public Player? DetermineWinner (IBoard board)
        {
            return (
                from line in board.SelectAllLines ()
                let winner = DetermineLineWinner (line)
                where winner.HasValue
                select winner
            ).FirstOrDefault ();
        }
  
        static Player? DetermineLineWinner (IEnumerable<Player?> line)
        {
            try {
                return line.Distinct ().Single ();
            } catch (InvalidOperationException) {
                return null;
            }
        }
    }
  

• Finally, I implemented an IO which has a simple interface:

    interface IGameIO
    {
        Tuple<int, int> AskNextMove (Player player, IBoard board);
        void DisplayError (GameError error);
        void DisplayWinner (Player player);
    }
  

• And just as simple implementation:

    class ConsoleGameIO : IGameIO
    {
        public Tuple<int, int> AskNextMove (Player player, IBoard board)
        {
            Console.WriteLine ("\n\n");
            Console.WriteLine ("{0}, what is your move?\n", FormatPlayer (player));
            Console.WriteLine (FormatBoard (board));
            Console.Write ("\nType A1 to C3: ", FormatPlayer (player));
  
            return ParseMove (Console.ReadLine ().Trim ().ToUpperInvariant ());
        }
  
        public void DisplayError (GameError error)
        {
            switch (error) {
            case GameError.CellAlreadyOccupied:
                Console.WriteLine ("Bad move: cell is already occupied.");
                break;
            case GameError.CouldNotParseMove:
                Console.WriteLine ("Bad move. Valid moves are A1 to C3.");
                break;
            default:
                Console.WriteLine ("Something went wrong.");
                break;
            }
        }
  
        public void DisplayWinner (Player player)
        {
            Console.WriteLine ("Congatulations, {0}! You won.", FormatPlayer (player));
        }
  
        static string FormatBoard (IBoard board)
        {
            return string.Join ("\n", from row in board.SelectAllRows () select FormatRow (row));
        }
  
        static string FormatRow (IEnumerable<Player?> row)
        {
            return string.Join ("|", from cell in row select FormatCell (cell));
        }
  
        static string FormatPlayer (Player player)
        {
            return FormatCell (player);
        }
  
        static string FormatCell (Player? cell)
        {
            return cell.HasValue ? cell.Value.ToString () : "_";
        }
  
        static Tuple<int, int> ParseMove (string input)
        {
            return Tuple.Create (
                input [0] - 'A',
                input [1] - '1'
            );
        }
    }
  

• Finally, there goes the Game class with the run loop and Main method:

    class Game
    {
        IBoard board;
        IBoardAnalyzer analyzer;
        IGameIO io;
  
        public Game (IBoard board, IBoardAnalyzer analyzer, IGameIO io)
        {
            this.board = board;
            this.analyzer = analyzer;
            this.io = io;
        }
  
        public void Run ()
        {
            Player player = Player.X;
            Player? winner = null;
  
            do {
                Tuple<int, int> move;
                try {
                    move = io.AskNextMove (player, board);
                } catch {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                if (!ValidateMove (move)) {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                try {
                    board [move.Item1, move.Item2] = player;
                } catch (InvalidOperationException) {
                    io.DisplayError (GameError.CellAlreadyOccupied);
                    continue;
                }
  
                player = GetNextPlayer (player);
                winner = analyzer.DetermineWinner (board);
  
            } while (!winner.HasValue);
  
            io.DisplayWinner (winner.Value);
        }
  
        bool ValidateMove (Tuple<int, int> move)
        {
            return (move.Item1 >= 0 && move.Item1 < board.Size)
                && (move.Item2 >= 0 && move.Item2 < board.Size);
        }
  
        static Player GetNextPlayer (Player player)
        {
            switch (player) {
            case Player.X:
                return Player.O;
            case Player.O:
                return Player.X;
            default:
                throw new NotImplementedException ();
            }
        }
  
        public static void Main (string[] args)
        {
            var game = new Game (new Board (3), new BoardAnalyzer (), new ConsoleGameIO ());
            game.Run ();
        }
    }
  

• Player is a simple enum:

    enum Player {
        X,
        O
    }
  

• IBoard represents a board with an indexer by row and column and Size.

    interface IBoard
    {
        int Size { get; }
        Player? this [int row, int column] { get; set; }
    }
  

  (really, you don't need anything else in IBoard)

• The implementation is trivial:

    class Board : IBoard
    {
        Player? [,] _cells;
  
        public int Size {
            get { return _cells.GetLength (0); }
        }
  
        public Board (int size)
        {
            _cells = new Player? [size, size];
        }
  
        public Player? this [int row, int column] {
            get {
                return _cells [row, column];
            } set {
                if (_cells [row, column].HasValue)
                    throw new InvalidOperationException ("The cell is already claimed.");
  
                _cells [row, column] = value;
            }
        }
    }
  

• IBoardAnalyzer has a single method that scans the board to find the winner, similarly to yours:

    interface IBoardAnalyzer
    {
        Player? DetermineWinner (IBoard board);
    }
  

• All the actual heavy-lifting for scanning the board lives in BoardExtensions that can enumerate board rows, columns and diagonals. There is also an über-method called SelectAllLines that returns a sequence of all “lines” (rows, columns and diagonals) on the board. Note that BoardExtensions does no analysis; it only provides convenience methods for extracting data out of Board.

    static class BoardExtensions
    {
        public enum DiagonalKind {
            Primary,
            Secondary
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllLines (this IBoard board)
        {
            return board.SelectAllDiagonals ()
                .Concat (board.SelectAllRows ())
                .Concat (board.SelectAllColumns ());
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllRows (this IBoard board)
        {
            return from row in board.SelectIndices ()
                   select board.SelectRow (row);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllColumns (this IBoard board)
        {
            return from column in board.SelectIndices ()
                   select board.SelectColumn (column);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllDiagonals (this IBoard board)
        {
            return from kind in new [] { DiagonalKind.Primary, DiagonalKind.Secondary }
                   select board.SelectDiagonal (kind);
        }
  
        public static IEnumerable<Player?> SelectRow (this IBoard board, int row)
        {
            return from column in board.SelectIndices ()
                   select board [row, column];
        }
  
        public static IEnumerable<Player?> SelectColumn (this IBoard board, int column)
        {
            return from row in board.SelectIndices ()
                   select board [row, column];
        }
  
        public static IEnumerable<Player?> SelectDiagonal (this IBoard board, DiagonalKind kind)
        {
            return from index in board.SelectIndices ()
                   let row = index
                   let column = (kind == DiagonalKind.Primary)
                       ? index
                       : board.Size - 1 - index
                   select board [row, column];
        }
  
        public static IEnumerable<int> SelectIndices (this IBoard board)
        {
            return Enumerable.Range (0, board.Size);
        }
    }
  

• The implementation for BoardAnalyzer uses BoardExtensions to find the winner, but in itself is trivial:

    class BoardAnalyzer : IBoardAnalyzer
    {
        public Player? DetermineWinner (IBoard board)
        {
            return (
                from line in board.SelectAllLines ()
                let winner = DetermineLineWinner (line)
                where winner.HasValue
                select winner
            ).FirstOrDefault ();
        }
  
        static Player? DetermineLineWinner (IEnumerable<Player?> line)
        {
            try {
                return line.Distinct ().Single ();
            } catch (InvalidOperationException) {
                return null;
            }
        }
    }
  

• Finally, I implemented an IO which has a simple interface:

    interface IGameIO
    {
        Tuple<int, int> AskNextMove (Player player, IBoard board);
        void DisplayError (GameError error);
        void DisplayWinner (Player player);
    }
  

• And just as simple implementation:

    class ConsoleGameIO : IGameIO
    {
        public Tuple<int, int> AskNextMove (Player player, IBoard board)
        {
            Console.WriteLine ("\n\n");
            Console.WriteLine ("{0}, what is your move?\n", FormatPlayer (player));
            Console.WriteLine (FormatBoard (board));
            Console.Write ("\nType A1 to C3: ", FormatPlayer (player));
  
            return ParseMove (Console.ReadLine ().Trim ().ToUpperInvariant ());
        }
  
        public void DisplayError (GameError error)
        {
            switch (error) {
            case GameError.CellAlreadyOccupied:
                Console.WriteLine ("Bad move: cell is already occupied.");
                break;
            case GameError.CouldNotParseMove:
                Console.WriteLine ("Bad move. Valid moves are A1 to C3.");
                break;
            default:
                Console.WriteLine ("Something went wrong.");
                break;
            }
        }
  
        public void DisplayWinner (Player player)
        {
            Console.WriteLine ("Congatulations, {0}! You won.", FormatPlayer (player));
        }
  
        static string FormatBoard (IBoard board)
        {
            return string.Join ("\n", from row in board.SelectAllRows () select FormatRow (row));
        }
  
        static string FormatRow (IEnumerable<Player?> row)
        {
            return string.Join ("|", from cell in row select FormatCell (cell));
        }
  
        static string FormatPlayer (Player player)
        {
            return FormatCell (player);
        }
  
        static string FormatCell (Player? cell)
        {
            return cell.HasValue ? cell.Value.ToString () : "_";
        }
  
        static Tuple<int, int> ParseMove (string input)
        {
            return Tuple.Create (
                input [0] - 'A',
                input [1] - '1'
            );
        }
    }
  

• Finally, there goes the Game class with the run loop and Main method:

    class Game
    {
        IBoard board;
        IBoardAnalyzer analyzer;
        IGameIO io;
  
        public Game (IBoard board, IBoardAnalyzer analyzer, IGameIO io)
        {
            this.board = board;
            this.analyzer = analyzer;
            this.io = io;
        }
  
        public void Run ()
        {
            Player player = Player.X;
            Player? winner = null;
  
            do {
                Tuple<int, int> move;
                try {
                    move = io.AskNextMove (player, board);
                } catch {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                if (!ValidateMove (move)) {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                try {
                    board [move.Item1, move.Item2] = player;
                } catch (InvalidOperationException) {
                    io.DisplayError (GameError.CellAlreadyOccupied);
                    continue;
                }
  
                player = GetNextPlayer (player);
                winner = analyzer.DetermineWinner (board);
  
            } while (!winner.HasValue);
  
            io.DisplayWinner (winner.Value);
        }
  
        bool ValidateMove (Tuple<int, int> move)
        {
            return (move.Item1 >= 0 && move.Item1 < board.Size)
                && (move.Item2 >= 0 && move.Item2 < board.Size);
        }
  
        static Player GetNextPlayer (Player player)
        {
            switch (player) {
            case Player.X:
                return Player.O;
            case Player.O:
                return Player.X;
            default:
                throw new NotImplementedException ();
            }
        }
  
        public static void Main (string[] args)
        {
            var game = new Game (new Board (3), new BoardAnalyzer (), new ConsoleGameIO ());
            game.Run ();
        }
    }
  

• Player is a simple enum:

    enum Player {
        X,
        O
    }
  

• IBoard represents a board with GetCell, SetCell and Size.

    interface IBoard
    {
        int Size { get; }
        Player? GetCell (int row, int column);
        void SetCell (int row, int column, Player player);
    }
  

  (really, you don't need anything else in IBoard)

• IBoardAnalyzer has a single method that scans the board to find the winner, similarly to yours:

    interface IBoardAnalyzer
    {
        Player? DetermineWinner (IBoard board);
    }
  

• All the actual heavy-lifting for scanning the board lives in BoardExtensions that can enumerate board rows, columns and diagonals. There is also an über-method called SelectAllLines that returns a sequence of all “lines” (rows, columns and diagonals) on the board. Note that BoardExtensions does no analysis; it only provides convenience methods for extracting data out of Board.

    static class BoardExtensions
    {
        public enum DiagonalKind {
            Primary,
            Secondary
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllLines (this IBoard board)
        {
            return board.SelectAllDiagonals ()
                .Concat (board.SelectAllRows ())
                .Concat (board.SelectAllColumns ());
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllRows (this IBoard board)
        {
            return from row in board.SelectIndices ()
                   select board.SelectRow (row);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllColumns (this IBoard board)
        {
            return from column in board.SelectIndices ()
                   select board.SelectColumn (column);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllDiagonals (this IBoard board)
        {
            return from kind in new [] { DiagonalKind.Primary, DiagonalKind.Secondary }
                   select board.SelectDiagonal (kind);
        }
  
        public static IEnumerable<Player?> SelectRow (this IBoard board, int row)
        {
            return from column in board.SelectIndices ()
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<Player?> SelectColumn (this IBoard board, int column)
        {
            return from row in board.SelectIndices ()
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<Player?> SelectDiagonal (this IBoard board, DiagonalKind kind)
        {
            return from index in board.SelectIndices ()
                   let row = index
                   let column = (kind == DiagonalKind.Primary)
                       ? index
                       : board.Size - 1 - index
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<int> SelectIndices (this IBoard board)
        {
            return Enumerable.Range (0, board.Size);
        }
    }
  

• The implementation for BoardAnalyzer uses BoardExtensions to find the winner, but in itself is trivial:

    class BoardAnalyzer : IBoardAnalyzer
    {
        public Player? DetermineWinner (IBoard board)
        {
            return (
                from line in board.SelectAllLines ()
                let winner = DetermineLineWinner (line)
                where winner.HasValue
                select winner
            ).FirstOrDefault ();
        }
  
        static Player? DetermineLineWinner (IEnumerable<Player?> line)
        {
            try {
                return line.Distinct ().Single ();
            } catch (InvalidOperationException) {
                return null;
            }
        }
    }
  

• Finally, I implemented an IO which has a simple interface:

    interface IGameIO
    {
        Tuple<int, int> AskNextMove (Player player, IBoard board);
        void DisplayError (GameError error);
        void DisplayWinner (Player player);
    }
  

• And just as simple implementation:

    class ConsoleGameIO : IGameIO
    {
        public Tuple<int, int> AskNextMove (Player player, IBoard board)
        {
            Console.WriteLine ("\n\n");
            Console.WriteLine ("{0}, what is your move?\n", FormatPlayer (player));
            Console.WriteLine (FormatBoard (board));
            Console.Write ("\nType A1 to C3: ", FormatPlayer (player));
  
            return ParseMove (Console.ReadLine ().Trim ().ToUpperInvariant ());
        }
  
        public void DisplayError (GameError error)
        {
            switch (error) {
            case GameError.CellAlreadyOccupied:
                Console.WriteLine ("Bad move: cell is already occupied.");
                break;
            case GameError.CouldNotParseMove:
                Console.WriteLine ("Bad move. Valid moves are A1 to C3.");
                break;
            default:
                Console.WriteLine ("Something went wrong.");
                break;
            }
        }
  
        public void DisplayWinner (Player player)
        {
            Console.WriteLine ("Congatulations, {0}! You won.", FormatPlayer (player));
        }
  
        static string FormatBoard (IBoard board)
        {
            return string.Join ("\n", from row in board.SelectAllRows () select FormatRow (row));
        }
  
        static string FormatRow (IEnumerable<Player?> row)
        {
            return string.Join ("|", from cell in row select FormatCell (cell));
        }
  
        static string FormatPlayer (Player player)
        {
            return FormatCell (player);
        }
  
        static string FormatCell (Player? cell)
        {
            return cell.HasValue ? cell.Value.ToString () : "_";
        }
  
        static Tuple<int, int> ParseMove (string input)
        {
            return Tuple.Create (
                input [0] - 'A',
                input [1] - '1'
            );
        }
    }
  

• Finally, there goes the Game class with the run loop and Main method:

    class Game
    {
        IBoard board;
        IBoardAnalyzer analyzer;
        IGameIO io;
  
        public Game (IBoard board, IBoardAnalyzer analyzer, IGameIO io)
        {
            this.board = board;
            this.analyzer = analyzer;
            this.io = io;
        }
  
        public void Run ()
        {
            Player player = Player.X;
            Player? winner = null;
  
            do {
                Tuple<int, int> move;
                try {
                    move = io.AskNextMove (player, board);
                } catch {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                if (!ValidateMove (move)) {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                try {
                    board.SetCell (move.Item1, move.Item2, player);
                } catch (InvalidOperationException) {
                    io.DisplayError (GameError.CellAlreadyOccupied);
                    continue;
                }
  
                player = GetNextPlayer (player);
                winner = analyzer.DetermineWinner (board);
  
            } while (!winner.HasValue);
  
            io.DisplayWinner (winner.Value);
        }
  
        bool ValidateMove (Tuple<int, int> move)
        {
            return (move.Item1 >= 0 && move.Item1 < board.Size)
                && (move.Item2 >= 0 && move.Item2 < board.Size);
        }
  
        static Player GetNextPlayer (Player player)
        {
            switch (player) {
            case Player.X:
                return Player.O;
            case Player.O:
                return Player.X;
            default:
                throw new NotImplementedException ();
            }
        }
  
        public static void Main (string[] args)
        {
            var game = new Game (new Board (3), new BoardAnalyzer (), new ConsoleGameIO ());
            game.Run ();
        }
    }
  

• Player is a simple enum:

    enum Player {
        X,
        O
    }
  

• IBoard represents a board with an indexer by row and column and Size.

    interface IBoard
    {
        int Size { get; }
        Player? this [int row, int column] { get; set; }
    }
  

  (really, you don't need anything else in IBoard)

• IBoardAnalyzer has a single method that scans the board to find the winner, similarly to yours:

    interface IBoardAnalyzer
    {
        Player? DetermineWinner (IBoard board);
    }
  

• All the actual heavy-lifting for scanning the board lives in BoardExtensions that can enumerate board rows, columns and diagonals. There is also an über-method called SelectAllLines that returns a sequence of all “lines” (rows, columns and diagonals) on the board. Note that BoardExtensions does no analysis; it only provides convenience methods for extracting data out of Board.

    static class BoardExtensions
    {
        public enum DiagonalKind {
            Primary,
            Secondary
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllLines (this IBoard board)
        {
            return board.SelectAllDiagonals ()
                .Concat (board.SelectAllRows ())
                .Concat (board.SelectAllColumns ());
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllRows (this IBoard board)
        {
            return from row in board.SelectIndices ()
                   select board.SelectRow (row);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllColumns (this IBoard board)
        {
            return from column in board.SelectIndices ()
                   select board.SelectColumn (column);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllDiagonals (this IBoard board)
        {
            return from kind in new [] { DiagonalKind.Primary, DiagonalKind.Secondary }
                   select board.SelectDiagonal (kind);
        }
  
        public static IEnumerable<Player?> SelectRow (this IBoard board, int row)
        {
            return from column in board.SelectIndices ()
                   select board [row, column];
        }
  
        public static IEnumerable<Player?> SelectColumn (this IBoard board, int column)
        {
            return from row in board.SelectIndices ()
                   select board [row, column];
        }
  
        public static IEnumerable<Player?> SelectDiagonal (this IBoard board, DiagonalKind kind)
        {
            return from index in board.SelectIndices ()
                   let row = index
                   let column = (kind == DiagonalKind.Primary)
                       ? index
                       : board.Size - 1 - index
                   select board [row, column];
        }
  
        public static IEnumerable<int> SelectIndices (this IBoard board)
        {
            return Enumerable.Range (0, board.Size);
        }
    }
  

• The implementation for BoardAnalyzer uses BoardExtensions to find the winner, but in itself is trivial:

    class BoardAnalyzer : IBoardAnalyzer
    {
        public Player? DetermineWinner (IBoard board)
        {
            return (
                from line in board.SelectAllLines ()
                let winner = DetermineLineWinner (line)
                where winner.HasValue
                select winner
            ).FirstOrDefault ();
        }
  
        static Player? DetermineLineWinner (IEnumerable<Player?> line)
        {
            try {
                return line.Distinct ().Single ();
            } catch (InvalidOperationException) {
                return null;
            }
        }
    }
  

• Finally, I implemented an IO which has a simple interface:

    interface IGameIO
    {
        Tuple<int, int> AskNextMove (Player player, IBoard board);
        void DisplayError (GameError error);
        void DisplayWinner (Player player);
    }
  

• And just as simple implementation:

    class ConsoleGameIO : IGameIO
    {
        public Tuple<int, int> AskNextMove (Player player, IBoard board)
        {
            Console.WriteLine ("\n\n");
            Console.WriteLine ("{0}, what is your move?\n", FormatPlayer (player));
            Console.WriteLine (FormatBoard (board));
            Console.Write ("\nType A1 to C3: ", FormatPlayer (player));
  
            return ParseMove (Console.ReadLine ().Trim ().ToUpperInvariant ());
        }
  
        public void DisplayError (GameError error)
        {
            switch (error) {
            case GameError.CellAlreadyOccupied:
                Console.WriteLine ("Bad move: cell is already occupied.");
                break;
            case GameError.CouldNotParseMove:
                Console.WriteLine ("Bad move. Valid moves are A1 to C3.");
                break;
            default:
                Console.WriteLine ("Something went wrong.");
                break;
            }
        }
  
        public void DisplayWinner (Player player)
        {
            Console.WriteLine ("Congatulations, {0}! You won.", FormatPlayer (player));
        }
  
        static string FormatBoard (IBoard board)
        {
            return string.Join ("\n", from row in board.SelectAllRows () select FormatRow (row));
        }
  
        static string FormatRow (IEnumerable<Player?> row)
        {
            return string.Join ("|", from cell in row select FormatCell (cell));
        }
  
        static string FormatPlayer (Player player)
        {
            return FormatCell (player);
        }
  
        static string FormatCell (Player? cell)
        {
            return cell.HasValue ? cell.Value.ToString () : "_";
        }
  
        static Tuple<int, int> ParseMove (string input)
        {
            return Tuple.Create (
                input [0] - 'A',
                input [1] - '1'
            );
        }
    }
  

• Finally, there goes the Game class with the run loop and Main method:

    class Game
    {
        IBoard board;
        IBoardAnalyzer analyzer;
        IGameIO io;
  
        public Game (IBoard board, IBoardAnalyzer analyzer, IGameIO io)
        {
            this.board = board;
            this.analyzer = analyzer;
            this.io = io;
        }
  
        public void Run ()
        {
            Player player = Player.X;
            Player? winner = null;
  
            do {
                Tuple<int, int> move;
                try {
                    move = io.AskNextMove (player, board);
                } catch {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                if (!ValidateMove (move)) {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                try {
                    board [move.Item1, move.Item2] = player;
                } catch (InvalidOperationException) {
                    io.DisplayError (GameError.CellAlreadyOccupied);
                    continue;
                }
  
                player = GetNextPlayer (player);
                winner = analyzer.DetermineWinner (board);
  
            } while (!winner.HasValue);
  
            io.DisplayWinner (winner.Value);
        }
  
        bool ValidateMove (Tuple<int, int> move)
        {
            return (move.Item1 >= 0 && move.Item1 < board.Size)
                && (move.Item2 >= 0 && move.Item2 < board.Size);
        }
  
        static Player GetNextPlayer (Player player)
        {
            switch (player) {
            case Player.X:
                return Player.O;
            case Player.O:
                return Player.X;
            default:
                throw new NotImplementedException ();
            }
        }
  
        public static void Main (string[] args)
        {
            var game = new Game (new Board (3), new BoardAnalyzer (), new ConsoleGameIO ());
            game.Run ();
        }
    }
  

I re-wrote my earlier toy Tic Tac Toe implementation specifically to address your question, with the following separation:

• Player is a simple enum:

    enum Player {
        X,
        O
    }
  

• IBoard represents a board with GetCell, SetCell and Size.

    interface IBoard
    {
        int Size { get; }
        Player? GetCell (int row, int column);
        void SetCell (int row, int column, Player player);
    }
  

  (really, you don't need anything else in IBoard)

• IBoardAnalyzer has a single method that scans the board to find the winner, similarly to yours:

    interface IBoardAnalyzer
    {
        Player? DetermineWinner (IBoard board);
    }
  

• All the actual heavy-lifting for scanning the board lives in BoardExtensions that can enumerate board rows, columns and diagonals. There is also an über-method called SelectAllLines that returns a sequence of all “lines” (rows, columns and diagonals) on the board. Note that BoardExtensions does no analysis; it only provides convenience methods for extracting data out of Board.

    static class BoardExtensions
    {
        public enum DiagonalKind {
            Primary,
            Secondary
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllLines (this IBoard board)
        {
            return board.SelectAllDiagonals ()
                .Concat (board.SelectAllRows ())
                .Concat (board.SelectAllColumns ());
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllRows (this IBoard board)
        {
            return from row in board.SelectIndices ()
                   select board.SelectRow (row);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllColumns (this IBoard board)
        {
            return from column in board.SelectIndices ()
                   select board.SelectColumn (column);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllDiagonals (this IBoard board)
        {
            return from kind in new [] { DiagonalKind.Primary, DiagonalKind.Secondary }
                   select board.SelectDiagonal (kind);
        }
  
        public static IEnumerable<Player?> SelectRow (this IBoard board, int row)
        {
            return from column in board.SelectIndices ()
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<Player?> SelectColumn (this IBoard board, int column)
        {
            return from row in board.SelectIndices ()
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<Player?> SelectDiagonal (this IBoard board, DiagonalKind kind)
        {
            return from index in board.SelectIndices ()
                   let row = index
                   let column = (kind == DiagonalKind.Primary)
                       ? index
                       : board.Size - 1 - index
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<int> SelectIndices (this IBoard board)
        {
            return Enumerable.Range (0, board.Size);
        }
    }
  

• The implementation for BoardAnalyzer uses BoardExtensions to find the winner, but in itself is trivial:

    class BoardAnalyzer : IBoardAnalyzer
    {
        public Player? DetermineWinner (IBoard board)
        {
            return (
                from line in board.SelectAllLines ()
                let winner = DetermineLineWinner (line)
                where winner.HasValue
                select winner
            ).FirstOrDefault ();
        }
  
        static Player? DetermineLineWinner (IEnumerable<Player?> line)
        {
            try {
                return line.Distinct ().Single ();
            } catch (InvalidOperationException) {
                return null;
            }
        }
    }
  

• Finally, I implemented an IO which has a simple interface:

    interface IGameIO
    {
        Tuple<int, int> AskNextMove (Player player, IBoard board);
        void DisplayError (GameError error);
        void DisplayWinner (Player player);
    }
  

• And just as simple implementation:

    class ConsoleGameIO : IGameIO
    {
        public Tuple<int, int> AskNextMove (Player player, IBoard board)
        {
            Console.WriteLine ("\n\n");
            Console.WriteLine ("{0}, what is your move?\n", FormatPlayer (player));
            Console.WriteLine (FormatBoard (board));
            Console.Write ("\nType A1 to C3: ", FormatPlayer (player));
  
            return ParseMove (Console.ReadLine ().Trim ().ToUpperInvariant ());
        }
  
        public void DisplayError (GameError error)
        {
            Console.WriteLine ("Bad move.");
        }
  
        public void DisplayWinner (Player player)
        {
            Console.WriteLine ("Congatulations, {0}! You won.", FormatPlayer (player));
        }
  
        static string FormatBoard (IBoard board)
        {
            return string.Join ("\n", from row in board.SelectAllRows () select FormatRow (row));
        }
  
        static string FormatRow (IEnumerable<Player?> row)
        {
            return string.Join ("|", from cell in row select FormatCell (cell));
        }
  
        static string FormatPlayer (Player player)
        {
            return FormatCell (player);
        }
  
        static string FormatCell (Player? cell)
        {
            return cell.HasValue ? cell.Value.ToString () : "_";
        }
  
        static Tuple<int, int> ParseMove (string input)
        {
            return Tuple.Create (
                input [0] - 'A',
                input [1] - '1'
            );
        }
    }
  

• Finally, there goes the Game class with the run loop and Main method:

    class Game
    {
        IBoard board;
        IBoardAnalyzer analyzer;
        IGameIO io;
  
        public Game (IBoard board, IBoardAnalyzer analyzer, IGameIO io)
        {
            this.board = board;
            this.analyzer = analyzer;
            this.io = io;
        }
  
        public void Run ()
        {
            Player player = Player.X;
            Player? winner = null;
  
            do {
                Tuple<int, int> move;
                try {
                    move = io.AskNextMove (player, board);
                } catch {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                if (!ValidateMove (move)) {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                try {
                    board.SetCell (move.Item1, move.Item2, player);
                } catch (InvalidOperationException) {
                    io.DisplayError (GameError.CellAlreadyOccupied);
                    continue;
                }
  
                player = GetNextPlayer (player);
                winner = analyzer.DetermineWinner (board);
  
            } while (!winner.HasValue);
  
            io.DisplayWinner (winner.Value);
        }
  
        bool ValidateMove (Tuple<int, int> move)
        {
            return (move.Item1 >= 0 && move.Item1 < board.Size)
                && (move.Item2 >= 0 && move.Item2 < board.Size);
        }
  
        static Player GetNextPlayer (Player player)
        {
            switch (player) {
            case Player.X:
                return Player.O;
            case Player.O:
                return Player.X;
            default:
                throw new NotImplementedException ();
            }
        }
  
        public static void Main (string[] args)
        {
            var game = new Game (new Board (3), new BoardAnalyzer (), new ConsoleGameIO ());
            game.Run ();
        }
    }
  

I re-wrote my earlier toy Tic Tac Toe implementation specifically to address your question, with the following separation:

• Player is a simple enum:

    enum Player {
        X,
        O
    }
  

• IBoard represents a board with GetCell, SetCell and Size.

    interface IBoard
    {
        int Size { get; }
        Player? GetCell (int row, int column);
        void SetCell (int row, int column, Player player);
    }
  

  (really, you don't need anything else in IBoard)

• IBoardAnalyzer has a single method that scans the board to find the winner, similarly to yours:

    interface IBoardAnalyzer
    {
        Player? DetermineWinner (IBoard board);
    }
  

• All the actual heavy-lifting for scanning the board lives in BoardExtensions that can enumerate board rows, columns and diagonals. There is also an über-method called SelectAllLines that returns a sequence of all “lines” (rows, columns and diagonals) on the board. Note that BoardExtensions does no analysis; it only provides convenience methods for extracting data out of Board.

    static class BoardExtensions
    {
        public enum DiagonalKind {
            Primary,
            Secondary
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllLines (this IBoard board)
        {
            return board.SelectAllDiagonals ()
                .Concat (board.SelectAllRows ())
                .Concat (board.SelectAllColumns ());
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllRows (this IBoard board)
        {
            return from row in board.SelectIndices ()
                   select board.SelectRow (row);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllColumns (this IBoard board)
        {
            return from column in board.SelectIndices ()
                   select board.SelectColumn (column);
        }
  
        public static IEnumerable<IEnumerable<Player?>> SelectAllDiagonals (this IBoard board)
        {
            return from kind in new [] { DiagonalKind.Primary, DiagonalKind.Secondary }
                   select board.SelectDiagonal (kind);
        }
  
        public static IEnumerable<Player?> SelectRow (this IBoard board, int row)
        {
            return from column in board.SelectIndices ()
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<Player?> SelectColumn (this IBoard board, int column)
        {
            return from row in board.SelectIndices ()
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<Player?> SelectDiagonal (this IBoard board, DiagonalKind kind)
        {
            return from index in board.SelectIndices ()
                   let row = index
                   let column = (kind == DiagonalKind.Primary)
                       ? index
                       : board.Size - 1 - index
                   select board.GetCell (row, column);
        }
  
        public static IEnumerable<int> SelectIndices (this IBoard board)
        {
            return Enumerable.Range (0, board.Size);
        }
    }
  

• The implementation for BoardAnalyzer uses BoardExtensions to find the winner, but in itself is trivial:

    class BoardAnalyzer : IBoardAnalyzer
    {
        public Player? DetermineWinner (IBoard board)
        {
            return (
                from line in board.SelectAllLines ()
                let winner = DetermineLineWinner (line)
                where winner.HasValue
                select winner
            ).FirstOrDefault ();
        }
  
        static Player? DetermineLineWinner (IEnumerable<Player?> line)
        {
            try {
                return line.Distinct ().Single ();
            } catch (InvalidOperationException) {
                return null;
            }
        }
    }
  

• Finally, I implemented an IO which has a simple interface:

    interface IGameIO
    {
        Tuple<int, int> AskNextMove (Player player, IBoard board);
        void DisplayError (GameError error);
        void DisplayWinner (Player player);
    }
  

• And just as simple implementation:

    class ConsoleGameIO : IGameIO
    {
        public Tuple<int, int> AskNextMove (Player player, IBoard board)
        {
            Console.WriteLine ("\n\n");
            Console.WriteLine ("{0}, what is your move?\n", FormatPlayer (player));
            Console.WriteLine (FormatBoard (board));
            Console.Write ("\nType A1 to C3: ", FormatPlayer (player));
  
            return ParseMove (Console.ReadLine ().Trim ().ToUpperInvariant ());
        }
  
        public void DisplayError (GameError error)
        {
            switch (error) {
            case GameError.CellAlreadyOccupied:
                Console.WriteLine ("Bad move: cell is already occupied.");
                break;
            case GameError.CouldNotParseMove:
                Console.WriteLine ("Bad move. Valid moves are A1 to C3.");
                break;
            default:
                Console.WriteLine ("Something went wrong.");
                break;
            }
        }
  
        public void DisplayWinner (Player player)
        {
            Console.WriteLine ("Congatulations, {0}! You won.", FormatPlayer (player));
        }
  
        static string FormatBoard (IBoard board)
        {
            return string.Join ("\n", from row in board.SelectAllRows () select FormatRow (row));
        }
  
        static string FormatRow (IEnumerable<Player?> row)
        {
            return string.Join ("|", from cell in row select FormatCell (cell));
        }
  
        static string FormatPlayer (Player player)
        {
            return FormatCell (player);
        }
  
        static string FormatCell (Player? cell)
        {
            return cell.HasValue ? cell.Value.ToString () : "_";
        }
  
        static Tuple<int, int> ParseMove (string input)
        {
            return Tuple.Create (
                input [0] - 'A',
                input [1] - '1'
            );
        }
    }
  

• Finally, there goes the Game class with the run loop and Main method:

    class Game
    {
        IBoard board;
        IBoardAnalyzer analyzer;
        IGameIO io;
  
        public Game (IBoard board, IBoardAnalyzer analyzer, IGameIO io)
        {
            this.board = board;
            this.analyzer = analyzer;
            this.io = io;
        }
  
        public void Run ()
        {
            Player player = Player.X;
            Player? winner = null;
  
            do {
                Tuple<int, int> move;
                try {
                    move = io.AskNextMove (player, board);
                } catch {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                if (!ValidateMove (move)) {
                    io.DisplayError (GameError.CouldNotParseMove);
                    continue;
                }
  
                try {
                    board.SetCell (move.Item1, move.Item2, player);
                } catch (InvalidOperationException) {
                    io.DisplayError (GameError.CellAlreadyOccupied);
                    continue;
                }
  
                player = GetNextPlayer (player);
                winner = analyzer.DetermineWinner (board);
  
            } while (!winner.HasValue);
  
            io.DisplayWinner (winner.Value);
        }
  
        bool ValidateMove (Tuple<int, int> move)
        {
            return (move.Item1 >= 0 && move.Item1 < board.Size)
                && (move.Item2 >= 0 && move.Item2 < board.Size);
        }
  
        static Player GetNextPlayer (Player player)
        {
            switch (player) {
            case Player.X:
                return Player.O;
            case Player.O:
                return Player.X;
            default:
                throw new NotImplementedException ();
            }
        }
  
        public static void Main (string[] args)
        {
            var game = new Game (new Board (3), new BoardAnalyzer (), new ConsoleGameIO ());
            game.Run ();
        }
    }