C# Window 访问远程路径

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;

namespace Access
{
    public class WNetMap
    {
        [DllImport("mpr.dll")]
        private static extern int WNetAddConnection2A(NETRESOURCE[] lpNetResource, string lpPassword, string lpUserName, int dwFlags);

        [DllImport("mpr.dll")]
        private static extern int WNetCancelConnection2A(string sharename, int dwFlags, int fForce);

        private static int Connect(string remotePath, string localPath, string username, string password)
        {
            NETRESOURCE[] share_driver = new NETRESOURCE[1];
            share_driver[0].dwScope = RESOURCE_SCOPE.RESOURCE_GLOBALNET;
            share_driver[0].dwType = RESOURCE_TYPE.RESOURCETYPE_DISK;
            share_driver[0].dwDisplayType = RESOURCE_DISPLAYTYPE.RESOURCEDISPLAYTYPE_SHARE;
            share_driver[0].dwUsage = RESOURCE_USAGE.RESOURCEUSAGE_CONNECTABLE;
            share_driver[0].lpLocalName = localPath;
            share_driver[0].lpRemoteName = remotePath;

            Disconnect(localPath);
            return WNetAddConnection2A(share_driver, password, username, 1);
        }

        private static int Disconnect(string localpath)
        {
            return WNetCancelConnection2A(localpath, 1, 1);
        }

        public static void WNetAccess(params string[] contents)
        {
            if (contents == null || contents.Length < 1)
                return;

            string[] args = null;
            int ret = -1;
            if (contents.Length > 0)
            {
                args = contents[0].Split(' ');
                if (args.Length > 3)
                {
                    // 0:remotePath, 1:localPath, 2:Username, 3:Password
                    ret = Connect(args[0], args[1], args[2], args[3]);
                    if (ret > 0)
                    {
                        throw new Exception(string.Format("ERROR {0} {1}", ret, (ERROR_ID)ret));
                    }
                }
            }

            if (ret == 0)
            {
                if (contents.Length > 1)
                    Process.Start(contents[1]);
                
                if (contents.Length > 2)
                {
                    var m = Regex.Match(contents[2], @"[\w]+");
                    if (m.Success)
                    {
                        string cmd = m.Groups[0].Value;
                        var dctPrm = GetArgs(contents[2]);
                        if (cmd == "find")
                        {
                            #region find -p -t -w
                            if (Directory.Exists(contents[1]))
                            {
                                DirectoryInfo dir = new DirectoryInfo(contents[1]);
                                List<FileInfo> files = new List<FileInfo>();
                                if (dctPrm.ContainsKey("-p"))
                                    files.AddRange(dir.GetFiles(dctPrm["-p"]));
                                else
                                    files.AddRange(dir.GetFiles());

                                if (dctPrm.ContainsKey("-t"))
                                    files = Find_HandleTimeArg(files, dctPrm["-t"]);

                                if (dctPrm.ContainsKey("-w"))
                                    files = Find_HandleKeyWordArg(files, dctPrm["-w"]);

                                if (dctPrm.ContainsKey("-c"))
                                    System.Windows.Clipboard.SetText(dctPrm["-c"]);

                                foreach (var f in files)
                                    Process.Start(f.FullName);
                            }
                            #endregion
                        }
                    }
                    else
                        throw new Exception("Can't support this action: " + contents[1]);
                }
                Disconnect(args[1]);
            }
        }


        static Dictionary<string, string> GetArgs(string args)
        {
            Dictionary<string, string> pDct = new Dictionary<string, string>();
            string pRex = @"[-][a-zA-Z][\w]*";
            var pNames = Regex.Matches(args, pRex, RegexOptions.Singleline);
            if (pNames.Count > 0)
            {
                var pValues = Regex.Split(args, pRex, RegexOptions.Singleline);
                for (int i = 0; i < pNames.Count; i++)
                {
                    pDct[pNames[i].Value] = pValues[i + 1].Trim();
                }
            }
            return pDct;
        }

        static List<FileInfo> Find_HandleTimeArg(List<FileInfo> files, string arg)
        {
            if (string.IsNullOrEmpty(arg))
                return files;
            List<FileInfo> result = new List<FileInfo>();
            var dt = arg.Split('|');
            DateTime? startDt = null;
            DateTime endDt = DateTime.Now;
            DateTime tmpDt;
            if (dt.Length > 1)
            {
                if (DateTime.TryParse(dt[0].Trim(), out tmpDt))
                    startDt = tmpDt;
                if (DateTime.TryParse(dt[1].Trim(), out tmpDt))
                    endDt = tmpDt;
            }
            else
            { 
                if (DateTime.TryParse(dt[0].Trim(), out tmpDt))
                    endDt = tmpDt;
            }

            FileInfo lastTimeFile = null;
            foreach (var f in files)
            {
                if (startDt.HasValue && f.LastWriteTime >= startDt.Value && f.LastWriteTime < endDt)
                {
                    result.Add(f);
                }
                else if (f.LastWriteTime >= endDt)
                {
                    if (lastTimeFile == null)
                    {
                        lastTimeFile = f;
                        result.Add(f);
                    }
                    else if (lastTimeFile.LastWriteTime > f.LastWriteTime)
                    {
                        result.Remove(lastTimeFile);
                        lastTimeFile = f;
                        result.Add(f);
                    }
                }

            }
            return result;
        }

