/******************'*********************************************
     *函 数 名：   ConnectShareDir
     *参    数：   TCHAR tcUserName[], 远程登录用户名
                  TCHAR tcUserPwd[],    远程登录密码
                  TCHAR szShareSource[] 共享文件夹名称
     *返回值：     bool  成功返回true  失败放回false
     *函数功能：   建立本地远程登录映射
*****************************************************************/
bool ConnectShareDir(TCHAR tcUserName[], TCHAR tcUserPwd[], TCHAR szShareSource[]);


bool ConnectShareDir(TCHAR szUserName[], TCHAR szUserPwd[], TCHAR szShareSource[])
{
	bool bRes = true;
	NETRESOURCE net_Resource;
	net_Resource.dwDisplayType = RESOURCEDISPLAYTYPE_DIRECTORY;
	net_Resource.dwScope = RESOURCE_CONNECTED;
	net_Resource.dwType = RESOURCETYPE_ANY;
	net_Resource.dwUsage = 0;
	net_Resource.lpComment = TEXT("");
	net_Resource.lpLocalName = TEXT("C:");  //映射成本地驱动器C:
	net_Resource.lpProvider= NULL;
	net_Resource.lpRemoteName = szShareSource;//TEXT("\\\\172.230.240.111\\ShareDir"); // \\servername\共享资源名
	DWORD dwFlags = CONNECT_UPDATE_PROFILE;
	DWORD dw = WNetAddConnection2(&net_Resource, szUserPwd, szUserName, dwFlags);
	switch(dw)
	{
	case ERROR_SUCCESS:
		ShellExecute(NULL, TEXT("open"), TEXT("C:"), NULL, NULL, SW_HIDE);
		OutputDebugString(_T("连接共享主机 ERROR_SUCCESS\r\n"));
		bRes = true;
		break;
	case ERROR_ACCESS_DENIED:
		OutputDebugString(_T("连接共享主机没有权访问 ERROR_ACCESS_DENIED\r\n"));
		bRes = false;
		break;
	case ERROR_ALREADY_ASSIGNED:
		ShellExecute(NULL, TEXT("open"), TEXT("C:"), NULL, NULL, SW_HIDE);
		OutputDebugString(_T("连接共享主机已经存在  ERROR_ALREADY_ASSIGNED\r\n"));
		bRes = true;
		break;
	case ERROR_INVALID_ADDRESS:
		OutputDebugString(_T("连接共享主机IP地址无效  ERROR_INVALID_ADDRESS\r\n"));
		bRes = false;
		break;
	case ERROR_NO_NETWORK:
		OutputDebugString(_T("连接共享主机网络不可达  ERROR_NO_NETWORK\r\n"));
		bRes = false;
		break;
	default:
		bRes = false;
	}
	return bRes;
}
访问时 
        CFile file;
	file.Open(_T("\\\\172.230.240.111\\ShareDir\\13_1.jpg"), CFile::modeReadWrite||CFile::modeCreate);
        DWORD dwError = GetLastError();
	file.Close();
本地测试可能存在找不到网络路径  dwError为53的错误
上述方式，亲测，在使用的时候对密码和用户名似乎不生效，只能是不需要用户名和密码的共享才可以访问；下面方式写到程序中才能保证用户名密码生效
net use \\172.18.0.15\sharedDoc password /user:administrator
net use * /del  /y 删除

 

前几天去现场，发现实施的同学在操作图形工作站上的文件特别麻烦，大屏分辨率比较大的话，还得开个放大镜去看，有的还要跑到机房去插U盘的，总之特别费劲！

其实，这些都可以在自己工作机上远程使用net user命令解决文件操作问题。

PS：首先的保证你的工作机能PING通图形工作站

如下有两种命令方式：

net use \\ip地址\ipc$ "密码" /user:"用户名" 建立IPC非空链接 
net use h: \\ip地址\c$ "密码" /user:"用户名" 直接登陆后映射对方C：到本地为H: 


下面举个示例：

需求：要从本机远程拷贝主机（172.16.14.95）C盘下的某文件

1.打开菜单下的运行栏，输入CMD



2.输入并执行命令

