C# 将文件直接从FTP传输到Azure文件存储，而无需将其保存在本地内存或磁盘中

我必须将文件从FTP传输到Azure文件存储。我的代码运行良好，但我正在内存中传输这些文件，这不是最佳做法。因此，首先我将流读取到内存中的

字节
数组中。然后我将输出上传到Azure文件存储

现在我知道最好是异步进行。但我不知道这是否可能以及如何做到

我的代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.WindowsAzure.Storage;
using System.Configuration;
using Microsoft.WindowsAzure.Storage.File;
using System.IO;
using Microsoft.Azure;
using System.Net;

namespace TransferFtpToAzure
{
    class Program
    {
        public static void Main(string[] args)
        {
            List<FileName> sourceFileList = new List<FileName>();
            List<FileName> targetFileList = new List<FileName>();

            string targetShareReference = ConfigurationManager.AppSettings["AzureShare"];
            string targetDirectoryReference = ConfigurationManager.AppSettings["Environment"] + "/" + Enums.AzureFolders.Mos + "/" + Enums.AzureFolders.In;
            string sourceURI = (ConfigurationManager.AppSettings["FtpConnectionString"] + ConfigurationManager.AppSettings["Environment"].ToUpper() +"/"+ Enums.FtpFolders.Mos + "/").Replace("\\","/");
            string sourceUser = ConfigurationManager.AppSettings["FtpServerUserName"];
            string sourcePass = ConfigurationManager.AppSettings["FtpServerPassword"];

            getFileLists(sourceURI, sourceUser, sourcePass, sourceFileList, targetShareReference, targetDirectoryReference, targetFileList);

            Console.WriteLine(sourceFileList.Count + " files found!");

            CheckLists(sourceFileList, targetFileList);
            targetFileList.Sort();

            Console.WriteLine(sourceFileList.Count + " unique files on sourceURI" + Environment.NewLine + "Attempting to move them.");

            foreach (var file in sourceFileList)
            {
                try
                {
                    CopyFile(file.fName, sourceURI, sourceUser, sourcePass, targetShareReference, targetDirectoryReference);
                }
                catch
                {
                    Console.WriteLine("There was move error with : " + file.fName);
                }
            }
        }

        public class FileName : IComparable<FileName>
        {
            public string fName { get; set; }
            public int CompareTo(FileName other)
            {
                return fName.CompareTo(other.fName);
            }
        }

        public static void CheckLists(List<FileName> sourceFileList, List<FileName> targetFileList)
        {
            for (int i = 0; i < sourceFileList.Count; i++)
            {
                if (targetFileList.BinarySearch(sourceFileList[i]) > 0)
                {
                    sourceFileList.RemoveAt(i);
                    i--;
                }
            }
        }

        public static void getFileLists(string sourceURI, string sourceUser, string sourcePass, List<FileName> sourceFileList, string targetShareReference, string targetDirectoryReference, List<FileName> targetFileList)
        {
            string line = "";
            /////////Source FileList
            FtpWebRequest sourceRequest;
            sourceRequest = (FtpWebRequest)WebRequest.Create(sourceURI);
            sourceRequest.Credentials = new NetworkCredential(sourceUser, sourcePass);
            sourceRequest.Method = WebRequestMethods.Ftp.ListDirectory;
            sourceRequest.UseBinary = true;
            sourceRequest.KeepAlive = false;
            sourceRequest.Timeout = -1;
            sourceRequest.UsePassive = true;
            FtpWebResponse sourceRespone = (FtpWebResponse)sourceRequest.GetResponse();
            //Creates a list(fileList) of the file names
            using (Stream responseStream = sourceRespone.GetResponseStream())
            {
                using (StreamReader reader = new StreamReader(responseStream))
                {
                    line = reader.ReadLine();
                    while (line != null)
                    {
                        var fileName = new FileName
                        {
                            fName = line
                        };
                        sourceFileList.Add(fileName);
                        line = reader.ReadLine();
                    }
                }
            }
            /////////////Target FileList
            CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
            CloudFileClient fileClient = storageAccount.CreateCloudFileClient();
            //var test = fileClient.ListShares();
            CloudFileShare fileShare = fileClient.GetShareReference(targetShareReference);
            if (fileShare.Exists())
            {
                CloudFileDirectory rootDirectory = fileShare.GetRootDirectoryReference();
                if (rootDirectory.Exists())
                {
                    CloudFileDirectory customDirectory = rootDirectory.GetDirectoryReference(targetDirectoryReference);
                    if (customDirectory.Exists())
                    {
                        var fileCollection = customDirectory.ListFilesAndDirectories().OfType<CloudFile>();
                        foreach (var item in fileCollection)
                        {
                            var fileName = new FileName
                            {
                                fName = item.Name
                            };
                            targetFileList.Add(fileName);
                        }
                    }
                }
            }
        }

