<\/p>\n
ZUGFeRD ist das Akronym für „Zentraler User Guide des Forums elektronische Rechnung Deutschland“. Außerdem ist es ein elektronisches Rechnungsdatenformat für den Austausch von Rechnungen und damit ein Lösungsansatz für die Frage, wie man die Daten einer Rechnung auf einfache Weise für die Durchführung der Überweisung des berechneten Betrags verarbeiten kann. Genau genommen nutzt man hier eine Kombination aus einem auf spezielle Weise hergestellten PDF-Dokuments und eines XML-Dokuments, das die in der Rechnung enthaltenen Daten einmal optimiert für das menschliche Auge und einmal optimiert für die Datenverarbeitung enthält. In diesem ersten Teil einer kleinen Beitragsreihe zeigen wir, wie Sie die Open Source-Bibliothek von Konik in einer .NET-Lösung nutzen, um daraus eine DLL für den Zugriff auf Access heraus zu erstellen.<\/b><\/p>\n
ZUGFeRD-Basics<\/b><\/p>\n
Grundidee hinter ZUGFeRD ist es, ein einheitliches Format für den Austausch von Rechnungsdaten zu schaffen, das sowohl vom Menschen als auch vom Computer optimal gelesen werden kann.<\/p>\n
Die üblichen Rechnungen sind durchaus so strukturiert, dass der Mensch die Daten für die zu tätigende Überweisung entnehmen kann – wenngleich hier eine weitere Vereinheitlichung bezüglich der Position der verschiedenen Informationen wünschenswert wäre.<\/p>\n
Wenn Sie die Rechnung computergestützt verarbeiten wollen, wird es ohne Standardisierung umso schwieriger – Algorithmen brauchen halt genaue Informationen, wo sie was einlesen sollen, damit sie ihre Arbeit fehlerfrei verrichten. Das ist bei gedruckten und eingescannten Rechnungen oder auch bei Rechnungen im PDF-Format nicht zuverlässig möglich.<\/p>\n
Also haben sich die Menschen hinter FeRD<\/b>, dem Forum elektronische Rechnung Deutschland<\/b>, etwas ausgedacht: Sie verwenden ein spezielles PDF-Format, nämlich das Format PDF\/A-3, mit dem ein PDF-Dokument, das mit herkömmlichen PDF-Readern angezeigt werden kann, um ein XML-Dokument erweitert werden kann. Dieses enthält die gleichen Daten, die auch schon im PDF-Dokument angezeigt werden, nochmal im XML-Format – also in einem Format, das von Computern besser verarbeitet werden kann als ein einfaches PDF-Format.<\/p>\n
Die Konik-Bibliothek<\/b><\/p>\n
Die Firma Konik bietet unter https:\/\/konik.io\/ <\/b>eine Open Source-Bibliothek für Java und .NET an. Als Access-Entwickler schauen wir erstmal wieder in die Röhre, denn es gibt keine direkte Möglichkeit für uns, direkt auf die Bibliothek zuzugreifen. Wir müssen uns also selbst eine DLL bauen, welche diese Bibliothek nutzt, und auf diese von Access aus zugreifen. Wir werden dies aber in diesem Teil der Beitragsreihe und in den folgenden Teilen detailliert darstellen.<\/p>\n
ZUGFeRD-Versionen<\/b><\/p>\n
Es gibt verschiedene Versionen von ZUGFeRD. Die erste Version 1.0 stammt von 2014. Das ist die Version, die wir im vorliegenden Beitrag beschreiben.<\/p>\n
Die neueste Version 2.01 liegt zum Zeitpunkt der Erstellung dieses Beitrags noch nicht in Form einer Open Source-Bibliothek vor.<\/p>\n
Visual Studio installieren<\/b><\/p>\n
Wenn Sie nicht bereits Visual Studio installiert haben, sollten Sie dies nachholen, sofern Sie die Beispiele dieses Beitrags nachvollziehen wollen. Sie können aber auch die hier erstellte DLL von Access aus verwenden.<\/p>\n
Visual Studio können Sie in der aktuellen Version zumindest für private Zwecke und Testzwecke in der Community Edition kostenlos herunterladen und nutzen (weitere Informationen hierzu erhalten Sie in den jeweiligen Lizenzbedingungen).<\/p>\n
Visual Studio als Administrator starten<\/b><\/p>\n
Da die DLL nicht nur erstellt, sondern auch registriert werden muss, benötigen Sie später Administratorrechte. Daher starten Sie Visual Studio gleich mit diesen Rechten.<\/p>\n
Dazu klicken Sie mit der rechten Maustaste auf den Eintrag für Visual Studio und wählen dort den Befehl Als Administrator öffnen <\/b>aus. Dass Visual Studio mit Administratorrechten gestartet wurde, erkennen Sie daran, dass in der Titelzeile Administrator <\/b>in Klammern ausgegeben wird.<\/p>\n
DLL erstellen<\/b><\/p>\n
Um eine geeignete DLL zu erstellen, öffnen Sie mit dem Menüpunkt Datei|Neu|Projekt… <\/b>den Dialog Neues Projekt<\/b>. Hier wählen Sie den Namen und den Speicherort des zu erstellenden Projekts aus.<\/p>\n
Am wichtigsten ist jedoch die Wahl des richtigen Projekttyps, in diesem Fall Visual Basic|Windows Desktop|Klassenbibliothek (.NET Framework)<\/b>. Vor dem Erstellen des Projekts sieht der Dialog wie in Bild 1 aus.<\/p>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2020_02\/pic_1231_001.png\")
<\/p>\n
Bild 1: Anlegen der Klassenbibliothek in Visual Studio<\/span><\/b><\/p>\n Vorbereitungen der DLL<\/b><\/p>\n Als Erstes benennen wir die automatisch hinzugefügte Klasse Class1 <\/b>um, und zwar in ZUGFeRD_NET<\/b>. Das erledigen Sie, indem Sie den entsprechenden Eintrag im Projektmappen-Explorer von Visual Studio ändern.<\/p>\n Wenn Sie das tun, fragt Visual Studio automatisch, ob Sie auch Verweise auf das Codeelement Class1 <\/b>umbenennen wollen, was Sie bejahen sollten. Dadurch wird auch die Klasse entsprechend umbenannt:<\/p>\n Danach erweitern wir den Inhalt der Datei ZUGFeRD_NET.vb <\/b>wie folgt um einen Verweis auf den Namespace System.Runtime.InteropServices <\/b>und einer Zusatzinformation:<\/p>\n Sichtbarmachen der Klassen und Methoden<\/b><\/p>\n Damit wir die Klasse und die nachfolgend definierten Methoden im VBA-Editor finden können, müssen wir noch weitere Schritte durchführen.<\/p>\n Dazu klicken Sie doppelt auf den Eintrag My Project <\/b>im Projektmappen-Explorer und zeigen so die Eigenschaften des Projekts an.<\/p>\n Hier wechseln Sie zum Bereich Anwendung<\/b>, sofern dieser noch nicht angezeigt wird, und klicken dort auf die Schaltfläche Assemblyinformationen… <\/b>(siehe Bild 2).<\/p>\n Bild 2: Anzeigen der Assemblyinformationen<\/span><\/b><\/p>\n Danach erscheint der Dialog Assemblyinformationen<\/b>. Hier finden Sie im unteren Bereich den Eintrag Assembly COM-sichtbar machen<\/b>, den Sie aktivieren (siehe Bild 3).<\/p>\n Bild 3: Assembly sichtbar für COM machen<\/span><\/b><\/p>\n Fehlt noch ein Schritt, den Sie in den Eigenschaften im Bereich Kompilieren <\/b>erledigen – hier muss die Option Für COM-Interop registrieren <\/b>aktiviert werden (siehe Bild 4).<\/p>\n Bild 4: Registrieren für COM-Interop<\/span><\/b><\/p>\n Schließlich fügen wir der Klasse ZUGFeRD_NET <\/b>die folgende Funktion hinzu:<\/p>\n Damit können wir das Projekt nun erstellen, indem wir den Menübefehl Erstellen|Projektmappe erstellen <\/b>von Visual Studio aufrufen. Dadurch wird die DLL erstellt und die Registry wird um die Informationen ergänzt, die gleich beim Öffnen von Access eingelesen werden, damit dort die neue Bibliothek als Verweis zur Verfügung steht.<\/p>\n Verweis auf die neue ZUGFeRD-Bibliothek einbinden<\/b><\/p>\n Um den Verweis zu einem VBA-Projekt einer Access-Datenbank hinzuzufügen, öffnen Sie zunächst die Access-Datenbank, in der Sie die DLL verwenden wollen.<\/p>\n Dann zeigen Sie den VBA-Editor an, am schnellsten mit der Tastenkombination Strg + G<\/b>, und öffnen dann mit dem Menüeintrag Extras|Verweise <\/b>den Verweise<\/b>-Dialog.<\/p>\n Hier finden Sie nun ganz unten den Eintrag ZUGFeRD<\/b>, den Sie anhaken, bevor Sie den Dialog wieder schließen (siehe Bild 5).<\/p>\n Bild 5: Verweis auf die neue DLL hinzufügen<\/span><\/b><\/p>\n Wenn dies geschehen ist, können Sie ausprobieren, ob die einzige bisher angelegte Funktion bereits wie erwartet arbeitet. Diese sollte beim Aufruf der folgenden Prozedur den Wert True <\/b>im Direktfenster ausgeben:<\/p>\n Dies gelingt wie erwartet, sodass wir uns nun der Programmierung zuwenden können.<\/p>\n ZUGFeRD-Paket zum VB-Projekt hinzufügen<\/b><\/p>\n Die Open Source-Bibliothek ZUGFeRD.NET <\/b>der Firma Konik kommt als NuGet-Paket. Solche Pakete können Sie einfach zu einem VB-Projekt unter Visual Studio hinzufügen.<\/p>\n Dazu wählen Sie im Kontextmenü des Projekt-Elements im Projektmappen-Explorer unter Visual Studio den Eintrag NuGet-Pakete verwalten <\/b>aus. Dies öffnet den NuGet-Paket-Manager<\/b>. Hier geben Sie als Suchbegriff ZUGFeRD <\/b>ein und wechseln dann zum Bereich Durchsuchen<\/b>.<\/p>\n Wir suchen den Eintrag ZUGFeRD.NET <\/b>der Firma Konik und fügen das entsprechende Paket durch einen Klick auf die Schaltfläche Installieren <\/b>zum aktuellen VB-Projekt hinzu (siehe Bild 6).<\/p>\n Bild 6: Hinzufügen des NuGet-Pakets <\/span><\/b><\/p>\n Namespace-Verweise<\/b><\/p>\n Im Modul ZUGFeRD_NET.vb <\/b>fügen Sie nun zunächst die folgenden Verweise auf die benötigen Namespaces hinzu:<\/p>\n Verschiedene Profile<\/b><\/p>\n Bevor wir in die Programmierung einsteigen, noch ein Hinweis auf die verschiedenen Profile für ZUGFeRD-Dateien.<\/p>\n Diese sehen wir folgt aus:<\/p>\n Eine bessere Unterscheidung ermöglicht die Betrachtung der verschiedenen Rechnungsarten.<\/p>\n Das BASIC<\/b>-Profil unterstützt diese Rechnungsarten:<\/p>\n Das COMFORT<\/b>-Profil bietet folgende zusätzlichen Rechnungsarten:<\/p>\n Die hier genannten Codes werden einer der Eigenschaften zugeordnet, die wir gleich über das Objektmodell der Bibliothek dem XML-Dokument zuweisen, das mit dem PDF-Dokument zusammengeführt werden soll.<\/p>\n Öffentliche Eigenschaften der DLL<\/b><\/p>\n Damit wir die im XML-Teil der Rechnung zu berücksichtigenden Informationen von Access aus an die DLL übergeben können, erstellen wir einige öffentliche Eigenschaften.<\/p>\n Deren Programmierung im Modul ZUGFeRD_NET.vb <\/b>besteht aus zwei Teilen – der privaten Deklaration einer Variablen zum Speichern der zugewiesenen Werte sowie einer öffentlichen Eigenschaft mit Getter und Setter.<\/p>\n Die Namen der privaten Variablen beginnen allesamt mit dem Unterstrich und werden wie folgt deklariert:<\/p>\n <\/p>\n Für jede der Variablen (mit wenigen Ausnahmen) fügen wir eine öffentliche Eigenschaft hinzu, die von außen gelesen und geschrieben werden kann.<\/p>\n Für die Variable _ZielPDF <\/b>sieht dieses Konstrukt wie folgt aus:<\/p>\n Für die übrigen Variablen haben wir ähnliche Konstrukte erstellt. In einigen Fällen benötigen wir alternative Getter und Setter, zum Beispiel für das Land. Hier müssen wir das als Zeichenkette gelieferte Länderkürzel in ein Objekt umwandeln (zum Beispiel Country.DE<\/b>) und umgekehrt:<\/p>\n Und für die fünf Eigenschaften Nettobetrag<\/b>, Aufschlaege<\/b>, Abschlaege<\/b>, Mehrwertsteuerbetrag <\/b>und Bruttobetrag <\/b>verwenden wir eine Eigenschaft wie die folgende – hier am Beispiel des Nettobetrags:<\/p>\n Dies ist den Inkompatibilitäten zwischen den Datentypen von Java, auf dem das NuGet-Paket basiert, und .NET begründet. Hier passiert Folgendes: Der Benutzer übergibt den Wert von Access aus als Dezimalzahl, in diesem Fall bei Zahlen ohne Nachkommastellen als Integer <\/b>(bis 32.767) oder Long <\/b>(ab 32.768) und mit Nachkommastellen als Double<\/b>.<\/p>\n Diese müssen wir in den Datentyp BigDecimal <\/b>konvertieren, denn die Eigenschaften, die wir für die Erstellung des XML-Dokuments mit den Zahlenwerten füllen müssen, weisen diesen Datentypen des Namespace java.math <\/b>auf.<\/p>\n Beim Zuweisen an die Eigenschaft erstellen wir auf Basis des Wertes aus value <\/b>mit New BigDecimal(value) <\/b>ein BigDecimal<\/b>-Objekt mit dem entsprechenden Wert. Beim Zurückgeben über den Getter ermitteln wir mit der Eigenschaft floatValue <\/b>die im BigDecimal<\/b>-Objekt enthaltene Zahl mit Nachkommastellen.<\/p>\n Hauptmethode der DLL<\/b><\/p>\n Neben den vielen Informationen, die wir der DLL über die oben genannten öffentlichen Eigenschaften mitteilen, gibt es zunächst eine einzige Methode, die tatsächlich etwas erledigt. Diese heißt ZUGFeRDRechnungErstellen <\/b>und sieht wie in Listing 1 aus.<\/p>\n Listing 1: Methode zum Erstellen einer Rechnung<\/span><\/b><\/p>\n Die Methode löscht zunächst eine eventuell bereits vorhandene Datei mit dem Namen der zu erstellenden Zieldatei. Dann folgt eine Anweisung, die die technische Voraussetzung für den Einsatz der Bibliotheken in einer DLL schafft (das ist etwa in einer WPF-Anwendung nicht nötig).<\/p>\n Nun erstellt die Prozedur mit der Methode CreateInvoice <\/b>ein neues Rechnungsobjekt. Diese Methode erledigt die Hauptarbeit und wird weiter unten beschrieben.<\/p>\n Im Anschluss erstellt die Prozedur ein neues PdfHandler<\/b>-Objekt sowie zwei FileInputStream<\/b>-Objekte auf Basis der bereits bestehenden PDF-Rechnung und für das Erstellen der neuen, um das XML-Dokument angereicherte Rechnungsdatei.<\/p>\n Schließlich sorgt die Methode appendInvoice <\/b>des PDFHandler<\/b>-Objekts dafür, dass die Rechnung zum Ausgangs-PDF hinzugefügt wird und dass die neue Version unter dem Namen des Zieldokuments gespeichert wird. Liegt das gewünschte PDF-Dokument anschließend vor, liefert die Methode den Wert True <\/b>zurück.<\/p>\n Die Methode CreateInvoice<\/b><\/p>\n Die weiter oben bereits erwähnte Methode CreateInvoice <\/b>stellt die über die öffentlichen Eigenschaften übergebenen Informationen zusammen.<\/p>\n Sie liefert ein Objekt des Typs Invoice <\/b>als Ergebnis an die aufrufende Routine zurück.<\/p>\n Die folgende Methode haben wir aus folgendem Link bezogen und dann an Visual Basic angepasst und um die öffentlichen Eigenschaften ergänzt:<\/p>\n Deklaration<\/b><\/p>\n Zu Beginn deklariert die Methode erst einmal einige Variablen, die wir im späteren Verlauf benötigen:<\/p>\n Vorbereitende Schritte<\/b><\/p>\n Dann füllt sie die Variable Today <\/b>mit dem aktuellen Datum in einem von der ZUGFeRD<\/b>-Bibliothek lesbaren Format.<\/p>\n In der Variablen nextMonth <\/b>speichern wir das Datum, das einen Monat hinter dem Rechnungsdatum liegt:<\/p>\n Die folgende Anweisung erstellt das grundlegende Rechnungsobjekt auf Basis der Vorlage BASIC<\/b>:<\/p>\n Das erste Element, das wir hinzufügen, heißt Header<\/b>. Es enthält Daten wie die Rechnungsnummer, den Dokumentcode (siehe oben – 380 <\/b>entspricht Handelsrechnungen, Bescheide oder kaufmännischen Gutschriften). setIssued <\/b>nimmt das Erstellungsdatum entgegen. Mit addNote <\/b>fügen wir einen Hinweistext hinzu wie beispielsweise Fällig in zehn Tagen<\/b>. Mit setName <\/b>legen wir die Bezeichnung fest: <\/p>\n Die folgende Anweisung fügt das Header<\/b>-Objekt über die Methode setHeader <\/b>zu objInvoice <\/b>hinzu:<\/p>\n Danach beginnen wir mit dem Eintragen weiterer Informationen in weitere Objekte, die später als Eigenschaften weiteren Objekten hinzugefügt werden.<\/p>\n Wir beginnen mit den Verkäuferdaten, die in einem Objekt des Typs TradeParty <\/b>namens objSeller <\/b>landen. Hier weisen wir den Namen des Verkäufers, seine Adressdaten sowie die Umsatzsteuer-Identifikationsnummer zu:<\/p>\nPublic Class<\/span> ZUGFeRD_NET\r\nEnd Class<\/span><\/pre>\nImports System.Runtime.InteropServices\r\n<ClassInterface(ClassInterfaceType.AutoDual)>\r\nPublic Class<\/span> ZUGFeRD_NET\r\nEnd Class<\/span><\/pre>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2020_02\/pic_1231_002.png\")
<\/p>\n![\"Assembly](\"..\/fileadmin\/_temp_\/2020_02\/pic_1231_003.png\")
<\/p>\n![\"Registrieren](\"..\/fileadmin\/_temp_\/2020_02\/pic_1231_004.png\")
<\/p>\nPublic Function <\/span>ZUGFeRDRechnungErstellen() As Boolean<\/span>\r\n Return True<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Verweis](\"..\/fileadmin\/_temp_\/2020_02\/pic_1231_005.png\")
<\/p>\nPublic Sub <\/span>ZUGFeRDTest()\r\n Dim <\/span>objZUGFeRD As <\/span>ZUGFeRD.ZUGFeRD_NET\r\n Set<\/span> objZUGFeRD = New<\/span> ZUGFeRD.ZUGFeRD_NET\r\n Debug.Print<\/span> objZUGFeRD.ZUGFeRDRechnungErstellen\r\nEnd Sub<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2020_02\/pic_1231_006.png\")
<\/p>\nImports System.Runtime.InteropServices \r\nImports java.io\r\nImports org.apache.commons.lang3.time\r\nImports com.neovisionaries.i18n\r\nImports io.konik\r\nImports io.konik.ZUGFeRD\r\nImports io.konik.ZUGFeRD.entity\r\nImports io.konik.ZUGFeRD.entity.trade\r\nImports io.konik.ZUGFeRD.entity.trade.item\r\nImports io.konik.ZUGFeRD.profile\r\nImports io.konik.ZUGFeRD.unece.codes\r\nImports io.konik.ZUGFeRD.unqualified\r\nImports java.math\r\nImports Country = com.neovisionaries.i18n.CountryCode\r\nImports Currency = com.neovisionaries.i18n.CurrencyCode<\/pre>\n
\n
\n
\n
Private <\/span>_QuellPDF As String<\/span>\r\n Private <\/span>_ZielPDF As String<\/span>\r\n Private <\/span>_Rechnungsnummer As String<\/span>\r\n Private <\/span>_Verkaeufer_Name As String<\/span>\r\n Private <\/span>_Verkaeufer_PLZ As String<\/span>\r\n Private <\/span>_Verkaeufer_Strasse As String<\/span>\r\n Private <\/span>_Verkaeufer_Ort As String<\/span>\r\n Private <\/span>_Verkaeufer_Land As <\/span>CountryCode\r\n Private <\/span>_Bemerkung As String<\/span>\r\n Private <\/span>_Verkaeufer_UstIDNr As String<\/span>\r\n Private <\/span>_Kaeufer_Name As String<\/span>\r\n Private <\/span>_Kaeufer_PLZ As String<\/span>\r\n Private <\/span>_Kaeufer_Strasse As String<\/span>\r\n Private <\/span>_Kaeufer_Ort As String<\/span>\r\n Private <\/span>_Kaeufer_Land As <\/span>CountryCode\r\n Private <\/span>_Kaeufer_UstIDNr As String<\/span>\r\n Private <\/span>_Verkaeufer_IBAN As String<\/span>\r\n Private <\/span>_Verkaeufer_BIC As String<\/span>\r\n Private <\/span>_Nettobetrag As <\/span>BigDecimal\r\n Private <\/span>_Aufschlaege As Long<\/span>\r\n Private <\/span>_Abschlaege As Long<\/span>\r\n Private <\/span>_Mehrwertsteuerbetrag As Long<\/span>\r\n Private <\/span>_Bruttobetrag As Long<\/span>\r\n Private <\/span>_Zahlungsreferenz As String<\/span>\r\n Private <\/span>_Produkt As String<\/span>\r\n Private <\/span>_AnzahlProdukt As Long<\/span><\/pre>\nPublic Property <\/span>ZielPDF As String<\/span>\r\n Get\r\n Return _ZielPDF\r\n End Get\r\n Set(value As String<\/span>)\r\n _ZielPDF = value\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPublic Property <\/span>Verkaeufer_Land As String<\/span>\r\n Get\r\n If <\/span>(_Verkaeufer_Land Is Country.DE) Then<\/span>\r\n Return \"DE\"\r\n End If<\/span>\r\n End Get\r\n Set(value As String<\/span>)\r\n Select Case value\r\n Case <\/span>\"DE\"\r\n _Verkaeufer_Land = Country.DE\r\n End Select<\/span>\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPublic Property <\/span>Nettobetrag As Double<\/span>\r\n Get\r\n Return _Nettobetrag.floatValue\r\n End Get\r\n Set(value As Double<\/span>)\r\n _Nettobetrag = New<\/span> BigDecimal(value)\r\n End Set<\/span>\r\nEnd Property<\/span><\/pre>\nPublic Function <\/span>ZUGFeRDRechnungErstellen() As Boolean<\/span>\r\n Dim <\/span>objInvoice As <\/span>Invoice\r\n Dim <\/span>objPDFHandler As <\/span>PdfHandler\r\n Dim <\/span>objInputPDf As <\/span>InputStream\r\n Dim <\/span>objResultingPDF As <\/span>OutputStream\r\n On Error Resume Next<\/span>\r\n Kill(ZielPDF)\r\n On Error GoTo<\/span> 0\r\n IKVM.Runtime.Startup.addBootClassPathAssembly( _\r\n GetType(io.konik.ZUGFeRD.ObjectFactory).Assembly)\r\n objInvoice = CreateInvoice()\r\n objPDFHandler = New<\/span> PdfHandler\r\n objInputPDf = New<\/span> FileInputStream(QuellPDF)\r\n objResultingPDF = New<\/span> FileOutputStream(ZielPDF)\r\n objPDFHandler.appendInvoice(objInvoice, objInputPDf, objResultingPDF)\r\n If <\/span>Len<\/span>(Dir(ZielPDF)) > 0 Then<\/span>\r\n Return True<\/span>\r\n Else<\/span>\r\n Return False<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nhttps:\/\/github.com\/konik-io\/ZUGFeRD.NET-Example\/blob\/master\/KonikNetExample\/NetExampleInvoice.cs<\/pre>\n
Private Function <\/span>CreateInvoice() As <\/span>Invoice\r\n Dim <\/span>objInvoice As <\/span>Invoice\r\n Dim <\/span>objHeader As <\/span>Header\r\n Dim <\/span>Today As <\/span>ZfDate\r\n Dim <\/span>nextMonth As <\/span>ZfDate\r\n Dim <\/span>objTrade As <\/span>Trade\r\n Dim <\/span>objSeller As <\/span>TradeParty\r\n Dim <\/span>objBuyer As <\/span>TradeParty\r\n Dim <\/span>objAgreement As <\/span>Agreement\r\n Dim <\/span>objSettlement As <\/span>Settlement\r\n Dim <\/span>objPaymentmeans As <\/span>PaymentMeans\r\n Dim <\/span>objMonetarySummation As <\/span>MonetarySummation\r\n Dim <\/span>objProduct As <\/span>Product\r\n Dim <\/span>objItem As <\/span>Item\r\n Dim <\/span>objSpecifiedDelivery As <\/span>SpecifiedDelivery\r\n Dim <\/span>objQuantity As <\/span>Quantity<\/pre>\n Today = New<\/span> ZfDateDay()\r\n nextMonth = New<\/span> ZfDateMonth(DateUtils.addMonths(Today, 1))<\/pre>\n objInvoice = New<\/span> Invoice(ConformanceLevel.BASIC)<\/pre>\n objHeader = New<\/span> Header\r\n With<\/span> objHeader\r\n .setInvoiceNumber(_Rechnungsnummer)\r\n .setCode(DocumentCode._380)\r\n .setIssued(Today)\r\n .addNote(New<\/span> Note(_Bemerkung))\r\n .setName(\"Rechnung\")\r\n End With<\/span><\/pre>\n objInvoice.setHeader(objHeader)<\/pre>\n
objSeller =