net use \\172.16.14.95\ipc$ Peony911 /user:wangq




3.再次回到运行栏，输入\\172.16.14.95\c$



4.双击其中的c$文件夹即可



另外一种方式，在DOS命令窗口输入

net use h: \\172.16.14.95\c$ Peony+911 /user:techstar\wangqin

执行成功后打开本地磁盘 

sshfs，就是可以把ssh连接到的主机资源，映射到本机的文件系统当中，然后用户可以像操作本地文件一样操作，而实际的文件改动将通过ssh传输到远程主机当中。以下就是详细步骤：
例如，现在有服务器A(192.168.1.2)和服务器B，我们想把A机器上的/mnt/test 目录作为共享目录挂载到B机器上的/home/test 目录上
1、分别在两个机器上下载sshfs（如果都有下载，则忽略该步骤）
yum install fuse sshfs
2、用挂载命令，开始挂载(需要A服务器的root用户密码，另外allow_other这个参数很重要，没有这个参数的话，挂载过来的目录只有root能够访问。)
sshfs root@192.168.1.2:/mnt/test  /home/test -o allow_other
以上两步，就已经成功的将服务器A上的/mnt/test 挂载到了B的/home/test 目录下。接下来，你在B上/home/test 目录下的任何操作，都等同于在A上的操作。
3、如果想卸载挂载目录，则执行命令：
fusermount -u /home/test

由于某项目中课件资源过多，资源文件的存储采用了分布式文件系统，但是在局域网中如何访问又面临着一个问题，即局域网中访问各主机的文件同访问本机盘符下的文件是不同的，本人通过网上查询各种方案的对比，并且在实际项目中应用后对各种局域网文件访问的方法作了完整的总结

1  调用Net use DOS命令


/// <summary>
    /// 1.远程操作工具类
    /// </summary>
    public class RemoteFileTools
    {

        /// <summary>
        /// 调用Net use命令，实现远程文件操作
        /// </summary>
        /// <param name="remoteHost"></param>
        /// <param name="userName"></param>
        /// <param name="passWord"></param>
        /// <returns></returns>
        /// <remarks>
        ///  使用方法：
        ///  if (Connect("192.168.1.48", "用户名", "密码"))   
        ///  {File.Copy(@"\\192.168.1.48\共享目录\test.txt",   @"e:\\test.txt",   true);}
        /// </remarks>
        public static bool Connect(string remoteHost, string userName, string passWord)
        {
            bool Flag = true;
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.StartInfo.FileName = "cmd.exe";
            proc.StartInfo.UseShellExecute = false;
            proc.StartInfo.RedirectStandardInput = true;
            proc.StartInfo.RedirectStandardOutput = true;
            proc.StartInfo.RedirectStandardError = true;
            proc.StartInfo.CreateNoWindow = true;
            try
            {
                proc.Start();
                string command = @"net use \\" + remoteHost + " " + passWord + " " + " /user:" + userName + ">NUL";
                proc.StandardInput.WriteLine(command);
                command = "exit";
                proc.StandardInput.WriteLine(command);
                while (proc.HasExited == false)
                {
                    proc.WaitForExit(1000);
                }
                string errormsg = proc.StandardError.ReadToEnd();
                if (errormsg != "")
                    Flag = false;
                proc.StandardError.Close();
            }
            catch (Exception ex)
            {
                Flag = false;
            }
            finally
            {
                proc.Close();
                proc.Dispose();
            }
            return Flag;
        }

        public static bool Ping(string remoteHost)
        {
            bool Flag = false;
            System.Diagnostics.Process proc = new System.Diagnostics.Process();
            try
            {
                proc.StartInfo.FileName = "cmd.exe"; proc.StartInfo.UseShellExecute = false;
                proc.StartInfo.RedirectStandardInput = true; proc.StartInfo.RedirectStandardOutput = true;
                proc.StartInfo.RedirectStandardError = true; proc.StartInfo.CreateNoWindow = true; proc.Start();
                string dosLine = @"ping -n 1 " + remoteHost; proc.StandardInput.WriteLine(dosLine);
                proc.StandardInput.WriteLine("exit"); while (!proc.HasExited)
                {
                    proc.WaitForExit(500);
                }
                string pingResult = proc.StandardOutput.ReadToEnd(); if (pingResult.IndexOf("(0% loss)") != -1)
                {
                    Flag = true;
                }
                proc.StandardOutput.Close();
            }
            catch (Exception ex) { }
            finally
            {
                proc.Close(); proc.Dispose();
            }
            return Flag;
        }
    }





2  同上面方法有些相似之处，映射远程资源，然后访问
/// <summary>
    /// 2.	调用WNetAddConnection2、WNetAddConnection3或者NetUseAdd函数，进行磁盘映射
    /// </summary>
    public class MyMap
    {
        [DllImport("mpr.dll", EntryPoint = "WNetAddConnection2")]
        public static extern uint WNetAddConnection2(
            [In] NETRESOURCE lpNetResource,
            string lpPassword,
            string lpUsername,
            uint dwFlags);

        [DllImport("Mpr.dll")]
        public static extern uint WNetCancelConnection2(
            string lpName,
            uint dwFlags,
            bool fForce);

        [StructLayout(LayoutKind.Sequential)]
        public class NETRESOURCE
        {
            public int dwScope;
            public int dwType;
            public int dwDisplayType;
            public int dwUsage;
            public string LocalName;
            public string RemoteName;
            public string Comment;
            public string Provider;
        }

        // remoteNetworkPath format:  @"\\192.168.1.48\sharefolder"
        // localDriveName format:     @"E:"
        public static bool CreateMap(string userName, string password, string remoteNetworkPath, string localDriveName)
        {
            NETRESOURCE myNetResource = new NETRESOURCE();
            myNetResource.dwScope = 2;       //2:RESOURCE_GLOBALNET
            myNetResource.dwType = 1;        //1:RESOURCETYPE_ANY
            myNetResource.dwDisplayType = 3; //3:RESOURCEDISPLAYTYPE_GENERIC
            myNetResource.dwUsage = 1;       //1: RESOURCEUSAGE_CONNECTABLE
            myNetResource.LocalName = localDriveName;
            myNetResource.RemoteName = remoteNetworkPath;
            myNetResource.Provider = null;

            uint nret = WNetAddConnection2(myNetResource, password, userName, 0);

            if (nret == 0)
                return true;
            else
                return false;
        }

        // localDriveName format:     @"E:"
        public static bool DeleteMap(string localDriveName)
        {
            uint nret = WNetCancelConnection2(localDriveName, 1, true);

            if (nret == 0)
                return true;
            else
                return false;
        }

        public void test()
        {
            // 注意：
            // remote、local、username的格式一定要正确，否则可能出现错误
            string remote = @"\\192.168.193.90\dir";
            string local = @"P:";
            string username = @"Domain\UserName";
            string password = @"Password";
            bool ret = MyMap.CreateMap(username, password, remote, local);
            if (ret)
            {
                //do what you want:
                // ...
                //File.Copy("q:\\test.htm", "c:\\test.htm");

                MyMap.DeleteMap(local);
            }
        }
    }



3 使用WebClient类实现
/// <summary>
    /// 3.	使用WebClient类实现
    /// </summary>
    public class WebClint
    {
        private void Test1()
        {
            try
            {
                WebClient client = new WebClient();
                NetworkCredential cred = new NetworkCredential("username", "password", "172.16.0.222");
                client.Credentials = cred;
                client.DownloadFile("file://172.16.0.222/test/111.txt", "111.txt");
            }
            catch (Exception ex)
            {
                // 如果网络很慢，而文件又很大，这时可能有超时异常（Time out）。
            }
        }

        public void Test()
        {
            try
            {
                WebClient client = new WebClient();
                NetworkCredential cred = new NetworkCredential("username", "password", "domain");
                client.Credentials = cred;
                client.DownloadFile("file://172.16.0.222/test/111.txt", "111.txt");
            }
            catch (Exception ex)
            {
                // 如果网络很慢，而文件又很大，这时可能有超时异常（Time out）。
            }
        }
    }