        public static void CopyFile(string fileName, string sourceURI, string sourceUser, string sourcePass, string targetShareReference, string targetDirectoryReference)
        {
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(sourceURI + fileName);
                request.Method = WebRequestMethods.Ftp.DownloadFile;
                request.Credentials = new NetworkCredential(sourceUser, sourcePass);
                FtpWebResponse response = (FtpWebResponse)request.GetResponse();
                Stream responseStream = response.GetResponseStream();
                Upload(fileName, ToByteArray(responseStream), targetShareReference, targetDirectoryReference);
                responseStream.Close();
            }
            catch
            {
                Console.WriteLine("There was an error with :" + fileName);
            }
        }

        public static Byte[] ToByteArray(Stream stream)
        {
            MemoryStream ms = new MemoryStream();
            byte[] chunk = new byte[4096];
            int bytesRead;
            while ((bytesRead = stream.Read(chunk, 0, chunk.Length)) > 0)
            {
                ms.Write(chunk, 0, bytesRead);
            }

            return ms.ToArray();
        }

        public static bool Upload(string FileName, byte[] Image, string targetShareReference, string targetDirectoryReference)
        {
            try
            {
                CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
                CloudFileClient fileClient = storageAccount.CreateCloudFileClient();
                //var test = fileClient.ListShares();
                CloudFileShare fileShare = fileClient.GetShareReference(targetShareReference);
                if (fileShare.Exists())
                {
                    CloudFileDirectory rootDirectory = fileShare.GetRootDirectoryReference();
                    if (rootDirectory.Exists())
                    {
                        CloudFileDirectory customDirectory = rootDirectory.GetDirectoryReference(targetDirectoryReference);
                        if (customDirectory.Exists())
                        {
                            var cloudFile = customDirectory.GetFileReference(FileName);
                            using (var stream = new MemoryStream(Image, writable: false))
                            {
                                cloudFile.UploadFromStream(stream);
                            }
                        }
                    }
                }
                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用Microsoft.WindowsAzure.Storage；
使用系统配置；
使用Microsoft.WindowsAzure.Storage.File；
使用System.IO；
使用Microsoft.Azure；
Net系统；
命名空间转移
{
班级计划
{
公共静态void Main（字符串[]args）
{
List sourceFileList=新列表（）；
List targetFileList=新列表（）；
字符串targetShareReference=ConfigurationManager.AppSettings[“AzureShare”]；
字符串targetDirectoryReference=ConfigurationManager.AppSettings[“环境”]+“/”+Enums.AzureFolders.Mos+“/”+Enums.AzureFolders.In；
字符串sourceURI=（ConfigurationManager.AppSettings[“FtpConnectionString”]+ConfigurationManager.AppSettings[“环境”]。ToUpper（）+“/”+Enums.FtpFolders.Mos+“/”。替换（“\\”，“/”）；
字符串sourceUser=ConfigurationManager.AppSettings[“FtpServerUserName”]；
字符串sourcePass=ConfigurationManager.AppSettings[“FtpServerPassword”]；
GetFileList（sourceURI、sourceUser、sourcePass、sourceFileList、targetShareReference、targetDirectoryReference、targetFileList）；
Console.WriteLine（sourceFileList.Count+“找到文件！”）；
检查列表（sourceFileList、targetFileList）；
targetFileList.Sort（）；
Console.WriteLine（sourceFileList.Count+“sourceURI上的唯一文件”+Environment.NewLine+“正在尝试移动它们”）；
foreach（sourceFileList中的var文件）
{
尝试
{
CopyFile（file.fName、sourceURI、sourceUser、sourcePass、targetShareReference、targetDirectoryReference）；
}
抓住
{
WriteLine（“存在移动错误：“+file.fName”）；
}
}
}
公共类文件名：IComparable
{
公共字符串fName{get；set；}
公共整数比较（文件名其他）
{
返回fName.CompareTo（其他.fName）；
}
}
公共静态无效检查列表（列表sourceFileList、列表targetFileList）
{
for（int i=0；i0）
{
sourceFileList.RemoveAt（i）；
我--；
}
}
}
公共静态void getFileList（字符串sourceURI、字符串sourceUser、字符串sourcePass、列表sourceFileList、字符串targetShareReference、字符串targetDirectoryReference、列表targetFileList）
{
字符串行=”；
/////////源文件列表
FtpWebRequest源请求；
sourceRequest=（FtpWebRequest）WebRequest.Create（sourceURI）；
sourceRequest.Credentials=新的网络凭据（sourceUser，sourcePass）；
sourceRequest.Method=WebRequestMethods.Ftp.ListDirectory；
sourceRequest.UseBinary=true；
sourceRequest.KeepAlive=false；
sourceRequest.Timeout=-1；
sourceRequest.useAmposive=true；
FtpWebResponse SourceResponse=（FtpWebResponse）sourceRequest.GetResponse（）；
//创建文件名的列表（文件列表）
使用（Stream responseStream=sourceRespone.GetResponseStream（））
{
使用（StreamReader=新StreamReader（responseStream））
{
line=reader.ReadLine（）；
while（行！=null）
{
var fileName=新文件名
{
fName=行
};
添加（文件名）；
line=reader.ReadLine（）；
}
}
}
/////////////目标文件列表
CloudStorageAccount-storageAccount=CloudStorageAccount.Parse（CloudConfigurationManager.GetSetting（“StorageConnectionString”）；
CloudFileClient fileClient=storageAccount.CreateCloudFileClient（）；
//var test=fileClient.ListShares（）；
CloudFileShare fileShare=fileClient.GetShareReference（targetShareReference）；
if（fileShare.Exists（））
{
CloudFileDirectory根目录=fileShare.GetRootDirectoryReference（）；
if（rootDirectory.Exists（））
{
CloudFileDirectory customDirectory=rootDirectory.GetDirectoryReference（targetDirectoryReference）；
if（customDirectory.Exists（））
{
var fileCollection=customDirectory.ListFilesAndDirectories（）.OfType（）；
foreach（fileCollection中的变量项）
{
var fileName=新文件名
{
fName=item.Name
};
targetFileList.Add（文件名）；
}
}
}
}
}
公共静态void CopyFile（字符串文件名、字符串sourceURI、字符串sourceUser、字符串sourcePass、字符串targetShareReference、字符串targetDi
var zipFiles = _directory.ListFilesAndDirectories()
    .OfType<CloudFile>()
    .Where(x => x.Name.ToLower().Contains(".zip"))
    .ToList();

foreach (var zipFile in zipFiles)
{
    using (var zipArchive = new ZipArchive(zipFile.OpenRead()))
    {
        foreach (var entry in zipArchive.Entries)
        {
            if (entry.Length > 0)
            {
                CloudFile extractedFile = _directory.GetFileReference(entry.Name);

                using (var entryStream = entry.Open())
                {
                    byte[] buffer = new byte[16 * 1024];
                    using (var ms = extractedFile.OpenWrite(entry.Length))
                    {
                        int read;
                        while ((read = entryStream.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            ms.Write(buffer, 0, read);
                        }
                    }
                }
            }
        }
    }               
}