Sau các cuộc thảo luận ở đây về SO, tôi đã đọc nhiều lần nhận xét rằng các cấu trúc có thể thay đổi được là Evil evil (giống như trong câu trả lời cho điều này câu hỏi ).

Vấn đề thực sự với tính đột biến và cấu trúc trong C # là gì?

Cấu trúc là các loại giá trị có nghĩa là chúng được sao chép khi chúng được truyền xung quanh.

Vì vậy, nếu bạn thay đổi một bản sao, bạn chỉ thay đổi bản sao đó, không phải bản gốc và không phải bất kỳ bản sao nào khác có thể có xung quanh.

Nếu cấu trúc của bạn là bất biến thì tất cả các bản sao tự động do được truyền theo giá trị sẽ giống nhau.

Nếu bạn muốn thay đổi nó, bạn phải có ý thức thực hiện nó bằng cách tạo một thể hiện mới của cấu trúc với dữ liệu đã sửa đổi. (không phải bản sao)

Bắt đầu từ đâu ;-p

Blog của Eric Lippert luôn tốt cho một trích dẫn:

Đây là một lý do khác tại sao các loại giá trị đột biến là xấu xa. Cố gắng luôn luôn làm cho các loại giá trị bất biến.

Đầu tiên, bạn có xu hướng mất các thay đổi khá dễ dàng ... ví dụ: đưa mọi thứ ra khỏi danh sách:

Foo foo = list[0];
foo.Name = "abc";

điều đó đã thay đổi điều gì? Không có gì hữu ích ...

Tương tự với các thuộc tính:

myObj.SomeProperty.Size = 22; // the compiler spots this one

buộc bạn phải làm:

Bar bar = myObj.SomeProperty;
bar.Size = 22;
myObj.SomeProperty = bar;

ít nghiêm trọng hơn, có một vấn đề kích thước; đối tượng đột biến có xu hướng có nhiều thuộc tính; Tuy nhiên, nếu bạn có một cấu trúc với hai ints, a string, a DateTimevà a bool, bạn có thể nhanh chóng ghi lại rất nhiều bộ nhớ. Với một lớp, nhiều người gọi có thể chia sẻ một tham chiếu đến cùng một thể hiện (các tham chiếu là nhỏ).

Tôi sẽ không nói xấu nhưng khả năng biến đổi thường là một dấu hiệu của sự hăng hái từ phía lập trình viên để cung cấp tối đa chức năng. Trong thực tế, điều này thường không cần thiết và đến lượt nó, làm cho giao diện nhỏ hơn, dễ sử dụng hơn và khó sử dụng hơn (= mạnh mẽ hơn).

Một ví dụ về điều này là đọc / ghi và viết / ghi xung đột trong điều kiện chủng tộc. Điều này chỉ đơn giản là không thể xảy ra trong các cấu trúc bất biến, vì một ghi không phải là một hoạt động hợp lệ.

Ngoài ra, tôi khẳng định rằng tính đột biến gần như không bao giờ thực sự cần thiết , lập trình viên chỉ nghĩ rằng nó có thể sẽ có trong tương lai. Ví dụ, đơn giản là không có ý nghĩa để thay đổi một ngày. Thay vào đó, tạo một ngày mới dựa trên ngày cũ. Đây là một hoạt động giá rẻ, vì vậy hiệu suất không phải là một cân nhắc.

Cấu trúc đột biến không phải là xấu xa.

Họ là hoàn toàn cần thiết trong hoàn cảnh hiệu suất cao. Ví dụ: khi các dòng bộ đệm và hoặc bộ sưu tập rác trở thành nút cổ chai.

Tôi sẽ không gọi việc sử dụng một cấu trúc bất biến trong các trường hợp sử dụng hoàn toàn hợp lệ này là "tội ác".

Tôi có thể thấy rằng cú pháp của C # không giúp phân biệt quyền truy cập của một thành viên của loại giá trị hoặc loại tham chiếu, vì vậy tôi tất cả đều thích các cấu trúc bất biến, thực thi bất biến, trên các cấu trúc có thể thay đổi.

Tuy nhiên, thay vì chỉ đơn giản gắn nhãn các cấu trúc bất biến là "xấu xa", tôi khuyên bạn nên nắm lấy ngôn ngữ và ủng hộ quy tắc ngón tay cái hữu ích và mang tính xây dựng hơn.

