info@a-coding-project.de

JScript.net: Namespaces, Packages und Interfaces

Ebenso wie Klassen sind auch Packages und Interfaces neu in Jscrip.NET. Ein Package definiert einen bestimmten Namespace, der wiederum bestimmte Klassen und Interfaces beinhalten kann. Ein Namespace (oder zu deutsch Namensraum) ist ein Bereich innerhalb dessen bestimmte Klassen zugänglich sind. Ein Interface ist eine Schnittstelle zu Klassen.

Namespaces

Ein Namespace ist - wie bereits gesagt - ein bestimmter Namensraum in dem bestimmte Dinge verfügbar sind. Diese Dinge können z.B. Klassen, Interfaces oder Enumeratoren sein. Das Klassensystem des .NET-Framework ist zum Beispiel in viele viele viele Namespaces aufgeteilt. Jeder Namespace verkörpert hier ein mehr oder weniger großes Teilsystem, welches wiederum Teilsysteme enthalten kann.
Um eine Klasse eines Namespaces verwenden zu können, muss der entsprechende Namespace importiert werden. Dazu dient die import-Anweisung. Nach diesem Wort wird der Name des zu importierenden Namespaces notiert. Handelt es sich dabei um ein Untersystem eines Namespaces, so werden die Teilsysteme wie bei Objekten durch einen Punkt getrennt. Die import-Anweisungen stehen normalerweise am Anfang eines Dokuments und machen sämtliche Dinge die innerhalb dieses Namespaces definiert sind verfügbar. Ein Beispiel für die Verwendung von Namespaces: Im Namespace System, das das .NET-Framework bereitstellt, ist das Objekt Console definiert, das den Zugriff auf die Ausgabekonsole ermöglicht. Wird der Namespace importiert kann auch auf das Objekt zugegriffen werden:

import System

print('Willkommen in JScript.Net');

//vor dem Beenden stoppen
Console.ReadLine();

Innerhalb des .NET-Frameworks besteht jeder Namespace und ebenso jeder Unterteil eines Namespaces aus einem Package. Beispielsweise ist System ein Package. Innerhalb von System sind wiederum ein weitere Package definiert: CodeDom, Collections, ComponentModel, Configuration, Data, Diagnostics und und und. Die Unterpakete können durch das Elternpakete aufgerufen werden: System.CodeDom, System.Collections, System.ComponentModel usw.
Ebenso wie die Packages des .NET-Frameworks können sie auch eigene Packages verwenden. Wird ein Namespace importiert, sucht JScript.NET zuerst im aktuellen Dokument nach einem entsprechenden Package. Kann dort keines gefunden werden, wird nach einem entsprechenden Assembly innerhalb des definierten Assemblyverzeichnises gesucht. Wird z.B. der Namespace ABC.DEF.GHI importiert, sucht JScript.NET nach folgenden Assemblies: ABC.DEF.GHI.dll, ABC.DEF.dll und ABC.dll.

Packages

Ein Paket (engl. Package) ist eine Zusammenfassung wichtiger Dinge zu einer großen Komponente. Mit Packages wird es möglich gleiche oder ähnliche Klassen mehrfach zu definieren - jede in einem anderen Package. So kann der Klassenname drucker z.B. einmal verwendet werden um die Klassen zum Drucken von Dokumenten für eine Anwendung zusammen zu fassen und zum anderen um z.B. den Zugriff auf die Druckereigenschaften eines Druckers für ein anderes Programm zu ermöglichen.
Packages werden mit Hilfe der package-Anweisung erstellt. Dem Wort folgt der frei wählbare Name des Paketes. Wiederum danach folgen innerhalb von geschweiften Klammern sämtliche Definitionen die in das Paket einfließen sollen. Das können z.B. Schnittstellen, Klassen oder Aufzählungen (etc.) sein. Beispiel:

package pak1
{
 class Klasse{ var Name : String = 'Klasse von pak1'; }
}

