Mặc dù các trường và thuộc tính trông giống nhau, nhưng chúng là 2 yếu tố ngôn ngữ hoàn toàn khác nhau.
Các trường là cơ chế duy nhất làm thế nào để lưu trữ dữ liệu ở cấp độ lớp. Các trường là các biến khái niệm ở phạm vi lớp. Nếu bạn muốn lưu trữ một số dữ liệu cho các thể hiện của các lớp (đối tượng) của bạn, bạn cần sử dụng các trường. Không còn lựa chọn nào khác. Các thuộc tính không thể lưu trữ bất kỳ dữ liệu nào, mặc dù, có vẻ như chúng có thể làm như vậy. Nhìn phía dưới.
Mặt khác tài sản không bao giờ lưu trữ dữ liệu. Chúng chỉ là các cặp phương thức (lấy và đặt) có thể được gọi một cách tổng hợp theo cách tương tự như các trường và trong hầu hết các trường hợp chúng truy cập (để đọc hoặc ghi) các trường, đó là nguồn gốc của một số nhầm lẫn. Nhưng vì các phương thức thuộc tính là (với một số hạn chế như nguyên mẫu cố định) nên các phương thức C # thông thường, chúng có thể làm bất cứ phương thức thông thường nào có thể làm. Nó có nghĩa là họ có thể có 1000 dòng mã, họ có thể ném ngoại lệ, gọi các phương thức khác, thậm chí có thể là ảo, trừu tượng hoặc ghi đè. Điều làm cho các thuộc tính trở nên đặc biệt, là thực tế là trình biên dịch C # lưu trữ một số siêu dữ liệu bổ sung vào các cụm có thể được sử dụng để tìm kiếm các thuộc tính cụ thể - tính năng được sử dụng rộng rãi.
Nhận và thiết lập các phương thức thuộc tính có các nguyên mẫu sau.
PROPERTY_TYPE get();
void set(PROPERTY_TYPE value);
Vì vậy, điều đó có nghĩa là các thuộc tính có thể được 'mô phỏng' bằng cách xác định một trường và 2 phương thức tương ứng.
class PropertyEmulation
{
private string MSomeValue;
public string GetSomeValue()
{
return(MSomeValue);
}
public void SetSomeValue(string value)
{
MSomeValue=value;
}
}
Việc mô phỏng thuộc tính như vậy là điển hình cho các ngôn ngữ lập trình không hỗ trợ các thuộc tính - như C ++ tiêu chuẩn. Trong C #, bạn phải luôn thích các thuộc tính như cách truy cập vào các trường của mình.
Bởi vì chỉ các trường có thể lưu trữ dữ liệu, điều đó có nghĩa là nhiều lớp trường chứa hơn, nhiều đối tượng bộ nhớ của lớp đó sẽ tiêu thụ. Mặt khác, việc thêm các thuộc tính mới vào một lớp không làm cho các đối tượng của lớp đó lớn hơn. Dưới đây là ví dụ.
class OneHundredFields
{
public int Field1;
public int Field2;
...
public int Field100;
}
OneHundredFields Instance=new OneHundredFields() // Variable 'Instance' consumes 100*sizeof(int) bytes of memory.
class OneHundredProperties
{
public int Property1
{
get
{
return(1000);
}
set
{
// Empty.
}
}
public int Property2
{
get
{
return(1000);
}
set
{
// Empty.
}
}
...
public int Property100
{
get
{
return(1000);
}
set
{
// Empty.
}
}
}
OneHundredProperties Instance=new OneHundredProperties() // !!!!! Variable 'Instance' consumes 0 bytes of memory. (In fact a some bytes are consumed becasue every object contais some auxiliarity data, but size doesn't depend on number of properties).
Mặc dù các phương thức thuộc tính có thể làm bất cứ điều gì, trong hầu hết các trường hợp, chúng phục vụ như một cách để truy cập vào các trường của đối tượng. Nếu bạn muốn làm cho một trường có thể truy cập được vào các lớp khác, bạn có thể thực hiện theo 2 cách.
- Làm cho các lĩnh vực là công cộng - không nên.
- Sử dụng tính chất.
Đây là một lớp sử dụng các lĩnh vực công cộng.
class Name
{
public string FullName;
public int YearOfBirth;
public int Age;
}
Name name=new Name();
name.FullName="Tim Anderson";
name.YearOfBirth=1979;
name.Age=40;
Mặc dù mã là hoàn toàn hợp lệ, từ quan điểm thiết kế, nó có một số nhược điểm. Vì các trường có thể được đọc và viết, bạn không thể ngăn người dùng viết vào các trường. Bạn có thể áp dụng readonlytừ khóa, nhưng theo cách này, bạn phải khởi tạo các trường chỉ đọc trong hàm tạo. Hơn nữa, không có gì ngăn cản bạn lưu trữ các giá trị không hợp lệ vào các trường của bạn.
name.FullName=null;
name.YearOfBirth=2200;
name.Age=-140;
Mã này là hợp lệ, tất cả các bài tập sẽ được thực hiện mặc dù chúng là phi logic. Agecó giá trị âm, YearOfBirthxa trong tương lai và không tương ứng với Tuổi và không FullNamecó giá trị. Với các trường bạn không thể ngăn người dùng class Namemắc lỗi như vậy.
Đây là một mã với các thuộc tính sửa chữa các vấn đề này.
class Name
{
private string MFullName="";
private int MYearOfBirth;
public string FullName
{
get
{
return(MFullName);
}
set
{
if (value==null)
{
throw(new InvalidOperationException("Error !"));
}
MFullName=value;
}
}
public int YearOfBirth
{
get
{
return(MYearOfBirth);
}
set
{
if (MYearOfBirth<1900 || MYearOfBirth>DateTime.Now.Year)
{
throw(new InvalidOperationException("Error !"));
}
MYearOfBirth=value;
}
}
public int Age
{
get
{
return(DateTime.Now.Year-MYearOfBirth);
}
}
public string FullNameInUppercase
{
get
{
return(MFullName.ToUpper());
}
}
}
Phiên bản cập nhật của lớp có những ưu điểm sau.
FullNamevà YearOfBirthđược kiểm tra các giá trị không hợp lệ.Agekhông thể ghi được. Nó được gọi là từ YearOfBirthvà năm nay.- Một thuộc tính mới
FullNameInUppercasechuyển đổi FullNamethành TRƯỜNG HỢP. Đây là một ví dụ nhỏ về sử dụng thuộc tính, trong đó các thuộc tính thường được sử dụng để trình bày các giá trị trường theo định dạng phù hợp hơn với người dùng - ví dụ sử dụng ngôn ngữ hiện tại trên định dạng số cụ thể DateTime.
Bên cạnh đó, các thuộc tính có thể được định nghĩa là ảo hoặc bị ghi đè - đơn giản vì chúng là các phương thức .NET thông thường. Các quy tắc tương tự áp dụng cho các phương thức thuộc tính như đối với các phương thức thông thường.
C # cũng hỗ trợ các bộ chỉ mục là các thuộc tính có tham số chỉ mục trong các phương thức thuộc tính. Dưới đây là ví dụ.
class MyList
{
private string[] MBuffer;
public MyList()
{
MBuffer=new string[100];
}
public string this[int Index]
{
get
{
return(MBuffer[Index]);
}
set
{
MBuffer[Index]=value;
}
}
}
MyList List=new MyList();
List[10]="ABC";
Console.WriteLine(List[10]);
Vì C # 3.0 cho phép bạn xác định các thuộc tính tự động. Dưới đây là ví dụ.
class AutoProps
{
public int Value1
{
get;
set;
}
public int Value2
{
get;
set;
}
}
Mặc dù class AutoPropschỉ chứa các thuộc tính (hoặc trông giống như vậy), nó có thể lưu trữ 2 giá trị và kích thước của các đối tượng của lớp này bằng sizeof(Value1)+sizeof(Value2)= 4 + 4 = 8 byte.
Lý do cho điều này là đơn giản. Khi bạn xác định một thuộc tính tự động, trình biên dịch C # tạo mã tự động chứa trường ẩn và thuộc tính có các phương thức thuộc tính truy cập vào trường ẩn này. Đây là trình biên dịch mã sản xuất.
Đây là một mã được tạo bởi ILSpy từ tập hợp đã biên dịch. Lớp chứa các trường và thuộc tính ẩn được tạo.
internal class AutoProps
{
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value1>k__BackingField;
[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Value2>k__BackingField;
public int Value1
{
[CompilerGenerated]
get
{
return <Value1>k__BackingField;
}
[CompilerGenerated]
set
{
<Value1>k__BackingField = value;
}
}
public int Value2
{
[CompilerGenerated]
get
{
return <Value2>k__BackingField;
}
[CompilerGenerated]
set
{
<Value2>k__BackingField = value;
}
}
}
Vì vậy, như bạn có thể thấy, trình biên dịch vẫn sử dụng các trường để lưu trữ các giá trị - vì các trường là cách duy nhất để lưu trữ giá trị vào các đối tượng.
Vì vậy, như bạn có thể thấy, mặc dù các thuộc tính và trường có cú pháp sử dụng tương tự nhưng chúng là các khái niệm rất khác nhau. Ngay cả khi bạn sử dụng các thuộc tính hoặc sự kiện tự động - các trường ẩn được tạo bởi trình biên dịch nơi dữ liệu thực được lưu trữ.
Nếu bạn cần làm cho giá trị trường có thể truy cập được ra thế giới bên ngoài (người dùng của lớp bạn), đừng sử dụng các trường công khai hoặc được bảo vệ. Các lĩnh vực luôn luôn phải được đánh dấu là riêng tư. Các thuộc tính cho phép bạn thực hiện kiểm tra giá trị, định dạng, chuyển đổi, v.v. và nói chung làm cho mã của bạn an toàn hơn, dễ đọc hơn và có thể mở rộng hơn cho các sửa đổi trong tương lai.