Ví dụ: "structs là các loại giá trị, được sao chép theo mặc định. Bạn cần tham chiếu nếu bạn không muốn sao chép chúng" hoặc "thử làm việc với các cấu trúc chỉ đọc trước" .

Các cấu trúc với các trường hoặc thuộc tính có thể thay đổi công khai không phải là xấu.

Các phương thức cấu trúc (khác với các setters thuộc tính) đột biến "cái này" là hơi xấu, chỉ vì .net không cung cấp một phương tiện để phân biệt chúng với các phương thức không. Các phương thức cấu trúc không làm thay đổi "cái này" sẽ là bất khả xâm phạm ngay cả trên các cấu trúc chỉ đọc mà không cần sao chép phòng thủ. Các phương thức làm đột biến "cái này" hoàn toàn không nên bất khả xâm phạm trên các cấu trúc chỉ đọc. Vì .net không muốn cấm các phương thức cấu trúc không sửa đổi "điều này" khỏi việc được gọi trên các cấu trúc chỉ đọc, nhưng không muốn cho phép các cấu trúc chỉ đọc bị đột biến, nên nó sao chép các cấu trúc trong đọc chỉ bối cảnh, được cho là tồi tệ nhất của cả hai thế giới.

Mặc dù có vấn đề với việc xử lý các phương thức tự biến đổi trong bối cảnh chỉ đọc, tuy nhiên, các cấu trúc có thể thay đổi thường cung cấp ngữ nghĩa vượt trội hơn nhiều so với các loại lớp có thể thay đổi. Hãy xem xét ba chữ ký phương pháp sau:

struct PointySturation {public int x, y, z;};
lớp PointyClass {công khai int x, y, z;};

void Phương thức1 (PointySturation foo);
void Phương thức 2 (ref PointySturation foo);
void Phương thức3 (PointyClass foo);

Đối với mỗi phương pháp, trả lời các câu hỏi sau:

1. Giả sử phương thức không sử dụng bất kỳ mã "không an toàn" nào, nó có thể sửa đổi foo không?
2. Nếu không có tham chiếu bên ngoài nào đến 'foo' trước khi phương thức được gọi, thì có thể tồn tại tham chiếu bên ngoài không?

_{Đáp án:}

Câu 1 ::
  Method1()không (ý định rõ ràng)
  Method2() : có (ý định rõ ràng)
  Method3() : có (ý định không chắc chắn)
Câu 2
  Method1():: không
  Method2(): không (trừ khi không an toàn)
  Method3() : có

Phương thức 1 không thể sửa đổi foo và không bao giờ có được tài liệu tham khảo. Phương thức 2 có một tham chiếu ngắn đến foo, nó có thể sử dụng sửa đổi các trường của foo bất kỳ số lần nào, theo bất kỳ thứ tự nào cho đến khi trả về, nhưng nó không thể duy trì tham chiếu đó. Trước khi Phương thức 2 trả về, trừ khi nó sử dụng mã không an toàn, mọi bản sao có thể được tạo từ tham chiếu 'foo' của nó sẽ biến mất. Phương thức 3, không giống như Phương thức 2, có một tài liệu tham khảo có thể chia sẻ bừa bãi cho foo và không biết nó có thể làm gì với nó. Nó có thể không thay đổi foo chút nào, nó có thể thay đổi foo và sau đó quay trở lại, hoặc nó có thể đưa ra một tham chiếu đến foo đến một chủ đề khác có thể thay đổi nó theo một cách tùy tiện vào một thời điểm tùy ý trong tương lai.

Mảng cấu trúc cung cấp ngữ nghĩa tuyệt vời. Với RectArray [500] loại Hình chữ nhật, rõ ràng và rõ ràng làm thế nào để sao chép phần tử 123 sang phần tử 456 và sau đó một thời gian sau đó đặt chiều rộng của phần tử 123 thành 555, mà không làm phiền phần tử 456. "RectArray [432] = RectArray [321] ]; ...; RectArray [123] .Width = 555; ". Biết rằng Hình chữ nhật là một cấu trúc với trường số nguyên có tên là Width sẽ cho mọi người biết tất cả những gì cần biết về các câu lệnh trên.

