Các chuỗi được truyền trong .NET như thế nào?

Khi tôi chuyển một hàm stringcho một hàm, một con trỏ đến nội dung của chuỗi có được truyền hay không, hay toàn bộ chuỗi được chuyển cho hàm trên ngăn xếp giống như a struct?

Một tham chiếu được thông qua; tuy nhiên, về mặt kỹ thuật nó không được thông qua bằng tham chiếu. Đây là một sự khác biệt tinh tế, nhưng rất quan trọng. Hãy xem xét đoạn mã sau:

void DoSomething(string strLocal)
{
    strLocal = "local";
}
void Main()
{
    string strMain = "main";
    DoSomething(strMain);
    Console.WriteLine(strMain); // What gets printed?
}

Có ba điều bạn cần biết để hiểu điều gì xảy ra ở đây:

1. Chuỗi là kiểu tham chiếu trong C #.
2. Chúng cũng không thay đổi, vì vậy bất cứ khi nào bạn làm điều gì đó có vẻ như bạn đang thay đổi chuỗi, bạn không phải vậy. Một chuỗi hoàn toàn mới được tạo, tham chiếu được trỏ vào nó và chuỗi cũ bị loại bỏ.
3. Mặc dù các chuỗi là kiểu tham chiếu, nhưng strMainkhông được chuyển bằng tham chiếu. Đó là một kiểu tham chiếu, nhưng bản thân tham chiếu được truyền theo giá trị . Bất kỳ khi nào bạn chuyển một tham số mà không có reftừ khóa (không tính outtham số), bạn đã truyền một giá trị nào đó.

Vì vậy, điều đó có nghĩa là bạn đang ... chuyển một tham chiếu theo giá trị. Vì đó là một loại tham chiếu, chỉ tham chiếu được sao chép vào ngăn xếp. Nhưng điều đó có nghĩa gì?

Chuyển các loại tham chiếu theo giá trị: Bạn đang làm điều đó

Biến C # là kiểu tham chiếu hoặc kiểu giá trị . Các tham số C # được truyền bởi tham chiếu hoặc được truyền bởi giá trị . Thuật ngữ là một vấn đề ở đây; những điều này nghe có vẻ giống nhau, nhưng không phải.

Nếu bạn chuyển một tham số BẤT KỲ loại nào và bạn không sử dụng reftừ khóa, thì bạn đã chuyển nó theo giá trị. Nếu bạn đã vượt qua nó theo giá trị, những gì bạn thực sự đã vượt qua là một bản sao. Nhưng nếu tham số là một kiểu tham chiếu, thì thứ bạn sao chép là tham chiếu, không phải bất cứ thứ gì nó đang trỏ vào.

Đây là dòng đầu tiên của Mainphương pháp:

string strMain = "main";

Chúng tôi đã tạo ra hai thứ trên dòng này: một chuỗi có giá trị mainđược lưu trữ trong bộ nhớ ở đâu đó và một biến tham chiếu được gọi là strMaintrỏ đến nó.

DoSomething(strMain);

Bây giờ chúng tôi chuyển tham chiếu đó tới DoSomething. Chúng tôi đã vượt qua nó theo giá trị, vì vậy có nghĩa là chúng tôi đã tạo một bản sao. Đó là một loại tham chiếu, vì vậy điều đó có nghĩa là chúng tôi đã sao chép tham chiếu, không phải chính chuỗi. Bây giờ chúng ta có hai tham chiếu mà mỗi tham chiếu trỏ đến cùng một giá trị trong bộ nhớ.

Bên trong callee

Đây là đầu của DoSomethingphương pháp:

void DoSomething(string strLocal)

Không có reftừ khóa, vì vậy strLocalvà strMainlà hai tham chiếu khác nhau trỏ đến cùng một giá trị. Nếu chúng tôi chỉ định lại strLocal...

strLocal = "local";   

... chúng tôi đã không thay đổi giá trị được lưu trữ; chúng tôi lấy tham chiếu được gọi strLocalvà nhắm nó vào một chuỗi hoàn toàn mới. Điều gì xảy ra strMainkhi chúng ta làm điều đó? Không có gì. Nó vẫn đang chỉ vào chuỗi cũ.

