Was ist ein Konstruktor-VisualC# 2010-Galileo Computing

[Klaus P. (Gast)]

"Häufig werden die Werte gekapselter Felder von schreibgeschützten 
Eigenschaften bei der Initialisierung des Objekts im Konstruktor 
festgelegt."

//Felder**********************************************
        private int _XKoordinate = 0;
        private int _YKoordinate = 0;
        private double _Radius = 0;
        private double _nurLesbar = 664.56;

        //Eigenschaften der Felder****************************
        public int XKoordinate
        {
            get { return _XKoordinate; }
            set { _XKoordinate = value; }
        }
        public int YKoordinate
        {
            get { return _YKoordinate; }
            set { _YKoordinate = value; }
        }
        public double Radius
        {
            get { return _Radius; }
            set
            {
                if (value >= 0)
                    _Radius = value;
                else
                    Console.WriteLine("Radius darf nicht negativ sein!");
            }
        }
        public double nurLesbar
        {
            get { return _nurLesbar; }
        }

Sind in diesem Absatz diese Variablen

        private int _XKoordinate = 0;
        private int _YKoordinate = 0;
        private double _Radius = 0;
        private double _nurLesbar = 664.56;

als Konstruktor gemeint?

Gibt es auch andere Definitionen von Konstruktor in Visual C# oder ist 
das immer die "Zusatz-Variable" welche benötigt wird um bestimmte 
Rechte/Regeln an Objekte bzw. Eigenschaften der Klasse zu definieren?

[bluppdidupp (Gast)]

public class EineKlasse
{
     private int einInt=0; // *1*
     private string einString="bla";

     // Konstruktur
     // Funktion die genauso heisst wie die Klasse selbst
     // hat keinen Rückgabewert
     // Hier werden normalerweise Zeugs wie einInt, einString initialisiert
     public EineKlasse()
     {
         this.einInt=12; // *2*
         this.einString="blapp";
     }
 
     public int addiere(int a, int b)
     {
         return a+b;
     }
}

...der Konstruktur ist einfach eine spezielle Funktion, die aufgerufen 
wird wenn das Objekt erzeugt wird.

Zu beachten ist das die Zuweisung einInt=0 vor dem Aufruf des 
Konstruktors passiert. Nach EineKlasse k=new EineKlasse(); hat einInt 
letzendlich den Wert 12.

[Klaus P. (Gast)]

Hm, wenn du das so erklärst, dann verstehe ich den Sinn des Konstruktors 
nicht, denn im Prinzip kann ich auch ohne Konstruktor die Variablen 
initialisieren, da brauche ich keine extra Funktion dafür.

[Peter II (Gast)]

Klaus P. schrieb:
> Hm, wenn du das so erklärst, dann verstehe ich den Sinn des Konstruktors
> nicht, denn im Prinzip kann ich auch ohne Konstruktor die Variablen
> initialisieren, da brauche ich keine extra Funktion dafür.

bei C# ja, bei C++ muss man es mit einen Konstruktor machen. (ja in der 
gerade erschienen version vom C Standard ist das auch nicht mehr so)

Im Konstruktor kannst aber zustäzlich parameter übergeben.

public class EineKlasse
{
     private int _einInt;

     public EineKlasse( int wert )
     {
         this.einInt= wert
     }
 
}

[Klaus P. (Gast)]

Peter II schrieb:
> Im Konstruktor kannst aber zustäzlich parameter übergeben.

Aha, das ist der Vorteil davon, wusste nicht dass das geht.

Peter II schrieb:

 public EineKlasse( int wert )
      {
          this.einInt= wert
      }

Was macht hier aber das Schlüsselwort "this"?

[--- (Gast)]

Wie wäre es mit einem C-Buch?

http://msdn.microsoft.com/en-us/library/dk1507sz(v=vs.80).aspx
http://en.wikipedia.org/wiki/This_(computer_programming)

[Klaus P. (Gast)]

--- schrieb:
> http://msdn.microsoft.com/en-us/library/dk1507sz(v...
> http://en.wikipedia.org/wiki/This_(computer_programming)

Ich lese gerade das Visual C# Buch von galileo computing open book.
Im Kapitel 3 Klassendesign wo ich gerade angekommen bin wird leider 
"this" verwendet ohne erläutert zu werden.

Deshalb meine Frage.

Ich denke aber in C gibt es das Schlüsselwort this nicht oder täusche 
ich mich da?

[Andreas (Gast)]

Mit this. spricht man eine Variable in den Objekt an.
Den eine Variable, die dem Objekt übergeben wird kann
u.U. genauso bezeichnet sein.

Also z.B.

 public EineKlasse( int wert )
      {
          this.wert= wert
      }

[Rufus Τ. F. (rufus)]

Klaus P. schrieb:
> Ich denke aber in C gibt es das Schlüsselwort this nicht oder täusche
> ich mich da?

In C nicht, aber in C++.

Aber C# ist etwas vollkommen anderes, und um C# zu lernen, ist weder ein 
C- noch ein C++-Buch sonderlich hilfreich.

[Klaus (Gast)]

Ok ein großes Danke an Andreas und Peter II.

Jetzt verstehe ich!

Jedoch bin ich mir bei einer Sache noch nicht ganz Sicher und zwar beim 
"this":

public EineKlasse( int wert )
{
    this.wert= wert
}

In diesem Fall mache ich meine ganzen Initialisieungen der Klasse 
EineKlasse im Konstruktor. Das Objekt welches in der Main() 
instanziert/erzeugt bzw. initialisert wird erwartet sich beim 
Initialisieren einen Integer Wert.

Meinst du jetzt dass es passieren kann, dass eine Variable außerhalb des 
Konstruktor mit dem gleichen Namen schon deklariert ist und deshalb this 
vorgesetzt wird?