Bây giờ, giả sử RectClass là một lớp có cùng các trường với Hình chữ nhật và người ta muốn thực hiện các thao tác tương tự trên RectClassArray [500] loại RectClass. Có lẽ mảng được cho là chứa 500 tham chiếu bất biến được khởi tạo trước cho các đối tượng RectClass có thể thay đổi. trong trường hợp đó, mã thích hợp sẽ là một cái gì đó như "RectClassArray [321]. SetBound (RectClassArray [456]); ...; RectClassArray [321] .X = 555;". Có lẽ mảng được giả sử giữ các trường hợp sẽ không thay đổi, vì vậy mã phù hợp sẽ giống như "RectClassArray [321] = RectClassArray [456]; ...; RectClassArray [321] = New RectClass (RectClassArray [321] ]); RectClassArray [321] .X = 555; " Để biết người ta phải làm gì, người ta sẽ phải biết nhiều hơn cả về RectClass (ví dụ: nó có hỗ trợ trình tạo bản sao, phương thức sao chép, v.v. ) và mục đích sử dụng của mảng. Không nơi nào gần như sạch sẽ như sử dụng một cấu trúc.

Chắc chắn, không có cách nào hay cho bất kỳ lớp container nào ngoài một mảng để cung cấp ngữ nghĩa rõ ràng của một mảng cấu trúc. Điều tốt nhất có thể làm, nếu một người muốn một bộ sưu tập được lập chỉ mục với một chuỗi, có lẽ sẽ cung cấp một phương thức "ActOnItem" chung để chấp nhận một chuỗi cho chỉ mục, một tham số chung và một đại biểu sẽ được thông qua bằng cách tham chiếu cả tham số chung và mục bộ sưu tập. Điều đó sẽ cho phép gần như cùng một ngữ nghĩa như các mảng cấu trúc, nhưng trừ khi mọi người có thể theo đuổi vb.net và C # để cung cấp một cú pháp hay, mã sẽ trông có vẻ lộn xộn ngay cả khi nó có hiệu suất hợp lý (truyền tham số chung sẽ cho phép sử dụng một ủy nhiệm tĩnh và sẽ tránh mọi nhu cầu tạo bất kỳ thể hiện lớp tạm thời nào).

Cá nhân, tôi cảm thấy căm ghét Eric Lippert et al. phun ra liên quan đến các loại giá trị đột biến. Họ cung cấp ngữ nghĩa sạch hơn nhiều so với các loại tham chiếu lăng nhăng được sử dụng ở mọi nơi. Mặc dù có một số hạn chế với sự hỗ trợ của .net đối với các loại giá trị, có nhiều trường hợp các loại giá trị có thể thay đổi phù hợp hơn bất kỳ loại thực thể nào khác.

Các loại giá trị về cơ bản đại diện cho các khái niệm bất biến. Fx, thật vô nghĩa khi có một giá trị toán học như số nguyên, vectơ, v.v. và sau đó có thể sửa đổi nó. Điều đó sẽ giống như xác định lại ý nghĩa của một giá trị. Thay vì thay đổi một loại giá trị, sẽ có ý nghĩa hơn khi gán một giá trị duy nhất khác. Hãy nghĩ về thực tế rằng các loại giá trị được so sánh bằng cách so sánh tất cả các giá trị thuộc tính của nó. Vấn đề là nếu các thuộc tính giống nhau thì đó là đại diện phổ quát của giá trị đó.

Như Konrad đề cập, việc thay đổi một ngày cũng không có ý nghĩa gì, vì giá trị đại diện cho điểm duy nhất đó theo thời gian và không phải là một thể hiện của một đối tượng thời gian có bất kỳ trạng thái hoặc phụ thuộc ngữ cảnh nào.

Hy vọng điều này có ý nghĩa với bạn. Đó là nhiều hơn về khái niệm bạn cố gắng nắm bắt với các loại giá trị hơn là chi tiết thực tế, để chắc chắn.

Có một vài trường hợp góc khác có thể dẫn đến hành vi không thể đoán trước theo quan điểm của lập trình viên.

