c# - 在 C# 中使用没有对话框的扫描仪

Question

我正在构建一个用于远程控制扫描仪设备的 .Net 4.0 应用程序。我已经尝试了 TWAIN 和 WIA 库，但我遇到了同样的问题。扫描图像没有扫描仪选择和扫描设置对话框。

我在 WIA scripting in .Net 上找到了一篇有用的文章，并将其修改为:

private Image Scan(string deviceName)
{
    WiaClass wiaManager = null;       // WIA manager COM object
    CollectionClass wiaDevs = null;   // WIA devices collection COM object
    ItemClass wiaRoot = null;         // WIA root device COM object
    CollectionClass wiaPics = null;   // WIA collection COM object
    ItemClass wiaItem = null;         // WIA image COM object

    try
    {
        // create COM instance of WIA manager
        wiaManager = new WiaClass();

        // call Wia.Devices to get all devices
        wiaDevs = wiaManager.Devices as CollectionClass;
        if ((wiaDevs == null) || (wiaDevs.Count == 0))
        {
            throw new Exception("No WIA devices found!");
        }

        object device = null;
        foreach (IWiaDeviceInfo currentDevice in wiaManager.Devices)
        {
            if (currentDevice.Name == deviceName)
            {
                device = currentDevice;
                break;
            }
        }

        if (device == null)
        {
            throw new Exception
            (
                "Device with name \"" + 
                deviceName + 
                "\" could not be found."
            );
        }

        // select device
        wiaRoot = (ItemClass)wiaManager.Create(ref device); 

        // something went wrong
        if (wiaRoot == null)
        {
            throw new Exception
            (
                "Could not initialize device \"" + 
                deviceName + "\"."
            );
        }

        wiaPics = wiaRoot.GetItemsFromUI
        (
            WiaFlag.SingleImage,
            WiaIntent.ImageTypeColor
        ) as CollectionClass;

        if (wiaPics == null || wiaPics.Count == 0)
        {
            throw new Exception("Could not scan image.");
        }

        Image image = null;

        // enumerate all the pictures the user selected
        foreach (object wiaObj in wiaPics)
        {
            if (image == null)
            {
                wiaItem = (ItemClass)Marshal.CreateWrapperOfType
                (
                    wiaObj, typeof(ItemClass)
                );

                // create temporary file for image
                string tempFile = Path.GetTempFileName();

                // transfer picture to our temporary file
                wiaItem.Transfer(tempFile, false);

                // create Image instance from file
                image = Image.FromFile(tempFile);
            }

            // release enumerated COM object
            Marshal.ReleaseComObject(wiaObj);
        }

        if (image == null)
        {
            throw new Exception("Error reading scanned image.");
        }

        return image;
    }
    finally
    {
        // release WIA image COM object
        if (wiaItem != null)
            Marshal.ReleaseComObject(wiaItem);

        // release WIA collection COM object
        if (wiaPics != null)
            Marshal.ReleaseComObject(wiaPics);

        // release WIA root device COM object
        if (wiaRoot != null)
            Marshal.ReleaseComObject(wiaRoot);

        // release WIA devices collection COM object
        if (wiaDevs != null)
            Marshal.ReleaseComObject(wiaDevs);

        // release WIA manager COM object
        if (wiaManager != null)
            Marshal.ReleaseComObject(wiaManager);
    }
}

有了这个，我实际上设法从配置中选择设备(扫描方法的输入参数)并在扫描后检索生成的图像。

但是扫描选项对话框的问题(使用设备名称扫描)。由于这是一个远程控制应用程序，对话框对用户不可见，因此我需要使用默认设置跳过它，或者在必要时使用配置中的设置。

扫描选项对话框:

Answer 1

最终我并没有使用题中写的扫描对话框的代码。我找到了一个有用的例子 Scanning with Windows Image Acquisition 2.0顺便说一句，它也有一个阻塞对话框，但这很容易修改，很快我就有了一个带有 Scan(string scannerId) 函数的简单类，它只会用选定的设备进行扫描，仅此而已，请参见下面的代码 ():

using System;
using System.Collections.Generic;
using System.IO;
using System.Drawing;

namespace WIATest
{
    class WIAScanner
    {
        const string wiaFormatBMP = "{B96B3CAB-0728-11D3-9D7B-0000F81EF32E}";

        class WIA_DPS_DOCUMENT_HANDLING_SELECT
        {
            public const uint FEEDER = 0x00000001;
            public const uint FLATBED = 0x00000002;
        }

        class WIA_DPS_DOCUMENT_HANDLING_STATUS
        {
            public const uint FEED_READY = 0x00000001;
        }

