Tất cả các cú pháp khởi tạo mảng có thể

Tất cả các cú pháp khởi tạo mảng có thể có với C # là gì?

Đây là các phương thức khai báo và khởi tạo hiện tại cho một mảng đơn giản.

string[] array = new string[2]; // creates array of length 2, default values
string[] array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
string[] array = new[] { "A", "B" }; // created populated array of length 2

Lưu ý rằng các kỹ thuật khác để có được các mảng tồn tại, chẳng hạn như các ToArray()phần mở rộng Linq trên IEnumerable<T>.

Cũng lưu ý rằng trong các khai báo ở trên, hai khai báo đầu tiên có thể thay thế string[]bên trái bằng var(C # 3+), vì thông tin bên phải là đủ để suy ra loại thích hợp. Dòng thứ ba phải được viết như được hiển thị, vì chỉ riêng cú pháp khởi tạo mảng là không đủ để đáp ứng nhu cầu của trình biên dịch. Thứ tư cũng có thể sử dụng suy luận. Vì vậy, nếu bạn tham gia vào toàn bộ điều ngắn gọn, những điều trên có thể được viết là

var array = new string[2]; // creates array of length 2, default values
var array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
var array = new[] { "A", "B" }; // created populated array of length 2 

Các cú pháp tạo mảng trong C # là các biểu thức là:

new int[3]
new int[3] { 10, 20, 30 }
new int[] { 10, 20, 30 }
new[] { 10, 20, 30 }

Trong phần đầu tiên, kích thước có thể là bất kỳ giá trị tích phân không âm nào và các phần tử mảng được khởi tạo thành các giá trị mặc định.

Trong phần thứ hai, kích thước phải là hằng số và số phần tử đã cho phải khớp. Phải có một chuyển đổi ngầm định từ các phần tử đã cho sang loại phần tử mảng đã cho.

Trong phần thứ ba, các phần tử phải được chuyển đổi hoàn toàn thành loại phần tử và kích thước được xác định từ số phần tử đã cho.

Trong phần tư, loại phần tử mảng được suy ra bằng cách tính loại tốt nhất, nếu có một, trong tất cả các phần tử đã cho có loại. Tất cả các yếu tố phải được chuyển đổi hoàn toàn sang loại đó. Kích thước được xác định từ số lượng các yếu tố được đưa ra. Cú pháp này đã được giới thiệu trong C # 3.0.

Ngoài ra còn có một cú pháp chỉ có thể được sử dụng trong một khai báo:

int[] x = { 10, 20, 30 };

Các phần tử phải được chuyển đổi hoàn toàn thành loại phần tử. Kích thước được xác định từ số lượng các yếu tố được đưa ra.

không có hướng dẫn tất cả trong một

Tôi giới thiệu bạn đến đặc tả C # 4.0, phần 7.6.10.4 "Biểu thức tạo mảng".

Mảng không trống

• var data0 = new int[3]

• var data1 = new int[3] { 1, 2, 3 }

• var data2 = new int[] { 1, 2, 3 }

• var data3 = new[] { 1, 2, 3 }

• var data4 = { 1, 2, 3 }không thể biên dịch được. Sử dụng int[] data5 = { 1, 2, 3 }thay thế.

Mảng trống

• var data6 = new int[0]
• var data7 = new int[] { }

• var data8 = new [] { } và int[] data9 = new [] { }không thể biên dịch được.

• var data10 = { }không thể biên dịch được. Sử dụng int[] data11 = { } thay thế.

Như một đối số của một phương thức

Chỉ các biểu thức có thể được chỉ định với vartừ khóa có thể được chuyển qua làm đối số.

• Foo(new int[2])
• Foo(new int[2] { 1, 2 })
• Foo(new int[] { 1, 2 })
• Foo(new[] { 1, 2 })
• Foo({ 1, 2 }) không thể biên dịch được
• Foo(new int[0])
• Foo(new int[] { })
• Foo({}) không thể biên dịch được

Enumerable.Repeat(String.Empty, count).ToArray()

Sẽ tạo ra chuỗi các chuỗi trống lặp lại 'đếm' lần. Trong trường hợp bạn muốn khởi tạo mảng với cùng giá trị phần tử mặc định đặc biệt. Cẩn thận với các loại tham chiếu, tất cả các yếu tố sẽ tham chiếu cùng một đối tượng.

var contacts = new[]
{
    new 
    {
        Name = " Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new 
    {
        Name = " Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};

Trong trường hợp bạn muốn khởi tạo một mảng cố định các phần tử bằng nhau (không phải nullhoặc không phải default) được khởi tạo trước , hãy sử dụng:

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

Ngoài ra xin vui lòng tham gia vào cuộc thảo luận này .

Ví dụ để tạo một mảng của một lớp tùy chỉnh

Dưới đây là định nghĩa lớp.

public class DummyUser
{
    public string email { get; set; }
    public string language { get; set; }
}

Đây là cách bạn có thể khởi tạo mảng:

private DummyUser[] arrDummyUser = new DummyUser[]
{
    new DummyUser{
       email = "abc.xyz@email.com",
       language = "English"
    },
    new DummyUser{
       email = "def@email.com",
       language = "Spanish"
    }
};

Lặp lại mà không có LINQ :

float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f);

int[] array = new int[4]; 
array[0] = 10;
array[1] = 20;
array[2] = 30;

hoặc là

string[] week = new string[] {"Sunday","Monday","Tuesday"};

hoặc là

string[] array = { "Sunday" , "Monday" };

và trong mảng đa chiều

    Dim i, j As Integer
    Dim strArr(1, 2) As String

    strArr(0, 0) = "First (0,0)"
    strArr(0, 1) = "Second (0,1)"

    strArr(1, 0) = "Third (1,0)"
    strArr(1, 1) = "Fourth (1,1)"

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

Một cách khác để tạo và khởi tạo một mảng các đối tượng. Điều này tương tự với ví dụ mà @Amol đã đăng ở trên , ngoại trừ ví dụ này sử dụng các hàm tạo. Một chút đa hình rắc vào, tôi không thể cưỡng lại.

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

Các lớp học cho bối cảnh:

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;
}

Đối với lớp dưới đây:

public class Page
{

    private string data;

    public Page()
    {
    }

    public Page(string data)
    {
        this.Data = data;
    }

    public string Data
    {
        get
        {
            return this.data;
        }
        set
        {
            this.data = value;
        }
    }
}

bạn có thể khởi tạo mảng của đối tượng trên như dưới đây.

Pages = new Page[] { new Page("a string") };

Hi vọng điêu nay co ich.

Bạn cũng có thể tạo các mảng động tức là trước tiên bạn có thể hỏi kích thước của mảng từ người dùng trước khi tạo nó.

Console.Write("Enter size of array");
int n = Convert.ToInt16(Console.ReadLine());

int[] dynamicSizedArray= new int[n]; // Here we have created an array of size n
Console.WriteLine("Input Elements");
for(int i=0;i<n;i++)
{
     dynamicSizedArray[i] = Convert.ToInt32(Console.ReadLine());
}

Console.WriteLine("Elements of array are :");
foreach (int i in dynamicSizedArray)
{
    Console.WriteLine(i);
}
Console.ReadKey();

Giải pháp tầm thường với các biểu thức. Lưu ý rằng với NewArrayInit, bạn có thể tạo mảng chỉ một chiều.

NewArrayExpression expr = Expression.NewArrayInit(typeof(int), new[] { Expression.Constant(2), Expression.Constant(3) });
int[] array = Expression.Lambda<Func<int[]>>(expr).Compile()(); // compile and call callback

Chỉ là một ghi chú

Các mảng sau:

string[] array = new string[2];
string[] array2 = new string[] { "A", "B" };
string[] array3 = { "A" , "B" };
string[] array4 = new[] { "A", "B" };

Sẽ được biên dịch thành:

string[] array = new string[2];
string[] array2 = new string[]
{
   "A",
   "B"
};
string[] array3 = new string[]
{
   "A",
   "B"
};
string[] array4 = new string[]
{
   "A",
   "B"
};