Kleines Klassenbibliothek (DLL) Tutorial

    • VB.NET

    Es gibt 17 Antworten in diesem Thema. Der letzte Beitrag () ist von zn-gong.

      Kleines Klassenbibliothek (DLL) Tutorial

      Hallo liebe Community!

      Da oft Personen fragen wie man eine dll erstellt habe ich hier ein kleines Tutorial dazu.
      Es beinhaltet die Grundlagen des programmierens einer Klassenbibiliothek.

      Dann fangen wir mal an:

      Schritt 1: Erstellen einer Klassenbibiliothek

      Wie der Name des Schritts schon sagt müssen wir eine Klassenbibliothek erstellen.
      Klickt dazu einfach auf: Neues Projekt --> Klassenbibliothek
      Spoiler anzeigen


      Schritt 2: Der Anfang
      Wenn ihr die Klassenbibliothek habt steht im Code derzeit:

      VB.NET-Quellcode

      1. Public Class Class1
      3. End Class


      Ihr könnt Class1 umbennen. Damit wird dann später eure Dll aufgerufen.
      Bei mir sieht das dann so aus:

      VB.NET-Quellcode

      1. Public Class MeineDll
      3. End Class


      Edit:// Man kann diesen Schritt auch mit einem Namespace machen. (Danke an zn-gong bzw. GambaJo )
      Das sieht dann so aus:

      VB.NET-Quellcode

      1. Namespace MeineDll
      2. Public Class DeineKlasse1
      3. ''''''
      4. End Class
      5. Public Class DeineKlasse2
      6. ''''''''
      7. End Class
      8. End Namespace

      Mit Namespace würde das als XML so aussehen:

      XML-Quellcode

      1. <MeineDll>
      2. <DeineKlaase1>
      3. </DeineKlasse1>
      4. <DeineKlasse2>
      5. </DeineKlasse2>
      6. </MeineDll>




      In diesem Tutorial verwende ich nur Methoden. Das solltet ihr noch wissen.

      Schritt 3: Die erste Funktion
      Nun beginnen wir mit unserer ersten Funktion.
      Ich möchte, dass wenn ich diese Funktion in meinem Programm aufrufe, dass ich meinen Computernamen zurück bekomme.
      Um einen Wert zurück zu bekommen verwenden wir z.B. Return

      Dann beginnen wir mal:
      Wir erstellen unsere Funktion. Ich nenne sie in diesem Fall get_ComputerName

      VB.NET-Quellcode

      1. Public Shared Function get_ComputerName() As String 'Der Name der Methode bzw. die Deklarierung (String, Integer...)
      2. Return
      3. End Function


      Um einen Wert zurück zu bekommen müssen wir nun einfach nach dem Return unseren Code anhängen.
      Also:

      VB.NET-Quellcode

      1. Public Shared Function get_ComputerName() As String 'Der Name der Methode bzw. die Deklarierung (String, Integer...)
      2. Return My.Computer.Name 'Gibt den Computernamen zurück
      3. End Function


      Nun ist auch schon die erste Funktion fertig.

      Schritt 4: Die zweite Funktion
      Nun erstellen wir unsere zweite Funktion.
      Ich will das ich nun das Kommando show_Box aufrufe und sich eine MsgBox mit dem gewünschten Text öffnet. (Ich weiß es geht natürlich auch mit MsgBox("text"))

      Also wir erstellen mal wieder eine Funktion. Doch dieses mal müssen wir noch einen String(Es muss nicht umbedingt einer Sein) erstellen.

      VB.NET-Quellcode

      1. Public Shared Function show_Box(ByVal input As String)
      3. End Function


      Nun müssen wir einfach für die Funktion ein MsgBox(Input) hinzufügen.

      VB.NET-Quellcode

      1. Public Shared Function show_Box(ByVal input As String)
      2. MsgBox(input)
      3. End Function


      Nun haben wir auch schon diesen Schritt erfolgreich abgeschlossen.
      Das war es eig. auch schon mim erstellen.

      Schritt 5: Das Benutzen
      Bevor wir die Dll in unser Projekt einbinden. Müsst ihr sie natürlich noch speichern und erstellen.

      So, nun erstellen wir einfach eine neue Windows Forms Anwendung.
      Als nächstes müssen wir den Verweis auf unsere Dll hinzufügen.
      Dazu klickt ihr auf: Projekt-->Verweis hinzufügen-->Durchsuchen-->[Eure Dll]

      Nun müssen wir die Dll natürlich noch importieren:

      VB.NET-Quellcode

      1. Imports Kleine_Dll '(So heißt sie bei mir.)


      Jetzt können wir die Funktionen ganz einfach aufrufen.
      Ich adde dazu einfach einen Button und eine Textbox.
      Um die erste Funktion aufzurufen coden wir jetzt einfach:

      VB.NET-Quellcode

      1. Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
      2. Me.Text = MeineDll.get_ComputerName 'Ich zeige den Output als Titel(text) der Form an
      3. End Sub


      Und für die zweite Funktion:
      Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
      MeineDll.show_Box(TextBox1.Text)
      End Sub

      Edit:// Nochwas was, was zn-gong gern macht:
      Ich Verwende auch gerne Functionen auf Abruf (Die Man Kopieren kann und und und..) Nent sich dann Lambada und sieht so aus ;)

      VB.NET-Quellcode

      1. Dim DasIstLambada = Sub()
      2. '''''
      3. End Sub



      Fertig!
      Das wars auch schon. Dies war nur ein klitzekleiner Einblick in eine Klassenbibliothek(Dll). Man kann natürlich noch viel mehr machen.
      Ich hoffe es war hilfreich.

      Hat euch das Theme bzw. Tutorial geholfen und oder gefallen? Dann klickt bitte auf Bedanken!
      Mfg: Gather
      Private Nachrichten bezüglich VB-Fragen werden Ignoriert!

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Gather“ ()

      Zwei Sachen:
      1. Man muss nicht unbedingt die DLL einbinden. Man kann auch das Projekt der Klassenbiblio-thek komplett einbinden. Je nach Fall kann das den Vorteil haben, dass man die Klassenbibliothek editieren kann, ohne eine zweite Die zu öffnen.
      2. Bei Klassenbibliothek sollten Namespaces genutzt werden

      Eigendlich ganz nett, ich würde so es alerdings lieber so machen ;)

      VB.NET-Quellcode

      1. Namespace MyDLL
      2. Public Class DeineKlasse1
      3. ''''''
      4. end class
      5. Public Class DeineKlasse2
      6. ''''''''
      7. end class
      8. end namespace


      Die siht dan als XML (um es logisch zu verstehen so aus:

      XML-Quellcode

      1. <MyDLL>
      2. <DeineKlaase1>
      3. </DeineKlasse1>
      4. <DeineKlasse2>
      5. </DeineKlasse2>
      6. </MyDLL>


      PS, Ich Verwende auch gerne Functionen auf Abruf (Die Man Kopieren kann und und und..) Nent sich dann Lambada und siht so aus ;)

      VB.NET-Quellcode

      1. Dim DassIstLambada = Sub()
      2. '''''
      3. end sub


      Aber hatt eigendlich nicht's mit zu Tuhen.

      PS: Ist eigendlich für VB Noobs ganz cool. Danke!

      Danke für eure Feedbacks!

      @zn-gong: Ich habe jetzt deinen Code zum Tutorial geaddet.
      Namespace ist also nun im Tutorial vorhanden.
      Mfg: Gather
      Private Nachrichten bezüglich VB-Fragen werden Ignoriert!

      Glaube das ist gemeint:

      Gabriel Esparza-Romero schrieb:

      Once you've added the comments change the 'Configuration
      Properties->Build->XML Documentation File' project property. The name
      should be TheNameOfYourAssembly.xml.

      When you add a reference to an assembly, intellisense will look for this
      xml file at the same location where the assembly is, if there's such a file
      it will copy it to the project's reference directory and it will show the
      comments in intellisense.

      You should provide your xml file alongside your assembly when doing
      development.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Eistee“ ()

      Das sind Kommentare. Gehe dazu zu deiner Prozedur (Vor "Public Sub/Function" o.Ä.) und tippe dann 3 mal '. Danach gib die gewünschten Informationen ein.

      z.B.:

      VB.NET-Quellcode

      1. ''' <summary>
      2. ''' Zeigt einen Text in einer MessageBox
      3. ''' </summary>
      4. ''' <param name="txt">Der anzuzeigende Text</param>
      5. ''' <remarks></remarks>
      6. Public Sub ShowString(ByVal txt As String)
      7. MessageBox.Show(txt)
      8. End Sub

      VB.NET-Quellcode

      1. Public Shared Function show_Box(ByVal input As String)
      3. End Function


      Funktionen geben Werte zurück, da hierbei kein Return verwendet wird tuts ein Sub auch.
      Ansonsten ganz gut :D

      Grüße
      "Life isn't about winning the race. Life is about finishing the race and how many people we can help finish the race." ~Marc Mero

      Nun bin ich also auch soweit: Keine VB-Fragen per PM! Es gibt hier ein Forum, verdammt!

      Da du ja schreibst
      Man kann diesen Schritt auch mit einem Namespace machen

      hier noch eine Ergänzung: Unter den Projekteinstellungen kann man im Reiter "Anwendung" einen Stammnamespace für alle Klassen des Assembly festlegen.

      Außerdem, wieso zeigst du nur statische Methoden in deinen Beispielen? Die benötigt man normalerweise eher selten. Wenn eine Klasse dennoch ausschließlich statische Methoden enthält wie bei dir gezeigt, verwende ein Modul.

      Aber was am wichtigsten ist: Option Strict On! Bei Funktionen immer den Rückgabetyp angeben und ein Return mit Rückgabewert einfügen!

      Was auch noch zu vermeiden wäre, ist die Verwendung des My-Namespace.

      Infinity schrieb:

      Außerdem, wieso zeigst du nur statische Methoden in deinen Beispielen? Die benötigt man normalerweise eher selten. Wenn eine Klasse dennoch ausschließlich statische Methoden enthält wie bei dir gezeigt, verwende ein Modul.

      Nein, Module verwendet man selten, bis gar nicht. Im etwas veralteten Stil, wie der Microsoft.VisualBasic.dll werden Module zwar noch verwendet, aber im restlichen Framework sind sie mir noch nie begegnet.

      Infinity schrieb:

      Was auch noch zu vermeiden wäre, ist die Verwendung des My-Namespace.

      Hört doch mal auf mit dem My-Namespace und den VB6-Funktionen. Der My-Namespace ist klarer Bestandteil einer Anwendung, also kann man darauf verzichten oder eben auch nicht (ich verzichte einfach darauf, weil ich ihn nicht brauche). VB6-Funktionen sind wenn dann nur stilistisch unschön, aber ebenfalls nicht absolut zu verbieten. Vor Allem CInt, CLng, CType, DirectCast etc. sind quasi verpflichtend (CStr definitiv nicht, String ist aber auch kein primitiver Datentyp). Man kann darauf verzichten, muss aber definitiv nicht und die zitierte Aussage ist damit repräsentativ für alle falsch.

      Gruß
      ~blaze~

      Sorry falls ich jetzt was verwechsle, aber ein Module in VB entspricht doch einer als static deklarierten Klassen in C# und da gibt es doch einige im Framework: System.IO.File, System.IO.Path, System.Math, System.BitConverter, ...

      Und zu den Alten VB-Funktionen würde ich CInt, CLng, ... nicht zählen. Die sind ja im Prinzip Bestandteil des Sprachsyntax (sind ja auch noch vorhanden, wenn man den VisualBasic-Namespace nicht importiert). Aber die wirklichen alten VB-Funktionen wie FileOpen, Shell, ... würde ich nicht mehr verwenden, da sie nicht mehr weiterentwickelt werden und es einfach nicht ins Konzept der objektorientierten Programmierung passt.

      Was den My-Namespace betrifft hast du mich aber überzeugt. Mir ist es zwar lieber, direkt die Klassen aus dem Framework zu nehmen, aber man muss nicht darauf verzichten.

      Es stimmt, dass System.IO.File, usw. nur statische Methoden und Felder enthalten, aber das heißt nicht, dass sie automatisch Module sind.
      Ich glaube, Module werden durch das Attribut Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute definiert, hat zumindest gerade ein Test ergeben.

      VB.NET-Quellcode

      1. GetType(System.IO.File).IsDefined(GetType(Microsoft.VisualBasic.CompilerServices.StandardModuleAttribute), False)

      Das ergibt False und im IntelliSense werden die Module auch komplett anders gehandhabt. Module sind sowieso überflüssig, scheinbar abgesehen von der Verwendung bei Extensions, die mMn. ebenfalls relativ sinnlos beschränkt wurde.
      Das mit den VB6-Fkt wurde hier nur erwähnt, weil das lauter so Gerüchte sind, die sich verbreitet haben, aber für die keiner den Grund zu kennen scheint.

      Gruß
      ~blaze~

      Infinity schrieb:

      hier noch eine Ergänzung: Unter den Projekteinstellungen kann man im Reiter "Anwendung" einen Stammnamespace für alle Klassen des Assembly festlegen.


      Ich wäre hier für ein entweder oder.

      Wenn alles im selben Namespace sein soll, dann würde ich den Stammnamespace verwenden. Sind in der DLL mehrere Namespaces enthalten, die nicht einem gemeinsamen Stamm entspringen, würde ich den Stammnamespace deaktivieren.

      Wie bereits gesagt wurde, ist die Verwendung von XML-Kommentaren sehr zu empfehlen, um anderen das Arbeiten mit der Bibliothek zu erleichtern.

      Auch die Verwendung von Sandcastle ist sehr zu empfehlen, um direkt eine Hilfe-Datei zu erstellen.
      SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

      Weil einfach, einfach zu einfach ist! :D

      @~blaze~: Ich hab gerade auch im Reflektor nachvollzogen, dass static class und Module nicht das selbe sind (und man sieht es im Prinzip auch schon in der IntelliSense, wie du ja schon schreibst). Gut zu wissen. Allerdings bedeutet das auch, dass es für die static class aus C# wohl keine 1:1 Entsprechung in VB.Net gibt (eine MustInherit Class tuts aber wahrscheinlich auch).

      @BiedermannS: Es ist schon oft sinnvoll, wenn alles in einem Stammnamespace ist, der dann weitere "Unternamespaces" enthält.

      @Infinity: So war das auch gar nicht gemeint. Wenn man einen übergeordneten Namespace hat macht es natürlich sinn (wobei auch manche behaupten der Stammnamespace wäre böse :)). Gemeint war, dass in einer DLL zwei oder mehr unabhängige Namespaces liegen, dann verwirrt der Stammnamespace nämlich nur. (Ist aber eher selten der Fall, dass man zwei völlig unabhängige Namespaces in eine DLL verlegt)
      SWYgeW91IGNhbiByZWFkIHRoaXMsIHlvdSdyZSBhIGdlZWsgOkQ=

      Weil einfach, einfach zu einfach ist! :D

      Thorstian schrieb:

      in der DLL
      In der DLL selbst nicht, das geht nur mit einer Klasse in einer DLL. Du kannst Dir eine Init-Funktion bauen, der Du die Werte mitgibst
      oder
      Du gibst der Klasse einfach entsprechende Properties.
      Ich präferiere die Properties.
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Was noch zum Tutorial gut passen würde.

      In den Project Eigenschaften kann man ja die "Stammnamespace" ändern, da kann man es dann A: Weglassen die Namespace für die Klasse zu setzen. Und man kann die Stammnamespace auch mit . drinnen benenen

      VB.NET-Quellcode

      1. Namespace vbparadiese.forum



      z.B. könnte man dan als Folgende Value in den Project Eigenschaften Anlagen.

      vbparadise.forum
      hätte die Selbe Deklartion.