Tham số có thể không đổi?

Tôi đang tìm kiếm C # tương đương với Java final. Nó tồn tại?

C # có bất cứ điều gì như sau:

public Foo(final int bar);

Trong ví dụ trên, barlà một biến chỉ đọc và không thể thay đổi bởi Foo(). Có cách nào để làm điều này trong C # không?

Ví dụ, có lẽ tôi có một phương pháp lâu rằng sẽ làm việc với x, yvà ztọa độ của một số đối tượng (kiểu int). Tôi muốn hoàn toàn chắc chắn rằng hàm không thay đổi các giá trị này theo bất kỳ cách nào, do đó làm hỏng dữ liệu. Vì vậy, tôi muốn tuyên bố chúng chỉ đọc.

public Foo(int x, int y, int z) {
     // do stuff
     x++; // oops. This corrupts the data. Can this be caught at compile time?
     // do more stuff, assuming x is still the original value.
}

Rất tiếc, bạn không thể làm điều này trong C #.

Các consttừ khóa chỉ có thể được sử dụng cho các biến địa phương và các lĩnh vực.

Các readonlytừ khóa chỉ có thể được sử dụng trên đồng ruộng.

LƯU Ý: Ngôn ngữ Java cũng hỗ trợ có các tham số cuối cùng cho một phương thức. Chức năng này không tồn tại trong C #.

từ http://www.25hoursaday.com/CsharpVsJava.html

EDIT (2019/08/13): Tôi đang sử dụng cái này để hiển thị vì nó được chấp nhận và cao nhất trong danh sách. Nó bây giờ là có thể với incác thông số. Xem câu trả lời bên dưới câu trả lời này để biết chi tiết.

Điều này hiện có thể thực hiện trong C # phiên bản 7.2:

Bạn có thể sử dụng intừ khóa trong chữ ký phương thức. Tài liệu MSDN .

Các intừ khóa nên được bổ sung trước khi xác định lập luận của phương pháp.

Ví dụ, một phương thức hợp lệ trong C # 7.2:

public long Add(in long x, in long y)
{
    return x + y;
}

Mặc dù những điều sau đây không được phép:

public long Add(in long x, in long y)
{
    x = 10; // It is not allowed to modify an in-argument.
    return x + y;
}

Lỗi sau sẽ được hiển thị khi cố gắng sửa đổi một trong hai xhoặc yvì chúng được đánh dấu bằng in:

Không thể gán cho biến 'in long' vì nó là biến chỉ đọc

Đánh dấu một đối số có innghĩa là:

Phương thức này không sửa đổi giá trị của đối số được sử dụng làm tham số này.

Đây là một câu trả lời ngắn gọn và ngọt ngào có thể sẽ nhận được rất nhiều phiếu bầu. Tôi chưa đọc tất cả các bài đăng và nhận xét, vì vậy xin hãy tha thứ cho tôi nếu điều này đã được đề xuất trước đó.

Tại sao không lấy các tham số của bạn và chuyển chúng vào một đối tượng hiển thị chúng là bất biến và sau đó sử dụng đối tượng đó trong phương thức của bạn?

Tôi nhận ra rằng đây có lẽ là một công việc rất rõ ràng xung quanh đã được xem xét và OP đang cố gắng tránh làm điều này bằng cách đặt câu hỏi này, nhưng tôi cảm thấy nó không nên ở đây ...

Chúc may mắn :-)

Câu trả lời: C # không có chức năng const như C ++.

Tôi đồng ý với Bennett Dill.

Từ khóa const rất hữu ích. Trong ví dụ, bạn đã sử dụng một số nguyên và mọi người không hiểu ý bạn. Nhưng, tại sao nếu tham số của bạn là một đối tượng lớn và phức tạp của người dùng mà không thể thay đổi bên trong hàm đó? Đó là việc sử dụng từ khóa const: tham số không thể thay đổi bên trong phương thức đó vì [bất kỳ lý do gì ở đây] không quan trọng đối với phương thức đó. Từ khóa Const rất mạnh và tôi thực sự nhớ nó trong C #.

