验证码：

char[,] a = new char[6, 6]
        {
            {'#', '#', '#', '%', '%', '%'},
            {'#', '#', '#', '%', '%', '%'},
            {'#', '#', '#', '%', '%', '%'},
            {'*', '*', '*', '+', '+', '+'},
            {'*', '*', '*', '+', '+', '+'},
            {'*', '*', '*', '+', '+', '+'},
        };
        Console.WriteLine("Rotate 90");
        for (int i = 0; i < 6; i++)
        {
            for (int j = 0; j < 6; j++)
            {
                Console.Write(" " + a[5 - j, i]);
            }
            Console.WriteLine();
        }
        Console.WriteLine();
        Console.WriteLine("Rotate 180");

        for (int i = 0; i < 6; i++)
        {
            for (int j = 0; j < 6; j++)
            {
                Console.Write(" "+ a[5-i, 5-j]);
            }
            Console.WriteLine();
        }
        Console.WriteLine();
        Console.WriteLine("Rotate 270");
        for (int i = 0; i < 6; i++)
        {
            for (int j = 0; j < 6; j++)
            {
                Console.Write(" " + a[j, 5-i ]);
            }
            Console.WriteLine();
        }

那么结果是：

这可能不适合你的家庭作业，但是，话说回来，我不为别人做家庭作业。
我创建了一个用数组初始化的类型，并提供了一种方法来查看它以几个Angular 旋转，而不是将数组旋转几次。
我放宽了一些限制，您询问了char的6x6数组，这为泛型类型T的MxN数组提供了一个通用的解决方案（即如果需要，数组可以是5x 7）。
您选择的字符很难测试，因此我使用以下字符：

private char[,] _theArray = new char[,]
        {
            {'a', 'b', 'c', 'd', 'e', 'f'},
            {'A', 'B', 'C', 'D', 'E', 'F'},
            {'g', 'h', 'i', 'j', 'k', 'l'},
            {'G', 'H', 'I', 'J', 'K', 'L'},
            {'m', 'n', 'o', 'p', 'q', 'r'},
            {'M', 'N', 'O', 'P', 'Q', 'R'},
        };

但我也测试了它：

private char[,] _theArray = new char[,]
        {
            {'a', 'b', 'c', 'd', 'e', 'f'},
            {'A', 'B', 'C', 'D', 'E', 'F'},
            {'g', 'h', 'i', 'j', 'k', 'l'},
            {'G', 'H', 'I', 'J', 'K', 'L'},
        };

以及：

private char[,] _theArray = new char[,]
        {
            {'a', 'b', 'c', 'd',},
            {'A', 'B', 'C', 'D',},
            {'g', 'h', 'i', 'j',},
            {'G', 'H', 'I', 'J',},
            {'m', 'n', 'o', 'p',},
            {'M', 'N', 'O', 'P',},
        };

因此，它适用于6x6、4x 6和6x 4阵列。
它没有使用整数（1-4）指定旋转，而是使用enum：

public enum RotationAngle
{
    Rotate0,
    Rotate90,
    Rotate180,
    Rotate270,
}

它依赖于名为RotatableArray<T>的泛型类：

public class RotatableArray<T>
{
    public int Width { get; }
    public int Height { get; }

    private T[,] _theArray;

    public RotatableArray(T[,] array)
    {
        _theArray = array;
        Width = array.GetLength(0);
        Height = array.GetLength(1);
    }

    public T this[int x, int y]
    {
        get
        {
            CheckParametersPlain(x, y);
            return _theArray[x, y];
        }
    }

    public T this[RotationAngle angle, int x, int y]
    {
        get
        {
            switch (angle)
            {
                case RotationAngle.Rotate0:
                    return this[x, y];
                case RotationAngle.Rotate90:
                    CheckParametersRotated(x, y);
                    return _theArray[Width - y - 1, x];
                case RotationAngle.Rotate180:
                    CheckParametersPlain(x, y);
                    return _theArray[Width - x - 1, Height - y - 1];
                case RotationAngle.Rotate270:
                    CheckParametersRotated(x, y);
                    return _theArray[y, Height - x - 1];
                default:
                    throw new ArgumentOutOfRangeException($"Parameter {nameof(angle)} must be one of {string.Join(", ", Enum.GetNames<RotationAngle>())}");
            }
        }
    }

