dll aus C in vb.net aufrufen

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 129 Antworten in diesem Thema. Der letzte Beitrag () ist von tron25.

    Hallo,

    nun wollte ich eine neue funktion einbinden. Aber leider gibt es ein Problem. Die Einzubindende Funktion erwartet ein Zeichen und gibt die entsprechenden Braillepunkte zurück. Hier erstmal die Funktion aus der DLL:

    int lou_dotsToChar (
    const char *tableList,
    const widechar *inbuf,
    widechar *outbuf,
    int length,
    int mode)

    Und hier die eingebundene Funktion in meinem Programm:

    VB.NET-Quellcode

    1. Imports System.Runtime.InteropServices
    2. Imports System.Text
    4. Class LibLouis
    5. Public Shared Function DotsToChar(input As String) As String
    6. If String.IsNullOrEmpty(input) Then
    7. Throw New ArgumentNullException("input")
    8. End If
    9. Dim refLength As Int32 = input.Length + 32 ' size heuristic
    10. Dim buffer As New StringBuilder(refLength)
    11. NativeMethods.lou_dotsToChar("Braille\Brailletabellen\de-de-g2.ctb", input, buffer, refLength, 0)
    12. buffer.Length = refLength
    13. Return buffer.ToString()
    14. End Function
    15. End Class
    17. Class NativeMethods
    18. <DllImport("liblouis.dll", BestFitMapping:=False, ThrowOnUnmappableChar:=True, CharSet:=CharSet.Unicode)>
    19. Public Shared Function lou_dotsToChar(
    20. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    21. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    22. <MarshalAs(UnmanagedType.LPWStr), Out()> outbuf As StringBuilder,
    23. length As Int32,
    24. mode As Int32) As Int32
    25. End Function
    26. end class


    Der Funktionsaufruf sieht folgendermaßen aus:

    VB.NET-Quellcode

    1. Private Sub TestMenue_Click(sender As Object, e As EventArgs) Handles TestMenue.Click
    2. If UngekuerztText.Text <> "" Then
    3. GekuerzterTextAnzeigenMenue.PerformClick()
    4. GekuerztText.Text = ""
    5. GekuerztText.Text = LouDotsToChar.DotsToChar(UngekuerztText.Text)
    6. End If
    7. End Sub


    Es gibt zwar keine Fehlermeldung, aber ich bekomme kein Ergebnis. Außerdem wird folgende Meldung angezeigt:

    Warnung BC42353 Die Funktion "lou_dotsToChar" gibt nicht für alle Codepfade einen Wert zurück. Fehlt eine Return-Anweisung?

    Kann mir da Jemand bitte helfen?

    Danke!

    @tron25 Diese Funktion macht nicht nur nix, sie gibt auch keinen Wert zurück.
    Du musst dieser Funktion einen Inhalt verpassen.
    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!

    Erst einmal ist mir ein kleiner Fehler unterlaufen. Die Funktion erstellt keine Punkte aus einem Zeichen, sondern sie erstellt ein Zeichen aus den Braillepunkten, die der Benutzer mitgibt.

    Was meinst du mit "Inhalt verpassen"? Ich habe, wie schon zuvor, zwei Eingabefelder, "Ungekuerzttext" und Gekuerzttext". Diese Felder benutze ich zum Testen. Die fertige Funktion soll dann später an einer anderen Stelle verwendet werden.

    Die Funktion "DotsToChar" hatt folgende Erklärung in der DLL:
    This function takes a widechar string in "inbuf" consisting of dot
    patterns and converts it to a widechar string in "outbuf" consisting of
    characters according to the specifications in "tableList". "length" is
    the length of both "inbuf" and "outbuf". The dot patterns in "inbuf"
    can be in either liblouis format or Unicode braille. The function
    returns 1 on success and 0 on failure.

    Ich habe versucht, sie anhand der vorherigen Funktion "lou_translateString" umzuschreiben. Folgender Unterschied ist mir aufgefallen:

    lou_translateString:
    int *inlen,

    lou_dotsToChar:
    int length,

    Die kompletten Deklarationen in der DLL sehen folgendermaßen aus:

    int lou_translateString(
    const char *tableList,
    const widechar *inbuf,
    int *inlen,
    widechar *outbuf,
    int *outlen,
    formtype *typeform,
    char *spacing,
    int mode);

    int lou_dotsToChar (
    const char *tableList,
    const widechar *inbuf,
    widechar *outbuf,
    int length,
    int mode);

    In meinem Programm sehen die Deklarationen so aus:

    VB.NET-Quellcode

    1. <DllImport("liblouis.dll", BestFitMapping:=False, ThrowOnUnmappableChar:=True, CharSet:=CharSet.Unicode)>
    2. Public Shared Function lou_translateString(
    3. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    4. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    5. ByRef inlen As Int32,
    6. <MarshalAs(UnmanagedType.LPWStr), Out()> outbuf As StringBuilder,
    7. ByRef outlen As Int32,
    8. typeform() As Typeforms,
    9. <MarshalAs(UnmanagedType.LPStr)> spacing As String,
    10. mode As Int32) As Int32
    11. End Function
    13. <DllImport("liblouis.dll", BestFitMapping:=False, ThrowOnUnmappableChar:=True, CharSet:=CharSet.Unicode)>
    14. Public Shared Function lou_dotsToChar(
    15. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    16. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    17. <MarshalAs(UnmanagedType.LPWStr), Out()> outbuf As StringBuilder,
    18. length As Int32,
    19. mode As Int32) As Int32
    20. End Function


    Der Aufruf beider Funktionen sieht folgendermaßen aus:

    VB.NET-Quellcode

    1. Public Shared Function Translate(input As String) As String
    2. If String.IsNullOrEmpty(input) Then
    3. Throw New ArgumentNullException("input")
    4. End If
    5. Dim refLength As Int32 = input.Length + 32 ' size heuristic
    6. Dim buffer As New StringBuilder(refLength)
    7. Dim typeform() = Enumerable.Repeat(NativeMethods.Typeforms.plain_text, refLength).ToArray()
    8. NativeMethods.lou_translateString("Braille\Brailletabellen\" & AktuelleUebersetzungstabelle, input, input.Length, buffer, refLength, typeform, Nothing, 0)
    9. buffer.Length = refLength
    10. Return buffer.ToString()
    11. End Function
    13. Public Shared Function DotsToChar(input As String) As String
    14. If String.IsNullOrEmpty(input) Then
    15. Throw New ArgumentNullException("input")
    16. End If
    17. Dim refLength As Int32 = input.Length + 32 ' size heuristic
    18. Dim buffer As New StringBuilder(refLength)
    19. NativeMethods.lou_dotsToChar("Braille\Brailletabellen\" & AktuelleUebersetzungstabelle, input, buffer, refLength, 0)
    20. buffer.Length = refLength
    21. Return buffer.ToString()
    22. End Function


    Ich bekomme zwar keine Fehlermeldungen und keine Warnungen mehr, aber wenn ich ein Punktmuster in "Ungekuerzttext" eintrage erhalte ich immer eine Leerzeile mit einem Zeichen, welches aus allen Braillepunkten besteht.

    Beispielsweise sollte das folgende Punktmuster das Wort "hallo" ergeben:
    125-1-123-123-135

    LG

    tron25 schrieb:

    Was meinst du mit "Inhalt verpassen"?
    Ich sehe keine Implementierung der Prozedur lou_dotsToChar. Geh da mal rein und überzeuge Dich, dass am Ende dieser Prozedur ein Return WhatEver steht.
    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!

    Irgendwie stehe ich auf dem Schlauch. Ich habe es doch so gemacht, wie die Funktion "lou_TranslateString". Nur die Variablen habe ich angepaßt. Wenn ich mit der Funktion "lou_translateString" einen Text in die Blindenkurzschrift übersetze, funktioniert es auch. Aus "Wochenende" wird "Wo4ccde".
    Bei "lou_dotsToChar" übergibt man einen String, der aus Zahlenfolgen besteht, die mit Bindestrichen getrennt sind. Dann sollte man eine Zeichenfolge bekommen. Jede Zahlengruppe zeigt die Punkte, aus dem ein Buchstabe besteht. Beispielsweise schreibt man für das Wort "hallo" die Zahlenfolge "125-1-123-123-135". Jedes Braillezeichen besteht aus 6 Punkten. Der Punkt links oben ist 1, der Punkt darunter 2, der Punkt links unten 3, der punkt rechts oben 4, darunter a5 und der punkt rechts unten 6. Der Buchstabe "h" besteht aus den Punkten "125", das "a" aus "1", usw.

    Irgendwas scheint die Funktion ja zurückzugeben. Denn wenn ich sie ausführe, bekomme ich eine Leerzeile mit einem einzigen Zeichen. Wenn ich mit dem Cursor auf dieses Zeichen gehe, sagt mir die Sprachausgabe "-36". Ich vermute, das etwas mit der Längenangabe nicht stimmt.

    Wenn die DLL-Funktion ein "int *outlen" erwartet, schreibe ich in VB "byref outlen AS int32". Wie schreibe ich das, wenn die DLL ein "int lenth" (ohne Sternchen) erwartet? In VB habe ich dort "length as int32" geschrieben.

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

    Du schon wieder ;) . Welches Ergebnis möchtest du denn haben? Die Schreibweise, wie du sie angibst (125-1-...) musst du erst ausrechnen. Die Funktion berechnet die codierte Form der Braillepunkte korrekt - siehe dazu en.wikipedia.org/wiki/Unicode_braille. Als String interpretiert werden das bei mir chinesische Zeichen.

    Beispiel:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Imports System.Runtime.InteropServices
    2. Imports System.Text
    3. Imports System.Runtime.CompilerServices
    5. Module Module1
    7. Sub Main()
    8. Dim w = LouTranslator.CharToDots("hallo")
    9. Dim x = LouTranslator.GetDotNumbers(w)
    10. Console.WriteLine(x)
    12. Dim y = LouTranslator.ParseDotNumbers(x)
    13. Dim z = LouTranslator.DotsToChar(y)
    14. Console.WriteLine(z)
    15. End Sub
    17. End Module
    19. Class LouTranslator
    21. Public Shared Function DotsToChar(input() As Short) As String
    22. If input Is Nothing Then
    23. Throw New ArgumentNullException("input")
    24. End If
    26. Dim buffer As New StringBuilder(input.Length)
    27. Dim status = NativeMethods.lou_dotsToChar("tables\de-de-g2.ctb", input, buffer, input.Length, NativeMethods.TranslationModes.ucBrl)
    29. Debug.Assert(status = 1)
    30. buffer.Length = input.Length
    32. Return buffer.ToString()
    33. End Function
    35. Public Shared Function CharToDots(input As String) As Short()
    36. If String.IsNullOrEmpty(input) Then
    37. Throw New ArgumentNullException("input")
    38. End If
    40. Dim buffer(input.Length - 1) As Short
    41. Dim status = NativeMethods.lou_charToDots("tables\de-de-g2.ctb", input, buffer, input.Length, NativeMethods.TranslationModes.ucBrl)
    42. Debug.Assert(status = 1)
    44. Return buffer
    45. End Function
    47. Public Shared Function GetDotNumbers(input() As Short) As String
    48. Dim result As New StringBuilder
    49. Dim l As Int32
    51. For Each s In input
    52. s = s And &HFFS
    53. l = 1
    55. While s <> 0
    56. If s Mod 2 = 1 Then result.Append(l)
    57. s \= 2S
    58. l += 1
    59. End While
    61. result.Append("-")
    62. Next
    64. result.Remove(result.Length - 1, 1)
    66. Return result.ToString()
    67. End Function
    69. Public Shared Function ParseDotNumbers(input As String) As Short()
    70. Dim result As New List(Of Short)
    71. Dim i, n As Short
    73. For Each c In input
    74. If c = "-"c Then
    75. result.Add(n Or &H2800S)
    76. n = 0
    77. Else
    78. i = Short.Parse(c)
    79. n += CShort(Math.Pow(2, i - 1))
    80. End If
    81. Next
    83. result.Add(n Or &H2800S)
    85. Return result.ToArray()
    86. End Function
    88. End Class
    91. Class NativeMethods
    93. 'int EXPORT_CALL lou_dotsToChar
    94. '(const char *tableList,
    95. ' widechar * inbuf,
    96. ' widechar * outbuf,
    97. ' int length,
    98. ' int mode)
    100. ' Requires proper input decoding
    101. <DllImport("liblouis-3.dll")>
    102. Public Shared Function lou_dotsToChar(
    103. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    104. inbuf() As Short,
    105. <MarshalAs(UnmanagedType.LPWStr), Out()> outbuf As StringBuilder,
    106. length As Int32,
    107. mode As Int32) As Int32
    108. End Function
    110. ' Uses unicode string as input
    111. <DllImport("liblouis-3.dll")>
    112. Public Shared Function lou_dotsToChar(
    113. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    114. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    115. <MarshalAs(UnmanagedType.LPWStr), Out()> outbuf As StringBuilder,
    116. length As Int32,
    117. mode As Int32) As Int32
    118. End Function
    120. 'int EXPORT_CALL lou_charToDots
    121. '(const char *tableList,
    122. ' const widechar * inbuf,
    123. ' widechar * outbuf,
    124. ' int length,
    125. ' int mode)
    127. ' Allows result reinterpretation
    128. <DllImport("liblouis-3.dll")>
    129. Public Shared Function lou_charToDots(
    130. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    131. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    132. outbuf() As Short,
    133. length As Int32,
    134. mode As Int32) As Int32
    135. End Function
    137. ' Result will be a unicode string
    138. <DllImport("liblouis-3.dll")>
    139. Public Shared Function lou_charToDots(
    140. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    141. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    142. <MarshalAs(UnmanagedType.LPWStr), Out()> outbuf As StringBuilder,
    143. length As Int32,
    144. mode As Int32) As Int32
    145. End Function
    147. Public Enum TranslationModes
    148. noContractions = 1
    149. compbrlAtCursor = 2
    150. dotsIO = 4
    151. comp8Dots = 8
    152. pass1Only = 16
    153. compbrlLeftCursor = 32
    154. otherTrans = 64
    155. ucBrl = 128
    156. End Enum
    158. End Class


    Gruß
    hal2000

    Hallo,
    sorry, daß ich micht so lange nicht rückgemeldet habe, aber wir sind in der Zwischenzeit umgezogen.

    Ich möchte einen Text eingeben und die Braillepunkte, aus denen die Buchstaben bestehen zurückbekommen. In der Datei "de-de-g2.ctb" werden Zeichen und Abkürzungen aufgelistet. Dahinter stehen die Punktkombinationen, aus denen sie in Blindenschrift bestehen.

    Ich habe dein Beispiel ausprobiert, aber leider nicht das gewünschte Ergebnis bekommen. Das Ergebnis bleibt leer.

    Hallo,

    ich bins wieder ;-).

    Ich möchte eine neue Funktion aus der DLL einbinden. Diese dient zur Silbentrennung. Soweit ich es verstanden habe, erwartet sie eine Übersetzungstabelle, das zu bearbeitende Wort, die Länge des Wortes und ein Ausgabearray mit einem Element mehr, als die Anzahl der Buchstaben des Wortes.

    Hier mal die Funktionsbeschreibung:

    int lou_hyphenate (
    const char *tableList,
    const widechar *inbuf,
    int inlen,
    char *hyphens,
    int mode);
    This function looks at the characters in inbuf and if it finds a sequence of letters attempts to hyphenate it as a word. Note that lou_hyphenate operates on single words only, and spaces or punctuation marks between letters are not allowed. Leading and trailing punctuation marks are ignored. The table named by the tableList parameter must contain a hyphenation table. If it does not, the function does nothing. inlen is the length of the character string in inbuf. hyphens is an array of characters and must be of size inlen + 1 (to account for the NULL terminator). If hyphenation is successful it will have a 1 at the beginning of each syllable and a 0 elsewhere. If the mode parameter is 0 inbuf is assumed to contain untranslated characters. Any nonzero value means that inbuf contains a translation. In this case, it is back-translated, hyphenation is performed, and it is re-translated so that the hyphens can be placed correctly. The lou_translate and lou_backTranslate functions are used in this process. lou_hyphenate returns 1 if hyphenation was successful and 0 otherwise. In the latter case, the contents of the hyphens parameter are undefined. This function was provided for use in liblouisutdml.

    Und hier mein Quellcode:

    VB.NET-Quellcode

    1. Class LibLouis
    2. Public Shared Function Hyphenate(input As String) As Short
    3. Dim buffer(input.Length) As Short
    4. NativeMethods.lou_hyphenate("Braille\Brailletabellen\hyph_de_DE.dic", input, input.Length, buffer, 0)
    5. Return buffer.ToString
    6. End Function
    7. End Class
    9. Class NativeMethods
    10. <DllImport("liblouis.dll", BestFitMapping:=False, ThrowOnUnmappableChar:=True, CharSet:=CharSet.Unicode)>
    11. Public Shared Function lou_hyphenate(
    12. <MarshalAs(UnmanagedType.LPStr)> tableList As String,
    13. <MarshalAs(UnmanagedType.LPWStr)> inbuf As String,
    14. inlen As Int32,
    15. Hyphens As Short,
    16. mode As Int32) As Int32
    17. End Function
    18. End Class


    Und hier der Funktionsaufruf:

    VB.NET-Quellcode

    1. GekuerztText.Text = LibLouis.Hyphenate(UngekuerztText.Text).ToString


    Beim Ausführen bekomme ich folgende Fehlermeldung:

    Fehler BC30311 Der Wert vom Typ "Short()" kann nicht in "Short" konvertiert werden.

    Vielen Dank schon mal im Voraus!

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

    Hallo, ich bins nochmal nach 7 Jahren.

    in den vergangenen Beiträgen dieses Themas habe ich mit eurer großartigen Hilfe eine C-DLL einbinden und für die Brailleübersetzung nutzen können.
    Nun möchte ich die neueste Version der DLL verwenden und habe versucht, diese ebenfalls auf gleichem Wege einzubinden, da die Funktionsbeschreibungen und Variablendeklarationen gleich geblieben sind. Ich habe in diesem Zuge die damaligen Beiträge nochmal durchgelesen und mich nochmal mit der MarshalAs()-Anweisung auseinandergesetzt. Soweit ich es verstanden habe ist es ein Zeiger und keine Variable.
    Nun habe ich eine kleine Anwendung geschrieben, mit der mein Problem nachvollzogen werden kann.
    Diese Anwendung besteht aus zwei Textboxen, einer Combobox und zwei Schaltflächen. Der Text aus der ersten Textbox soll in die Blindenkurzschrift übersetzt und in Textbox2 geschrieben werden. Zuvor muß die Übersetzungstabelle "de-g2.ctb" ausgewählt werden. Bei Erfolg sollte dann in der rechten Textbox die Kurzfassung stehen. Aus dem Wort "wochenende" sollte dann "wo4ccde" werden.
    4 = ch
    c = en

    Außerdem befindet sich im Programmverzeichnis die Datei, in der alle Funktionen der DLL erklärt werden. Unter dem Punkt 7.6 wird die Funktion "lou_translatestring" beschrieben.
    Ich vermute einen Fehler bei der Variablendeklaration. Ich habe daher schon einiges leider erfolglos versucht. So habe ich beispielsweise aus "int32" "integer" gemacht, da laut VS-Beschreibung beides das Gleiche ist.

    Ich bin für jede Hilfe dankbar.
    Dateien

    • LibLouis Test.zip

      (684,6 kB, 32 mal heruntergeladen, zuletzt: )

    @tron25 Woran hast Du festgemacht, dass die neue DLL nicht funktioniert?
    Fehlermeldung, Codezeile dazu, ...
    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!

    Synthaktisch funktioniert das Programm. Wenn ich einen Text übersetze, bekomme ich ein "'" zurück. Das ist nicht richtig. Damals hatte ich die Version 3.0,0.irgendwas, die aktuelle ist 3.24.0. Um es zu testen, geht man folgendermaßen vor:

    1. In das linke Textfeld das Wort "wochenende" ohne Anführungszeichen eingeben
    2. Aus der Ausklappliste den Eintrag "German, contracted" auswählen - sorry, oben habe ich es falsch beschrieben.
    3. Auf "Übersetzen" klicken

    Im optimalen Fall sollte dann in dem rechten Textfeld "wo4ccde" stehen.

    In Deinem Code kommen in den Deklarationen UnmanagedType.LPStr und UnmanagedType.LPWStr nebeneinander vor.
    Das kann ich mir eigentlich nicht vorstellen.
    Vereinheitliche das mal.
    Und:
    Gib ComboBox1 die Property DropDownStyle = DropDownList.
    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!

    @tron25 Kannst Du mal beim Hersteller der DLL oder bei anderen Nutzern dieser DLL nachfragen?
    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!

    Laut der Deklaration arbeitet die DLL hauptsächlich mit Zeigern. Um nicht als zu viele Baustellen zu haben, habe ich ein weiteres kleines Projekt erstellt, welches nur die Versionsnummer der DLL-Datei zurückgeben soll. Ich bekomme zwar eine Nummer zurück, aber nicht die Version. Vermutlich ist es die Speicheradresse. Wie kann ich aus dieser den eigentlichen Wert lesen?
    Im Hauptverzeichnis befindet sich die Datei "liblouis.html" mit den Funktionsbeschreibungen. Die Funktion, um die es geht heißt "lou_version".
    Dateien

    • WindowsApp1.zip

      (171,36 kB, 28 mal heruntergeladen, zuletzt: )

    tron25 schrieb:

    Ich bekomme zwar eine Nummer zurück, aber nicht die Version.
    Du hast die Prozedur als As Integer deklariert, also bekommst Du ein Integer zurück (in dieser Richtung funktioniert das bei einer Function immer, mit anderen Typen nicht).
    Du musst mal mit der Deklaration etwas rumspielen, das ist etwas Dwetektivarbeit.
    Anhaltspunkte findest Du im Link in Post #2: Austausch von Daten zwischen einer VB.NET-exe und einer C-DLL, 32 und 64 Bit
    ====
    Probier mal

    VB.NET-Quellcode

    1. Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    2. Dim ptr = lou_version()
    3. Dim txt As String = Marshal.PtrToStringAnsi(ptr)
    4. TextBox1.Text = txt
    5. End Sub

    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!

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

Facebook
Telefonspende