[XML Serialization] Crashes application ?

// -- Create the Chunk.
/// <summary>
/// Creates the Chunk at the Cooardinate and returns the string..
/// </summary>
/// <param name="?"></param>
private string CreateChunk(int ChunkX, int ChunkY)
{
    // -- Create a stream writer.
    StreamWriter _Writer = new StreamWriter(Path + ChunkX + "_" + ChunkY + ".txt");

    // -- Create a new Chunk.
    Chunk _Chunk = new Chunk(ChunkX, ChunkY, ChunkSize, ChunkSize);

    // -- Generate the Chunk.
    for (int x = 0; x < ChunkSize; x++)
    {
        for (int y = 0; y < ChunkSize; y++)
        {
            // -- Block.
            byte Block = ID.BLOCK_AIR;
            if (ChunkY == 0 && y > ChunkSize / 2)
                Block = ID.BLOCK_GRASS;

            // -- Set the Block.
            _Chunk.SetBlockID(x, y, Block);
        }
    }

    // -- Get the XML string.
    string _ReturnString;
    _ReturnString = SerializeToString(_Chunk);

    // -- Write.
    _Writer.Write(_ReturnString);

    // -- Close the Writer.
    _Writer.Flush();
    _Writer.Close();

    // -- Return.
    return _ReturnString;
}

public static T SerializeFromString<T>(string xml)
{
    XmlSerializer serializer = new XmlSerializer(typeof(T));

    using (StringReader reader = new StringReader(xml))
    {
        return (T)serializer.Deserialize(reader);
    }
}


public static string SerializeToString(object obj)
{
    XmlSerializer serializer = new XmlSerializer(obj.GetType());

    using (StringWriter writer = new StringWriter())
    {
        serializer.Serialize(writer, obj);

        return writer.ToString();
    }
}

[Serializable]
public class Chunk
{
    // -- Blocks.
    private Block[,] _Blocks;

    // -- Cooardinates.
    public int X { get; set; }
    public int Y { get; set; }

    // -- Chunk.
    /// <summary>
    /// Initializes a new Chunk based on the Width and Height given.
    /// </summary>
    /// <param name="Width"></param>
    /// <param name="Height"></param>
    public Chunk(int X, int Y, int Width, int Height)
    {
        // -- Create the Block List.
        _Blocks = new Block[Width, Height];

        // -- Create all the Blocks.
        for (int i = 0; i < Width; i++)
        {
            for (int j = 0; j < Height; j++)
            {
                // -- Create a new block.
                Block _Block = new Block(ID.BLOCK_AIR);

                // -- Add the block.
                _Blocks[i,j] = _Block;
            }
        }
    }

    // -- Set a Block.
    /// <summary>
    /// Sets the block in the Chunk.
    /// </summary>
    /// <param name="X">X of the block.</param>
    /// <param name="Y">Y of the block.</param>
    /// <param name="ID">The ID of the block.</param>
    public void SetBlockID(int X, int Y, byte ID)
    {
        // -- Set the Block.
        _Blocks[X, Y].ID = ID;
    }

    // -- Get a block.
    /// <summary>
    /// Returns the ID of the given block.
    /// </summary>
    /// <param name="X">The X of the Block.</param>
    /// <param name="Y">The Y of the Block.</param>
    public byte GetBlockID(int X, int Y)
    {
        // -- Return.
        return _Blocks[X, Y].ID;
    }
}

[Serializable]
public static class ID
{
    public static int BlockSize = 32;

    public const byte BLOCK_AIR = 30;
    public const byte BLOCK_DIRT = 31;
    public const byte BLOCK_GRASS = 32;
}

[Serializable]
public class Block
{
    public byte ID { get; set; }

    // -- Block
    /// <summary>
    /// Initializes a new Block with the ID given.
    /// </summary>
    /// <param name="_ID">The ID of the block.</param>
    public Block(byte _ID)
    {
        // -- Set the ID.
        ID = _ID;
    }
}