    public int AdjustedWidth(RotationAngle angle)
    {
        if (angle == RotationAngle.Rotate0 || angle == RotationAngle.Rotate180)
        {
            return Width;
        }
        else
        {
            return Height;
        }
    }

    public int AdjustedHeight(RotationAngle angle)
    {
        if (angle == RotationAngle.Rotate0 || angle == RotationAngle.Rotate180)
        {
            return Height;
        }
        else
        {
            return Width;
        }
    }

    private void CheckParametersPlain(int x, int y)
    {
        if (x >= Width)
        {
            throw new ArgumentOutOfRangeException(nameof(x), $"Parameter must be less than the array Width ({Width})");
        }
        if (y >= Height)
        {
            throw new ArgumentOutOfRangeException(nameof(y), $"Parameter must be less than the array Height ({Height})");
        }
    }

    private void CheckParametersRotated(int x, int y)
    {
        if (y >= Width)
        {
            throw new ArgumentOutOfRangeException(nameof(y), $"After rotation, parameter must be less than the array Width ({Width})");
        }
        if (x >= Height)
        {
            throw new ArgumentOutOfRangeException(nameof(x), $"After rotation, parameter must be less than the array Height ({Height})");
        }
    }
}

RotatableArray<T>的一个示例用T的一个二维数组初始化（/构造），这个数组永远不会改变。

var rotArray = new RotatableArray<char>(_theArray);

相反，该类依赖于一个三参数的 Indexed Property（也称为 Indexerhttps://learn.microsoft.com/en-Us/dotnet/csharp/programming-guide/indexers/）在初始化时使用的不可变数组的顶部提供一个可旋转的外观。
不是旋转数组，而是对它进行索引（二维），传入一个RotationAngle值来描述您希望如何显示。
我在一个Windows窗体应用程序中测试了这一点（将输出放入一个多行文本框中）。

private void ShowRotated (RotatableArray<char> array, RotationAngle angle)
{
    textBox1.Clear();
    var row = new List<char>();
    for (int i = 0; i < array.AdjustedWidth(angle); i++)
    {
        row.Clear();
        for (int j = 0; j < array.AdjustedHeight(angle); j++)
        {
            row.Add(array[angle, i, j]);
        }
        textBox1.Text += (string.Join(" | ", row) + Environment.NewLine);
    }
}

请注意，它与您提供的代码基本相同，不同之处在于它不是访问：

array[i, j]

我正在访问：

array[angle, i, j]

其中angle是Rotate0、Rotate90、Rotate180或Rotate270中的一个。
使用此数组作为示例：

private char[,] _theArray = new char[,]
        {
            {'a', 'b', 'c', 'd', 'e', 'f'},
            {'A', 'B', 'C', 'D', 'E', 'F'},
            {'g', 'h', 'i', 'j', 'k', 'l'},
            {'G', 'H', 'I', 'J', 'K', 'L'},
        };

以下是我得到的结果：
仅显示原始数组：

a | b | c | d | e | f
A | B | C | D | E | F
g | h | i | j | k | l
G | H | I | J | K | L

将其显示在Rotate0会导致相同的结果：

a | b | c | d | e | f
A | B | C | D | E | F
g | h | i | j | k | l
G | H | I | J | K | L

在90，你得到：

G | g | A | a
H | h | B | b
I | i | C | c
J | j | D | d
K | k | E | e
L | l | F | f

以及在180：

L | K | J | I | H | G
l | k | j | i | h | g
F | E | D | C | B | A
f | e | d | c | b | a

最后在270：

f | F | l | L
e | E | k | K
d | D | j | J
c | C | i | I
b | B | h | H
a | A | g | G

这可以很容易地扩展到提供换位，以及颠倒的东西都垂直和水平。
这里面应该有足够的代码供你完成作业。