impression – Imprimer des codes à barres d'une page Web vers une imprimante Zebra – Serveur d’impression

essayez de créer un WebSocket qui contrôle l’impression côté client et envoie les données avec ajax de la page à localhost. /// websocket en utilisant le système; using System.Net; using System.Net.WebSockets; using System.Text; using System.Threading;

Serveur d'espace de noms {     programme de classe              WebsocketServer statique public ws;         static void Main (chaîne[] args)                      ws = new Server.WebsocketServer ();             ws.LogMessage + = Ws_LogMessage;             ws.Start ("http: // localhost: 2645 / service /");             Console.WriteLine ("Appuyez sur n'importe quelle touche pour quitter ...");             Console.ReadKey ();         

        void statique privé Ws_LogMessage (expéditeur de l'objet, WebsocketServer.LogMessageEventArgs e)                      Console.WriteLine (e.Message);              

    classe publique WebsocketServer     {         événement public OnLogMessage LogMessage;         délégué public void OnLogMessage (Expéditeur d'objet, LogMessageEventArgs e);         Classe publique LogMessageEventArgs: EventArgs                      chaîne publique Message get; ensemble;             public LogMessageEventArgs (chaîne Message)                              this.Message = Message;                      

        bool public started = false;         public async void Start (chaîne httpListenerPrefix)                      HttpListener httpListener = new HttpListener ();             httpListener.Prefixes.Add (httpListenerPrefix);             httpListener.Start ();             LogMessage (this, new LogMessageEventArgs ("Listening ..."));             commencé = vrai;

            alors que (commencé)                              HttpListenerContext httpListenerContext = wait httpListener.GetContextAsync ();                 if (httpListenerContext.Request.IsWebSocketRequest)                                      ProcessRequest (httpListenerContext);                                  autre                                      httpListenerContext.Response.StatusCode = 400;                     httpListenerContext.Response.Close ();                     LogMessage (this, new LogMessageEventArgs ("Closed ..."));                                       

        public void Stop ()                      commencé = faux;                  ProcessRequest (HttpListenerContext httpListenerContext)         {             WebSocketContext webSocketContext = null;

            essayer                              webSocketContext = wait httpListenerContext.AcceptWebSocketAsync (subProtocol: null);                 LogMessage (this, nouveau LogMessageEventArgs ("Connecté"));                          catch (Exception e)                              httpListenerContext.Response.StatusCode = 500;                 httpListenerContext.Response.Close ();                 LogMessage (this, new LogMessageEventArgs (String.Format ("Exception: 0", e)));                 revenir;             

            WebSocket webSocket = webSocketContext.WebSocket;             essayer             {

                while (webSocket.State == WebSocketState.Open)                 {

                    ArraySegment buffer = new ArraySegment(nouvel octet[8192])

                    WebSocketReceiveResult resultat = null;

                    using (var ms = new System.IO.MemoryStream ())                     {                         faire                                                      result = wait webSocket.ReceiveAsync (tampon, CancellationToken.None);                             ms.Write (buffer.Array, buffer.Offset, result.Count);                                                  while (! result.EndOfMessage);

                        ms.Seek (0, System.IO.SeekOrigin.Begin);

                        if (result.MessageType == WebSocketMessageType.Text)                         {                             using (var reader = new System.IO.StreamReader (ms, Encoding.UTF8))                                                              var r = System.Text.Encoding.UTF8.GetString (ms.ToArray ());                                 var t = Newtonsoft.Json.JsonConvert.DeserializeObject(r);                                 bool valid = true;                                 octet[] toBytes = Encoding.UTF8.GetBytes (""); ;

                                si (t! = null)                                                                      if (t.printer.Trim () == string.Empty)                                                                              var imprimantes = "";                                         foreach (var imp dans System.Drawing.Printing.PrinterSettings.InstalledPrinters)                                                                                      imprimantes + = imp + " n";                                         

                                        toBytes = Encoding.UTF8.GetBytes ("Aucune indication sur l'impression nLas Impresoras disponibles:" + imprimantes);                                         valide = faux;                                                                          if (t.name.Trim () == string.Empty)                                                                              toBytes = Encoding.UTF8.GetBytes ("Aucune indication sur le document");                                         valide = faux;                                                                          if (t.code == null)                                                                              toBytes = Encoding.UTF8.GetBytes ("Aucune donnée n'est affichée à la suite de l'impression");                                         valide = faux;                                     

                                    si (valide)                                                                              print.RawPrinter.SendStringToPrinter (t.printer, t.code, t.name);                                         toBytes = Encoding.UTF8.GetBytes ("Correcto ...");                                     

                                    attendez webSocket.SendAsync (nouvel ArraySegment(toBytes, 0, int.Parse (toBytes.Length.ToString ())), WebSocketMessageType.Binary, result.EndOfMessage, CancellationToken.None);                                                                  autre                                                                      toBytes = Encoding.UTF8.GetBytes ("Erreur ...");                                     attendez webSocket.SendAsync (nouvel ArraySegment(toBytes, 0, int.Parse (toBytes.Length.ToString ())), WebSocketMessageType.Binary, result.EndOfMessage, CancellationToken.None);                                                                                       }                     }                 }             }             catch (Exception e)                              LogMessage (this, new LogMessageEventArgs (String.Format ("Exception: 0 nLinea: 1", e, e.StackTrace))));                          enfin                              si (webSocket! = null)                     webSocket.Dispose ();                      }     }

    classe publique Datos              nom de chaîne publique get; ensemble;         code de chaîne publique get; ensemble;         chaîne publique imprimante get; ensemble; = "";      }