Ich meine folgendes:

    public class Circle
    {
        //Variablen-Deklarationen
        private int _XKoordinate;
        private int _YKoordinate;
        private double _Radius;
        public double _nurLesbar;

        //Konstruktor(Initialisierung der Klasse)*************
        public Circle(double _nurLesbar)
        {
            _XKoordinate = 0;
            _YKoordinate = 0;
            _Radius = 0;
            if (this._nurLesbar == 50)//Parameter
                _nurLesbar = 664.5; //private Variable
        }
    }

Ich habe das einmal ausprobiert und komme auf folgenden Schluss: Im 
Konstruktor zeigt mir Intellisense nur die Variable _nurLesbar an, die 
dem Parameter entspricht.
Die Variable, die als (private) double bei dem Deklarationen definiert 
ist wird in keiner Weise im Konstruktor angezeigt oder durch 
Intellisense angeboten-sprich ich habe keinen Zugriff auf _nurLesbar 
außerhalb des Konstruktors.

Das bedeutet, dass es keinen Unterschied in dem Sinne macht ein this 
vorzusetzen oder nicht. Der Parameter Name darf einfach nicht gleich 
einer vorher deklarierten Variable sein denn ansonsten darf ich keine 
Zuweisung der Variablen außerhalb des Konstruktors machen.

Stimmt das jetzt oder mache ich irgendetwas falsch?

[M. K. (avr-frickler)]

Klaus schrieb:
> Jedoch bin ich mir bei einer Sache noch nicht ganz Sicher und zwar beim
> "this":
...
> Meinst du jetzt dass es passieren kann, dass eine Variable außerhalb des
> Konstruktor mit dem gleichen Namen schon deklariert ist und deshalb this
> vorgesetzt wird?

Schau dir mal den von dir geposteten Konstruktor an
Klaus schrieb:
> public EineKlasse( int wert )
> {
>     this.wert= wert
> }
ändere ihn in (this. entfernen)

public EineKlasse( int wert )
{
    wert= wert
}

Wenn du nun Compiler wärst, wirst du dich sicher fragen "Ist das Kunst 
oder kann das weg?"

Mit this.wert ist die Variable gemeint die in der Deklaration der Klasse 
EineKlasse steht, wert hingegen ist die Variable die als Parameter im 
Konstruktor angegeben ist.

Du machst hier nichts anderes als die Variable wert der Klasse 
EineKlasse mit dem Parameter wert des Konstruktors zu initialisieren.

Zum Sinn des Konstruktors, man könnte jetzt meinen der ist überflüssig, 
mache ich einfach alles public und initialisiere die Variable in main() 
(oder einer anderen Methode).

1. Du hast mit einem Konstruktor die Möglichkeit Werte vorher auf 
Korrektheit zu prüfen.
2. Ein Funktionsaufruf mit Parametern schreibt sich kürzer als mehrere 
Zeilen mit Initialisierungen von Variablen ;)
3. Das ist schlechtes Klassen-Design

Klaus schrieb:
> Ich habe das einmal ausprobiert und komme auf folgenden Schluss: Im
> Konstruktor zeigt mir Intellisense nur die Variable _nurLesbar an, die
> dem Parameter entspricht.

Da fragt sich woher das 'Intelli' bei IntelliSense her kommen soll, hier 
kommt die IDE anscheinend in einen Konflikt. In dem Konstruktor sollten 
jedenfalls beide Variablen verfügbar sein.

Klaus schrieb:
> Das bedeutet, dass es keinen Unterschied in dem Sinne macht ein this
> vorzusetzen oder nicht.

doch es macht einen Unterschied, s.o.

> Der Parameter Name darf einfach nicht gleich
> einer vorher deklarierten Variable sein denn ansonsten darf ich keine
> Zuweisung der Variablen außerhalb des Konstruktors machen.

Doch der Parametername darf genau so heißen wie eine Variable der Klasse 
um aber beide Variablen unterscheiden zu können braucht es this um dem 
Compiler mit zu teilen welche Variable du meinst.

Von wo aus du auf die Variablen einer Klasse zugreifen darfst bestimmen 
die Schlüsselwörter public, protected und private bei der Deklaration 
der Variablen.

[Klaus (Gast)]

Ok, verstehe wo mein Problem lag. Ich habe nämlich gedacht, dass "this" 
für alles was im Block definiert wurde angewendet werden muss.

Herauskan jedoch, dass ich this für alle Variablen, die in der Klasse 
definiert sind anwenden muss.
ALso einfach umdrehen und das Problem hat sich.

Dankeschön MK!

[Rufus Τ. F. (rufus)]

Klaus schrieb:
> Herauskan jedoch, dass ich this für alle Variablen, die in der Klasse
> definiert sind anwenden muss.

Nein, das musst Du nicht. Das musst Du nur dann, wenn in einer Funktion 
("Methode") lokale Variablen bzw. Funktionsparameter gleichen Namens 
verwendet werden, um auf die durch den gleichen Namen überdeckte 
Membervariable zuzugreifen.

Würde der Deinem Konstruktor übergebene Parameter nicht "wert" heißen, 
so wäre kein this erforderlich:

public class EineKlasse
{
  private int wert;

  public EineKlasse(int bla)
  {
    wert = bla;
  }

Eine Möglichkeit, Membervariablen als solche zu kennzeichnen, ist die 
Verwendung von Namenspräfixen, wie es im microsoftlastigem Umfeld mit m_ 
gemacht wird:

public class EineKlasse
{
  private int m_wert;

  public EineKlasse(int bla)
  {
    m_wert = bla;
  }

Aber das ist natürlich nur eine von vielen möglichen Konventionen.