Here the knew code:

/* ***************************************************************************
* This file is part of the NashCoding tutorial on SharpNEAT 2.
*
* Copyright 2010, Wesley Tansey (wes@nashcoding.com)
*
* Both SharpNEAT and this tutorial are free software: you can redistribute
* it and/or modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* SharpNEAT is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with SharpNEAT. If not, see .
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TicTacToeLib
{
///
/// A perfect Tic-Tac-Toe player.
///
public class OptimalPlayer : IPlayer
{
public SquareTypes SquareType { get; set; }

public OptimalPlayer(SquareTypes type)
{
SquareType = type;
}

public Move GetMove(SquareTypes[,] board)
{
TicTacToeGame.GetWinner(board);

int x = 0;
int y = 0;

//make a winning move if possible
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
if (board[i, j] != SquareTypes.N)
continue;

board[i, j] = SquareType;
var winner = TicTacToeGame.GetWinner(board);
board[i, j] = SquareTypes.N;
if (winner == SquareType)
return new Move(i, j);
}

//if we can't win, check if there are any moves that we have to make
//to prevent ourselves from losing
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
if (board[i, j] != SquareTypes.N)
continue;

//set the move to the opponent's type
board[i, j] = SquareType == SquareTypes.X ? SquareTypes.O : SquareTypes.X;
var winner = TicTacToeGame.GetWinner(board);
board[i, j] = SquareTypes.N;

//if the opponent will win by moving here, move here to block them
if (winner != SquareTypes.N)
return new Move(i, j);
}

if (board[1, 1] == SquareTypes.N)
return new Move(1, 1);

if (SquareType == SquareTypes.O)
{
if (board[1, 1] == SquareTypes.X)
{
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
switch (i)
{
case 0:
x = 2;
break;
case 1:
x = 1;
break;
case 2:
x = 0;
break;
}
switch (j)
{
case 0:
y = 2;
break;
case 1:
y = 1;
break;
case 2:
y = 0;
break;
}
if (board[i, j] == SquareTypes.X && board[x, y] == SquareTypes.O)
{
return new Move(x, j);
}
}
}
}
if (SquareType == SquareTypes.X)
{
if (board[1, 1] == SquareTypes.O)
{
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
switch (i)
{
case 0:
x = 2;
break;
case 1:
x = 1;
break;
case 2:
x = 0;
break;
}
switch (j)
{
case 0:
y = 2;
break;
case 1:
y = 1;
break;
case 2:
y = 0;
break;
}
if (board[i, j] == SquareTypes.X && board[x, y] == SquareTypes.O)
{
return new Move(x, j);
}
}
}
}

//if we're here, that means we have made at least 1 move already and can't win
//nor lose in 1 move, so just make the optimal play which would be to a free
//corner that isn't blocked
Move move = null;
int max = -1;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
{
if (board[i, j] != SquareTypes.N)
continue;

board[i, j] = SquareType;
int count = 0;
for (int m = 0; m < 3; m++)
for (int n = 0; n max)
{
move = new Move(i, j);
max = count;
}
}

return move;
}
}
}

withe best Regards

Roman T.