Tại sao các câu lệnh gán trả về một giá trị?

Điều này được cho phép:

int a, b, c;
a = b = c = 16;

string s = null;
while ((s = "Hello") != null) ;

Theo hiểu biết của tôi, việc gán s = ”Hello”;chỉ nên “Hello”được gán cho s, nhưng thao tác không nên trả về bất kỳ giá trị nào. Nếu đó là sự thật, thì ((s = "Hello") != null)sẽ tạo ra một lỗi, vì nullsẽ được so sánh với không có gì.

Lý do đằng sau cho phép các câu lệnh gán trả về một giá trị là gì?

Theo hiểu biết của tôi, gán s = "Xin chào"; chỉ nên khiến "Xin chào" được gán cho s, nhưng thao tác không nên trả về bất kỳ giá trị nào.

Hiểu biết của bạn là 100% không chính xác. Bạn có thể giải thích tại sao bạn tin điều sai lầm này?

Lý do đằng sau cho phép các câu lệnh gán trả về một giá trị là gì?

Trước hết, các câu lệnh gán không tạo ra một giá trị. Biểu thức chuyển nhượng tạo ra một giá trị. Một biểu thức chuyển nhượng là một tuyên bố pháp lý; chỉ có một số ít các biểu thức là các câu lệnh pháp lý trong C #: đang chờ một biểu thức, xây dựng thể hiện, tăng, giảm, gọi và các biểu thức gán có thể được sử dụng khi dự kiến ​​một câu lệnh.

Chỉ có một loại biểu thức trong C # không tạo ra một loại giá trị nào đó, đó là một lời gọi của một cái gì đó được gõ là trả về khoảng trống. (Hoặc, tương tự, chờ đợi một nhiệm vụ không có giá trị kết quả liên quan.) Mỗi ​​loại biểu thức khác tạo ra một giá trị hoặc biến hoặc tham chiếu hoặc truy cập thuộc tính hoặc truy cập sự kiện, v.v.

Lưu ý rằng tất cả các biểu thức hợp pháp như các tuyên bố đều hữu ích cho các tác dụng phụ của chúng . Đó là cái nhìn sâu sắc quan trọng ở đây, và tôi nghĩ có lẽ nguyên nhân của trực giác của bạn rằng các bài tập nên là các phát biểu chứ không phải các biểu thức. Lý tưởng nhất là chúng ta có chính xác một tác dụng phụ cho mỗi câu lệnh và không có tác dụng phụ nào trong một biểu thức. Nó là một chút kỳ quặc rằng mã phụ ảnh hưởng có thể được sử dụng trong một bối cảnh biểu hiện ở tất cả.

Lý do đằng sau cho phép tính năng này là vì (1) nó thường thuận tiện và (2) nó là thành ngữ trong các ngôn ngữ giống như C.

Người ta có thể lưu ý rằng câu hỏi đã được đặt ra: tại sao thành ngữ này trong các ngôn ngữ giống như C?

Thật không may, Dennis Ritchie không còn có thể hỏi nữa, nhưng tôi đoán là một bài tập hầu như luôn để lại giá trị vừa được gán trong một thanh ghi. C là một loại ngôn ngữ rất "gần với máy". Có vẻ hợp lý và phù hợp với thiết kế của C rằng có một tính năng ngôn ngữ có nghĩa là "tiếp tục sử dụng giá trị mà tôi vừa gán". Rất dễ dàng để viết một trình tạo mã cho tính năng này; bạn chỉ cần tiếp tục sử dụng thanh ghi lưu trữ giá trị được gán.

Bạn đã không cung cấp câu trả lời? Đó là để kích hoạt chính xác các loại cấu trúc bạn đã đề cập.

Một trường hợp phổ biến trong đó thuộc tính này của toán tử gán được sử dụng là đọc các dòng từ một tệp ...

string line;
while ((line = streamReader.ReadLine()) != null)
    // ...

Việc sử dụng biểu thức gán yêu thích của tôi là dành cho các thuộc tính khởi tạo lười biếng.

private string _name;
public string Name
{
    get { return _name ?? (_name = ExpensiveNameGeneratorMethod()); }
}

Đối với một, nó cho phép bạn xâu chuỗi các bài tập của mình, như trong ví dụ của bạn:

a = b = c = 16;

Mặt khác, nó cho phép bạn gán và kiểm tra kết quả trong một biểu thức:

while ((s = foo.getSomeString()) != null) { /* ... */ }

Cả hai đều có thể là lý do mơ hồ, nhưng chắc chắn có những người thích những công trình này.

Ngoài các lý do đã được đề cập (chuỗi phân công, thiết lập và kiểm tra trong vòng lặp, v.v.), để sử dụng đúngusing câu lệnh bạn cần tính năng này:

using (Font font3 = new Font("Arial", 10.0f))
{
    // Use font3.
}

MSDN không khuyến khích khai báo đối tượng dùng một lần bên ngoài câu lệnh đang sử dụng, vì sau đó nó sẽ vẫn ở trong phạm vi ngay cả sau khi nó đã được xử lý (xem bài viết MSDN tôi liên kết).

Tôi muốn giải thích về một điểm cụ thể mà Eric Lippert đã đưa ra trong câu trả lời của mình và đặt sự chú ý vào một dịp đặc biệt mà không ai có thể chạm vào được. Eric nói:

[...] một nhiệm vụ hầu như luôn để lại giá trị vừa được gán trong một thanh ghi.

Tôi muốn nói rằng bài tập sẽ luôn để lại giá trị mà chúng tôi đã cố gán cho toán hạng bên trái của chúng tôi. Không chỉ "hầu như luôn luôn". Nhưng tôi không biết vì tôi chưa tìm thấy vấn đề này trong tài liệu này. Về mặt lý thuyết, đây có thể là một quy trình được thực hiện rất hiệu quả để "bỏ lại phía sau" và không đánh giá lại toán hạng bên trái, nhưng nó có hiệu quả không?

'Hiệu quả' có cho tất cả các ví dụ cho đến nay được xây dựng trong các câu trả lời của chủ đề này. Nhưng hiệu quả trong trường hợp thuộc tính và bộ chỉ mục sử dụng bộ truy cập get- và set? Không có gì. Xem xét mã này:

class Test
{
    public bool MyProperty { get { return true; } set { ; } }
}

Ở đây chúng ta có một thuộc tính, thậm chí không phải là một trình bao bọc cho một biến riêng. Bất cứ khi nào được kêu gọi anh ta sẽ trở về đúng, bất cứ khi nào cố gắng thiết lập giá trị của mình, anh ta sẽ không làm gì cả. Vì vậy, bất cứ khi nào tài sản này được đánh giá, anh ta sẽ được trung thực. Hãy xem điều gì xảy ra:

Test test = new Test();

if ((test.MyProperty = false) == true)
    Console.WriteLine("Please print this text.");

else
    Console.WriteLine("Unexpected!!");

Đoán xem nó in cái gì? Nó in Unexpected!!. Hóa ra, bộ truy cập thiết lập thực sự được gọi, không có gì. Nhưng sau đó, người truy cập get không bao giờ được gọi cả. Việc chuyển nhượng chỉ đơn giản là để lại falsegiá trị mà chúng tôi đã cố gắng gán cho tài sản của chúng tôi. Và falsegiá trị này là những gì câu lệnh if đánh giá.

Tôi sẽ kết thúc với một ví dụ thực tế khiến tôi phải nghiên cứu vấn đề này. Tôi đã tạo một bộ chỉ mục là một trình bao bọc thuận tiện cho một bộ sưu tập ( List<string>) mà một lớp của tôi có một biến riêng.

Tham số được gửi tới bộ chỉ mục là một chuỗi, được coi là một giá trị trong bộ sưu tập của tôi. Trình truy cập get chỉ đơn giản trả về giá trị true hoặc false nếu giá trị đó tồn tại trong danh sách hay không. Do đó, bộ truy cập get là một cách khác để sử dụng List<T>.Containsphương thức.

Nếu bộ truy cập tập hợp chỉ mục được gọi với một chuỗi làm đối số và toán hạng bên phải là một bool true, anh ta sẽ thêm tham số đó vào danh sách. Nhưng nếu cùng một tham số được gửi đến người truy cập và toán hạng bên phải là một bool false, thay vào đó anh ta sẽ xóa phần tử khỏi danh sách. Do đó, bộ truy cập đã được sử dụng như là một thay thế thuận tiện cho cả hai List<T>.Addvà List<T>.Remove.

Tôi nghĩ rằng tôi đã có một "API" gọn gàng và gọn gàng trong danh sách với logic riêng của tôi được triển khai như một cổng. Với sự giúp đỡ của một người lập chỉ mục, tôi có thể làm nhiều việc với một vài tổ hợp phím. Chẳng hạn, làm thế nào tôi có thể thử thêm một giá trị vào danh sách của mình và xác minh rằng nó có trong đó không? Tôi nghĩ rằng đây là dòng mã duy nhất cần thiết:

if (myObject["stringValue"] = true)
    ; // Set operation succeeded..!

Nhưng như ví dụ trước đây của tôi đã chỉ ra, trình truy cập get được cho là để xem liệu giá trị thực sự có trong danh sách thậm chí không được gọi hay không. Các truegiá trị luôn được bỏ lại phía sau một cách hiệu quả phá hủy bất cứ logic tôi đã thực hiện trong get accessor tôi.