4 通过身份模拟实现远程资源访问
/// <summary>
    /// 1.局域网内跨主机远程文件访问类，实现模拟登录，获取凭证后即可同本机路径一样访问
    /// </summary>
    /// <remarks>
    /// invoke demo,详见方法中的TestFunc:
    /// RemoteFileHelper rm = new RemoteFileHelper();
    ///  if (rm.impersonateValidUser("administrator", "\\192.168.193.50", "******"))
    ///  {System.IO.File.Copy(@"\\192.168.193.50\123\platV0.1.zip", @"E:\\f1\\platV0.1.zip", true); 
    ///  System.IO.File.Copy(@"E:\\f1\\platV0.1.zip",@"\\192.168.193.50\123\platV0.2.zip", true);}
    /// </remarks>
    public class RemoteFileHelper
    {
        // logon types
        const int LOGON32_LOGON_INTERACTIVE = 2;
        const int LOGON32_LOGON_NETWORK = 3;
        const int LOGON32_LOGON_NEW_CREDENTIALS = 9;
        // logon providers
        const int LOGON32_PROVIDER_DEFAULT = 0;
        const int LOGON32_PROVIDER_WINNT50 = 3;
        const int LOGON32_PROVIDER_WINNT40 = 2;
        const int LOGON32_PROVIDER_WINNT35 = 1;

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern int LogonUser(String lpszUserName,
            String lpszDomain,
            String lpszPassword,
            int dwLogonType,
            int dwLogonProvider,
            ref IntPtr phToken);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern int DuplicateToken(IntPtr hToken,
            int impersonationLevel,
            ref IntPtr hNewToken);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public static extern bool RevertToSelf();

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        public static extern bool CloseHandle(IntPtr handle);

        private WindowsImpersonationContext impersonationContext;

        public bool impersonateValidUser(String userName, String domain, String password)
        {
            WindowsIdentity tempWindowsIdentity;
            IntPtr token = IntPtr.Zero;
            IntPtr tokenDuplicate = IntPtr.Zero;

            if (RevertToSelf())
            {
                // 这里使用LOGON32_LOGON_NEW_CREDENTIALS来访问远程资源。
                // 如果要（通过模拟用户获得权限）实现服务器程序，访问本地授权数据库可
                // 以用LOGON32_LOGON_INTERACTIVE
                if (LogonUser(userName, domain, password, LOGON32_LOGON_NEW_CREDENTIALS,
                    LOGON32_PROVIDER_DEFAULT, ref token) != 0)
                {
                    if (DuplicateToken(token, 2, ref tokenDuplicate) != 0)
                    {
                        tempWindowsIdentity = new WindowsIdentity(tokenDuplicate);
                        impersonationContext = tempWindowsIdentity.Impersonate();
                        if (impersonationContext != null)
                        {
                            System.AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
                            IPrincipal pr = System.Threading.Thread.CurrentPrincipal;
                            IIdentity id = pr.Identity;
                            CloseHandle(token);
                            CloseHandle(tokenDuplicate);
                            return true;
                        }
                    }
                }
            }

            if (token != IntPtr.Zero)
                CloseHandle(token);

            if (tokenDuplicate != IntPtr.Zero)
                CloseHandle(tokenDuplicate);

            return false;
        }

        public void undoImpersonation()
        {
            impersonationContext.Undo();
        }

        public void Test()
        {
            bool isImpersonated = false;
            try
            {
                if (impersonateValidUser("UserName", "Domain", "Password"))
                {
                    isImpersonated = true;
                    File.Copy(@"\\192.168.1.48\generals\now.htm", "c:\\now.htm", true);
                }
            }
            finally
            {
                if (isImpersonated)
                    undoImpersonation();
            }
        }
    }


5  总结

1.第一种通过调用Shell命令NetUse实现，有点笨拙，且在调试时未能成功调试
2.第二种和方法一有些相似之处，映射远程资源，然后访问，需要额外的映射
3.第三种采用的是httpRequest请求，采用的是http协议，传输效率低且会有超时异常出现，所以在网络速度快、传输小文件时是可以的
4.第四种通过身份模拟实现远程资源访问，一些服务器进程就是通过这种方式运行的，也是本人项目中最终采用的方案，并有详细的注释，推荐使用