Tôi sẽ bắt đầu với intphần. intlà một kiểu giá trị và trong .Net, điều đó có nghĩa là bạn thực sự đang xử lý một bản sao. Đó là một ràng buộc thiết kế thực sự kỳ lạ khi nói với một phương pháp "Bạn có thể có một bản sao của giá trị này. Đó là bản sao của bạn, không phải của tôi; Tôi sẽ không bao giờ nhìn thấy nó nữa. Nhưng bạn không thể thay đổi bản sao." Trong lời gọi phương thức, việc sao chép giá trị này là được, nếu không thì chúng ta không thể gọi phương thức một cách an toàn. Nếu phương thức cần bản gốc, hãy để người thực hiện tạo một bản sao để lưu. Cung cấp giá trị cho phương thức hoặc không cung cấp giá trị cho phương thức. Đừng đi tất cả những điều khôn ngoan ở giữa.

Hãy chuyển sang các loại tham chiếu. Bây giờ nó có một chút khó hiểu. Ý của bạn là một tham chiếu không đổi, nơi mà bản thân tham chiếu không thể thay đổi được, hay một đối tượng hoàn toàn bị khóa, không thể thay đổi? Nếu trước đó, các tham chiếu trong .Net theo mặc định được chuyển theo giá trị. Đó là, bạn nhận được một bản sao của tài liệu tham khảo. Vì vậy, về cơ bản chúng ta có cùng một tình huống như đối với các loại giá trị. Nếu người triển khai sẽ cần tham chiếu ban đầu, họ có thể tự giữ nó.

Điều đó chỉ để lại cho chúng ta đối tượng không đổi (bị khóa / không thay đổi). Điều này có vẻ ổn từ góc độ thời gian chạy, nhưng làm cách nào để trình biên dịch thực thi nó? Vì tất cả các thuộc tính và phương pháp đều có thể có tác dụng phụ, về cơ bản bạn sẽ bị giới hạn quyền truy cập trường chỉ đọc. Một đối tượng như vậy có thể không thú vị lắm.

Tạo một giao diện cho lớp của bạn mà chỉ có những người truy cập thuộc tính chỉ đọc. Sau đó, hãy để tham số của bạn là của giao diện đó thay vì của chính lớp. Thí dụ:

public interface IExample
{
    int ReadonlyValue { get; }
}

public class Example : IExample
{
    public int Value { get; set; }
    public int ReadonlyValue { get { return this.Value; } }
}


public void Foo(IExample example)
{
    // Now only has access to the get accessors for the properties
}

Đối với cấu trúc, hãy tạo một trình bao bọc const chung.

public struct Const<T>
{
    public T Value { get; private set; }

    public Const(T value)
    {
        this.Value = value;
    }
}

public Foo(Const<float> X, Const<float> Y, Const<float> Z)
{
// Can only read these values
}

Tuy nhiên, điều đáng chú ý là bạn muốn làm những gì bạn yêu cầu làm liên quan đến cấu trúc, với tư cách là tác giả của phương pháp, bạn nên mong đợi biết điều gì đang xảy ra trong phương thức đó. Nó sẽ không ảnh hưởng đến các giá trị được truyền vào để sửa đổi chúng trong phương thức, vì vậy mối quan tâm duy nhất của bạn là đảm bảo rằng bạn tự xử lý theo phương thức bạn đang viết. Có một điểm mà sự cảnh giác và mã sạch là chìa khóa, việc thực thi quá mức const và các quy tắc khác.

Nếu bạn thường xuyên gặp rắc rối như thế này thì bạn nên xem xét "ứng dụng hungarian". Loại tốt, đối lập với loại xấu . Mặc dù điều này thường không cố gắng thể hiện hằng số của một tham số phương thức (điều đó quá bất thường), nhưng chắc chắn không có gì ngăn bạn thêm một chữ "c" vào trước tên mã định danh.

Đối với tất cả những người đau đầu để đóng nút downvote ngay bây giờ, vui lòng đọc ý kiến ​​của những người nổi tiếng này về chủ đề:

• Eric Lippert
• Larry Osterman
• Joel Spolsky

Tôi biết điều này có thể hơi muộn. Nhưng đối với những người vẫn đang tìm kiếm các cách khác cho điều này, có thể có một cách khác để giải quyết hạn chế này của tiêu chuẩn C #. Chúng ta có thể viết lớp wrapper ReadOnly <T> trong đó T: struct. Với chuyển đổi ngầm định sang kiểu cơ sở T. Nhưng chỉ chuyển đổi rõ ràng sang lớp wrapper <T>. Điều này sẽ thực thi các lỗi trình biên dịch nếu nhà phát triển cố gắng đặt ngầm định thành giá trị của loại ReadOnly <T>. Như tôi sẽ trình bày hai cách sử dụng có thể có dưới đây.

