{"id":55000010,"date":"2015-02-01T00:00:00","date_gmt":"2020-08-25T08:43:20","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=10"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Objektorientierte_Programmierung_Teil_1","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Objektorientierte_Programmierung_Teil_1\/","title":{"rendered":"Objektorientierte Programmierung, Teil 1"},"content":{"rendered":"

Wer mit VBA programmiert, nutzt eigentlich schon eine Reihe der Elemente der objektorientierten Programmierung – zum Beispiel, wenn er Objekte auf Basis der Klasse Database oder Recordset erstellt und dann mit deren Methoden und Eigenschaften durch die Daten einer Tabelle navigiert. Auch benutzerdefinierte Klassen lassen sich mit VBA erstellen. Unter C# erhalten Sie jedoch Zugriff auf den kompletten Umfang der objektorientierten Programmierung. Dieser Artikel liefert einen Einstieg in die objektorientierte Programmierung mit C#.<\/b><\/p>\n

Prozeduren starten ade<\/b><\/p>\n

Eines müssen wir direkt klarstellen: Einfach mal eben wie im VBA-Editor eine Prozedur in einem Standardmodul programmieren und diese mit F5 <\/b>ausführen – das gelingt in Visual Studio unter C# nicht. Dort müssen Sie etwa in einer Konsolenanwendung zumindest die standardmäßig vorhandene Klasse verwenden, die dort enthaltene Prozedur Main<\/b> mit den gewünschten Codezeilen füllen und auf F5 <\/b>drücken.<\/p>\n

Die Klasse Program<\/b><\/p>\n

Wenn Sie ein neues Projekt auf Basis der Vorlage Konsolenanwendung <\/b>erstellen, erhalten Sie eine Datei mit einer Klasse namens Program <\/b>mit einer Methode namens Main<\/b>, die standardmäßig beim Start der Anwendung ausgeführt wird.<\/p>\n

Von der Methode Main <\/b>aus werden wir gleich starten, um unsere erste selbst erstellte Klasse zu instanzieren und zu nutzen.<\/p>\n

Eine Klasse pro Datei<\/b><\/p>\n

Jede Klasse sollte in einer eigenen Datei erstellt werden, um die Übersicht zu gewährleisten. Sollten Sie mehrere Klassen in einer Datei anlegen, finden Sie solche Klassen, deren Name sich von dem der Datei unterscheidet, nicht mehr so schnell über den Projektmappen-Explorer wieder.<\/p>\n

Neue Klasse erstellen<\/b><\/p>\n

Dementsprechend beginnen wir nun, indem wir eine neue Klasse erstellen. Dies erledigen wir über den Menüeintrag Projekt|Klasse hinzufügen… <\/b>Dies öffnet den Dialog Neues Element <\/b>hinzufügen und stellt die Vorlage direkt auf den Eintrag Klasse <\/b>ein. Wir nennen die Klasse Konto<\/b> und klicken dann auf Hinzufügen (siehe Bild 1). Alternativ öffnen Sie den Dialog Neues Element <\/b>mit dem Kontextmenü-Eintrag Hinzufügen|Klasse… <\/b>des Eintrags für das Projekt im Projektmappen-Explorer.<\/p>\n

\"Hinzufügen<\/p>\n

Bild 1: Hinzufügen einer neuen Klasse<\/span><\/b><\/p>\n

Die neue Klasse erscheint nun sowohl im Projektmappen-Explorer als auch mit dem vollständigen Quellcode im Code-Fenster (siehe Bild 2). Abgesehen von den using<\/b>-Anweisungen, dem namespace<\/b>– und dem class<\/b>-Element ist die Klasse noch jungfräulich:<\/p>\n

\"Die<\/p>\n

Bild 2: Die neue, noch unberührte Klasse Konto<\/span><\/b><\/p>\n

namespace OOProgrammierung {\r\n     class Konto {\r\n     }\r\n}<\/pre>\n
Benennung<\/b><\/p>\n
Der Klassenname sollte möglichst genau beschreiben, welchem Objekt der Realität die Klasse entspricht – sofern dies gegeben ist. Soll die Klasse eine Person aufnehmen, heißt sie Person<\/b>, soll sie wie in unserem Fall ein Konto aufnehmen, lautet der Klassenname Konto<\/b>.<\/p>\n
Wir verwenden kein Präfix, außerdem beginnt der Klassenname mit einem Großbuchstaben. Besteht der Klassenname aus mehreren zusammengesetzten Wörtern, sollten auch die folgenden Wörter jeweils wieder groß geschrieben werden.<\/p>\n
Wenn Sie den Namen der Datei mit der Klasse später noch einmal ändern möchten, erledigen Sie da am besten über den Projektmappen-Explorer. Visual Studio ändert dann optional alle Verweise auf diese Klasse. Wenn Sie den Dateinamen Konto <\/b>in Bankkonto <\/b>ändern, benennt Visual Studio auch automatisch die Klasse im Code um.<\/p>\n
Objekt instanzieren<\/b><\/p>\n
Die Klasse ist zwar noch leer (sie hat noch keine Methoden, Eigenschaften et cetera), aber wir können diese dennoch bereits deklarieren und auch instanzieren. Dazu wechseln Sie nun zur Klasse Program<\/b>. Dort erweitern Sie die Methode Main <\/b>um zwei Zeilen:<\/p>\n
static void Main(string[] args) {\r\n     Konto konto;\r\n     konto = new Konto();\r\n}<\/pre>\n
Die erste Zeile deklariert ein neues Objekt namens konto <\/b>mit dem Typ Konto <\/b>(man beachte die Groß-\/Kleinschreibung). Beides können Sie auch in einer einzigen Anweisung erledigen:<\/p>\n
Konto konto = new Konto();<\/pre>\n
Die Deklaration reserviert den Speicher für das Objekt, die new<\/b>-Anweisung erstellt das Objekt nach dem in der Klasse definierten Bauplan. Mit dem Objekt können wir nun noch nicht viel anfangen, da wir noch keine Methoden oder Eigenschaften hinzugefügt haben.<\/p>\n
Sie können auch mehrere Objekte auf Basis der gleichen Klasse erstellen:<\/p>\n
Konto konto1 = new Konto();\r\nKonto konto2 = new Konto();<\/pre>\n
Sichtbarkeit der Klasse<\/b><\/p>\n
Wenn Sie mit Access gearbeitet haben, kennen Sie die Klassenbibliotheken, die Sie üblicherweise per Verweis in ein VBA-Projekt eingebunden haben. Diese haben dann, sowohl über den Objektkatalog einsehbare als auch im Code referenzierbare Klassen bereitgestellt. Wenn Sie eine Klasse in einem C#-Projekt erstellen, um von anderen Anwendung darauf zuzugreifen, müssen Sie die Deklaration dieser Klasse mit dem Schlüsselwort public <\/b>versehen:<\/p>\n
     public class Konto {\r\n     }<\/pre>\n
Wenn Sie das Schlüsselwort public <\/b>nicht angeben, verwendet die Klasse die Standardeinstellung, welche dem Einsatz des Schlüsselworts internal <\/b>entspricht und den Zugriff von außerhalb der Klassenbibliothek verwehrt.<\/p>\n
Objekt freigeben<\/b><\/p>\n
Objekte belegen Arbeitsspeicher. Unter VBA haben Sie eine Objektvariable durch Setzen auf den Wert Nothing <\/b>freigegeben:<\/p>\n
VBA-Code:\r\nSet<\/span> rst = Nothing<\/pre>\n
Unter C# stellen Sie das Objekt auf den Wert null <\/b>ein:<\/p>\n
konto = null;<\/pre>\n
Damit können Sie nun nicht mehr auf das Objekt zugreifen. Der Speicherplatz wird jedoch erst freigegeben, wenn die Garbage Collection startet und das Objekt löscht. Dies geschieht je nach Auslastung (bei hoher Auslastung seltener) und verfügbarem Speicherplatz (wenn der Platz knapp wird) oder bei Schließen der Anwendung.<\/p>\n
Eigenschaften einer Klasse<\/b><\/p>\n
Unsere Konto-Klasse soll verschiedene Eigenschaften bieten, zum Beispiel Kontoinhaber<\/b>, Bankleitzahl<\/b>, Kontonummer<\/b>, Kontostand <\/b>und Dispositionsrahmen<\/b>. Um diese Eigenschaften nach dem Instanzieren eines Objekts auf Basis der Klasse Konto <\/b>zu lesen und auch zu schreiben, deklarieren Sie diese wie folgt:<\/p>\n
class Konto {\r\n     public string Kontoinhaber;\r\n     public string Kontonummer;\r\n     public string Bankleitzahl;\r\n     public decimal Kontostand;\r\n     public decimal Dispositionsrahmen;\r\n}<\/pre>\n
Sie können dann von einer anderen Klasse aus, in diesem Fall Program<\/b>, per IntelliSense auf die Eigenschaften zugreifen (siehe Bild 3). Dort sehen Sie noch einige weitere Methoden, beispielsweise Equals <\/b>oder GetType<\/b>.<\/p>\n
\"Eigenschaften<\/p>\n
Bild 3: Eigenschaften per IntelliSense<\/span><\/b><\/p>\n
Eigenschaften zuweisen und ausgeben<\/b><\/p>\n
Das folgende Beispiel deklariert und instanziert das Objekt konto<\/b> auf Basis der Klasse Konto<\/b>, weist den Eigenschaften Werte zu und gibt diese dann in der Konsole aus:<\/p>\n
Konto konto;\r\nkonto = new Konto();\r\nkonto.Kontoinhaber = \"André Minhorst\";\r\nkonto.Kontonummer = \"1234567890\";\r\nkonto.Bankleitzahl = \"87654321\";\r\nkonto.Kontostand = 100;\r\nkonto.Dispositionsrahmen = 1000;\r\nConsole.WriteLine(\"Kontoinhaber: {0}\", konto.Kontoinhaber);\r\nConsole.WriteLine(\"Kontonummer:  {0}\", konto.Kontonummer);\r\nConsole.WriteLine(\"Bankleitzahl: {0}\", konto.Bankleitzahl);\r\nConsole.ReadLine();<\/pre>\n
Datenkapselung<\/b><\/p>\n
Von VBA kennen Sie es vielleicht bereits: Die Eigenschaften einer Klasse werden nie als öffentliche Variablen deklariert, sondern mit den Schlüsselwort Private<\/b>. Stattdessen erstellen Sie sogenannte Property Get<\/b>– und Property Let<\/b>– (für Werttypen) oder Property Set<\/b>-Methoden (für Referenztypen), um auf die Inhalte der jeweiligen Variablen zuzugreifen. Hier haben wir dann zunächst eine private Variable für den Wert der Eigenschaft deklariert:<\/p>\n
'VBA-Code:\r\nPrivate <\/span>m_Kontostand As Currency<\/span><\/pre>\n
Die Property Let<\/b>-Methode erlaubte dann das Setzen des Wertes dieser Variablen von außerhalb der Klasse:<\/p>\n
'VBA-Code:\r\nPublic Property Let <\/span>Kontostand(curKontostand As Currency<\/span>)\r\n     m_Kontostand = curKontostand\r\nEnd Property<\/span><\/pre>\n
Mit der Get<\/b>-Methode konnte man den Wert hingegen lesen:<\/p>\n
'VBA-Code:\r\nPublic Property Get <\/span>Kontostand As Currency<\/span>\r\n     Kontostand = m_Kontostand\r\nEnd Property<\/span><\/pre>\n
Durch diese Methoden war es möglich, beispielsweise Eingaben auf ihre Gültigkeit hin zu prüfen. Unter C# sieht das ähnlich aus, allerdings ist der Aufbau etwas anders. Die Deklaration ändern wir, indem wir das Schlüsselwort public<\/b> auf private <\/b>ändern. Außerdem soll die Schreibweise mit dem großen Anfangsbuchstaben für die Eigenschaft nach außen hin erkennbar sein. Das heißt, dass wir den Namen der Variablen ändern müssen – Namen für Variablen, Methoden, Eigenschaften et cetera müssen innerhalb eines Namespaces eindeutig sein.<\/p>\n
Also ändern wir beim Variablennamen den großen Anfangsbuchstaben in einen kleinen:<\/p>\n
private string kontoinhaber;<\/pre>\n
Wenn Sie dies zu unübersichtlich finden, können Sie alternativ auch etwa den Namen mit Großbuchstaben verwenden und diesem einen Unterstrich voranstellen – also etwa _Kontoinhaber<\/b>. Außerdem fügen wir eine öffentliche Eigenschaft mit einem get<\/b>– und einem set<\/b>-Block hinzu. Diese wird wieder mit großem Anfangsbuchstaben notiert:<\/p>\n
public string Kontoinhaber {\r\n     get {\r\n         return kontoinhaber;\r\n     }\r\n     set {\r\n         kontoinhaber = value;           \r\n     }\r\n}<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t