Các loại giá trị bất biến và các trường chỉ đọc

    // Simple mutable structure. 
    // Method IncrementI mutates current state.
    struct Mutable
    {
        public Mutable(int i) : this() 
        {
            I = i;
        }

        public void IncrementI() { I++; }

        public int I { get; private set; }
    }

    // Simple class that contains Mutable structure
    // as readonly field
    class SomeClass 
    {
        public readonly Mutable mutable = new Mutable(5);
    }

    // Simple class that contains Mutable structure
    // as ordinary (non-readonly) field
    class AnotherClass 
    {
        public Mutable mutable = new Mutable(5);
    }

    class Program
    {
        void Main()
        {
            // Case 1. Mutable readonly field
            var someClass = new SomeClass();
            someClass.mutable.IncrementI();
            // still 5, not 6, because SomeClass.mutable field is readonly
            // and compiler creates temporary copy every time when you trying to
            // access this field
            Console.WriteLine(someClass.mutable.I);

            // Case 2. Mutable ordinary field
            var anotherClass = new AnotherClass();
            anotherClass.mutable.IncrementI();

            // Prints 6, because AnotherClass.mutable field is not readonly
            Console.WriteLine(anotherClass.mutable.I);
        }
    }

Các loại giá trị có thể thay đổi và mảng

Giả sử chúng ta có một mảng Mutablecấu trúc của chúng ta và chúng ta đang gọi IncrementIphương thức cho phần tử đầu tiên của mảng đó. Hành vi nào bạn mong đợi từ cuộc gọi này? Nó nên thay đổi giá trị của mảng hay chỉ là một bản sao?

    Mutable[] arrayOfMutables = new Mutable[1];
    arrayOfMutables[0] = new Mutable(5);

    // Now we actually accessing reference to the first element
    // without making any additional copy
    arrayOfMutables[0].IncrementI();

    // Prints 6!!
    Console.WriteLine(arrayOfMutables[0].I);

    // Every array implements IList<T> interface
    IList<Mutable> listOfMutables = arrayOfMutables;

    // But accessing values through this interface lead
    // to different behavior: IList indexer returns a copy
    // instead of an managed reference
    listOfMutables[0].IncrementI(); // Should change I to 7

    // Nope! we still have 6, because previous line of code
    // mutate a copy instead of a list value
    Console.WriteLine(listOfMutables[0].I);

Vì vậy, các cấu trúc đột biến không phải là xấu xa miễn là bạn và phần còn lại của nhóm hiểu rõ những gì bạn đang làm. Nhưng có quá nhiều trường hợp góc khi hành vi chương trình sẽ khác với những gì được mong đợi, điều đó có thể dẫn đến những lỗi khó sản xuất và khó hiểu.

Nếu bạn đã từng lập trình bằng một ngôn ngữ như C / C ++, các cấu trúc sẽ ổn khi sử dụng như là biến đổi. Chỉ cần vượt qua chúng với ref, xung quanh và không có gì có thể đi sai. Vấn đề duy nhất tôi tìm thấy là các hạn chế của trình biên dịch C # và trong một số trường hợp, tôi không thể ép buộc điều ngu ngốc đó là sử dụng tham chiếu đến struct, thay vì Copy (như khi struct là một phần của lớp C # ).

Vì vậy, các cấu trúc đột biến không phải là xấu xa, C # đã làm cho chúng trở nên xấu xa. Tôi sử dụng các cấu trúc đột biến trong C ++ mọi lúc và chúng rất thuận tiện và trực quan. Ngược lại, C # đã khiến tôi từ bỏ hoàn toàn các cấu trúc với tư cách là thành viên của các lớp vì cách chúng xử lý các đối tượng. Sự tiện lợi của họ đã khiến chúng ta phải trả giá.

