Der Accessor einer Eigenschaft enth?lt ausführbare Anweisungen zum Abrufen oder Festlegen der Eigenschaft. Eine Accessor-Deklaration kann einen Get-Accessor, einen Set-Accessor oder beides enthalten. Die Deklaration hat eine der folgenden Formen:

get {}
set {}

get accessor:
get Der Zugriffsk?rper ?hnelt dem Methodenk?rper. Es muss einen Wert des Eigenschaftstyps zurückgeben. Das Ausführen des Get-Accessors entspricht dem Lesen des Feldwerts.

Die folgenden Get-Accessoren geben den Wert des privaten Feldnamens zurück:

private string name;  // the name field
 
public string Name  // the Name 
 
property
{    
   get
   {       
       return name;
   }
}

Wenn auf eine Eigenschaft verwiesen wird, wird der Get-Accessor aufgerufen, um die Eigenschaft zu lesen, es sei denn, die Eigenschaft ist referenziert das Ziel des Zuweisungswertes.

Zum Beispiel:

Employee e1 = new Employee();
　...
　Console.Write(e1.Name); // The get accessor is invoked here

Der Get-Accessor muss in einer Return- oder Throw-Anweisung beendet werden und die Kontrolle kann nicht über den Accessor-K?rper hinausgehen.

Set-Accessor:
Der Set-Accessor ?hnelt einer Methode, die void zurückgibt. Es ben?tigt einen impliziten Parameter namens value. Der Typ dieses Parameters ist der Typ der Eigenschaft.

Im folgenden Beispiel wird ein Set-Accessor zur Name-Eigenschaft hinzugefügt:

public string Name
{  
   get
   {  
        return name;
   }  
     
   set
   {
       name = value;
   }
}

Wenn einer Eigenschaft ein Wert zugewiesen wird, ruft die Operation den Set-Accessor auf.

Zum Beispiel:

e1.Name = "Joe"; // The set accessor is invoked here

Es ist ein Fehler, implizite Parameternamen (Werte) für lokale Variablendeklarationen im Set-Accessor zu verwenden.

Hinweis:

Eigenschaften werden je nach verwendetem Accessor wie folgt klassifiziert:
Nur mit get Accessor-Eigenschaften sogenannte schreibgeschützte Eigenschaften. Einer schreibgeschützten Eigenschaft kann kein Wert zugewiesen werden.
Eigenschaften mit nur Set-Accessoren werden als schreibgeschützte Eigenschaften bezeichnet. Auf eine schreibgeschützte Eigenschaft kann nur als Ziel einer Zuweisung verwiesen werden.
Eigenschaften mit Get- und Set-Accessoren sind Lese-/Schreibeigenschaften.
Bei der Eigenschaftendeklaration müssen sowohl Get- als auch Set-Accessoren innerhalb des Eigenschaftenk?rpers deklariert werden.
Die Verwendung des Get-Accessors zum ?ndern des Status eines Objekts ist ein schlechter Programmierstil.

Wir verwenden das folgende Beispiel, um zu verstehen, was ein Accessor ist:

 using System; 
 namespace AccessorEG
 {     
     public class Student
     {         
         // 私有字段 private field
         private int _age; 
          
         // 公開的屬性 public property
         public int Age
         {             
            get { return _age; }             
            set { _age = value; }
         }
     } 
      
     class Program
     {         
         static void Main(string[] args)
         {
             Student stu = new Student();
             stu.Age = 10;                           // 使用了修改
             Console.WriteLine(stu.Age.ToString()); //使用了讀取 輸出 10                  
             Console.ReadKey();                    
         }
     }
 }

Es ist leicht zu verstehen, dass sich ein Accessor auf den Zugriff eines bezieht Objekttyp-Member zur Au?enwelt Eine Schnittstelle ist eine Brücke, die den Informationsaustausch zwischen Objekttyp-Membern und der Au?enwelt erm?glicht. Mit Accessoren kann die Au?enwelt entsprechende Operationen zum Lesen und Schreiben von Objekt-Membern durchführen.