Nếu gán không trả về giá trị, dòng a = b = c = 16sẽ không hoạt động.

Ngoài ra đôi khi có thể viết những thứ như while ((s = readLine()) != null)có thể hữu ích.

Vì vậy, lý do đằng sau để cho phép gán trả về giá trị được gán, là để cho bạn làm những việc đó.

Tôi nghĩ bạn đang hiểu sai về cách trình phân tích cú pháp sẽ diễn giải cú pháp đó. Bài tập sẽ được đánh giá đầu tiên và sau đó kết quả sẽ được so sánh với NULL, tức là câu lệnh tương đương với:

s = "Hello"; //s now contains the value "Hello"
(s != null) //returns true.

Như những người khác đã chỉ ra, kết quả của một bài tập là giá trị được gán. Tôi thấy khó có thể tưởng tượng được lợi thế để có

((s = "Hello") != null)

và

s = "Hello";
s != null;

không tương đương ...

Tôi nghĩ lý do chính là sự giống nhau (có chủ ý) với C ++ và C. Làm cho toán tử xác nhận (và rất nhiều cấu trúc ngôn ngữ khác) hoạt động giống như các đối tác C ++ của họ chỉ tuân theo nguyên tắc ít gây bất ngờ nhất và bất kỳ lập trình viên nào đến từ một xoăn khác ngôn ngữ khung có thể sử dụng chúng mà không tốn nhiều suy nghĩ. Dễ dàng chọn các lập trình viên C ++ là một trong những mục tiêu thiết kế chính của C #.

Vì hai lý do bạn đưa vào bài đăng
1) để bạn có thể thực hiện a = b = c = 16
2) để bạn có thể kiểm tra nếu một bài tập thành công if ((s = openSomeHandle()) != null)

Việc 'a ++' hoặc 'printf ("foo")' có thể hữu ích như là một câu lệnh khép kín hoặc là một phần của biểu thức lớn hơn có nghĩa là C phải cho phép khả năng kết quả biểu thức có thể hoặc không đã sử dụng. Do đó, có một khái niệm chung là các biểu thức có thể hữu ích 'trả lại' một giá trị cũng có thể làm như vậy. Chuỗi chuyển nhượng có thể hơi "thú vị" trong C và thậm chí thú vị hơn trong C ++, nếu tất cả các biến trong câu hỏi không có cùng loại chính xác. Tập quán như vậy có lẽ tốt nhất nên tránh.

Một trường hợp sử dụng ví dụ tuyệt vời khác, tôi sử dụng điều này mọi lúc:

var x = _myVariable ?? (_myVariable = GetVariable());
//for example: when used inside a loop, "GetVariable" will be called only once

Một lợi thế nữa mà tôi không thấy được đưa ra trong các câu trả lời ở đây, đó là cú pháp chuyển nhượng dựa trên số học.

Bây giờ x = y = b = c = 2 + 3có nghĩa là một cái gì đó khác nhau về số học so với ngôn ngữ kiểu C; trong số học, đây là một khẳng định, chúng tôi tuyên bố rằng x bằng y, v.v. và trong ngôn ngữ kiểu C, đó là một lệnh làm cho x bằng y, v.v. sau khi nó được thực thi.

Điều này nói rằng, vẫn còn đủ mối quan hệ giữa số học và mã mà không có nghĩa là không cho phép những gì tự nhiên trong số học trừ khi có lý do chính đáng. (Một điều khác mà các ngôn ngữ kiểu C lấy từ việc sử dụng ký hiệu bằng là sử dụng == để so sánh bằng. Ở đây, mặc dù bởi vì hầu hết các quyền == trả về một giá trị loại chuỗi này là không thể.)

Tôi thích sử dụng giá trị trả về chuyển nhượng khi tôi cần cập nhật một loạt các công cụ và trả lại cho dù có bất kỳ thay đổi nào hay không:

bool hasChanged = false;

hasChanged |= thing.Property != (thing.Property = "Value");
hasChanged |= thing.AnotherProperty != (thing.AnotherProperty = 42);
hasChanged |= thing.OneMore != (thing.OneMore = "They get it");

return hasChanged;

Hãy cẩn thận. Bạn có thể nghĩ rằng bạn có thể rút ngắn nó về điều này:

return thing.Property != (thing.Property = "Value") ||
    thing.AnotherProperty != (thing.AnotherProperty = 42) ||
    thing.OneMore != (thing.OneMore = "They get it");

Nhưng điều này thực sự sẽ ngừng đánh giá hoặc các tuyên bố sau khi nó tìm thấy sự thật đầu tiên. Trong trường hợp này có nghĩa là nó dừng gán các giá trị tiếp theo một khi nó gán giá trị đầu tiên khác.

Xem https://dotnetfiddle.net/e05Rh8 để chơi xung quanh với điều này