创建和初始化对象数组的另一种方法。这与上面@Amol发布的示例类似，只是这一个使用了构造函数。一点点多态性洒了进来，我无法抗拒。

IUser[] userArray = new IUser[]
{
    new DummyUser("abc@cde.edu", "Gibberish"),
    new SmartyUser("pga@lna.it", "Italian", "Engineer")
};

上下文类：

interface IUser
{
    string EMail { get; }       // immutable, so get only an no set
    string Language { get; }
}

public class DummyUser : IUser
{
    public DummyUser(string email, string language)
    {
        m_email = email;
        m_language = language;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }
}

public class SmartyUser : IUser
{
    public SmartyUser(string email, string language, string occupation)
    {
        m_email = email;
        m_language = language;
        m_occupation = occupation;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }

    private string m_occupation;
}

非空数组

var data0=新int[3]var data1=新int[3]｛1，2，3｝var data2=新int[]｛1，2，3｝var data3=新[]｛1，2，3｝var data4={1，2，3}不可编译。请改用int[]data5＝｛1，2，3｝。

空数组

var data6=新int[0]var data7=新int[]｛｝vardata8=new[]｛｝和int[]data9=new[]｝不可编译。var data10={}不可编译。请改用int[]data11={}。

作为方法的参数

只有可以指定var关键字的表达式才能作为参数传递。

Foo（新int[2]）Foo（新int[2]｛1，2｝）Foo（新int[]｛1，2｝）Foo（新[]｛1，2｝）Foo（｛1，2｝）不可编译Foo（新int[0]）Foo（新int[]｛｝）Foo（｛｝）不可编译

For Class initialization:
var page1 = new Class1();
var page2 = new Class2();
var pages = new UIViewController[] { page1, page2 };

如果您想初始化一个预先初始化的相等（非空或非默认）元素的固定数组，请使用以下命令：

var array = Enumerable.Repeat(string.Empty, 37).ToArray();

也请参加本次讨论。

要初始化空数组，在dotnet 5.0中应该是array.empty＜T＞（）

对于字符串

var items = Array.Empty<string>();

对于编号

var items = Array.Empty<int>();

另一种方法是调用静态函数（用于静态对象）或实例对象的任何函数。这可用于成员初始化。

现在我还没有测试所有这些，所以我将把我测试过的（静态成员和静态函数）

Class x {
    private static Option[] options = GetOptionList();
    private static Option[] GetOptionList() {

        return (someSourceOfData).Select(dataitem => new Option()
                 {field=dataitem.value,field2=dataitem.othervalue});
    }
}

我想知道的是，是否有绕过函数声明的方法。我知道在这个例子中，它可以直接使用，但假设函数稍微复杂一些，不能简化为一个表达式。

我想象如下（但不起作用）

Class x {
    private static Option[] options = () => {
        Lots of prep stuff here that means we can not just use the next line
        return (someSourceOfData).Select(dataitem => new Option()
                 {field=dataitem.value,field2=dataitem.othervalue});
    }
}

基本上是为填充变量的范围声明函数的一种方式。如果有人能教我怎么做，我会很高兴的。