package pak2
{
 class Klasse{ var Name : String = 'Klasse von pak2'; }
 class Klasse2{ var Name : String = 'Klasse2 von pak2'; }
}

import pak1;
import pak2;

var a:pak1.Klasse = new pak1.Klasse;
var b:pak2.Klasse = new pak2.Klasse;
var c:Klasse2 = new Klasse2;

print(a.Name); //Klasse von pak1
print(b.Name); //Klasse von pak2
print(c.Name); //Klasse2 von pak2

Wie zuvor beschrieben, wird im Beispiel zweimal die gleiche Klasse erstellt (Klasse). Je eine gehört zu den Packages pak1 und pak2. Mit der import-Anweisung werden die Packages für die Verwendung eingegliedert. Die Variablen a und b enthalten nun - obwohl sie von Klassen des gleichen Namens sind - unterschiedliche Werte. Anhand des Beispiels ist auch der Aufruf der Klassen zu sehen: Über den Paketnamen und einen anschließenden Punkt kann wie bei Objekten auf eine Klasse des Paketes zugegriffen werden. Werden so Klassen importiert die nur einmal vorhanden sind (also in keinem weiteren importierten Paket enthalten sind), kann auch direkt auf die Klasse zugegriffen werden - ohne den Paketnamen nennen zu müssen.

Interfaces

Interfaces oder zu deutsch Schnittstellen sind im Grunde nichts anderes als Klassen. Jedoch weisen Sie einen gewissen Unterschied auf: Interfaces definieren zwar auch Eigenschaften und Methoden - hier aber ohne weiteren Inhalt. Innerhalb einer Schnittstelle wird lediglich mitgeteilt, dass es diese Eigenschaften und Methoden gibt - jedoch nicht wie sie funktionieren. Klassen können diese Schnittstellen dann wiederum aufgreifen und ihnen "Leben" einhauchen. Für einfache Programmierungen klingt dies zwar wenig interessant - ist jedoch im speziellen Fall eine gute Sache. Ein Programmierer kann so z.B. mehrere Klassen verwenden, die auf dem gleichen Interface basieren. Dem Programmierer kann es dabei letztlich egal sein, wie die Funktionen einer Klasse arbeiten, ihm reicht es zu wissen, welche es gibt. Genau diese Aufgabe erfüllt die Schnittstelle. Sie liefert so ein nach Außen eindeutiges Abbild der Funktionen (Methoden, Getter und Setter) einer Klasse.

Die Definition eines Interfaces erfolgt wie die einer Klasse nur mit dem Unterschied, dass keine Klassen erweitert werden können (siehe extends-Anweisung). Sämtliche Funktionen dürfen zudem keinen Funktionskörper besitzen, sondern bestehen lediglich aus dem Funktionskopf. Zudem wird natürlich die class-Anweisung durch eine interface-Anweisung ersetzt. Bitte beachten Sie: Aus einem Interface kann kein Objekt erstellt werden. Beispiel:

public interface Lebewesen
{
 enum eLebewesen {Mensch, Tier};
 function get Typ():eLebewesen;
}

public class Mensch implements Lebewesen
{
 enum eGeschlecht {Mann, Frau};
 var Geschlecht: eGeschlecht;
 function get Typ():Lebewesen.eLebewesen
 {return(Lebewesen.eLebewesen.Mensch);}
}

public class Tier implements Lebewesen
{
 function get Typ():Lebewesen.eLebewesen
 {return(Lebewesen.eLebewesen.Tier);}
}

var a : Mensch = new Mensch;
var b : Tier = new Tier;
print(a.Typ); //gibt Mensch aus
print(b.Typ); //gibt Tier aus

Das Beispiel entspricht dem Beispiel von Kapitel "Klassen erweitern".

Weiterlesen: ⯈ Webservices

Über uns

Stefan Wienströer

Wir entwickeln Webanwendungen mit viel Leidenschaft. Unser Wissen geben wir dabei gerne weiter. Mehr über a coding project

Auch interessant