Question

我正在处理矩阵，并且在对象的类型取决于条件时（如果其他条件），如何正确初始化不同的2D对象数组存在问题。如果我在其他情况之前声明矩阵及其类型，则无法在其中声明其他类型。如果我在其他地方声明它，则它不在范围之外。

关于堆栈溢出的问题已经很相似了，我发现了一些解决此问题的方法。

将所有方法（即使没有重载-两种类型的方法都完全相同）放入其他容器中。 ->可以，但是代码重复。
设置通用接口。 ->方法不适用于ICell，我不知道将ICell [] []重命名为CellA [] []。
将矩阵声明为vars数组。 ->无法确定其工作原理。

还有其他选择，什么是最佳解决方案？还是我的方法完全错误？

谢谢

P.S。代码很长，这是简化版本。

class CellA : IComparable {
    // 2 attributes
    //constructor 1 param
    public int CompareTo(object obj) {
        //code
    }
}

class CellB : CellA {  
    // 3 attributes  
    //constructor 2 params  
}

class Program {    
    static void Main(string[] args) {
        data[0] = "...";
        ...
        data[x] = "...";
        //user input own data or chooses data set
        ...
        bool mode = true/false; //user chooses computing mode
        if (mode) {
            CellA[][] matrix = InitializeMatrixA(data[indexOfSet]);
        } else {
            CellB[][] matrix = InitializeMatrixB(data[indexOfSet]);
        }
        DoSomethingOther(ref matrix);
        //several ref matrix manipulation methods
        Console.WriteLine(DoSomethingSame(matrix));
    }

    static CellA[][] InitializeMatrixA(string data) {
        //string processing, not important
        CellA[][] matrix = new CellA[9][];
        for (int i = 0; i < 9; i++) {
            matrix[i] = new Cell[9];
            for (int j = 0; j < 9; j++) {
                matrix[i][j] = new CellA(stringPart[i*9+j]);
            }
        }
        return matrix;
    }

    static CellB[][] InitializeMatrixB(string data) {
        //different string processing, not important
        CellB[][] matrix = new CellB[9][];
        for (int i = 0; i < 9; i++) {
            matrix[i] = new Cell[9];
            for (int j = 0; j < 9; j++) {
                matrix[i][j] = new CellA(stringPart[i*18+j*2], stringPart[i*18+j*2+1]);
            }
        }
        return matrix;
    }
    //same function for As and Bs
    static int DoSomethingSame(ref CellA[][] matrix) { //code }

    //many different overloaded methods all working with reference to "matrix", slightly different computing for As and Bs
    static void DoSomethingOther(ref CellA[][] matrix) { //code }
    static void DoSomethingOther(ref CellB[][] matrix) { // slightly different code}

Answer 1

我认为，您发布的第二个解决方案将是最好的解决方案，即称为ICell的通用接口。

我要处理的方式是像这样创建ICell：不需要ref修饰符，数组自然通过引用传递。

    import axios from 'axios'

export const register = newUser => {
    return axios
        .post('api/v1/register', newUser,
        {
            headers: { 'Content-Type': 'application/json' }
        })
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.log(err)
    })
}

然后我将创建类：CellA，CellB，并使每个类通过自己的逻辑实现ICell接口。单元类的每个构造函数都通过自己的逻辑定义InitializeMatrix的逻辑。因此，当您创建类的实例时，它已经初始化了矩阵。

然后在主目录中：

public interface ICell
{
    int DoSomethingSame(ICell[][] matrix);
    void DoSomethingOther(ICell[][] matrix);
}

如果您需要有关如何定义CellA和CellB的示例，请告诉我，我将进行更新。

编辑：完整的解决方案是：

static void Main(string[] args)
{
    data[0] = "...";
    ...
    data[x] = "...";
    //user input own data or chooses data set
    ...
    bool mode = true/false; //user chooses computing mode
    ICell[][] matrix = (mode)? new CellA(data[indexOfSet]): new CellB(data[indexOfSet])

    DoSomethingOther(ref matrix);
    //several ref matrix manipulation methods
    Console.WriteLine(DoSomethingSame(matrix));
}

我将在类内部实现doSomething方法。

然后在主目录中：

public class Matrix
{
    ICell[][] cell;
    public Matrix(bool mode, string data)
    {
        cell = (mode)? new CellA(data): new CellB(data);
    }
}

}

声明不同对象类型的2D数组，具体取决于其他（或切换）C＃

1 个答案: