DHL Shipment Validation by C#

公司要導入跟物流的自動交互，如此就可以自動從 ERP 將資料傳到物流的系統，順便直接產生出提單 Label 直接可以貼在箱上。

DHL 提供的範例為 Java 的，只好問 Google 看看大家的經驗了，

經過好幾天的看文件，找範例，問廠商，總算可以順利的印出 Label 了。

string requestText//導入 XML 資料
WebRequest requestRate = HttpWebRequest.Create("https://xmlpitest-ea.dhl.com/XMLShippingServlet");//DHL 的測試環境
requestRate.ContentType = "application/x-www-form-urlencoded";
requestRate.Method = "POST";

using (var stream = requestRate.GetRequestStream())
{
var arrBytes = System.Text.ASCIIEncoding.ASCII.GetBytes(requestText);
stream.Write(arrBytes, 0, arrBytes.Length);

stream.Close();

}



WebResponse responseRate = requestRate.GetResponse();

var respStream = responseRate.GetResponseStream();

var reader = new StreamReader(respStream, System.Text.Encoding.ASCII);

string strResponse = reader.ReadToEnd();

respStream.Close();



XmlDocument xdoc = new XmlDocument();

xdoc.LoadXml(strResponse);



            XmlNodeList list = xdoc.GetElementsByTagName("OutputImage");



if (list.Count > 0)

{

//EPL2 直接傳給印表機進行列印

byte[] bytes = Convert.FromBase64String(list[0].InnerText.ToString());

IntPtr pUnmanagedBytes = new IntPtr(0);

int nLength = bytes.Length;

pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);

Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);

RawPrinterHelper.SendBytesToPrinter("DHL_Label", pUnmanagedBytes, nLength);

Marshal.FreeCoTaskMem(pUnmanagedBytes);

}

這邊會用到一個 Microsoft 網站只有找到 VB.Net 的，但網路上有人已經改成 C# 的 Class

public class RawPrinterHelper
  {
    // Structure and API declarions:
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public class DOCINFOA
    {
      [MarshalAs(UnmanagedType.LPStr)]
      public string pDocName;
      [MarshalAs(UnmanagedType.LPStr)]
      public string pOutputFile;
      [MarshalAs(UnmanagedType.LPStr)]
      public string pDataType;
    }
    [DllImport("winspool.Drv", EntryPoint = "OpenPrinterA", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
    public static extern bool OpenPrinter([MarshalAs(UnmanagedType.LPStr)] string szPrinter, out IntPtr hPrinter, IntPtr pd);

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

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

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

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

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

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

    // SendBytesToPrinter()
    // When the function is given a printer name and an unmanaged array
    // of bytes, the function sends those bytes to the print queue.
    // Returns true on success, false on failure.
    public static bool SendBytesToPrinter(string szPrinterName, IntPtr pBytes, Int32 dwCount)
    {
      Int32 dwError = 0, dwWritten = 0;
      IntPtr hPrinter = new IntPtr(0);
      DOCINFOA di = new DOCINFOA();
      bool bSuccess = false; // Assume failure unless you specifically succeed.

      di.pDocName = "My C#.NET RAW Document";
      di.pDataType = "RAW";

      // Open the printer.
      if (OpenPrinter(szPrinterName.Normalize(), out hPrinter, IntPtr.Zero))
      {
        // Start a document.
        if (StartDocPrinter(hPrinter, 1, di))
        {
          // Start a page.
          if (StartPagePrinter(hPrinter))
          {
            // Write your bytes.
            bSuccess = WritePrinter(hPrinter, pBytes, dwCount, out dwWritten);
            EndPagePrinter(hPrinter);
          }
          EndDocPrinter(hPrinter);
        }
        ClosePrinter(hPrinter);
      }
      // If you did not succeed, GetLastError may give more information
      // about why not.
      if (bSuccess == false)
      {
        dwError = Marshal.GetLastWin32Error();
      }
      return bSuccess;
    }
    public static bool SendMemoryToPrinter(string szPrinterName, MemoryStream ms)
    {
      BinaryReader br = new BinaryReader(ms);
      Byte[] bytes = new Byte[ms.Length];
      bool bSuccess = false;
      IntPtr pUnmanagedBytes = new IntPtr(0);
      int nLength;

      nLength = Convert.ToInt32(ms.Length);
      bytes = br.ReadBytes(nLength);
      pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
      Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
      bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
      Marshal.FreeCoTaskMem(pUnmanagedBytes);
      return bSuccess;
    }
    public static bool SendFileToPrinter(string szPrinterName, string szFileName)
    {
      // Open the file.
      FileStream fs = new FileStream(szFileName, FileMode.Open);
      // Create a BinaryReader on the file.
      BinaryReader br = new BinaryReader(fs);
      // Dim an array of bytes big enough to hold the file's contents.
      Byte[] bytes = new Byte[fs.Length];
      bool bSuccess = false;
      // Your unmanaged pointer.
      IntPtr pUnmanagedBytes = new IntPtr(0);
      int nLength;

      nLength = Convert.ToInt32(fs.Length);
      // Read the contents of the file into the array.
      bytes = br.ReadBytes(nLength);
      // Allocate some unmanaged memory for those bytes.
      pUnmanagedBytes = Marshal.AllocCoTaskMem(nLength);
      // Copy the managed byte array into the unmanaged array.
      Marshal.Copy(bytes, 0, pUnmanagedBytes, nLength);
      // Send the unmanaged bytes to the printer.
      bSuccess = SendBytesToPrinter(szPrinterName, pUnmanagedBytes, nLength);
      // Free the unmanaged memory that you allocated earlier.
      Marshal.FreeCoTaskMem(pUnmanagedBytes);
      return bSuccess;
    }
    public static bool SendStringToPrinter(string szPrinterName, string szString)
    {
      IntPtr pBytes;
      Int32 dwCount;
      // How many characters are in the string?
      dwCount = szString.Length;
      // Assume that the printer is expecting ANSI text, and then convert
      // the string to ANSI text.
      pBytes = Marshal.StringToCoTaskMemAnsi(szString);
      // Send the converted ANSI string to the printer.
      SendBytesToPrinter(szPrinterName, pBytes, dwCount);
      Marshal.FreeCoTaskMem(pBytes);
      return true;
    }
  }