Welche Mitglieder k?nnen also Zugriffsberechtigte haben? Accessoren k?nnen für nicht schreibgeschützte Felder und Ereignisse deklariert werden. Natürlich kann die schreibgeschützte Dom?ne auch eine Schnittstelle bereitstellen, die von der Au?enwelt abgerufen werden kann, n?mlich get, aber sie kann nur in der Deklaration oder im Konstruktor initialisiert werden und unterstützt die Set-Methode nicht.

 using System; 
 namespace AccessorEG
 {     
     public class Student
     {         
         // 私有字段 private field
         private readonly int _age = 10; 
          
         // 公開的屬性 public property
         public int Age
         {   
               get { return _age; }
         }
     } 
      
     class Program
     {        
         static void Main(string[] args)
         {
             Student stu = new Student();
             Console.WriteLine(stu.Age.ToString());  // 使用了讀取   輸出 10                
             Console.ReadKey();                              
         }
     }
 }

Der Wert des schreibgeschützten Felds im obigen Code wurde bei der Deklaration zugewiesen, und die Set-Methode kann nicht im Accessor bereitgestellt werden, der dem ?ffentlichen Attribut entspricht, andernfalls wird dies nicht der Fall sein kompiliert, kann aber von der Au?enwelt bezogen werden.

Wir müssen etwas über Feldzugriffsmethoden sagen:

using System; 
 namespace AccessorEG
 {     
     public class Student
     {         
         #region 全訪問權限         // 私有字段
         private int _age;        // 與_age對應的公開屬性，包含了set和get方法
          
         public int Age
         {             
             get { return _age; }             
             set { _age = value; }
         } 
         // 如果您安裝了.NET3.0，那么您可以使用自動屬性，屆時，上面的代碼即可以下面的代替
 　　　　 // 在VS.NET下輸入 prop 連擊兩下Tab鍵，編譯器會自動幫您生成自動屬性
 　　　　 // public int Age { get; set; }
         #endregion // 全訪問權限
  
         #region 只讀屬性         
         private string _name; 
          
         public string Name
         {             
            get { return _name; }
         } 
         // 等同于
 　　　　 // public string Name { private set; get; }
         #endregion
  
         #region 只寫屬性         
         private bool _sex; 
          
         public bool Sex
         {          
             set { _sex = value; }
         }         
         // 等同于
 　　　　 // public bool Sex { set; private get; }
         #endregion
  
     } 
      
     class Program
     {         
         static void Main(string[] args)
         {
             Student stu = new Student();
             stu.Age = 18;             
             // stu.Name = "Johness"; 異常，編譯錯誤，因為該屬性只讀
 　　　　　　  // Console.WriteLine(stu.Sex.ToString()); 異常，編譯錯誤，因為該屬性只寫
             Console.WriteLine(stu.Age.ToString());  // 使用了讀取                    Console.ReadKey();             // 輸出 18         
         }
     }
 }

Das Nur-Lesen und das Nur-Schreiben im obigen Beispiel gelten nur für die Au?enwelt . Wenn Sie ?Gibt den Eigentümer des Accessors an“, ein privates Feld der Klasse, anzeigen. Dann k?nnen Sie innerhalb der Klasse weiterhin bequem die von Ihnen definierten privaten Felder für Lese- und Schreibvorg?nge verwenden. Daher empfehle ich Freunden, Felder und ihre Zugriffsmethoden mit der Syntax von .NET2.0 anstelle der neuen Syntax von 3.0 (automatische Attribute) zu definieren ). Natürlich k?nnen auch Accessoren verwendet werden, um die Datengültigkeit besser zu überprüfen:

using System; 
 namespace AccessorEG
 {     
     public class Student
     {         
         // 私有字段
         private int _age;  // 與_age對應的公開屬性，包含了set和get方法
          
         public int Age
         {             
             get { return _age; } // 利用訪問器對輸入的年齡進行驗證
 　　　　　　  // 如果輸入值小于0或者大于100
　　　　　　   // 可以賦為默認值18或者不進行操作
             set 
             {                 
                   if (value >= 0 && value <= 100)
                    _age = value;   // 如果數(shù)據(jù)無效不進行操作可以注釋以下內(nèi)容
                   else
                    _age = 18;
             }
         }
  
     } 
      
     class Program
     {         
         static void Main(string[] args)
         {
             Student stu = new Student();
             stu.Age = -2;   // 賦無效值                     
             Console.WriteLine(stu.Age.ToString()); 
             Console.ReadKey();    // 輸出 18         
         }
     }
 }