string strMain = "main";    // Store a string, create a reference to it
DoSomething(strMain);       // Reference gets copied, copy gets re-pointed
Console.WriteLine(strMain); // The original string is still "main" 

Bất biến

Hãy thay đổi kịch bản trong một giây. Hãy tưởng tượng chúng ta không làm việc với các chuỗi, nhưng một số loại tham chiếu có thể thay đổi, như một lớp bạn đã tạo.

class MutableThing
{
    public int ChangeMe { get; set; }
}

Nếu bạn làm theo tham chiếu objLocalđến đối tượng mà nó trỏ tới, bạn có thể thay đổi các thuộc tính của nó:

void DoSomething(MutableThing objLocal)
{
     objLocal.ChangeMe = 0;
} 

Vẫn chỉ có một MutableThingtrong bộ nhớ và cả tham chiếu đã sao chép và tham chiếu gốc vẫn trỏ đến nó. Các thuộc tính của MutableThingchính nó đã thay đổi :

void Main()
{
    var objMain = new MutableThing();
    objMain.ChangeMe = 5; 
    Console.WriteLine(objMain.ChangeMe); // it's 5 on objMain

    DoSomething(objMain);                // now it's 0 on objLocal
    Console.WriteLine(objMain.ChangeMe); // it's also 0 on objMain   
}

Ah, nhưng các chuỗi là bất biến! Không có thuộc ChangeMetính nào để đặt. Bạn không thể làm strLocal[3] = 'H'trong C # như bạn có thể làm với charmảng kiểu C ; thay vào đó bạn phải tạo một chuỗi hoàn toàn mới. Cách duy nhất để thay đổi strLocallà trỏ tham chiếu vào một chuỗi khác và điều đó có nghĩa là không có gì bạn làm strLocalcó thể ảnh hưởng strMain. Giá trị là không thay đổi và tham chiếu là một bản sao.

Chuyển một tham chiếu bằng tham chiếu

Để chứng minh có sự khác biệt, đây là những gì sẽ xảy ra khi bạn chuyển một tham chiếu bằng tham chiếu:

void DoSomethingByReference(ref string strLocal)
{
    strLocal = "local";
}
void Main()
{
    string strMain = "main";
    DoSomethingByReference(ref strMain);
    Console.WriteLine(strMain);          // Prints "local"
}

Lần này, chuỗi trong Mainthực sự bị thay đổi bởi vì bạn đã chuyển tham chiếu mà không sao chép nó trên ngăn xếp.

Vì vậy, mặc dù các chuỗi là kiểu tham chiếu, việc chuyển chúng theo giá trị có nghĩa là bất cứ điều gì xảy ra trong callee sẽ không ảnh hưởng đến chuỗi trong trình gọi. Nhưng vì chúng là kiểu tham chiếu, bạn không cần phải sao chép toàn bộ chuỗi vào bộ nhớ khi bạn muốn chuyển nó.

Các nguồn khác:

• Đây là bài viết hay nhất mà tôi đã đọc về sự khác biệt giữa các loại tham chiếu và loại giá trị trong C # và tại sao một loại tham chiếu không giống với tham số được truyền tham chiếu.
• Như thường lệ, Eric Lippert cũng có một số bài đăng trên blog xuất sắc về chủ đề này .
• Anh ấy cũng có một số thứ tuyệt vời về tính bất biến .

Các chuỗi trong C # là các đối tượng tham chiếu bất biến. Điều này có nghĩa là các tham chiếu đến chúng được truyền xung quanh (theo giá trị) và khi một chuỗi được tạo, bạn không thể sửa đổi nó. Các phương thức tạo ra các phiên bản đã sửa đổi của chuỗi (chuỗi con, phiên bản bị cắt xén, v.v.) tạo ra các bản sao đã sửa đổi của chuỗi gốc.

Chuỗi là trường hợp đặc biệt. Mỗi trường hợp là bất biến. Khi bạn thay đổi giá trị của một chuỗi, bạn đang cấp phát một chuỗi mới trong bộ nhớ.

Vì vậy, chỉ có tham chiếu được chuyển đến hàm của bạn, nhưng khi chuỗi được chỉnh sửa, nó sẽ trở thành một phiên bản mới và không sửa đổi phiên bản cũ.