• C#实现检测打印机状态(包括打印机是否缺纸、打印队列任务数)

    最近工作中碰到一个需求，用户要求需要连续打印8000多张处方用于存档，但是考虑到程序发送文档到打印队列的速度远远大于打印机打印的速度，需要控制程序发送文档到打印队列的速度，这就需要检测打印机打印队列中的任务数，超过一定的任务数就停止发送，低于一定数量继续发送。同时，还得检测是否缺纸，用于提示用户。本文中的代码在惠普打印机中测试通过，废话不多说，直接上代码，相信你一定能看懂的。

    方式1：使用Win32  API（我采用的方式）

    其中

    方法 public static int GetTaskNumber()是检测打印队列中的任务数

    方法public static int GetPrinterStatusCodeInt()是检测打印机的状态码

    1.  #region 方式1
    2.         [DllImport("winspool.drv", CharSet = CharSet.Auto, SetLastError = true)]
    3.         private static extern bool OpenPrinter(string pPrinterName, out IntPtr hPrinter, IntPtr pDefault);
    4.  
    5.  
    6.         [DllImport("winspool.drv", SetLastError = true)]
    7.         private static extern bool ClosePrinter(IntPtr hPrinter);
    8.  
    9.  
    10.         [DllImport("winspool.drv", SetLastError = true)]
    11.         private static extern bool GetPrinter(IntPtr hPrinter,
    12.             int dwLevel, IntPtr pPrinter, int cbBuf, out int pcbNeeded);
    13.  
    14.  
    15.         [DllImport("winspool.drv", CharSet = CharSet.Auto)]
    16.         public static extern int EnumJobs(IntPtr hPrinter, int FirstJob, int NoJobs, int Level, IntPtr pInfo, int cdBuf,
    17.                                   out int pcbNeeded, out int pcReturned);
    18.  
    19.  
    20.         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    21.         public struct PRINTER_INFO_2
    22.         {
    23.             public string pServerName;
    24.             public string pPrinterName;
    25.             public string pShareName;
    26.             public string pPortName;
    27.             public string pDriverName;
    28.             public string pComment;
    29.             public string pLocation;
    30.             public IntPtr pDevMode;
    31.             public string pSepFile;
    32.             public string pPrintProcessor;
    33.             public string pDatatype;
    34.             public string pParameters;
    35.             public IntPtr pSecurityDescriptor;
    36.             public uint Attributes;
    37.             public uint Priority;
    38.             public uint DefaultPriority;
    39.             public uint StartTime;
    40.             public uint UntilTime;
    41.             public uint Status;
    42.             public uint cJobs;
    43.             public uint AveragePPM;
    44.         }
    45.  
    46.         /// 
    47.         /// 默认打印机的名称
    48.         /// 
    49.         private static string printerName = new LocalPrintServer().DefaultPrintQueue.Name;
    50.  
    51.  
    52.         /// 
    53.         /// 获取打印机的状态编码(方式1)
    54.         /// 
    55.         /// 
    56.         public static int GetPrinterStatusCodeInt()
    57.         {
    58.             int intRet = 0;
    59.             IntPtr hPrinter;
    60.  
    61.  
    62.             if (OpenPrinter(printerName, out hPrinter, IntPtr.Zero))
    63.             {
    64.                 int cbNeeded = 0;
    65.                 bool bolRet = GetPrinter(hPrinter, 2, IntPtr.Zero, 0, out cbNeeded);
    66.                 if (cbNeeded > 0)
    67.                 {
    68.                     IntPtr pAddr = Marshal.AllocHGlobal((int)cbNeeded);
    69.                     bolRet = GetPrinter(hPrinter, 2, pAddr, cbNeeded, out cbNeeded);
    70.                     if (bolRet)
    71.                     {
    72.                         PRINTER_INFO_2 Info2 = new PRINTER_INFO_2();
    73.  
    74.  
    75.                         Info2 = (PRINTER_INFO_2)Marshal.PtrToStructure(pAddr, typeof(PRINTER_INFO_2));
    76.  
    77.  
    78.                         intRet = System.Convert.ToInt32(Info2.Status);
    79.                     }
    80.                     Marshal.FreeHGlobal(pAddr);
    81.                 }
    82.                 ClosePrinter(hPrinter);
    83.             }
    84.  
    85.  
    86.             return intRet;
    87.         }
    88.         /// 
    89.         /// 检查打印机是否可用(方式1)
    90.         /// 
    91.         /// 
    92.         /// 
    93.         public static bool CheckIsEnable(int intStatusCodeValue)
    94.         {
    95.             bool isEnable = false;
    96.             if (PrinterHelper.GetTaskNumber() == 0)
    97.             {
    98.                 return true;
    99.             }
    100.             if (intStatusCodeValue == 0x0008000 || intStatusCodeValue == 0x00000400 || intStatusCodeValue == 0x00004000)
    101.             {
    102.                 return true;
    103.             }
    104.             return isEnable;
    105.         }
    106.  
    107.  
    108.         /// 
    109.         /// 获取打印机的状态信息(方式1)
    110.         /// 
    111.         /// 
    112.         public static string GetPrinterStatusMessage(int intStatusCodeValue)
    113.         {
    114.             string strRet = string.Empty;
    115.             switch (intStatusCodeValue)
    116.             {
    117.                 case 0:
    118.                     strRet = "准备就绪（Ready）";
    119.                     break;
    120.                 case 0x00000200:
    121.                     strRet = "忙(Busy）";
    122.                     break;
    123.                 case 0x00400000:
    124.                     strRet = "被打开（Printer Door Open）";
    125.                     break;
    126.                 case 0x00000002:
    127.                     strRet = "错误(Printer Error）";
    128.                     break;
    129.                 case 0x0008000:
    130.                     strRet = "初始化(Initializing）";
    131.                     break;
    132.                 case 0x00000100:
    133.                     strRet = "正在输入,输出（I/O Active）";
    134.                     break;
    135.                 case 0x00000020:
    136.                     strRet = "手工送纸（Manual Feed）";
    137.                     break;
    138.                 case 0x00040000:
    139.                     strRet = "无墨粉（No Toner）";
    140.                     break;
    141.                 case 0x00001000:
    142.                     strRet = "不可用（Not Available）";
    143.                     break;
    144.                 case 0x00000080:
    145.                     strRet = "脱机（Off Line）";
    146.                     break;
    147.                 case 0x00200000:
    148.                     strRet = "内存溢出（Out of Memory）";
    149.                     break;
    150.                 case 0x00000800:
    151.                     strRet = "输出口已满（Output Bin Full）";
    152.                     break;
    153.                 case 0x00080000:
    154.                     strRet = "当前页无法打印（Page Punt）";
    155.                     break;
    156.                 case 0x00000008:
    157.                     strRet = "塞纸（Paper Jam）";
    158.                     break;
    159.                 case 0x00000010:
    160.                     strRet = "打印纸用完（Paper Out）";
    161.                     break;
    162.                 case 0x00000040:
    163.                     strRet = "纸张问题（Page Problem）";
    164.                     break;
    165.                 case 0x00000001:
    166.                     strRet = "暂停（Paused）";
    167.                     break;
    168.                 case 0x00000004:
    169.                     strRet = "正在删除（Pending Deletion）";
    170.                     break;
    171.                 case 0x00000400:
    172.                     strRet = "正在打印（Printing）";
    173.                     break;
    174.                 case 0x00004000:
    175.                     strRet = "正在处理（Processing）";
    176.                     break;
    177.                 case 0x00020000:
    178.                     strRet = "墨粉不足（Toner Low）";
    179.                     break;
    180.                 case 0x00100000:
    181.                     strRet = "需要用户干预（User Intervention）";
    182.                     break;
    183.                 case 0x20000000:
    184.                     strRet = "等待（Waiting）";
    185.                     break;
    186.                 case 0x00010000:
    187.                     strRet = "热机中（Warming Up）";
    188.                     break;
    189.                 default:
    190.                     strRet = "未知状态（Unknown Status）";
    191.                     break;
    192.             }
    193.             return strRet;
    194.         }
    195.  
    196.         /// 
    197.         /// 获取打印机正在打印的任务数(方式1)
    198.         /// 
    199.         /// 
    200.         public static int GetTaskNumber()
    201.         {
    202.             IntPtr handle;
    203.             int FirstJob = 0;
    204.             int NumJobs = 127;
    205.             int pcbNeeded;
    206.             int pcReturned = -1;
    207.             OpenPrinter(printerName, out handle, IntPtr.Zero);
    208.             // get num bytes required, here we assume the maxt job for the printer quest is 128 (0..127)
    209.             EnumJobs(handle, FirstJob, NumJobs, 1, IntPtr.Zero, 0, out pcbNeeded, out pcReturned);
    210.  
    211.             // allocate unmanaged memory
    212.             IntPtr pData = Marshal.AllocHGlobal(pcbNeeded);
    213.  
    214.             // get structs
    215.             EnumJobs(handle, FirstJob, NumJobs, 1, pData, pcbNeeded, out pcbNeeded, out pcReturned);
    216.  
    217.             return pcReturned;
    218.         }
    219.  
    220.  
    221.  
    222.  
    223.  
    224.         #endregion

    方式2：使用LocalPrintServer

    不过有一点需要注意的是，如果需要实时检测打印机的状态，每次检测状态码，都需要重新new LocalPrintServer对象，不然检测不到新的状态信息

    1. #region 方式2
    2.         /// 
    3.         /// 获取打印机的状态编码(方式2)
    4.         /// 
    5.         /// 
    6.         public static int GetPrinterStatusCodeInt2()
    7.         {
    8.             int statusCode = 0;
    9.             PrintQueue queue = new LocalPrintServer().DefaultPrintQueue;
    10.             if (queue.IsNotAvailable)
    11.             {
    12.                 statusCode = 1;
    13.                 return statusCode;
    14.             }
    15.             if (queue.IsOutOfPaper)
    16.             {
    17.                 statusCode = 2;
    18.                 return statusCode;
    19.             }
    20.  
    21.             if (queue.IsBusy)
    22.             {
    23.                 statusCode = 3;
    24.                 return statusCode;
    25.             }
    26.             if (queue.IsInError)
    27.             {
    28.                 statusCode = 4;
    29.                 return statusCode;
    30.             }
    31.             if (queue.IsOffline)
    32.             {
    33.                 statusCode = 5;
    34.                 return statusCode;
    35.             }
    36.             if (queue.IsOutOfMemory)
    37.             {
    38.                 statusCode = 6;
    39.                 return statusCode;
    40.             }
    41.             if (queue.HasPaperProblem)
    42.             {
    43.                 statusCode = 7;
    44.                 return statusCode;
    45.             }
    46.             if (queue.IsPaused)
    47.             {
    48.                 statusCode = 8;
    49.                 return statusCode;
    50.             }
    51.  
    52.             return statusCode;
    53.         }
    54.  
    55.         /// 
    56.         /// 检查打印机是否可用(方式2)
    57.         /// 
    58.         /// 打印机状态编码
    59.         /// 
    60.         public static bool CheckIsEnable2(int intStatusCodeValue)
    61.         {
    62.             bool isEnable = false;
    63.             if (intStatusCodeValue == 0)
    64.             {
    65.                 return true;
    66.             }
    67.             return isEnable;
    68.         }
    69.  
    70.  
    71.         /// 
    72.         /// 获取打印机的状态信息(方式2)
    73.         /// 
    74.         /// 打印机状态编码
    75.         /// 
    76.         public static string GetPrinterStatusMessage2(int intStatusCodeValue)
    77.         {
    78.             string strRet = string.Empty;
    79.             switch (intStatusCodeValue)
    80.             {
    81.                 case 1:
    82.                     strRet = "打印机不可用";
    83.                     break;
    84.                 case 2:
    85.                     strRet = "打印机缺纸";
    86.                     break;
    87.                 case 3:
    88.                     strRet = "打印机正忙";
    89.                     break;
    90.                 case 4:
    91.                     strRet = "打印机正在处于错误状态";
    92.                     break;
    93.                 case 5:
    94.                     strRet = "打印机处于脱机状态";
    95.                     break;
    96.                 case 6:
    97.                     strRet = "打印机内存溢出";
    98.                     break;
    99.                 case 7:
    100.                     strRet = "遇到了未指定的纸张错误";
    101.                     break;
    102.                 case 8:
    103.                     strRet = "打印机打印队列暂停了";
    104.                     break;
    105.                 default:
    106.                     strRet = "未知状态（Unknown Status）";
    107.                     break;
    108.             }
    109.             return strRet;
    110.         }
    111.  
    112.         /// 
    113.         /// 获取打印队列的任务数(方式2)
    114.         /// 
    115.         /// 
    116.         public static int GetTaskNumber2()
    117.         {
    118.             return new LocalPrintServer().DefaultPrintQueue.NumberOfJobs;
    119.         }
    120.         #endregion

    完整代码如下：

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Management;
    5. using System.Printing;
    6. using System.Runtime.InteropServices;
    7. using System.Text;
    8.  
    9. namespace iih.mp.dg.presbatchprint2.bp
    10. {
    11.     /// 
    12.     /// 打印机状态帮助类
    13.     /// 
    14.     public class PrinterHelper
    15.     {
    16.         #region 方式1
    17.         [DllImport("winspool.drv", CharSet = CharSet.Auto, SetLastError = true)]
    18.         private static extern bool OpenPrinter(string pPrinterName, out IntPtr hPrinter, IntPtr pDefault);
    19.  
    20.  
    21.         [DllImport("winspool.drv", SetLastError = true)]
    22.         private static extern bool ClosePrinter(IntPtr hPrinter);
    23.  
    24.  
    25.         [DllImport("winspool.drv", SetLastError = true)]
    26.         private static extern bool GetPrinter(IntPtr hPrinter,
    27.             int dwLevel, IntPtr pPrinter, int cbBuf, out int pcbNeeded);
    28.  
    29.  
    30.         [DllImport("winspool.drv", CharSet = CharSet.Auto)]
    31.         public static extern int EnumJobs(IntPtr hPrinter, int FirstJob, int NoJobs, int Level, IntPtr pInfo, int cdBuf,
    32.                                   out int pcbNeeded, out int pcReturned);
    33.  
    34.  
    35.         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    36.         public struct PRINTER_INFO_2
    37.         {
    38.             public string pServerName;
    39.             public string pPrinterName;
    40.             public string pShareName;
    41.             public string pPortName;
    42.             public string pDriverName;
    43.             public string pComment;
    44.             public string pLocation;
    45.             public IntPtr pDevMode;
    46.             public string pSepFile;
    47.             public string pPrintProcessor;
    48.             public string pDatatype;
    49.             public string pParameters;
    50.             public IntPtr pSecurityDescriptor;
    51.             public uint Attributes;
    52.             public uint Priority;
    53.             public uint DefaultPriority;
    54.             public uint StartTime;
    55.             public uint UntilTime;
    56.             public uint Status;
    57.             public uint cJobs;
    58.             public uint AveragePPM;
    59.         }
    60.  
    61.         /// 
    62.         /// 默认打印机的名称
    63.         /// 
    64.         private static string printerName = new LocalPrintServer().DefaultPrintQueue.Name;
    65.  
    66.  
    67.         /// 
    68.         /// 获取打印机的状态编码(方式1)
    69.         /// 
    70.         /// 
    71.         public static int GetPrinterStatusCodeInt()
    72.         {
    73.             int intRet = 0;
    74.             IntPtr hPrinter;
    75.  
    76.  
    77.             if (OpenPrinter(printerName, out hPrinter, IntPtr.Zero))
    78.             {
    79.                 int cbNeeded = 0;
    80.                 bool bolRet = GetPrinter(hPrinter, 2, IntPtr.Zero, 0, out cbNeeded);
    81.                 if (cbNeeded > 0)
    82.                 {
    83.                     IntPtr pAddr = Marshal.AllocHGlobal((int)cbNeeded);
    84.                     bolRet = GetPrinter(hPrinter, 2, pAddr, cbNeeded, out cbNeeded);
    85.                     if (bolRet)
    86.                     {
    87.                         PRINTER_INFO_2 Info2 = new PRINTER_INFO_2();
    88.  
    89.  
    90.                         Info2 = (PRINTER_INFO_2)Marshal.PtrToStructure(pAddr, typeof(PRINTER_INFO_2));
    91.  
    92.  
    93.                         intRet = System.Convert.ToInt32(Info2.Status);
    94.                     }
    95.                     Marshal.FreeHGlobal(pAddr);
    96.                 }
    97.                 ClosePrinter(hPrinter);
    98.             }
    99.  
    100.  
    101.             return intRet;
    102.         }
    103.         /// 
    104.         /// 检查打印机是否可用(方式1)
    105.         /// 
    106.         /// 
    107.         /// 
    108.         public static bool CheckIsEnable(int intStatusCodeValue)
    109.         {
    110.             bool isEnable = false;
    111.             if (PrinterHelper.GetTaskNumber() == 0)
    112.             {
    113.                 return true;
    114.             }
    115.             if (intStatusCodeValue == 0x0008000 || intStatusCodeValue == 0x00000400 || intStatusCodeValue == 0x00004000)
    116.             {
    117.                 return true;
    118.             }
    119.             return isEnable;
    120.         }
    121.  
    122.  
    123.         /// 
    124.         /// 获取打印机的状态信息(方式1)
    125.         /// 
    126.         /// 
    127.         public static string GetPrinterStatusMessage(int intStatusCodeValue)
    128.         {
    129.             string strRet = string.Empty;
    130.             switch (intStatusCodeValue)
    131.             {
    132.                 case 0:
    133.                     strRet = "准备就绪（Ready）";
    134.                     break;
    135.                 case 0x00000200:
    136.                     strRet = "忙(Busy）";
    137.                     break;
    138.                 case 0x00400000:
    139.                     strRet = "被打开（Printer Door Open）";
    140.                     break;
    141.                 case 0x00000002:
    142.                     strRet = "错误(Printer Error）";
    143.                     break;
    144.                 case 0x0008000:
    145.                     strRet = "初始化(Initializing）";
    146.                     break;
    147.                 case 0x00000100:
    148.                     strRet = "正在输入,输出（I/O Active）";
    149.                     break;
    150.                 case 0x00000020:
    151.                     strRet = "手工送纸（Manual Feed）";
    152.                     break;
    153.                 case 0x00040000:
    154.                     strRet = "无墨粉（No Toner）";
    155.                     break;
    156.                 case 0x00001000:
    157.                     strRet = "不可用（Not Available）";
    158.                     break;
    159.                 case 0x00000080:
    160.                     strRet = "脱机（Off Line）";
    161.                     break;
    162.                 case 0x00200000:
    163.                     strRet = "内存溢出（Out of Memory）";
    164.                     break;
    165.                 case 0x00000800:
    166.                     strRet = "输出口已满（Output Bin Full）";
    167.                     break;
    168.                 case 0x00080000:
    169.                     strRet = "当前页无法打印（Page Punt）";
    170.                     break;
    171.                 case 0x00000008:
    172.                     strRet = "塞纸（Paper Jam）";
    173.                     break;
    174.                 case 0x00000010:
    175.                     strRet = "打印纸用完（Paper Out）";
    176.                     break;
    177.                 case 0x00000040:
    178.                     strRet = "纸张问题（Page Problem）";
    179.                     break;
    180.                 case 0x00000001:
    181.                     strRet = "暂停（Paused）";
    182.                     break;
    183.                 case 0x00000004:
    184.                     strRet = "正在删除（Pending Deletion）";
    185.                     break;
    186.                 case 0x00000400:
    187.                     strRet = "正在打印（Printing）";
    188.                     break;
    189.                 case 0x00004000:
    190.                     strRet = "正在处理（Processing）";
    191.                     break;
    192.                 case 0x00020000:
    193.                     strRet = "墨粉不足（Toner Low）";
    194.                     break;
    195.                 case 0x00100000:
    196.                     strRet = "需要用户干预（User Intervention）";
    197.                     break;
    198.                 case 0x20000000:
    199.                     strRet = "等待（Waiting）";
    200.                     break;
    201.                 case 0x00010000:
    202.                     strRet = "热机中（Warming Up）";
    203.                     break;
    204.                 default:
    205.                     strRet = "未知状态（Unknown Status）";
    206.                     break;
    207.             }
    208.             return strRet;
    209.         }
    210.  
    211.         /// 
    212.         /// 获取打印机正在打印的任务数(方式1)
    213.         /// 
    214.         /// 
    215.         public static int GetTaskNumber()
    216.         {
    217.             IntPtr handle;
    218.             int FirstJob = 0;
    219.             int NumJobs = 127;
    220.             int pcbNeeded;
    221.             int pcReturned = -1;
    222.             OpenPrinter(printerName, out handle, IntPtr.Zero);
    223.             // get num bytes required, here we assume the maxt job for the printer quest is 128 (0..127)
    224.             EnumJobs(handle, FirstJob, NumJobs, 1, IntPtr.Zero, 0, out pcbNeeded, out pcReturned);
    225.  
    226.             // allocate unmanaged memory
    227.             IntPtr pData = Marshal.AllocHGlobal(pcbNeeded);
    228.  
    229.             // get structs
    230.             EnumJobs(handle, FirstJob, NumJobs, 1, pData, pcbNeeded, out pcbNeeded, out pcReturned);
    231.  
    232.             return pcReturned;
    233.         }
    234.  
    235.  
    236.  
    237.  
    238.  
    239.         #endregion
    240.  
    241.  
    242.         #region 方式2
    243.         /// 
    244.         /// 获取打印机的状态编码(方式2)
    245.         /// 
    246.         /// 
    247.         public static int GetPrinterStatusCodeInt2()
    248.         {
    249.             int statusCode = 0;
    250.             PrintQueue queue = new LocalPrintServer().DefaultPrintQueue;
    251.             if (queue.IsNotAvailable)
    252.             {
    253.                 statusCode = 1;
    254.                 return statusCode;
    255.             }
    256.             if (queue.IsOutOfPaper)
    257.             {
    258.                 statusCode = 2;
    259.                 return statusCode;
    260.             }
    261.  
    262.             if (queue.IsBusy)
    263.             {
    264.                 statusCode = 3;
    265.                 return statusCode;
    266.             }
    267.             if (queue.IsInError)
    268.             {
    269.                 statusCode = 4;
    270.                 return statusCode;
    271.             }
    272.             if (queue.IsOffline)
    273.             {
    274.                 statusCode = 5;
    275.                 return statusCode;
    276.             }
    277.             if (queue.IsOutOfMemory)
    278.             {
    279.                 statusCode = 6;
    280.                 return statusCode;
    281.             }
    282.             if (queue.HasPaperProblem)
    283.             {
    284.                 statusCode = 7;
    285.                 return statusCode;
    286.             }
    287.             if (queue.IsPaused)
    288.             {
    289.                 statusCode = 8;
    290.                 return statusCode;
    291.             }
    292.  
    293.             return statusCode;
    294.         }
    295.  
    296.         /// 
    297.         /// 检查打印机是否可用(方式2)
    298.         /// 
    299.         /// 打印机状态编码
    300.         /// 
    301.         public static bool CheckIsEnable2(int intStatusCodeValue)
    302.         {
    303.             bool isEnable = false;
    304.             if (intStatusCodeValue == 0)
    305.             {
    306.                 return true;
    307.             }
    308.             return isEnable;
    309.         }
    310.  
    311.  
    312.         /// 
    313.         /// 获取打印机的状态信息(方式2)
    314.         /// 
    315.         /// 打印机状态编码
    316.         /// 
    317.         public static string GetPrinterStatusMessage2(int intStatusCodeValue)
    318.         {
    319.             string strRet = string.Empty;
    320.             switch (intStatusCodeValue)
    321.             {
    322.                 case 1:
    323.                     strRet = "打印机不可用";
    324.                     break;
    325.                 case 2:
    326.                     strRet = "打印机缺纸";
    327.                     break;
    328.                 case 3:
    329.                     strRet = "打印机正忙";
    330.                     break;
    331.                 case 4:
    332.                     strRet = "打印机正在处于错误状态";
    333.                     break;
    334.                 case 5:
    335.                     strRet = "打印机处于脱机状态";
    336.                     break;
    337.                 case 6:
    338.                     strRet = "打印机内存溢出";
    339.                     break;
    340.                 case 7:
    341.                     strRet = "遇到了未指定的纸张错误";
    342.                     break;
    343.                 case 8:
    344.                     strRet = "打印机打印队列暂停了";
    345.                     break;
    346.                 default:
    347.                     strRet = "未知状态（Unknown Status）";
    348.                     break;
    349.             }
    350.             return strRet;
    351.         }
    352.  
    353.         /// 
    354.         /// 获取打印队列的任务数(方式2)
    355.         /// 
    356.         /// 
    357.         public static int GetTaskNumber2()
    358.         {
    359.             return new LocalPrintServer().DefaultPrintQueue.NumberOfJobs;
    360.         }
    361.         #endregion
    362.  
    363.  
    364.         #region 方式3
    365.         public static void ToDo()
    366.         {
    367.             //获取所有打印机信息
    368.             //string query = string.Format("SELECT * from Win32_Printer ");
    369.             //var searcher = new ManagementObjectSearcher(query);
    370.             //var printers = searcher.Get();
    371.  
    372.             //foreach (var printer in printers)
    373.             //{
    374.             //    Console.WriteLine(printer.Properties["Name"].Value);
    375.             //    foreach (var property in printer.Properties)
    376.             //    {
    377.             //        Console.WriteLine(string.Format("\t{0}: {1}", property.Name, property.Value));
    378.             //    }
    379.             //    Console.WriteLine();
    380.             //}
    381.         }
    382.         #endregion
    383.     }
    384. }

  • 相关阅读:
    【微信小程序】全局样式文件app.wxss、页面的根元素page、 app.json中的window配置项
    Java进阶之路-目录
    二叉树进阶oj题
    【Mysql实现递归树查询】
    操作系统4小时速成：文件管理，文件结构，属性，基本操作，逻辑有无结构，目录结构，文件系统
    Mybatis 中的转义字符用法及说明
    Canonical 发布公告，Ubuntu可以在 Windows 10 商店找到
    亚马逊云科技面向 macOS 的 Amazon 云服务器 EC2 M1 Mac 实例
    vue3 使用simplebar【滚动条】
    【Solution】商品秒杀之Redis缓存与MQ异步优化以及超卖一人一单等问题的解决
  • 原文地址：https://blog.csdn.net/zxy13826134783/article/details/126310926