        static List<FileInfo> Find_HandleKeyWordArg(List<FileInfo> files, string arg)
        {
            if (string.IsNullOrEmpty(arg))
                return files;
            List<FileInfo> result = new List<FileInfo>();
            int line, col; 
            foreach (var f in files)
            {
                line = col = 0;
                using (var sr = f.OpenText())
                {
                    while (sr.Peek() >= 0)
                    {
                        line++;
                        col = sr.ReadLine().IndexOf(arg) + 1;
                        if (col > 0)
                        {
                            result.Add(f);
                            sr.Close();
                            break;
                        }
                    }
                }
            }
            return result;
        }
    }

    #region Define NetWare Connect Class

    public enum ERROR_ID
    {
        ERROR_SUCCESS = 0,  // Success
        ERROR_BUSY = 170,
        ERROR_MORE_DATA = 234,
        ERROR_NO_BROWSER_SERVERS_FOUND = 6118,
        ERROR_INVALID_LEVEL = 124,
        ERROR_ACCESS_DENIED = 5,
        ERROR_INVALID_PASSWORD = 86,
        ERROR_INVALID_PARAMETER = 87,
        ERROR_BAD_DEV_TYPE = 66,
        ERROR_NOT_ENOUGH_MEMORY = 8,
        ERROR_NETWORK_BUSY = 54,
        ERROR_BAD_NETPATH = 53,
        ERROR_NO_NETWORK = 1222,
        ERROR_INVALID_HANDLE_STATE = 1609,
        ERROR_EXTENDED_ERROR = 1208,
        ERROR_DEVICE_ALREADY_REMEMBERED = 1202,
        ERROR_NO_NET_OR_BAD_PATH = 1203,
        ERROR_SESSION_CREDENTIAL_CONFLICT = 1219
    }

    public enum RESOURCE_SCOPE
    {
        RESOURCE_CONNECTED = 1,
        RESOURCE_GLOBALNET = 2,
        RESOURCE_REMEMBERED = 3,
        RESOURCE_RECENT = 4,
        RESOURCE_CONTEXT = 5
    }

    public enum RESOURCE_TYPE
    {
        RESOURCETYPE_ANY = 0,
        RESOURCETYPE_DISK = 1,
        RESOURCETYPE_PRINT = 2,
        RESOURCETYPE_RESERVED = 8,
    }

    public enum RESOURCE_USAGE
    {
        RESOURCEUSAGE_CONNECTABLE = 1,
        RESOURCEUSAGE_CONTAINER = 2,
        RESOURCEUSAGE_NOLOCALDEVICE = 4,
        RESOURCEUSAGE_SIBLING = 8,
        RESOURCEUSAGE_ATTACHED = 16,
        RESOURCEUSAGE_ALL = (RESOURCEUSAGE_CONNECTABLE | RESOURCEUSAGE_CONTAINER | RESOURCEUSAGE_ATTACHED),
    }

    public enum RESOURCE_DISPLAYTYPE
    {
        RESOURCEDISPLAYTYPE_GENERIC = 0,
        RESOURCEDISPLAYTYPE_DOMAIN = 1,
        RESOURCEDISPLAYTYPE_SERVER = 2,
        RESOURCEDISPLAYTYPE_SHARE = 3,
        RESOURCEDISPLAYTYPE_FILE = 4,
        RESOURCEDISPLAYTYPE_GROUP = 5,
        RESOURCEDISPLAYTYPE_NETWORK = 6,
        RESOURCEDISPLAYTYPE_ROOT = 7,
        RESOURCEDISPLAYTYPE_SHAREADMIN = 8,
        RESOURCEDISPLAYTYPE_DIRECTORY = 9,
        RESOURCEDISPLAYTYPE_TREE = 10,
        RESOURCEDISPLAYTYPE_NDSCONTAINER = 11
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct NETRESOURCE
    {
        public RESOURCE_SCOPE dwScope;
        public RESOURCE_TYPE dwType;
        public RESOURCE_DISPLAYTYPE dwDisplayType;
        public RESOURCE_USAGE dwUsage;

        [MarshalAs(UnmanagedType.LPStr)]
        public string lpLocalName;

        [MarshalAs(UnmanagedType.LPStr)]
        public string lpRemoteName;

        [MarshalAs(UnmanagedType.LPStr)]
        public string lpComment;

        [MarshalAs(UnmanagedType.LPStr)]
        public string lpProvider;
    }

    #endregion
}