Closed. This question is opinion-based。它当前不接受答案。












想改善这个问题吗?更新问题,以便editing this post用事实和引用来回答。

2年前关闭。



Improve this question




假设我有一个这样的类(class):
public class Fraction
{
   int numerator;
   int denominator;

   public Fraction(int n, int d)
   {
      // set the member variables
   }

   // And then a bunch of other methods
}

我想以一种不错的方式初始化它们的数组,而这篇文章是一大堆容易出错或语法繁琐的方法。

当然,数组构造函数会很好,但是没有这样的事情:
public Fraction[](params int[] numbers)

所以我被迫使用类似的方法
public static Fraction[] CreateArray(params int[] numbers)
{
    // Make an array and pull pairs of numbers for constructor calls
}

这相对笨拙,但我看不到解决方法。

两种形式都容易出错,因为用户可能错误地传递了奇数个参数,可能是因为他/他跳过了一个值,这会使函数挠头想知道用户实际想要什么。它可能会引发异常,但随后用户将需要尝试/捕获。如果可能的话,我宁愿不要强加给用户。因此,让我们强制配对。
public static Fraction[] CreateArray(params int[2][] pairs)

但是您不能以一种很好的方式调用此CreateArray,例如
Fraction.CreateArray({0,1}, {1,2}, {1,3}, {1,7}, {1,42});

你甚至都做不到
public static Fraction[] CreateArray(int[2][] pairs)
// Then later...
int[2][] = {{0,1}, {1,2}, {1,3}, {1,7}, {1,42}};
Fraction.CreateArray(numDenArray);

请注意,这在C++中可以正常工作(我很确定)。

您不得不执行以下其中一项操作,这是可恶的。语法很糟糕,并且当所有元素都具有相同的长度时,使用锯齿数组似乎很尴尬。
int[2][] fracArray = {new int[2]{0,1}, /*etc*/);
Fraction.CreateArray(fracArray);
// OR
Fraction.CreateArray(new int[2]{0,1}, /*etc*/);

同样,Python样式的元组是非法的,而C#版本是icky:
Fraction.CreateArray(new Tuple<int,int>(0,1), /*etc*/);

纯2D数组的使用可能采用以下形式,但这是非法的,而且我敢肯定没有合法的方式来表达它:
public static Fraction[] CreateArray(int[2,] twoByXArray)
// Then later...
Fraction[] fracArray =
    Fraction.CreateArray(new int[2,4]{{0,1}, {1,2}, {1,3}, {1,6}});

这不强制配对:
public static Fraction[] CreateArray(int[,] twoByXArray)

好那怎么样
public static Fraction[] CreateArray(int[] numerators, int[] denominators)

但是这两个数组的长度可能不同。 C++允许
public static Fraction[] CreateArray<int N>(int[N] numerators, int[N] denominators)

但是,这不是C++,对吗?

这种事情是非法的:
public static implicit operator Fraction[](params int[2][] pairs)

而且仍然无法使用,再次是由于令人讨厌的语法:
Fraction[] fracArray = new Fraction[](new int[2]{0,1}, /*etc*/ );

这可能很好:
public static implicit operator Fraction(string s)
{
    // Parse the string into numerator and denominator with
    // delimiter '/'
}

那你可以做
string[] fracStrings = new string[] {"0/1", /*etc*/};
Fraction[] fracArray = new Fraction[fracStrings.Length];
int index = 0;
foreach (string fracString in fracStrings) {
    fracArray[index] = fracStrings[index];
}

我不喜欢这种方法有五个原因。一个,隐式强制转换不可避免地实例化了一个新对象,但是我们已经有了一个非常好的对象,即我们要初始化的对象。第二,阅读可能会令人困惑。第三,它迫使您首先明确地完成我想封装的内容。第四,它留有不良格式化的空间。五,它涉及一次性解析字符串文字,这更像是一个恶作剧,而不是良好的编程风格。

以下还需要浪费时间的实例化:
var fracArray = Array.ConvertAll(numDenArray, item => (Fraction)item);

除非您使用那些可怕的锯齿状数组,否则对属性的以下使用都会遇到相同的问题:
public int[2] pair {
    set {
        numerator = value[0];
        denominator = value[1];
    }
}
// Then later...
var fracStrings = new int[2,4] {{0,1}, /*etc*/};
var fracArray = new Fraction[fracStrings.Length];
int index = 0;
foreach (int[2,] fracString in fracStrings) {
    fracArray[index].pair = fracStrings[index];
}

此变体不强制配对:
foreach (int[,] fracString in fracStrings) {
    fracArray[index].pair = fracStrings[index];
}

同样,这种方法仍然很重要。

这些都是我知道如何得出的想法。有没有好的解决方案?

最佳答案

我想不出一个优雅的,同时具有内存效率的数组解决方案。

但是,利用C#6 collection initializer功能,可以为列表(及类似方法)提供一个优雅的解决方案:

public static class Extensions
{
    public static void Add(this ICollection<Fraction> target, int numerator, int denominator)
    {
        target.Add(new Fraction(numerator, denominator));
    }
}

使用该扩展方法后,您可以轻松地初始化Fraction列表,例如:
var list = new List<Fraction> { { 0, 1 }, { 1, 2 }, { 1, 3 }, { 1, 7 }, { 1, 42 } };

当然,尽管内存效率不高,但是您可以使用它来初始化Fraction数组:
var array = new List<Fraction> { { 0, 1 }, { 1, 2 }, { 1, 3 }, { 1, 7 }, { 1, 42 } }.ToArray();

甚至通过使用隐式数组转换运算符声明列表派生类来使其更加简洁:
public class FractionList : List<Fraction>
{
    public static implicit operator Fraction[](FractionList x) => x?.ToArray();
}

然后使用
Fraction[] array = new FractionList { { 0, 1 }, { 1, 2 }, { 1, 3 }, { 1, 7 }, { 1, 42 } };

关于c# - 用C#优雅地初始化类实例的数组,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/36736372/

10-14 16:53
查看更多