Bondrucker ansteuern

  • VB.NET

Es gibt 30 Antworten in diesem Thema. Der letzte Beitrag () ist von frifri.

    Bondrucker ansteuern

    Hallo,

    ich hole den Thread noch mal aus der Tiefe weil das genau zur Zeit mein Thema ist.

    Ich hab das Beispiel von Dizzy versucht auszuprobieren aber ich bekomme schon div Fehler angezeigt.

    - Private m_Printer As Microsoft.PointOfService.PosPrinter = Nothing
    " Microsoft.PointOfService.PosPrinter " wird rot unterstrichen

    ich hab es dann auf das geändert, weiß aber nicht obs stimmt.
    Private m_Printer As Microsoft.PointOfService.WMI.WmiPosDevice = Nothing


    - Dim deviceInfo As DeviceInfo
    - Dim m_posExplorer As PosExplorer
    - m_Printer.Open()
    - m_Printer.Claim(1000)
    und so weiter

    m_Printer. kennt er wohl gar nicht und im Netzt finde ich so gar nix was passt.

    eigentlich suche ich nur was mit dem ich Text auf dem Drucker ausgeben kann und div ESC Sequenzen.
    vielleicht kann jemand helfen.

    Ausgelagert aus Problem mit (Bon)drucker. ~Thunderbolt

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

    @frifri Was für einen Drucker möchtest Du denn ansteuern?
    Welche API / DLLs hast Du eingefügt?
    Kannst Du mal das Projekt als ZIP, ohne bin und ohne obj-Verzeichnis posten?
    Erweiterte Antwort => Dateianhänge => Hochladen.
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    1. welchen Drucker hast du? und hast du den entsprechenden Driver für POS installiert?
    für Epson Drucker: EPSON OPOS ADK for NET Version 1.14.6
    2. hast du das Microsoft POS for .Net installiert. und einen verweis in dein Projekt darauf gemacht?

    schau dir mal mein post auf der 1. Seite hier an vielleicht hilft das schon weiter.
    mein Drucker ist ein
    Type 4610-TF6
    S/N 41-PGND6
    IBM

    eingefügt als Verweis habe ich:
    Microsoft.PointOfService.WMI

    EPSON OPOS ADK for NET Version 1.14.6
    hab ich installiert

    für mich sieht es so aus als würde VB.Net die DLL gar nicht einladen, weil er mit

    Dim deviceInfo As DeviceInfo
    Dim m_posExplorer As PosExplorer

    schon gar nicht klar kommt

    VB.Net kenntdie Variablentypen:
    DeviceInfo
    PosExplorer

    gar nicht.
    Dateien
    • PosPrinter.zip

      (215,94 kB, 6 mal heruntergeladen, zuletzt: )

    frifri schrieb:

    Microsoft.PointOfService.WMI
    Startet das Programm oder sagt der Compiler, dass da was fehlt?
    Wo kommt denn diese DLL her? Ist sie überhaupt vorhanden bei Dir?
    Pack mal den Code aus der Form_Load in die Form_Shown.
    Bei der Form_Load gibt es blöde Effekte, wenn Exceptions auftreten.
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    die Datei Microsoft.PointOfService.WMI.dll
    habe ich von Microsoft microsoft.com/en-us/download/confirmation.aspx?id=42081

    Fehler 2 Der Typ "DeviceInfo" ist nicht definiert. C:\Users\Friese\documents\visual studio 2013\Projects\EscPosDrucker\EscPosDrucker\Form1.vb 19 27 EscPosDrucker

    Fehler 5 "DeviceType" wurde nicht deklariert. Auf das Objekt kann aufgrund seiner Schutzstufe möglicherweise nicht zugegriffen werden. C:\Users\Friese\documents\visual studio 2013\Projects\EscPosDrucker\EscPosDrucker\Form1.vb 31 50 EscPosDrucker

    in FormShow gibt es keinen unterschied

    frifri schrieb:

    für mich sieht es so aus als würde VB.Net die DLL gar nicht einladen, weil er mit

    Dim deviceInfo As DeviceInfo
    Dim m_posExplorer As PosExplorer

    schon gar nicht klar kommt


    Hast du denn nur die DLL als Referenz eingeladen? Die Referenz selber solltest du dann auch noch laden via Imports - ansonsten, wie @RodFromGermany schon sagte, einfach mal ohne bin und obj hochladen und dann kann man sich das mal näher anschauen. Von "mein Auto klingt komisch" wird der Mechaniker ja auch nicht schlauer, dafür fährt man den Karren schon in die Werkstatt. :)

    Toorms schrieb:

    Hast du denn nur die DLL als Referenz eingeladen?
    Ja, hat er.
    @frifri Tut mir leid, der will eine komplette Installation runterladen, das mach ich nicht.
    Pack mal die DLL als solche in eine ZIP und hänge sie an.
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    Hallo @frifri

    Ich programmiere seit 2005 (VB6 und VB.NET) Kassensoftware und habe daher andauernd mit Bondruckern zu tun.
    Den Ansatz bestimmte Bondrucker direkt anzusprechen habe ich schon früh verworfen, da man damit nur mit sehr wenigen Druckertypen kompatibel ist.

    Besser ist der Ansatz auf den ganz normalen Windows-Druckertreiber zu bauen.
    Dann druckt man Dokumente wie auf einem normalen A4-Drucker (eben nur mit anderem Papierformat) und kann somit wirklich jeden Bondrucker mit Windows-Treiber verwenden.

    Ich steuere die Drucker nicht direkt mit .NET Funktionen an, sondern verwende VPE (ein externes kostengünstiges Report-"teil"). Da wird das Dokument im Speicher generiert und dann zum Drucker geschickt, am Bildschirm angezeigt oder als PDF abgespeichert.

    Falls Du Fragen dazu hast, helfe ich Dir gerne weiter.
    Liebe Grüße
    Roland Berghöfer

    Bei der Entwicklung meiner Anwendung(en) steht nicht "Code nach .NET Lehrbuch" im Vordergrund, sondern eine stabile und brauchbare Anwendung die der Anwender ordentlich verwenden kann. Usability für den Kunden und Supportbarkeit beim Kunden stehen an oberster Stelle. Das spiegelt sich auch in meinen Fragen und Antworten wider. Bitte verzeiht, dass meine VB.NET Quellcodes etwas VB6-lastig sind aber das ist für das funktionierende Endergebnis nicht wirklich relevant.

    RodFromGermany schrieb:

    Toorms schrieb:

    Hast du denn nur die DLL als Referenz eingeladen?
    Ja, hat er.
    @frifri Tut mir leid, der will eine komplette Installation runterladen, das mach ich nicht.
    Pack mal die DLL als solche in eine ZIP und hänge sie an.


    ich hab nur die Dateien die Du wolltest in die Zip gepackt, keine ganze installation und in der Form1 ist auch nur das was Dizzy in dem anderen Post als Code vorgeschlagen hat.



    hallo @dive26

    das hört sich sehr interessant an.
    wie ist das denn mit dem öffnen der Kassenlade und wie schnell geht das?
    Ich hab nämlich auch schon mitKassenprogrammen gearbeitet, da war der Kunde schon fast zur Tür raus als die Kasse endlich auf ging.
    Dateien
    @frifri Da kommt immer noch ein Sack voll Fehler, da kann ich Dir leider ohne weitere Installationsdateien nicht weiterhelfen:
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    Habs selbst mal wo rauskopiert und modifiziert. Der Code ist noch sehr VB6 lastig weil ich den in meiner "VB.NET Lernphase" 2014 erstellt habe, funktioniert aber.

    Die Sub OeffneKassenlade ruft je nach Systemkonfiguration (in My.Settings) das Öffnen über Bondrucker oder das Öffnen über einen RS232 Öffner (Meist USB zu RS232 Adapter mit Öffnerlogik) auf. Ich habe Dir das komplette Modul 1:1 aus meinem Projekt kopiert - musst nur noch die Variablen auf eigene anpassen. Der SUB OeffneKassenlade wird als Argument der Name des Druckers übergeben (z.B. "EPSON TM-20").

    Idealerweise öffnet man die Lade bevor das Dokument zum Drucker geschickt wird. Denn ablauftechnisch wird ja sowieso zuerst kassiert und dann erst der Kassenzettel ausgehändigt.


    VB.NET-Quellcode

    1. Option Strict On
    2. Imports System.Runtime.InteropServices
    3. Imports System.IO
    4. Imports System.IO.Ports
    5. Module mdlprint
    6. <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)> _
    7. Public Structure DOCINFO
    8. <MarshalAs(UnmanagedType.LPWStr)> _
    9. Public pDocName As String
    10. <MarshalAs(UnmanagedType.LPWStr)> _
    11. Public pOutputFile As String
    12. <MarshalAs(UnmanagedType.LPWStr)> _
    13. Public pDataType As String
    14. End Structure
    15. <DllImport("winspool.drv", EntryPoint:="OpenPrinterW", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    16. Public Function OpenPrinter(ByVal printerName As String, ByRef hPrinter As IntPtr, ByVal printerDefaults As Integer) As Boolean
    17. End Function
    18. <DllImport("winspool.drv", EntryPoint:="ClosePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    19. Public Function ClosePrinter(ByVal hPrinter As IntPtr) As Boolean
    20. End Function
    21. <DllImport("winspool.drv", EntryPoint:="StartDocPrinterW", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    22. Public Function StartDocPrinter(ByVal hPrinter As IntPtr, ByVal level As Integer, ByRef documentInfo As DOCINFO) As Boolean
    23. End Function
    24. <DllImport("winspool.drv", EntryPoint:="EndDocPrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    25. Public Function EndDocPrinter(ByVal hPrinter As IntPtr) As Boolean
    26. End Function
    27. <DllImport("winspool.drv", EntryPoint:="StartPagePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    28. Public Function StartPagePrinter(ByVal hPrinter As IntPtr) As Boolean
    29. End Function
    30. <DllImport("winspool.drv", EntryPoint:="EndPagePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    31. Public Function EndPagePrinter(ByVal hPrinter As IntPtr) As Boolean
    32. End Function
    33. <DllImport("winspool.drv", EntryPoint:="WritePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    34. Public Function WritePrinter(ByVal hPrinter As IntPtr, ByVal buffer As IntPtr, ByVal bufferLength As Integer, ByRef bytesWritten As Integer) As Boolean
    35. End Function
    36. Public Function OpenCashDrawer(ByVal printerName As String) As Boolean
    37. Dim origString As String = Chr(27) & Chr(112) & Chr(48) & Chr(64) & Chr(64)
    38. Dim hPrinter As IntPtr
    39. Dim spoolData As New DOCINFO
    40. Dim dataToSend As IntPtr
    41. Dim dataSize As Integer
    42. Dim bytesWritten As Integer
    43. dataSize = origString.Length()
    44. dataToSend = Marshal.StringToCoTaskMemAnsi(origString)
    45. spoolData.pDocName = "OpenDrawer"
    46. spoolData.pDataType = "RAW"
    47. Try
    48. Call OpenPrinter(printerName, hPrinter, 0)
    49. Call StartDocPrinter(hPrinter, 1, spoolData)
    50. Call StartPagePrinter(hPrinter)
    51. Call WritePrinter(hPrinter, dataToSend, _
    52. dataSize, bytesWritten)
    53. EndPagePrinter(hPrinter)
    54. EndDocPrinter(hPrinter)
    55. ClosePrinter(hPrinter)
    56. OpenCashDrawer = True
    57. Catch ex As Exception
    58. '("Error occurred: " & ex.ToString)
    59. OpenCashDrawer = False
    60. Finally
    61. Marshal.FreeCoTaskMem(dataToSend)
    62. End Try
    63. End Function
    64. ''' <summary>
    65. ''' Öffnet die Kassenschublade abhängig von der Systemeinstellung (über Drucker oder externem Öffner an COM Port)
    66. ''' </summary>
    67. ''' <remarks></remarks>
    68. Public Sub OeffneKassenlade()
    69. 'My.Settings.KassenladenTyp (Integer): 0=Bondrucker 1 oder 2 = serieller Öffner
    70. Select Case My.Settings.KassenLadeTyp
    71. Case 0
    72. 'Bondrucker (Rückgabewert True>geöffnet oder False>Fehler könnte verarbeitet werden)
    73. OpenCashDrawer(My.Settings.KassenLadeDrucker)
    74. Case 1, 2
    75. If My.Settings.KassenLadePort = "" Then Exit Sub
    76. 'USB Öffner
    77. Dim sp As New SerialPort()
    78. 'My.Settings.KassenladenPort (String) enthält denn Com-Port (z.B. "COM1")
    79. sp.PortName = My.Settings.KassenLadePort
    80. sp.BaudRate = 9600
    81. sp.Parity = Parity.None
    82. sp.DataBits = 8
    83. sp.StopBits = StopBits.One
    84. On Error Resume Next
    85. If Not sp.IsOpen Then sp.Open()
    86. If Err.Number <> 0 Then
    87. MessageBox.Show("Fehler beim Öffnen des Kassenladenanschlusses an " + My.Settings.KassenLadePort, "Konfigurationsfehler!", MessageBoxButtons.OK, MessageBoxIcon.Warning)
    88. GoTo nichtstun
    89. End If
    90. On Error GoTo 0
    91. sp.WriteLine(Convert.ToChar(7) + Convert.ToChar(13)) 'Normal
    92. sp.Close()
    93. nichtstun:
    94. Case 2
    95. '...
    96. End Select
    97. End Sub
    98. End Module

    Liebe Grüße
    Roland Berghöfer

    Bei der Entwicklung meiner Anwendung(en) steht nicht "Code nach .NET Lehrbuch" im Vordergrund, sondern eine stabile und brauchbare Anwendung die der Anwender ordentlich verwenden kann. Usability für den Kunden und Supportbarkeit beim Kunden stehen an oberster Stelle. Das spiegelt sich auch in meinen Fragen und Antworten wider. Bitte verzeiht, dass meine VB.NET Quellcodes etwas VB6-lastig sind aber das ist für das funktionierende Endergebnis nicht wirklich relevant.

    Dieser Beitrag wurde bereits 10 mal editiert, zuletzt von „dive26“ ()

    dive26 schrieb:

    Der Code ist noch sehr VB6 lastig
    Ich hab mal probiert, das nach VB.NET zu übertragen (nicht getestet).
    Dazu gehört auch, die nativen Deklarationen in einer Shared Klasse namens NativeMethods zu kapseln:
    NativeMethods

    VB.NET-Quellcode

    1. Imports System.Runtime.InteropServices
    2. Class NativeMethods
    3. ''' <summary>
    4. ''' Konstruktor
    5. ''' </summary>
    6. ''' <remarks>nicht von außen instanziierbar</remarks>
    7. Private Sub New()
    8. End Sub
    9. ' ----- Define the data type that supplies basic print job information to the spooler.
    10. <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)> _
    11. Public Structure DOCINFO
    12. <MarshalAs(UnmanagedType.LPWStr)> _
    13. Public pDocName As String
    14. <MarshalAs(UnmanagedType.LPWStr)> _
    15. Public pOutputFile As String
    16. <MarshalAs(UnmanagedType.LPWStr)> _
    17. Public pDataType As String
    18. End Structure
    19. ' ----- Define interfaces to the functions supplied in the DLL.
    20. <DllImport("winspool.drv", EntryPoint:="OpenPrinterW", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    21. Public Shared Function OpenPrinter(ByVal printerName As String, ByRef hPrinter As IntPtr, ByVal printerDefaults As Integer) As Boolean
    22. End Function
    23. <DllImport("winspool.drv", EntryPoint:="ClosePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    24. Public Shared Function ClosePrinter(ByVal hPrinter As IntPtr) As Boolean
    25. End Function
    26. <DllImport("winspool.drv", EntryPoint:="StartDocPrinterW", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    27. Public Shared Function StartDocPrinter(ByVal hPrinter As IntPtr, ByVal level As Integer, ByRef documentInfo As DOCINFO) As Boolean
    28. End Function
    29. <DllImport("winspool.drv", EntryPoint:="EndDocPrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    30. Public Shared Function EndDocPrinter(ByVal hPrinter As IntPtr) As Boolean
    31. End Function
    32. <DllImport("winspool.drv", EntryPoint:="StartPagePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    33. Public Shared Function StartPagePrinter(ByVal hPrinter As IntPtr) As Boolean
    34. End Function
    35. <DllImport("winspool.drv", EntryPoint:="EndPagePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    36. Public Shared Function EndPagePrinter(ByVal hPrinter As IntPtr) As Boolean
    37. End Function
    38. <DllImport("winspool.drv", EntryPoint:="WritePrinter", SetLastError:=True, CharSet:=CharSet.Unicode, ExactSpelling:=True, CallingConvention:=CallingConvention.StdCall)> _
    39. Public Shared Function WritePrinter(ByVal hPrinter As IntPtr, ByVal buffer As IntPtr, ByVal bufferLength As Integer, ByRef bytesWritten As Integer) As Boolean
    40. End Function
    41. End Class
    Modul Print

    VB.NET-Quellcode

    1. Imports System.IO
    2. Imports System.IO.Ports
    3. Imports System.Runtime.InteropServices
    4. Module Print
    5. Public Function OpenCashDrawer(ByVal printerName As String) As Boolean
    6. ' ----- Send a string of raw data to the printer.
    7. Dim origString As String = Chr(27) & Chr(112) & Chr(48) & Chr(64) & Chr(64)
    8. Dim hPrinter As IntPtr
    9. Dim spoolData As New NativeMethods.DOCINFO
    10. Dim dataToSend As IntPtr
    11. Dim dataSize As Integer
    12. Dim bytesWritten As Integer
    13. dataSize = origString.Length()
    14. dataToSend = Marshal.StringToCoTaskMemAnsi(origString)
    15. spoolData.pDocName = "OpenDrawer" ' class='highlight'
    16. spoolData.pDataType = "RAW"
    17. Try
    18. NativeMethods.OpenPrinter(printerName, hPrinter, 0)
    19. NativeMethods.StartDocPrinter(hPrinter, 1, spoolData)
    20. NativeMethods.StartPagePrinter(hPrinter)
    21. NativeMethods.WritePrinter(hPrinter, dataToSend, dataSize, bytesWritten)
    22. NativeMethods.EndPagePrinter(hPrinter)
    23. NativeMethods.EndDocPrinter(hPrinter)
    24. NativeMethods.ClosePrinter(hPrinter)
    25. Return True
    26. Catch ex As Exception
    27. 'MsgBox("Error occurred: " & ex.ToString)
    28. Return False
    29. Finally
    30. ' ----- Get rid of the special ANSI version.
    31. Marshal.FreeCoTaskMem(dataToSend)
    32. End Try
    33. End Function
    34. ''' <summary>
    35. ''' Öffnet die Kassenschublade abhängig von der Systemeinstellung (über Drucker oder externem Öffner an COM Port)
    36. ''' </summary>
    37. ''' <remarks></remarks>
    38. Public Sub OeffneKassenlade()
    39. 'My.Settings.KassenladenTyp (Integer): 0 = Bondrucker 1 oder 2 = serieller Öffner
    40. Select Case My.Settings.KassenLadeTyp
    41. Case 0
    42. 'Bondrucker
    43. 'My.Settings.KassenladenDrucker (String) enthält den Druckernamen (Z.B. "EPSON TM-T20")
    44. If My.Settings.KassenLadeDrucker <> "" Then
    45. OpenCashDrawer(My.Settings.KassenLadeDrucker)
    46. End If
    47. Case 1, 2
    48. ' 1 oder 2 = serieller Öffner
    49. If My.Settings.KassenLadePort = "" Then
    50. Exit Sub
    51. End If
    52. 'USB Öffner
    53. Dim sp As SerialPort = Nothing
    54. Try
    55. sp = New SerialPort()
    56. 'My.Settings.KassenladenPort (String) enthält denn Com-Port (z.B. "COM1")
    57. sp.PortName = My.Settings.KassenLadePort
    58. sp.BaudRate = 9600
    59. sp.Parity = Parity.None
    60. sp.DataBits = 8
    61. sp.StopBits = StopBits.One
    62. If Not sp.IsOpen Then
    63. sp.Open()
    64. End If
    65. If Err.Number <> 0 Then
    66. MessageBox.Show("Fehler beim Öffnen des Kassenladenanschlusses an " + My.Settings.KassenLadePort, "Konfigurationsfehler!", MessageBoxButtons.OK, MessageBoxIcon.Warning)
    67. Return
    68. End If
    69. Catch ex As Exception
    70. Finally
    71. If sp IsNot Nothing Then
    72. sp.WriteLine(Convert.ToChar(7) + Convert.ToChar(13)) 'Normal
    73. sp.Close()
    74. End If
    75. End Try
    76. Case 2
    77. '...
    78. End Select
    79. End Sub
    80. End Module
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    Ernste Frage: Was bringt das aufwändige Kapseln in eine Klasse, wenn diese Funktionen hier und nur hier verwendet wird und sonst nirgends. Bis auf einen längeren Code sehe ich da keinen Unterschied. Bringt es einen Unterschied in der Performande oder Systemstabilität oder ist es nur "der Lesbarkeit wegen"?

    Ich vergleiche es einmal mit dem Kochen: Wenn man die Zwiebel in Streifen statt in Würfel scheidet und dann so lange kocht bis nur noch eine Soße übrig ist, dann ist es doch im Prinzip für das Endergebnis egal dass ich es nicht (wie im Kochbuch) in Würfel geschnitten habe ;)

    PS: Die Funktion wie ich sie gepostet habe ist bereits in VB.NET seit 2014 integriert und lauffähig. Ist also kein reiner VB6 Code mehr.
    Liebe Grüße
    Roland Berghöfer

    Bei der Entwicklung meiner Anwendung(en) steht nicht "Code nach .NET Lehrbuch" im Vordergrund, sondern eine stabile und brauchbare Anwendung die der Anwender ordentlich verwenden kann. Usability für den Kunden und Supportbarkeit beim Kunden stehen an oberster Stelle. Das spiegelt sich auch in meinen Fragen und Antworten wider. Bitte verzeiht, dass meine VB.NET Quellcodes etwas VB6-lastig sind aber das ist für das funktionierende Endergebnis nicht wirklich relevant.

    dive26 schrieb:

    Ernste Frage
    Führe mal mit Deinem Projekt eine Codeanalyse durch, da wird dies angemeckert bzw. gefordert:


    Zweite Frage :?:
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    Ok, vielen Dank für die Aufklärung. Codeanalyse hatte ich bis jetzt noch nie verwendet. Mit Euch lernt man nie aus.

    PS: Zu einer ernsten Frage gibt es keine zweite Frage ;)
    Liebe Grüße
    Roland Berghöfer

    Bei der Entwicklung meiner Anwendung(en) steht nicht "Code nach .NET Lehrbuch" im Vordergrund, sondern eine stabile und brauchbare Anwendung die der Anwender ordentlich verwenden kann. Usability für den Kunden und Supportbarkeit beim Kunden stehen an oberster Stelle. Das spiegelt sich auch in meinen Fragen und Antworten wider. Bitte verzeiht, dass meine VB.NET Quellcodes etwas VB6-lastig sind aber das ist für das funktionierende Endergebnis nicht wirklich relevant.

    dive26 schrieb:

    ernsten
    :thumbsup:
    Diese Codeanalyse ist ein wichtig Ding, wenn ich große Projekte von anderen Entwicklern überarbeiten muss, ich nehme da die volle Dröhnung an Regeln.
    Man muss nicht alles machen, was da gelistet wird, aber da kommen echt harte Fehler zu Tage, z.B. vergessene Dispose()s oder Programmierfehler gekaufter (!) DLLs, wo das Dispose falsch implementiert war.
    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).
    VB-Fragen über PN / Konversation werden ignoriert!
    Hallo, ich nochmal.

    Ich hab mich nun ein bisschen im Netzt versucht mit der winspool.drv anzufreunden aber ich finde da irgendwie nicht durch.

    @dive26 wie kann ich denn jetzt mit dem Drucker drucken bzw mit welchem befehl schicke ich Text an den Drucker.

    Der Drucker ist ein Epson TM-T20ii (hab ich extra neu gekauft :) )
    unter Windows ist er eingerichtet und ich kann auch, mit Word z.B. drucken.


    My.Settings.KassenLadeTyp ist 0
    My.Settings.KassenLadeDrucker ist EPSON TM-T20II Receipt
    My.Setting.KassenLadePort ist ESDPRT001
    @frifri

    Das friemeln mit den VB.NET Druckroutinen war mir auch zu umständlich. Ich verwende die VPE (Virtual Print Engine). Für den Anfang reicht für Dich sicher die kostenfreie Community-Edition: idealsoftware.com/en/download/vpe_win.html .
    Liebe Grüße
    Roland Berghöfer

    Bei der Entwicklung meiner Anwendung(en) steht nicht "Code nach .NET Lehrbuch" im Vordergrund, sondern eine stabile und brauchbare Anwendung die der Anwender ordentlich verwenden kann. Usability für den Kunden und Supportbarkeit beim Kunden stehen an oberster Stelle. Das spiegelt sich auch in meinen Fragen und Antworten wider. Bitte verzeiht, dass meine VB.NET Quellcodes etwas VB6-lastig sind aber das ist für das funktionierende Endergebnis nicht wirklich relevant.