如何在接口或基类中定义具有固定大小的数组

如果您需要类似cell[row, column]，这可能是一个建议：

static void Main()
{
    var card = new Card();
    card.cells[3, 2] = true;
    Console.WriteLine(card.cells[2, 4]); // False
    Console.WriteLine(card.cells[3, 2]); // True
    Console.WriteLine(card.cells[8, 9]); // Exception
}
public interface ICard
{
    Cells cells { get; set; }
}
public class Card : ICard
{
    Cells _cells = new Cells();
    public Cells cells { get { return _cells; } set { _cells = value; } }
}
public class Cells : List<bool>
{
    public Cells()
    {
        for (int i = 0; i < 25; i++)
        {
            this.Add(false);
        }
    }
    public virtual bool this[int row, int col]
    {
        get
        {
            if (row < 0 || row >= 5 || col < 0 || col >= 5) throw new IndexOutOfRangeException("Something");
            return this[row * 5 + col];
        }
        set
        {
            if (row < 0 || row >= 5 || col < 0 || col >= 5) throw new IndexOutOfRangeException("Something");
            this[row * 5 + col] = value;
        }
    }
}

无法指定方法或属性返回的数组的实际大小。更好的方法是让代码处理任何大小的数组，并使用 Array.GetUpperBound 方法在运行时确定实际大小的实际大小。

bool[,] cells = obj.cells;
for(int i = 0; i <= cells.GetUpperBound(0); i++) {
    for(int j = 0; j <= cells.GetUpperBound(1); j++) {
        // Do something with cells[i,j] 
    }
}

另外，我会将接口更改为使用方法而不是属性：

public interface ICard<T>
{
    T[,] GetCells();
    T GetCell(int row, column);
}

为了确保卡是固定大小，您可以将数组的大小传递到实现ICard的构造函数中：

public class Card : ICard
{    
    ...
    public const int MaxRows = 5;
    public const int MaxColumns = 5;
    private readonly int _rows;
    private readonly int _columns;
    public Card(int rows, int columns)
    {
        if(columns > MaxColumns || rows > MaxRows) 
        {
            throw new ArgumentExcetion(...);
        }
    }
    ...
    public int Rows { get { return _rows; } }
    public int Columns { get { return _columns; } } 
}

这样，您可以限制卡的最大大小。然后，如果您对允许的最大大小改变主意，请更改MaxRows和MaxColumns，一切都应该继续工作。如果你想要不同大小的卡片，那么只需将不同的值传递到构造函数中。

如果您一直想使用固定大小，请添加默认构造函数，如下所示：

public Card()
    : this(MaxRows, MaxColumns)
{
}

无论您选择哪种实现方式，都不应该公开该信息。您已经有卡的接口。但是你需要的是几种能够以安全的方式提供细胞的方法。例如索引器：

public Cell this[int row, int column]
{
   // check for boundaries
   return _cells[row, column];
}

或其他一些帮助程序方法，例如：

public IEnumerable<Cell> GetRow(int row)
{
    // return all cells of specified row
}

和一个属性 CardSize，表示卡片上有多少列和行。CardSize 应该是在构造函数中初始化的只读信息。

当我在考虑它时，您将需要另一种卡方法，例如"SetCell"，"MoveCell"，"ClearCell"。（对不起，我不知道宾果游戏是如何工作的。

我最初的想法是使用 2 维数组，但这有一个问题，即我不允许指定大小，因此在传递对象时，其他类无法知道它应该有 5 行和 5 列。

不要使用数组。

我会这样写：

public class Cell
{
  public int Value { get; set; }
  public bool Flagged { get; set; }  // terrible name imho
}
public class Board
{
  private List<List<Cell>> Rows;
  private List<List<Cell>> Columns;      
  public Board(IEnumerable<Cell> cells)
  {
    if (cells == null)
      throw new ArgumentNullException();
    if (cells.Count() != 25)
      throw new ArgumentException("cells must contain exactly 25 cells");
    // additional logic to make sure you don't have same values
    // or to many numbers in a specific range etc
    var orderedCells = cells.OrderBy(c => c.Value);
    Columns = new List<List<Cell>>()
    {
      orderedCells.Take(5).ToList(),
      orderedCells.Skip(5).Take(5).ToList(),  
      orderedCells.Skip(10).Take(5).ToList(),  
      orderedCells.Skip(15).Take(5).ToList(), 
      orderedCells.Skip(20).Take(5).ToList()  
    }
    Rows = Enumerable.Range(0,5)
      .Select(i => new List<Int>()
        {
          Columns.ElementAt(0).Skip(i).First(),
          Columns.ElementAt(1).Skip(i).First(),
          Columns.ElementAt(2).Skip(i).First(),
          Columns.ElementAt(3).Skip(i).First(),
          Columns.ElementAt(4).Skip(i).First(),
        })
      .ToList();
  }
  public IEnumerable<Cell> GetRow(int index)
  {
    if (index < 0 || index >= Rows.Count())
      throw new ArgumentOutOfRangeException();
    return Rows.ElementAt(index);
  }

  public IEnumerable<Cell> GetColumn(int index)
  {
    if (index < 0 || index >= Rows.Count())
      throw new ArgumentOutOfRangeException();
    return Rows.ElementAt(index);
  }

  public Cell GetCell(int column, int row)
  {
    if (column < 0 || column >= Columns.Count())
      throw new ArgumentOutOfRangeException();
    if (row < 0 || row >= Rows.Count())
      throw new ArgumentOutOfRangeException();

    return Rows.ElementAt(row).ElementAt(column);
  }
}

创建一个从 List 派生的自定义列表类型，在默认构造函数中强制执行容量，例如

class ListOfFives<T> : List<T>
{
  public ListOfFives<T>(): base(capacity:5)
  { 
  }
}

然后在您的界面中使用它

public interface ICard
{
    ListOfFives<ListOfFives<T>> Cells { get; }
}

出于显而易见的原因，您需要使用列表而不是数组。给出一个显式的类型名称来解释约束将使列表的实现者和用户一目了然。