Was ist der Unterschied zwischen einem Feld und einer Immobilie?
https://stackoverflow.com/questions/295104
-
08-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
In C #, was macht ein Feld unterscheidet sich von einer Eigenschaft, und wann sollte ein Feld anstelle einer Eigenschaft verwendet werden?
Lösung
Eigenschaften aussetzen Felder aus. Die Felder sollten (fast immer) zu einer Klasse privat gehalten werden und über Get- und Set-Eigenschaften abgerufen. Eigenschaften bieten eine Abstraktionsebene so dass Sie die Felder ändern, während die externe Art und Weise beeinflussen sie durch die Dinge, zugegriffen werden, die Ihre Klasse verwenden.
public class MyClass
{
// this is a field. It is private to your class and stores the actual data.
private string _myField;
// this is a property. When accessed it uses the underlying field,
// but only exposes the contract, which will not be affected by the underlying field
public string MyProperty
{
get
{
return _myField;
}
set
{
_myField = value;
}
}
// This is an AutoProperty (C# 3.0 and higher) - which is a shorthand syntax
// used to generate a private field for you
public int AnotherProperty{get;set;}
}
@Kent weist darauf hin, dass Eigenschaften nicht verkapseln Felder erforderlich, sie eine Berechnung auf anderen Bereichen tun könnte, oder andere Zwecke dienen.
@GSS weist darauf hin, dass Sie auch andere Logik zu tun, wie Validierung, wenn eine Eigenschaft zugegriffen wird, eine weitere nützliche Funktion.
Andere Tipps
Objektorientierte Programmierung Prinzipien zu sagen, dass, sollten die internen Abläufe einer Klasse von der Außenwelt verborgen. Wenn Sie ein Feld aussetzen Sie sind im Wesentlichen die interne Implementierung der Klasse auszusetzen. Deshalb wickeln wir Felder mit Eigenschaften (oder Methoden in Java Fall), um uns die Möglichkeit zu geben, die Umsetzung zu ändern, ohne Code zu brechen uns abhängig. Da wir Logik im Eigentum setzen können auch ermöglicht es uns, Validierungslogik usw. durchführen, wenn wir sie brauchen. C # 3 hat die möglicherweise verwirrende Vorstellung von autoproperties. Dies ermöglicht es uns, einfach das Eigentum zu definieren und die C # 3 Compiler den privaten Bereich für uns erzeugen.
public class Person
{
private string _name;
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
public int Age{get;set;} //AutoProperty generates private field for us
}
Ein wichtiger Unterschied ist, dass Schnittstellen Eigenschaften haben kann, aber keine Felder. Dies ist für mich, betont, dass die Eigenschaften verwendet werden sollen, eine Klasse öffentliche Schnittstelle zu definieren, während Felder im privaten, internen Abläufen einer Klasse verwendet werden sollen. Ich habe selten öffentliche Felder erzeugen in der Regel und in ähnlicher Weise selten schaffe ich nicht öffentliche Eigenschaften.
ich Sie ein paar Beispiele für die Verwendung Eigenschaften geben, dass die Zahnräder drehen könnten bekommen:
- Verzögerte Initialisierung : Wenn Sie eine Eigenschaft eines Objekts haben das ist teuer zu laden, ist aber nicht allzu viel in normalen Läufen des Codes zugegriffen, wird seinen Laden über die Eigenschaft verzögern. Auf diese Weise, es wird dort nur zu sitzen, aber das erste Mal versucht, ein anderes Modul, das Eigentum zu nennen, überprüft er, ob das zugrunde liegende Feld null ist - wenn es ist, es geht voran und lädt sie, unbekannt zu dem anrufenden Modul. Dies kann erheblich Objektinitialisierung beschleunigen.
- Schmutzige Tracking: Was ich tatsächlich gelernt über von meinem eigene Frage hier auf Stackoverflow. Wenn ich eine Menge von Objekten, die Werte während eines Laufes geändert haben könnten, kann ich die Eigenschaft verwenden, um zu verfolgen, wenn sie wieder in die Datenbank oder nicht gespeichert werden müssen. Wenn nicht eine einzige Eigenschaft eines Objekts geändert hat, wird die IsDirty Flagge nicht ausgelöst werden, und deshalb wird die Einsparung Funktionalität über sie überspringen bei der Entscheidung, was in die Datenbank erhalten muss.
Eigenschaften verwenden, können Sie ein Ereignis werfen, wenn der Wert der Eigenschaft geändert wird (aka. PropertyChangedEvent) oder bevor der Wert geändert wird Abbruch zu unterstützen.
Dies ist nicht möglich mit (direktem Zugriff auf) Feldern aus.
public class Person {
private string _name;
public event EventHandler NameChanging;
public event EventHandler NameChanged;
public string Name{
get
{
return _name;
}
set
{
OnNameChanging();
_name = value;
OnNameChanged();
}
}
private void OnNameChanging(){
EventHandler localEvent = NameChanging;
if (localEvent != null) {
localEvent(this,EventArgs.Empty);
}
}
private void OnNameChanged(){
EventHandler localEvent = NameChanged;
if (localEvent != null) {
localEvent(this,EventArgs.Empty);
}
}
}
Da viele von ihnen mit technischen Vor- und Nachteile der Properties und Field erklärt haben, ist es Zeit, in Echtzeit Beispiele zu erhalten.
1. Eigenschaften können Sie die Nur-Lese-Zugriffsebene auf
Nehmen wir den Fall dataTable.Rows.Count und dataTable.Columns[i].Caption. Sie kommen aus der Klasse DataTable und beide sind öffentlich zu uns. Der Unterschied in der Zugangsebene zu ihnen ist, dass wir nicht Wert auf dataTable.Rows.Count einstellen können, aber wir können auf dataTable.Columns[i].Caption lesen und schreiben. Ist das möglich durch Field? Nein!!! Dies kann nur mit Properties erfolgen.
public class DataTable
{
public class Rows
{
private string _count;
// This Count will be accessable to us but have used only "get" ie, readonly
public int Count
{
get
{
return _count;
}
}
}
public class Columns
{
private string _caption;
// Used both "get" and "set" ie, readable and writable
public string Caption
{
get
{
return _caption;
}
set
{
_caption = value;
}
}
}
}
2. Immobilien in Property
Sie könnten mit Button in Visual Studio gearbeitet. Seine Eigenschaften sind in der PropertyGrid wie Text gezeigt, Name usw. Wenn wir eine Schaltfläche ziehen, und wenn wir die Eigenschaften klicken, wird es automatisch die Klasse Button und Filter Properties und zeigen, dass in PropertyGrid (wo PropertyGrid nicht zeigen Field auch wenn sie öffentlich sind).
public class Button
{
private string _text;
private string _name;
private string _someProperty;
public string Text
{
get
{
return _text;
}
set
{
_text = value;
}
}
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
[Browsable(false)]
public string SomeProperty
{
get
{
return _someProperty;
}
set
{
_someProperty= value;
}
}
In PropertyGrid, die Eigenschaften Name und Text werden gezeigt, aber nicht SomeProperty. Warum??? Da Eigenschaften können Attribute. Es zeigt nicht den Fall, dass [Browsable(false)] falsch ist.
3. Kann ausführen Anweisungen innerhalb Eigenschaften
public class Rows
{
private string _count;
public int Count
{
get
{
return CalculateNoOfRows();
}
}
public int CalculateNoOfRows()
{
// Calculation here and finally set the value to _count
return _count;
}
}
4. Nur Eigenschaften können in Bindungsquelle verwendet werden
Quelle Bindung hilft uns, die Zahl zu verringern von Zeilen Code. Fields werden nicht von BindingSource akzeptiert. Wir sollten Properties dafür.
5. Debugging-Modus
Betrachten wir Field werden mit einem Wert zu halten. An einem gewissen Punkt müssen wir debuggen und überprüfen, wo der Wert für dieses Feld null erhält. Es wird schwierig sein, zu tun, wo die Anzahl der Codezeilen sind mehr als 1000. In solchen Situationen, die wir Property verwenden können und Debug-Modus innerhalb Property einstellen können.
public string Name
{
// Can set debug mode inside get or set
get
{
return _name;
}
set
{
_name = value;
}
}
Differences - VERWENDUNGEN (wann und warum)
A ist eine Variable, die direkt in einer Klasse oder Struktur deklariert wird. Eine Klasse oder Struktur kann beispielsweise Felder oder statische Felder oder beides haben. Im Allgemeinen sollten Sie verwenden Felder nur für Variablen, die private oder geschützte Zugänglichkeit haben . Daten, die Ihre Klasse Client-Code macht sollten durch Methoden, Eigenschaften und Indexer zur Verfügung gestellt werden. Durch die Verwendung dieser Konstrukte für den indirekten Zugriff auf interne Felder, können Sie Schutz gegen ungültige Eingabewerte.
Eigenschaft ist ein Element, das einen flexiblen Mechanismus bietet zum Lesen, Schreiben oder den Wert eines privaten Feld zu berechnen. Eigenschaften können verwendet werden, als ob sie öffentliche Datenmitglieder sind, aber sie sind tatsächlich spezielle Methoden namens Accessoren . Dies ermöglicht es, Daten leicht zugegriffen werden kann und hilft immer noch die Sicherheit und Flexibilität von Methoden zu fördern . Eigenschaften ermöglichen eine Klasse eine öffentliche Art und Weise zu belichten zu bekommen und Werte einstellen, während der Umsetzung oder Bestätigungs-Code versteckt. Ein get Eigenschaftenaccessor wird verwendet, um den Eigenschaftswert zurückzukehren, und ein Satz Accessor wird verwendet, um einen neuen Wert zuzuweisen.
Eigenschaften haben den primären Vorteil, dass Sie die Möglichkeit, Daten auf einem Objekt zu ändern zugegriffen wird es öffentliche Schnittstelle, ohne zu brechen. Zum Beispiel, wenn Sie zusätzliche Validierung hinzufügen müssen, oder ein gespeichertes Feld in ein Sie tun berechnet sich ändern kann so leicht, wenn Sie zunächst das Feld als Eigenschaft ausgesetzt. Wenn Sie nur ein Feld direkt ausgesetzt sind, dann würden Sie die öffentliche Schnittstelle der Klasse ändern müssen, um die neue Funktionalität hinzuzufügen. Diese Änderung würde bestehende Kunden brechen, erfordern sie neu kompiliert werden, bevor sie die neue Version des Codes verwenden könnten.
Wenn Sie eine Klassenbibliothek für breiten Verbrauch (wie das .NET Framework, die von Millionen von Menschen verwendet wird) zu schreiben, kann das ein Problem sein. Wenn Sie jedoch sind eine Klasse zu schreiben intern in einem kleinen Codebasis verwendet (zB <= 50 K Zeilen), es ist wirklich keine große Sache, denn niemand würde sich negativ durch die Änderungen betroffen sein. In diesem Fall kommt es wirklich nur auf den persönlichen Vorlieben.
Eigenschaften unterstützen asymmetrische Zugang, das heißt Sie können entweder einen Getter und einen Setter haben oder nur eine der beiden. Ebenso unterstützen Eigenschaften der individuellen Zugänglichkeit für Getter / Setter. Die Felder sind immer symmetrisch, das heißt Sie können beide immer erhalten und den Wert festgelegt. Ausnahme ist nur lesbar Felder, die offensichtlich nicht nach der Initialisierung eingestellt werden.
Eigenschaften können für eine sehr lange Zeit laufen, Nebenwirkungen haben, und auch Ausnahmen auslösen können. Die Felder sind schnell, ohne Nebenwirkungen und werden niemals Ausnahmen werfen. Aufgrund von Nebenwirkungen kann eine Eigenschaft, einen anderen Wert für jeden Anruf zurück (wie es der Fall für DateTime.Now sein kann, d.h. DateTime.Now nicht immer gleich DateTime.Now). Felder immer den gleichen Wert zurück.
Die Felder können für out / ref Parameter verwendet werden, können Eigenschaften nicht. Eigenschaften unterstützen zusätzliche Logik - diese verwendet werden könnte, verzögertes Laden unter anderem zu implementieren
.Eigenschaften unterstützen eine Abstraktionsebene durch Verkapselung, was es bedeutet, um den Wert zu erhalten / set.
Verwenden Sie Eigenschaften in den meisten / alle Fälle, sondern versuchen, Nebenwirkungen zu vermeiden.
Im Hintergrund eine Eigenschaft wird in Methoden zusammengestellt. So eine Name Eigenschaft wird in get_Name() und set_Name(string value) zusammengestellt. Sie können dies sehen, wenn Sie den kompilierten Code studieren.
So gibt es eine (sehr) kleinen Performance-Overhead, wenn mit ihnen. Normalerweise werden Sie immer eine Eigenschaft verwenden, wenn Sie ein Feld nach außen aussetzen, und Sie werden es oft intern verwenden, wenn Sie die Validierung des Wertes tun müssen.
Wenn Sie möchten, dass Ihre private Variable (Feld) von anderen Klassen zu Objekt der Klasse zugänglich sein, Sie Eigenschaften für diese Variablen erstellen müssen.
zum Beispiel, wenn ich Variablen mit dem Namen als „id“ habe und „namen“ das ist privat aber es könnte Situation, wo diese Variable für Lese- / Schreibvorgang benötigt außerhalb der Klasse. Zu dieser Situation kann Eigenschaft mir helfen, diese Variable zu erhalten, lesen / schreiben, abhängig von dem get / set für die Eigenschaft definiert. Eine Eigenschaft kann ein Nur-Lese / write / Lese-Schreib beide.
Hier ist die Demo
class Employee
{
// Private Fields for Employee
private int id;
private string name;
//Property for id variable/field
public int EmployeeId
{
get
{
return id;
}
set
{
id = value;
}
}
//Property for name variable/field
public string EmployeeName
{
get
{
return name;
}
set
{
name = value;
}
}
}
class MyMain
{
public static void Main(string [] args)
{
Employee aEmployee = new Employee();
aEmployee.EmployeeId = 101;
aEmployee.EmployeeName = "Sundaran S";
}
}
Die zweite Frage ist hier, „wann sollte ein Feld anstelle einer Eigenschaft verwendet werden?“, Wird nur kurz gestreift in auf diesem anderen beantworten und irgendwie diese auch , aber nicht wirklich viel Detail.
In der Regel alle anderen Antworten sind Spot-on über gutes Design: bevorzugen Eigenschaften über Belichtungsfeldern aus. Während Sie wahrscheinlich nicht regelmäßig finden sich sagen „wow, vorstellen, wie viel schlimmer Dinge wäre, wenn ich dieses ein Feld gemacht hatte, anstelle einer Eigenschaft“, es ist so viel selten eine Situation zu denken, wo man würde sagen: „wow, ich danke Gott, dass ich hier ein Feld anstelle einer Eigenschaft verwendet.“
Aber es gibt einen Vorteil, dass Felder über Eigenschaften haben, und das ist ihre Fähigkeit, als „ref“ / „out“ Parameter genutzt werden. Angenommen, Sie haben eine Methode mit folgenden Signatur:
public void TransformPoint(ref double x, ref double y);
und nehmen wir an, dass Sie diese Methode verwenden möchten ein Array wie folgt erstellt zu transformieren:
System.Windows.Point[] points = new Point[1000000];
Initialize(points);
Hier ist denke ich der schnellste Weg, es zu tun, da Y sind Eigenschaften:
for (int i = 0; i < points.Length; i++)
{
double x = points[i].X;
double y = points[i].Y;
TransformPoint(ref x, ref y);
points[i].X = x;
points[i].Y = y;
}
Und das wird ziemlich gut sein! Es sei denn, Sie Messungen, die das Gegenteil beweisen, gibt es keinen Grund, einen Gestank zu werfen. Aber ich glaube, es ist technisch nicht so schnell, wie dies sein garantiert:
internal struct MyPoint
{
internal double X;
internal double Y;
}
// ...
MyPoint[] points = new MyPoint[1000000];
Initialize(points);
// ...
for (int i = 0; i < points.Length; i++)
{
TransformPoint(ref points[i].X, ref points[i].Y);
}
Doing einige Messungen selbst, die Version mit Feldern dauert etwa 61% der Zeit, als die Version mit Eigenschaften (.NET 4.6, Windows 7, x64, Release-Modus, kein Debugger angeschlossen). Je teurer die TransformPoint Methode wird, desto weniger ausgeprägt, dass der Unterschied wird. Um es zu wiederholen diese Texte selbst, mit der ersten Zeile läuft kommentiert-out und damit nicht kommentiert-out.
Auch wenn es keine Performance-Vorteile für die oben waren, gibt es andere Orte, an denen ref verwenden zu können und out-Parameter könnte von Vorteil sein, wie zum Beispiel beim Aufruf der verriegelt oder Volatile Familie von Methoden. Hinweis: Bei dieser neu für Sie ist, Flüchtige ist im Grunde eine Art und Weise auf dem gleichen Verhalten des volatile Schlüsselwort zur Verfügung gestellt zu bekommen. Als solche wie volatile, löst es nicht auf magische Weise alle Thread-Sicherheit Leiden wie sein Name schon sagt, dass es könnte.
Ich möchte auf jeden Fall nicht scheinen, wie ich dafür ein, dass Sie gehen „oh, ich anfangen sollte Felder anstelle von Eigenschaften ausgesetzt werden.“ Der Punkt ist, dass, wenn Sie brauchen, um regelmäßig diese Elemente in Anrufe zu verwenden, die „ref“ oder „out“ Parameter übernehmen, vor allem auf etwas, das ein einfacher Wert Typ sein könnte, die unwahrscheinlich ist, jemals eine der wertschöpf müssen Elemente der Eigenschaften, ein Argument kann gemacht werden.
Auch Eigenschaften können Sie Logik verwenden, wenn die Werte zu setzen.
Sie können also sagen, dass Sie nur einen Wert zu einem Integer-Feld gesetzt werden sollen, wenn der Wert größer als x ist, sonst eine Ausnahme aus.
Wirklich nützliche Funktion.
Wenn Sie Thread Primitive verwenden werden Sie gezwungen sind, Felder zu verwenden. Eigenschaften können Sie Ihre Gewinde Code brechen. Abgesehen davon, was Cory sagte korrekt ist.
(Dies soll wirklich ein Kommentar sein, aber ich kann einen Kommentar nicht veröffentlichen, also bitte entschuldigen, wenn es nicht angemessen, als Post ist).
Ich habe einmal an einem Ort, wo die empfohlene Praxis öffentliche Felder anstelle von Eigenschaften, wenn die entsprechende Eigenschaft def hat nur ein Feld zugreifen würde zu verwenden war, wie in:
get { return _afield; }
set { _afield = value; }
Ihre Argumentation war, dass das öffentliche Feld in eine Immobilie in Zukunft später umgewandelt werden könnte, falls erforderlich. Es schien ein wenig seltsam für mich an der Zeit. Gemessen an diesen Stellen sieht es aus wie hier nicht viele entweder zustimmen würden. Was könnten Sie gesagt haben, zu versuchen, die Dinge zu ändern?
Edit: Ich soll, dass an dieser Stelle all der Code-Basis hinzufügen, die gleichzeitig kompiliert wurde, so dass sie vielleicht gedacht haben, dass die öffentliche Schnittstelle von Klassen zu ändern (von einem öffentlichen Bereich auf eine Eigenschaft zu ändern) war kein Problem .
Technisch, ich glaube nicht, dass es einen Unterschied gibt, weil Objekte sind nur Wrapper um Felder vom Benutzer erstellt oder automatisch durch die compiler.The Zweck der Eigenschaften erstellt ist encapsuation zu erzwingen und eine leichte Methode artig bieten Feature. Es ist nur eine schlechte Praxis Felder als öffentlich zu erklären, aber es hat keine Probleme.
Diese Seite auf MSDN hat einen Vergleich und Tipps, die man zu verwenden, wenn:
https://msdn.microsoft.com /en-us/library/9d65as2e(v=vs.90).aspx
Die Felder sind ordentliches Mitglied Variablen oder Mitglied Instanzen einer Klasse. Immobilien sind eine Abstraktion zu bekommen und setzen ihre Werte . Die Eigenschaften sind auch Accessoren genannt, weil sie eine Möglichkeit bieten, ein Feld zu ändern und abrufen, wenn Sie ein Feld in der Klasse als privat aussetzen. Im Allgemeinen sollten Sie Ihre Mitgliedsvariablen privat deklarieren, dann deklarieren oder definieren Eigenschaften für sie.
class SomeClass
{
int numbera; //Field
//Property
public static int numbera { get; set;}
}
Eigenschaften kapseln Felder, so dass Sie eine zusätzliche Verarbeitung auf dem Wert auszuführen gesetzt oder abgerufen werden. Es ist in der Regel viel des Guten Eigenschaften zu verwenden, wenn Sie keine Vor- oder Nachverarbeitung auf dem Feldwert tun.
IMO, sind Eigenschaften nur die "SetXXX ()" "getXXX ()" Funktionen / Methoden / Schnittstellen Paare wir vorher benutzt, aber sie sind prägnant und elegant.
Traditionell private Felder werden über Getter und Setter-Methoden festgelegt. Aus Gründen der weniger Code können Sie die Eigenschaften verwenden, um Felder anstelle einzustellen.
Wenn Sie eine Klasse, die „Auto“ ist. Die Eigenschaften sind Farbe, Form ..
Dabei gilt als Felder sind Variablen im Rahmen einer Klasse definiert sind.
Von Wikipedia - Objektorientierte Programmierung :
Die objektorientierte Programmierung (OOP) ist ein Programmierparadigma auf dem Konzept der „Objekte“ basiert, die Datenstrukturen sind, die Daten, in Form von Feldern enthalten, die oft als Attribut bekannt; und Code in Form von Verfahren, die oft als Methoden bekannt . (Hervorhebung hinzugefügt)
Eigenschaften sind tatsächlich Teil eines Verhaltens des Objekts, sondern sollen die Verbraucher des Objekts die Illusion / Abstraktion zu geben, mit der Objektdaten zu arbeiten.
Mein Entwurf eines Feldes ist, dass ein Feld, das durch seine Eltern nur geändert werden muss, damit die Klasse. Ergebnis der Variable wird privat, dann in der Lage sein das Recht zu geben, die Klassen / Methoden zu lesen außerhalb ich durch das System der Immobilie gehen nur mit dem Get. Das Feld wird dann durch die Eigenschaft abgerufen und schreibgeschützt! Wenn Sie es ändern wollen, müssen Sie durch Methoden gehen (zum Beispiel der Konstruktor) und ich finde, dass dank dieser Art und Weise machen Sie sicher, wir eine bessere Kontrolle über unseren Code, weil wir „Flansch“ haben. Man könnte sehr gut immer alles in der Öffentlichkeit setzen so jeden möglichen Fall, der Begriff der Variablen / Methoden / Klassen etc ... meiner Meinung nach ist nur eine Hilfe für die Entwicklung, Pflege des Codes. Zum Beispiel, wenn eine Person einen Code mit dem öffentlichen Bereichen wieder aufgenommen wird, kann er alles tun, und deshalb Dinge „unlogisch“ in Bezug auf das Ziel, die Logik, warum der Code geschrieben. Es ist mein Standpunkt.
Wenn ich ein klassisches Modellfeld privat nutzen / public Nur-Lese-Eigenschaften, für 10 Gemeinen Felder soll ich 10 publics Eigenschaften schreiben! Der Code kann wirklich groß schneller sein. Ich entdecke die privaten Setter und jetzt verwende ich nur öffentliche Eigenschaften mit einem privaten Setter. Der Setter erstellen im Hintergrund ein privates Feld.
Das warum mein alter klassischer Programmierstil war:
public class MyClass
{
private int _id;
public int ID { get { return _id; } }
public MyClass(int id)
{
_id = id;
}
}
Mein neuer Programmierstil:
public class MyClass
{
public int ID { get; private set; }
public MyClass(int id)
{
ID = id;
}
}
Die Felder sind die Variablen in Klassen. Die Felder sind die Daten, die Sie durch die Verwendung von Zugriffsmodifikatoren einkapseln können.
Eigenschaften ähnlich sind Felder, dass sie definieren Zustände und die mit einem Objekt zugeordneten Daten.
Im Gegensatz zu einem Feld einer Eigenschaft, eine spezielle Syntax hat, der steuert, wie eine Person die Daten liest und schreibt die Daten, diese werden als Get- und Set-Betreiber bekannt. Die eingestellte Logik kann oft verwendet werden, die Validierung zu tun.
Eigenschaften sind spezielle Art von Klassenmitglied, In Eigenschaften verwenden wir ein vordefiniertes Set oder method.They Verwendung Accessoren, durch die Get können wir, geschrieben oder ändern die Werte der privaten Felder lesen.
Zum Beispiel, lassen Sie uns nehmen Sie eine Klasse namens Employee, mit eigenem Felder für Namen, Alter und employee_id. Wir können nicht auf diese Felder von außerhalb der Klasse, aber wir können diese privaten Felder durch Eigenschaften zugreifen zu können.
Warum wir Eigenschaften verwenden?
Making the Klassenfeld der Öffentlichkeit und Aussetzen es riskant ist, da Sie nicht die Kontrolle haben, was zugewiesen wird und zurückgegeben.
dies klar zu verstehen, mit einem Beispiel eine Schüler-Klasse können nehmen, die ID, Passmark haben, Namen. Jetzt in diesem Beispiel ein Problem mit dem öffentlichen Bereich
- ID sollte nicht -ve.
- Name kann nicht auf null gesetzt werden
- Bestanden sollte nur gelesen werden.
- Wenn Student Name No Name fehlt sollte Rückkehr sein.
Dieses Problem wir erhalten und Set-Methode verwenden, um zu entfernen.
// A simple example
public class student
{
public int ID;
public int passmark;
public string name;
}
public class Program
{
public static void Main(string[] args)
{
student s1 = new student();
s1.ID = -101; // here ID can't be -ve
s1.Name = null ; // here Name can't be null
}
}
Nun nehmen wir ein Beispiel bekommen und setzen Methode
public class student
{
private int _ID;
private int _passmark;
private string_name ;
// for id property
public void SetID(int ID)
{
if(ID<=0)
{
throw new exception("student ID should be greater then 0");
}
this._ID = ID;
}
public int getID()
{
return_ID;
}
}
public class programme
{
public static void main()
{
student s1 = new student ();
s1.SetID(101);
}
// Like this we also can use for Name property
public void SetName(string Name)
{
if(string.IsNullOrEmpty(Name))
{
throw new exeception("name can not be null");
}
this._Name = Name;
}
public string GetName()
{
if( string.IsNullOrEmpty(This.Name))
{
return "No Name";
}
else
{
return this._name;
}
}
// Like this we also can use for Passmark property
public int Getpassmark()
{
return this._passmark;
}
}
Eigenschaften werden verwendet, Feld zu belichten. Sie verwenden Accessoren (set, get), durch die die Werte der privaten Felder gelesen werden können, geschrieben oder manipuliert werden können.
Eigenschaften Name nicht über die Lagerorte. Stattdessen haben sie Accessoren, die lesen, schreiben oder ihre Werte berechnen.
Eigenschaften verwenden wir die Validierung von der Art der Daten festlegen können, die auf einem Feld festgelegt ist.
Zum Beispiel haben wir privates Integer-Feld Alter auf, dass sollten wir positive Werte erlauben, da das Alter nicht negativ sein kann.
Wir können diese Getter und Setter mit auf zwei Arten tun und mit Eigentum.
Using Getter and Setter
// field
private int _age;
// setter
public void set(int age){
if (age <=0)
throw new Exception();
this._age = age;
}
// getter
public int get (){
return this._age;
}
Now using property we can do the same thing. In the value is a key word
private int _age;
public int Age{
get{
return this._age;
}
set{
if (value <= 0)
throw new Exception()
}
}
Auto Eigenschaft Implementiert, wenn wir nicht Logik zu tun bekommen und setzen Accessoren wir auto umgesetzt Eigenschaft nutzen können.
Wenn u se automatisch implementierte Eigenschaft kompiliert schafft ein privates, anonymes Feld , die nur durch get- und set-Accessoren zugegriffen werden kann.
public int Age{get;set;}
Abstrakte Eigenschaften Eine abstrakte Klasse kann eine abstrakte Eigenschaft hat, die in der abgeleiteten Klasse implementiert werden sollte,
public abstract class Person
{
public abstract string Name
{
get;
set;
}
public abstract int Age
{
get;
set;
}
}
// overriden something like this
// Declare a Name property of type string:
public override string Name
{
get
{
return name;
}
set
{
name = value;
}
}
Wir können privat eine Eigenschaft In diesem können wir privat stellen Sie die Eigenschaft auto (Set mit in der Klasse)
public int MyProperty
{
get; private set;
}
Sie können mit diesem Code gleiche erreichen. In diesem Objekt ist nicht verfügbar, da wir Wert setzen müssen direkt in das Feld ein.
private int myProperty;
public int MyProperty
{
get { return myProperty; }
}
Denken Sie daran: Sie haben einen Raum und eine Tür das Zimmer zu betreten. Wenn Sie überprüfen wollen, wie die in kommt und Ihr Zimmer sichern, dann sollten Sie Eigenschaften verwenden, sonst werden sie nicht eine Tür sein und jeder leicht kommt in w / o jede Verordnung
class Room {
public string sectionOne;
public string sectionTwo;
}
Room r = new Room();
r.sectionOne = "enter";
Die Menschen in ist immer ziemlich leicht sectionOne, es gab keine Kontrolle
class Room
{
private string sectionOne;
private string sectionTwo;
public string SectionOne
{
get
{
return sectionOne;
}
set
{
sectionOne = Check(value);
}
}
}
Room r = new Room();
r.SectionOne = "enter";
Jetzt überprüfen Sie die Person und wissen, ob er etwas Böses mit ihm hat
Die überwiegende Mehrheit der Fälle, es wird eine Eigenschaft Namen sein, den Sie als zu einem Variablennamen im Gegensatz Zugriff ( ) Der Grund dafür ist es in .NET als gute Praxis ist und in C # in insbesondere jedes Stück von Daten innerhalb einer Klasse zu schützen, wäre es eine Instanzvariable oder eine statische Variable (Klassenvariable) ist, weil es mit einer Klasse zugeordnet ist.
all diese Variablen Schützen mit Eigenschaften entsprechen, die es Ihnen ermöglichen, zu definieren, gesetzt und erhalten Math-Klasse (System-Namespace), gibt es ein paar statische Eigenschaften, die in die Klasse gebaut werden. eine davon ist die mathematische Konstante PI
zB. Math.PI
und weil PI ein Stück von Daten ist, die gut definiert ist, wir brauchen nicht mehrere Kopien von PI haben, es wird immer der gleiche Wert sein. So statische Variablen werden manchmal zu teilen Daten unter Objekt einer Klasse verwendet, aber die sind auch häufig für konstante Informationen verwendet, wenn Sie nur eine Kopie von einem Stück von Daten benötigen.
Basic und allgemeiner Unterschied ist:
Felder
- immer geben beide erhalten und setzen Zugang
- NICHT Ursache Nebenwirkungen (Ausnahmen werfen, Methoden aufrufen, Ändern von Feldern außer dem einen stand / Set werden, usw.)
Eigenschaften
- NICHT IMMER geben beide erhalten und setzen Zugang
- CAN Ursache Nebenwirkungen
