C# 遠程連接共享文件夾下載文件

遠程連接FTP並下載文件

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
 
namespace MyFtp
{
    public class FtpHandle
    {
        public string strUserName;
        public string strUserPwd;
        public string strUrl;
        public FtpWebRequest request;
 
        public FtpHandle(string strUserName,string strUserPwd,string strIPAdd,string strPort,string strFolder)
        {
            this.strUserName = strUserName;
            this.strUserPwd = strUserPwd;
            this.strUrl = @"ftp://" + strIPAdd + @":" + strPort + @"/" + strFolder;
        }
 
        //創建FTP連接
        private void Connect()
        {
            this.request = FtpWebRequest.Create(new Uri(this.strUrl)) as FtpWebRequest;
            this.request.UseBinary = true;   //指定數據傳輸類型為二進制
            this.request.Credentials = new NetworkCredential(this.strUserName,strUserPwd);  //設置用戶名和密碼
        }
 
        /// <summary>
        /// 從ftp服務器下載文件的功能
        /// </summary>
        /// <param name="strTargetFile">本地目標路徑</param>
        /// <returns></returns>
        public bool Download(string strTargetFile)
        {
            try
            {                
                if (File.Exists(strTargetFile))
                {
                    File.Delete(strTargetFile);//文件夾存在同名文件，直接刪除同名文件
                }
                Connect();
                FtpWebResponse response = (FtpWebResponse)request.GetResponse();
                Stream ftpStream = response.GetResponseStream();
                long cl = response.ContentLength;
                int bufferSize = 2048;
                int readCount;
                byte[] buffer = new byte[bufferSize];
                readCount = ftpStream.Read(buffer, 0, bufferSize);
                FileStream outputStream = new FileStream(strTargetFile, FileMode.Create);
                while (readCount > 0)
                {
                    outputStream.Write(buffer, 0, readCount);
                    readCount = ftpStream.Read(buffer, 0, bufferSize);
                }
                ftpStream.Close();
                outputStream.Close();
                response.Close();                
                return true;
            }
            catch (Exception ex)
            {                
                throw ex;
            }
        }
    }
}

　　遠程共享文件夾並下載文件

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
 
namespace WindowsFormsApp1
{
    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;
    }
 
    public class NetworkConnection
    {
        //創建網絡連接
        [DllImport("mpr.dll")]
        public static extern int WNetAddConnection2A(NETRESOURCE[] lpNetResource, string lpPassword, string lpUserName, int dwFlags);
 
        //取消現有網絡連接
        [DllImport("mpr.dll")]
        public static extern int WNetCancelConnection2A(string sharename, int dwFlags, int fForce);
 
        /// <summary>
        /// 連接遠程共享文件夾
        /// </summary>
        /// <param name="remotePath">文件夾路徑</param>
        /// <param name="username"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        public static int Connect(string remotePath, string username, string password)
        {
            //必須是\\127.0.1.1\test格式，最后不能帶斜杠
            if (remotePath.EndsWith("\\"))
            {
                remotePath = remotePath.Substring(0, remotePath.Length - 1);
            }
            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].lpRemoteName = remotePath;
            //連接前先斷開一次，否則會報錯
            Disconnect(remotePath);
            int ret = WNetAddConnection2A(share_driver, password, username, 1);
            return ret;
        }
 
        /// <summary>
        /// 斷開遠程共享文件夾
        /// </summary>
        /// <param name="remotePath"></param>
        /// <returns></returns>
        public static int Disconnect(string remotePath)
        {
            try
            {
                //必須是\\127.0.1.1\test格式，最后不能帶斜杠
                if (remotePath.EndsWith("\\"))
                {
                    remotePath = remotePath.Substring(0, remotePath.Length - 1);
                }
                int status = WNetCancelConnection2A(remotePath, 1, 1);
                return status;
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
 
        /// <summary>
        /// 錯誤信息
        /// </summary>
        /// <param name="status"></param>
        /// <returns></returns>
        public static string GetErrorString(int status)
        {
            string strDesc = string.Empty;
            switch (status)
            {
                case 0:
                    strDesc = "Success";
                    break;
                case 5:
                    strDesc = "網絡訪問拒絕";
                    break;
                case 86:
                case 1326:
                    strDesc = "無效的用戶名或密碼";
                    break;
                case 1203:
                    strDesc = "無效的網絡路徑";
                    break;
                case 1219:
                    strDesc = "提供的憑據與已存在的憑據集沖突";
                    break;
                default:
                    strDesc = "無法連接網絡路徑，錯誤代碼：";
                    break;
            }
            return strDesc;
        }
 
        /// <summary>
        /// cmd命令刪除本機網絡磁盤緩存用戶
        /// </summary>
        public static void DelCacheUser()
        {
            try
            {
                string strCommand = @"NET USE * /DELETE /Y";
                Process p = new Process();
                ProcessStartInfo startInfo = new ProcessStartInfo();
                startInfo.FileName = "cmd.exe";
                startInfo.Arguments = "/C " + strCommand;
                startInfo.UseShellExecute = false;
                startInfo.RedirectStandardInput = false;
                startInfo.RedirectStandardOutput = true;
                startInfo.CreateNoWindow = true;
                p.StartInfo = startInfo;
                p.Start();
                p.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
 
    public class DiskHandle
    {
        public string userName;
        public string passWord;        
 
        public DiskHandle(string strUserName, string strPwd)
        {
            this.userName = strUserName;
            this.passWord = strPwd;            
        }
 
        /// <summary>
        /// 共享路徑下載文件
        /// </summary>
        /// <param name="strFullPath">遠程文件全路徑</param>
        /// <param name="strTargetFile">保存到本地的文件路徑</param>
        /// <param name="errorInfo">錯誤信息</param>
        /// <returns></returns>
        public bool DownLoad(string strFullPath, string strTargetFile, out string errorInfo)
        {
            errorInfo = string.Empty;
            try
            {
                string strRemotePath = Path.GetDirectoryName(strFullPath);
                if (!File.Exists(strFullPath))
                {
                    return false;
                }
                int status = NetworkConnection.Connect(strRemotePath, this.userName, this.passWord);  //連接遠程共享文件夾
                if (status != 0)
                {
                    errorInfo = strFullPath + "," + NetworkConnection.GetErrorString(status);
                    return false;
                }
                else
                {                    
                    if (File.Exists(strTargetFile))
                    {
                        File.Delete(strTargetFile);//文件夾存在同名文件，直接刪除同名文件
                    }
 
                    using (FileStream fileStream = new FileStream(strFullPath, FileMode.Open))
                    {
                        //讀取
                        int readCount;
                        int bufferSize = 2048;
                        byte[] buffer = new byte[bufferSize];
                        readCount = fileStream.Read(buffer, 0, buffer.Length);
                        FileStream outputStream = new FileStream(strTargetFile, FileMode.Create);
                        while (readCount > 0)
                        {
                            outputStream.Write(buffer, 0, readCount);
                            readCount = fileStream.Read(buffer, 0, bufferSize);
                        }
                        outputStream.Close();
                    }
                    return true;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}