Nếu bạn sử dụng các cấu trúc được dự định cho (trong C #, Visual Basic 6, Pascal / Delphi, kiểu cấu trúc C ++ (hoặc các lớp) khi chúng không được sử dụng làm con trỏ), bạn sẽ thấy rằng cấu trúc không nhiều hơn một biến ghép . Điều này có nghĩa là: bạn sẽ coi chúng như một tập hợp các biến, dưới một tên chung (một biến bản ghi mà bạn tham chiếu từ các thành viên).

Tôi biết rằng sẽ khiến nhiều người nhầm lẫn với OOP, nhưng điều đó không đủ lý do để nói những thứ như vậy vốn là xấu xa, nếu được sử dụng đúng cách. Một số cấu trúc không thể thay đổi được như họ dự định (đây là trường hợp của Python namedtuple), nhưng đó là một mô hình khác để xem xét.

Có: cấu trúc liên quan đến rất nhiều bộ nhớ, nhưng nó sẽ không chính xác hơn bộ nhớ bằng cách thực hiện:

point.x = point.x + 1

so với:

point = Point(point.x + 1, point.y)

Tiêu thụ bộ nhớ sẽ ít nhất là như nhau, hoặc thậm chí nhiều hơn trong trường hợp không thể thay đổi (mặc dù trường hợp đó là tạm thời, đối với ngăn xếp hiện tại, tùy thuộc vào ngôn ngữ).

Nhưng, cuối cùng, cấu trúc là cấu trúc , không phải đối tượng. Trong POO, thuộc tính chính của một đối tượng là danh tính của chúng , mà hầu hết thời gian không nhiều hơn địa chỉ bộ nhớ của nó. Struct là viết tắt của cấu trúc dữ liệu (không phải là một đối tượng thích hợp và vì vậy dù sao họ cũng không có danh tính) và dữ liệu có thể được sửa đổi. Trong các ngôn ngữ khác, bản ghi (thay vì struct , như trường hợp của Pascal) là từ và giữ cùng một mục đích: chỉ là một biến bản ghi dữ liệu, dự định được đọc từ tệp, được sửa đổi và đổ vào tệp (đó là chính sử dụng và, trong nhiều ngôn ngữ, bạn thậm chí có thể xác định căn chỉnh dữ liệu trong bản ghi, trong khi đó không nhất thiết là trường hợp được gọi đúng là Đối tượng).

Bạn muốn một ví dụ tốt? Cấu trúc được sử dụng để đọc các tập tin dễ dàng. Python có thư viện này bởi vì, nó hướng đối tượng và không hỗ trợ các cấu trúc, nên nó phải thực hiện nó theo một cách khác, điều này hơi xấu. Các ngôn ngữ thực hiện cấu trúc có tính năng đó ... tích hợp. Hãy thử đọc một tiêu đề bitmap với cấu trúc phù hợp bằng các ngôn ngữ như Pascal hoặc C. Sẽ dễ dàng (nếu cấu trúc được xây dựng và căn chỉnh chính xác; trong Pascal, bạn sẽ không sử dụng truy cập dựa trên bản ghi mà có chức năng đọc dữ liệu nhị phân tùy ý). Vì vậy, đối với các tệp và truy cập bộ nhớ trực tiếp (cục bộ), các cấu trúc tốt hơn các đối tượng. Cho đến ngày nay, chúng ta đã quen với JSON và XML và vì vậy chúng ta quên việc sử dụng các tệp nhị phân (và như một tác dụng phụ, việc sử dụng các cấu trúc). Nhưng có: họ tồn tại, và có một mục đích.

Họ không xấu xa. Chỉ cần sử dụng chúng cho đúng mục đích.

Nếu bạn nghĩ về búa, bạn sẽ muốn coi ốc vít là đinh, để tìm ốc vít khó cắm vào tường hơn, và đó sẽ là lỗi của ốc vít, và chúng sẽ là những kẻ xấu.

Hãy tưởng tượng bạn có một mảng gồm 1.000.000 cấu trúc. Mỗi cấu trúc đại diện cho một vốn chủ sở hữu với các công cụ như price_price, Offer_price (có lẽ là số thập phân), v.v., điều này được tạo bởi C # / VB.

Hãy tưởng tượng mảng đó được tạo trong một khối bộ nhớ được phân bổ trong heap không được quản lý để một số luồng mã gốc khác có thể truy cập đồng thời vào mảng (có lẽ một số mã hoàn hảo cao đang làm toán).

Hãy tưởng tượng mã C # / VB đang lắng nghe nguồn cấp thị trường về sự thay đổi giá, mã đó có thể phải truy cập vào một số phần tử của mảng (đối với bất kỳ bảo mật nào) và sau đó sửa đổi một số trường giá.

Hãy tưởng tượng điều này đang được thực hiện hàng chục hoặc thậm chí hàng trăm ngàn lần mỗi giây.

Hãy đối mặt với sự thật, trong trường hợp này, chúng tôi thực sự muốn các cấu trúc này có thể thay đổi được, chúng cần phải được chia sẻ bởi một số mã gốc khác nên việc tạo các bản sao sẽ không giúp ích gì; chúng cần phải được thực hiện bởi vì việc tạo một bản sao của cấu trúc 120 byte ở các tốc độ này là sự mất trí, đặc biệt là khi một bản cập nhật thực sự có thể tác động chỉ một hoặc hai byte.

Hugo

Khi một cái gì đó có thể được đột biến, nó có được một cảm giác đồng nhất.

struct Person {
    public string name; // mutable
    public Point position = new Point(0, 0); // mutable

    public Person(string name, Point position) { ... }
}

Person eric = new Person("Eric Lippert", new Point(4, 2));

Bởi vì Personcó thể thay đổi, nên nghĩ về việc thay đổi vị trí của Eric sẽ tốt hơn là nhân bản Eric, di chuyển bản sao và phá hủy bản gốc . Cả hai hoạt động sẽ thành công trong việc thay đổi nội dung của eric.position, nhưng một hoạt động trực quan hơn so với hoạt động khác. Tương tự như vậy, sẽ trực quan hơn khi vượt qua Eric (như một tài liệu tham khảo) cho các phương pháp để sửa đổi anh ta. Đưa ra một phương pháp một bản sao của Eric hầu như sẽ luôn gây ngạc nhiên. Bất cứ ai muốn đột biến Personđều phải nhớ yêu cầu tham khảo Personhoặc họ sẽ làm sai.

Nếu bạn làm cho loại bất biến, vấn đề sẽ biến mất; nếu tôi không thể sửa đổi eric, điều đó sẽ không khác biệt gì đối với tôi dù tôi nhận được erichay là một bản sao eric. Tổng quát hơn, một loại an toàn để vượt qua giá trị nếu tất cả trạng thái quan sát được của nó được giữ trong các thành viên:

• bất biến
• loại tham khảo
• an toàn để vượt qua giá trị

Nếu các điều kiện đó được đáp ứng thì loại giá trị có thể thay đổi hoạt động giống như loại tham chiếu vì bản sao nông sẽ vẫn cho phép người nhận sửa đổi dữ liệu gốc.

Trực giác của một bất biến Personphụ thuộc vào những gì bạn đang cố gắng làm mặc dù. Nếu Personchỉ đại diện cho một tập hợp dữ liệu về một người, thì không có gì là không trực quan về nó; Personcác biến thực sự đại diện cho các giá trị trừu tượng , không phải các đối tượng. (Trong trường hợp đó, có lẽ sẽ thích hợp hơn để đổi tên thành PersonData.) NếuPerson thực sự là mô hình hóa bản thân một người, ý tưởng liên tục tạo và di chuyển bản sao là ngớ ngẩn ngay cả khi bạn tránh được cạm bẫy khi nghĩ rằng bạn đang sửa đổi bản gốc. Trong trường hợp đó, có lẽ sẽ tự nhiên hơn khi chỉ cần tạo Personmột kiểu tham chiếu (nghĩa là một lớp.)

Cấp, vì lập trình chức năng đã dạy chúng ta có những lợi ích để biến mọi thứ thành bất biến (không ai có thể bí mật giữ tham chiếu ericvà biến đổi anh ta), nhưng vì đó không phải là thành ngữ trong OOP nên nó vẫn không trực quan với bất kỳ ai làm việc với bạn mã.

Nó không liên quan gì đến các cấu trúc (và không phải với C #), nhưng trong Java, bạn có thể gặp vấn đề với các đối tượng có thể thay đổi khi chúng là các khóa trong bản đồ băm. Nếu bạn thay đổi chúng sau khi thêm chúng vào bản đồ và nó thay đổi mã băm của nó , điều xấu có thể xảy ra.

Cá nhân khi tôi nhìn vào mã, những thứ sau đây trông khá khó hiểu với tôi:

data.value.set (data.value.get () + 1);

thay vì chỉ đơn giản

dữ liệu.value ++; hoặc data.value = data.value + 1;

Đóng gói dữ liệu rất hữu ích khi chuyển một lớp xung quanh và bạn muốn đảm bảo giá trị được sửa đổi theo kiểu được kiểm soát. Tuy nhiên, khi bạn đã thiết lập công khai và nhận các hàm ít hơn nhiều so với đặt giá trị cho những gì đã được truyền vào, làm thế nào đây là một cải tiến so với việc chuyển một cấu trúc dữ liệu công cộng xung quanh?

Khi tôi tạo một cấu trúc riêng bên trong một lớp, tôi đã tạo cấu trúc đó để tổ chức một tập hợp các biến thành một nhóm. Tôi muốn có thể sửa đổi cấu trúc đó trong phạm vi lớp, không nhận được các bản sao của cấu trúc đó và tạo các thể hiện mới.

Đối với tôi điều này ngăn việc sử dụng hợp lệ các cấu trúc đang được sử dụng để tổ chức các biến công khai, nếu tôi muốn kiểm soát truy cập tôi sẽ sử dụng một lớp.

Có một số vấn đề với ví dụ của ông Eric Lippert. Nó được cố gắng để minh họa điểm mà các cấu trúc được sao chép và làm thế nào đó có thể là một vấn đề nếu bạn không cẩn thận. Nhìn vào ví dụ tôi thấy nó là kết quả của một thói quen lập trình xấu và không thực sự là vấn đề với cả struct hoặc class.

1. Một cấu trúc được cho là chỉ có các thành viên công cộng và không yêu cầu đóng gói. Nếu có thì nó thực sự phải là một loại / lớp. Bạn thực sự không cần hai cấu trúc để nói cùng một điều.

2. Nếu bạn có lớp bao quanh một cấu trúc, bạn sẽ gọi một phương thức trong lớp để thay đổi cấu trúc thành viên. Đây là những gì tôi sẽ làm như một thói quen lập trình tốt.

Một thực hiện đúng sẽ như sau.

struct Mutable {
public int x;
}

class Test {
    private Mutable m = new Mutable();
    public int mutate()
    { 
        m.x = m.x + 1;
        return m.x;
    }
  }
  static void Main(string[] args) {
        Test t = new Test();
        System.Console.WriteLine(t.mutate());
        System.Console.WriteLine(t.mutate());
        System.Console.WriteLine(t.mutate());
    }

Có vẻ như đó là một vấn đề với thói quen lập trình trái ngược với một vấn đề với chính struct. Structs được cho là có thể thay đổi, đó là ý tưởng và ý định.

Kết quả của những thay đổi voila hành xử như mong đợi:

1 2 3 Nhấn phím bất kỳ để tiếp tục. . .

Có nhiều ưu điểm và nhược điểm đối với dữ liệu có thể thay đổi. Bất lợi triệu đô là răng cưa. Nếu cùng một giá trị đang được sử dụng ở nhiều nơi và một trong số chúng thay đổi nó, thì nó sẽ xuất hiện để thay đổi một cách kỳ diệu đến những nơi khác đang sử dụng nó. Điều này có liên quan đến, nhưng không giống với điều kiện chủng tộc.

Lợi thế triệu đô là đôi khi. Trạng thái có thể thay đổi có thể cho phép bạn ẩn thông tin thay đổi khỏi mã mà không cần biết về nó.

Nghệ thuật của thông dịch viên đi sâu vào những sự đánh đổi này một cách chi tiết, và đưa ra một số ví dụ.

Tôi không tin rằng họ xấu xa nếu sử dụng đúng cách. Tôi sẽ không đưa nó vào mã sản xuất của mình, nhưng tôi sẽ làm một cái gì đó giống như các thử nghiệm đơn vị có cấu trúc, trong đó tuổi thọ của một cấu trúc tương đối nhỏ.

Sử dụng ví dụ Eric, có lẽ bạn muốn tạo một phiên bản thứ hai của Eric đó, nhưng thực hiện các điều chỉnh, vì đó là bản chất của thử nghiệm của bạn (nghĩa là sao chép, sau đó sửa đổi). Không có vấn đề gì xảy ra với phiên bản đầu tiên của Eric nếu chúng ta chỉ sử dụng Eric2 cho phần còn lại của tập lệnh thử nghiệm, trừ khi bạn có kế hoạch sử dụng anh ấy làm so sánh thử nghiệm.

Điều này sẽ rất hữu ích để kiểm tra hoặc sửa đổi mã kế thừa mà nông xác định một đối tượng cụ thể (điểm của cấu trúc), nhưng bằng cách có một cấu trúc bất biến, điều này ngăn cản việc sử dụng nó một cách khó chịu.