C#-Eigenschaftszugriffstool

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;   // 如果数据无效不进行操作可以注释以下内容
                   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         
         }
     }
 }