        class WIA_PROPERTIES
        {
            public const uint WIA_RESERVED_FOR_NEW_PROPS = 1024;
            public const uint WIA_DIP_FIRST = 2;
            public const uint WIA_DPA_FIRST = WIA_DIP_FIRST + WIA_RESERVED_FOR_NEW_PROPS;
            public const uint WIA_DPC_FIRST = WIA_DPA_FIRST + WIA_RESERVED_FOR_NEW_PROPS;
            //
            // Scanner only device properties (DPS)
            //
            public const uint WIA_DPS_FIRST = WIA_DPC_FIRST + WIA_RESERVED_FOR_NEW_PROPS;
            public const uint WIA_DPS_DOCUMENT_HANDLING_STATUS = WIA_DPS_FIRST + 13;
            public const uint WIA_DPS_DOCUMENT_HANDLING_SELECT = WIA_DPS_FIRST + 14;
        }

        /// <summary>
        /// Use scanner to scan an image (with user selecting the scanner from a dialog).
        /// </summary>
        /// <returns>Scanned images.</returns>
        public static List<Image> Scan()
        {
            WIA.ICommonDialog dialog = new WIA.CommonDialog();
            WIA.Device device = dialog.ShowSelectDevice(WIA.WiaDeviceType.UnspecifiedDeviceType, true, false);

            if (device != null)
            {
                return Scan(device.DeviceID);
            }
            else
            {
                throw new Exception("You must select a device for scanning.");
            }
        }

        /// <summary>
        /// Use scanner to scan an image (scanner is selected by its unique id).
        /// </summary>
        /// <param name="scannerName"></param>
        /// <returns>Scanned images.</returns>
        public static List<Image> Scan(string scannerId)
        {
            List<Image> images = new List<Image>();

            bool hasMorePages = true;
            while (hasMorePages)
            {
                // select the correct scanner using the provided scannerId parameter
                WIA.DeviceManager manager = new WIA.DeviceManager();
                WIA.Device device = null;

                foreach (WIA.DeviceInfo info in manager.DeviceInfos)
                {
                    if (info.DeviceID == scannerId)
                    {
                        // connect to scanner
                        device = info.Connect();
                        break;
                    }
                }

                // device was not found
                if (device == null)
                {
                    // enumerate available devices
                    string availableDevices = "";
                    foreach (WIA.DeviceInfo info in manager.DeviceInfos)
                    {
                        availableDevices += info.DeviceID + "n";
                    }

                    // show error with available devices
                    throw new Exception("The device with provided ID could not be found. Available Devices:n" + availableDevices);
                }

                WIA.Item item = device.Items[1] as WIA.Item;

                try
                {
                    // scan image
                    WIA.ICommonDialog wiaCommonDialog = new WIA.CommonDialog();
                    WIA.ImageFile image = (WIA.ImageFile)wiaCommonDialog.ShowTransfer(item, wiaFormatBMP, false);

                    // save to temp file
                    string fileName = Path.GetTempFileName();
                    File.Delete(fileName);
                    image.SaveFile(fileName);
                    image = null;

                    // add file to output list
                    images.Add(Image.FromFile(fileName));
                }
                catch (Exception exc)
                {
                    throw exc;
                }
                finally
                {
                    item = null;

                    //determine if there are any more pages waiting
                    WIA.Property documentHandlingSelect = null;
                    WIA.Property documentHandlingStatus = null;

                    foreach (WIA.Property prop in device.Properties)
                    {
                        if (prop.PropertyID == WIA_PROPERTIES.WIA_DPS_DOCUMENT_HANDLING_SELECT)
                            documentHandlingSelect = prop;

                        if (prop.PropertyID == WIA_PROPERTIES.WIA_DPS_DOCUMENT_HANDLING_STATUS)
                            documentHandlingStatus = prop;
                    }

                    // assume there are no more pages
                    hasMorePages = false;

                    // may not exist on flatbed scanner but required for feeder
                    if (documentHandlingSelect != null)
                    {
                        // check for document feeder
                        if ((Convert.ToUInt32(documentHandlingSelect.get_Value()) &amp;amp;amp;amp; WIA_DPS_DOCUMENT_HANDLING_SELECT.FEEDER) != 0)
                        {
                            hasMorePages = ((Convert.ToUInt32(documentHandlingStatus.get_Value()) &amp;amp;amp;amp; WIA_DPS_DOCUMENT_HANDLING_STATUS.FEED_READY) != 0);
                        }
                    }
                }
            }

            return images;
        }

        /// <summary>
        /// Gets the list of available WIA devices.
        /// </summary>
        /// <returns></returns>
        public static List<string> GetDevices()
        {
            List<string> devices = new List<string>();
            WIA.DeviceManager manager = new WIA.DeviceManager();

            foreach (WIA.DeviceInfo info in manager.DeviceInfos)
            {
                devices.Add(info.DeviceID);
            }

            return devices;
        }

    }
}