impression brute: using Microsoft.VisualBasic; en utilisant le système; using System.Collections; using System.Collections.Generic; using System.Data; using System.Diagnostics; using System.Runtime.InteropServices; using System.IO;

print de l'espace de noms {     Classe publique RawPrinter     {         // Déclarations de structure et d'API: [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] classe publique DOCINFOA          [MarshalAs(UnmanagedType.LPStr)] chaîne publique pDocName; [MarshalAs(UnmanagedType.LPStr)] chaîne publique pOutputFile; [MarshalAs(UnmanagedType.LPStr)] chaîne publique pDataType;          [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public statique extern bool OpenPrinter ([MarshalAs(UnmanagedType.LPStr)] chaîne szPrinter, réf IntPtr hPriknter, IntPtr pd);

[DllImport("winspool.Drv", EntryPoint = "ClosePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public extern externe bool ClosePrinter (IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "StartDocPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public statique externe bool StartDocPrinter (IntPtr hPrinter, niveau Int32, [In(), MarshalAs(UnmanagedType.LPStruct)] DOCINFOA di);

[DllImport("winspool.Drv", EntryPoint = "EndDocPrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public extern externe bool EndDocPrinter (IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "StartPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public statique extern bool StartPagePrinter (IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "EndPagePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public statique extern bool EndPagePrinter (IntPtr hPrinter);

[DllImport("winspool.Drv", EntryPoint = "WritePrinter", SetLastError = true, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)] public statique externe bool WritePrinter (IntPtr hPrinter, IntPtr pBytes, Int32 dwCount, ref Int32 dwWritten);

        // SendBytesToPrinter ()         // Lorsque la fonction reçoit un nom d'imprimante et un tableau non géré         // d'octets, la fonction envoie ces octets à la file d'attente d'impression.         // Renvoie true en cas de succès, false en cas d'échec.         public bool statique SendBytesToPrinter (chaîne szPrinterName, pbits IntPtr, dwCount Int32, chaîne DocName = "")                      Int32 dwError = 0;             Int32 dwWritten = 0;             IntPtr hPrinter = new IntPtr (0);             DOCINFOA di = new DOCINFOA ();             bool bSuccess = false;             // Suppose l'échec sauf si vous y parvenez.             di.pDocName = string.IsNullOrEmpty (DocName)? "Mon document RAW C # .NET": DocName;             di.pDataType = "RAW";

            // Ouvre l'imprimante.             if (OpenPrinter (szPrinterName.Normalize (), réf hPrinter, IntPtr.Zero))                              // Démarrer un document.                 if (StartDocPrinter (hPrinter, 1, di))                                      // Démarrer une page.                     if (StartPagePrinter (hPrinter))                                              // Ecrivez vos octets.                         bSuccess = WritePrinter (hPrinter, pBytes, dwCount, ref dwWritten);                         EndPagePrinter (hPrinter);                                          EndDocPrinter (hPrinter);                                  ClosePrinter (hPrinter);                          // Si vous n'avez pas réussi, GetLastError peut donner plus d'informations             // pourquoi pas.             if (bSuccess == false)                              dwError = Marshal.GetLastWin32Error ();                          retourner bSuccess;         

        public bool statique SendFileToPrinter (string szPrinterName, string szFileName)                      // ouvre le fichier.             FileStream fs = new FileStream (szFileName, FileMode.Open);             // Crée un BinaryReader sur le fichier.             BinaryReader br = new BinaryReader (fs);             // Dimette un tableau d'octets assez grand pour contenir le contenu du fichier.             Octet[] octets = nouvel octet[fs.Length];             bool bSuccess = false;             // Votre pointeur non géré.             IntPtr pUnmanagedBytes = new IntPtr (0);             int nLength = 0;

            nLength = Convert.ToInt32 (fs.Length);             // Lit le contenu du fichier dans le tableau.             octets = br.ReadBytes (nLength);             // Alloue de la mémoire non gérée pour ces octets.             pUnmanagedBytes = Marshal.AllocCoTaskMem (nLength);             // Copiez le tableau d'octets gérés dans le tableau non géré.             Marshal.Copy (octets, 0, pUnmanagedBytes, nLength);             // Envoie les octets non gérés à l'imprimante.             bSuccess = SendBytesToPrinter (szPrinterName, pUnmanagedBytes, nLength);             // Libère la mémoire non gérée que vous avez allouée précédemment.             Marshal.FreeCoTaskMem (pUnmanagedBytes);             retourner bSuccess;                  public bool statique SendStringToPrinter (string szPrinterName, string szString, string DocName = "")                      IntPtr pBytes = default (IntPtr);             Int32 dwCount = default (Int32);             // Combien de caractères y a-t-il dans la chaîne?             dwCount = szString.Length;             // Supposons que l'imprimante attend du texte ANSI, puis convertit             // la chaîne en texte ANSI.             pBytes = Marshal.StringToCoTaskMemAnsi (szString);             // Envoie la chaîne ANSI convertie à l'imprimante.             SendBytesToPrinter (szPrinterName, pBytes, dwCount, DocName);             Marshal.FreeCoTaskMem (pBytes);             retourne vrai;              } }

page html:

Enviar

puis envoyez un code ZPL à partir de HTML (écrivez ceci sur du code textarea); ^ XA ^ FO200,50 ^ BY2 ^ B3N, N, 80, Y, N ^ FD0123456789 ^ FS ^ PQ1 ^ XZ

Click to rate this post! [Total: 0 Average: 0]