SỬ DỤNG 1 định nghĩa người gọi bắt buộc để thay đổi. Việc sử dụng này sẽ chỉ được sử dụng trong việc kiểm tra tính đúng đắn của mã chức năng "TestCalled" của bạn. Trong khi ở cấp độ phát hành / bản dựng, bạn không nên sử dụng nó. Vì trong các phép toán quy mô lớn có thể chuyển đổi quá mức cần thiết và làm cho mã của bạn chậm. Tôi sẽ không sử dụng nó, nhưng chỉ với mục đích trình diễn, tôi đã đăng nó.

SỬ DỤNG 2 mà tôi muốn đề xuất, có sử dụng Gỡ lỗi và Phát hành được chứng minh trong chức năng TestCalled2. Ngoài ra, sẽ không có chuyển đổi trong chức năng TestCaller khi sử dụng cách tiếp cận này, nhưng nó yêu cầu thêm một chút mã hóa các định nghĩa TestCaller2 bằng cách sử dụng điều hòa trình biên dịch. Bạn có thể nhận thấy lỗi trình biên dịch trong cấu hình gỡ lỗi, trong khi cấu hình phát hành, tất cả mã trong hàm TestCalled2 sẽ biên dịch thành công.

using System;
using System.Collections.Generic;

public class ReadOnly<VT>
  where VT : struct
{
  private VT value;
  public ReadOnly(VT value)
  {
    this.value = value;
  }
  public static implicit operator VT(ReadOnly<VT> rvalue)
  {
    return rvalue.value;
  }
  public static explicit operator ReadOnly<VT>(VT rvalue)
  {
    return new ReadOnly<VT>(rvalue);
  }
}

public static class TestFunctionArguments
{
  static void TestCall()
  {
    long a = 0;

    // CALL USAGE 1.
    // explicite cast must exist in call to this function
    // and clearly states it will be readonly inside TestCalled function.
    TestCalled(a);                  // invalid call, we must explicit cast to ReadOnly<T>
    TestCalled((ReadOnly<long>)a);  // explicit cast to ReadOnly<T>

    // CALL USAGE 2.
    // Debug vs Release call has no difference - no compiler errors
    TestCalled2(a);

  }

  // ARG USAGE 1.
  static void TestCalled(ReadOnly<long> a)
  {
    // invalid operations, compiler errors
    a = 10L;
    a += 2L;
    a -= 2L;
    a *= 2L;
    a /= 2L;
    a++;
    a--;
    // valid operations
    long l;
    l = a + 2;
    l = a - 2;
    l = a * 2;
    l = a / 2;
    l = a ^ 2;
    l = a | 2;
    l = a & 2;
    l = a << 2;
    l = a >> 2;
    l = ~a;
  }


  // ARG USAGE 2.
#if DEBUG
  static void TestCalled2(long a2_writable)
  {
    ReadOnly<long> a = new ReadOnly<long>(a2_writable);
#else
  static void TestCalled2(long a)
  {
#endif
    // invalid operations
    // compiler will have errors in debug configuration
    // compiler will compile in release
    a = 10L;
    a += 2L;
    a -= 2L;
    a *= 2L;
    a /= 2L;
    a++;
    a--;
    // valid operations
    // compiler will compile in both, debug and release configurations
    long l;
    l = a + 2;
    l = a - 2;
    l = a * 2;
    l = a / 2;
    l = a ^ 2;
    l = a | 2;
    l = a & 2;
    l = a << 2;
    l = a >> 2;
    l = ~a;
  }

}

Nếu struct được truyền vào một phương thức, trừ khi nó được truyền bởi ref, nó sẽ không bị thay đổi bởi phương thức mà nó được truyền vào. Vì vậy, theo nghĩa đó, có.

Bạn có thể tạo một tham số có giá trị không thể được chỉ định trong phương thức hoặc có thuộc tính không thể được đặt khi ở trong phương thức không? Không. Bạn không thể ngăn giá trị được gán trong phương thức, nhưng bạn có thể ngăn việc thiết lập các thuộc tính của nó bằng cách tạo một kiểu không thay đổi.

Câu hỏi không phải là liệu tham số hay thuộc tính của nó có thể được gán cho trong phương thức hay không. Câu hỏi là nó sẽ như thế nào khi phương thức thoát.

Lần duy nhất bất kỳ dữ liệu bên ngoài nào sẽ bị thay đổi là nếu bạn chuyển một lớp vào và thay đổi một trong các thuộc tính của nó hoặc nếu bạn chuyển một giá trị bằng cách sử dụng từ khóa ref. Tình huống bạn đã nêu ra cũng không.