public void CancelFileReceive(string taskid)
{
if (PaddingReceiveTask == null)
{
return;
}
ulong pkgid = ulong.Parse(taskid);
FileTaskInfo task = PaddingReceiveTask.SingleOrDefault(m => m.PackageID == pkgid);
if (task == null)
{
return;
}
PaddingReceiveTask.Remove(task);
OnTaskDiscardRequired(new FileTaskEventArgs(task));
}
//选择保存文件夹的地方
public string SelectSaveFolder(string description, string currentPath, string pkgid, string idx)
{
if (_folderBrowserDialog == null)
{
_folderBrowserDialog = new FolderBrowserDialog();
}
_folderBrowserDialog.Description = description;
if (!string.IsNullOrEmpty(currentPath) && System.IO.Directory.Exists(currentPath))
{
_folderBrowserDialog.SelectedPath = currentPath;
}
if (_folderBrowserDialog.ShowDialog() == DialogResult.OK)
{
Env.ClientConfig.FunctionConfig.Share_LastSelectedPath = _folderBrowserDialog.SelectedPath;
//
ulong pid = ulong.Parse(pkgid);
int index = int.Parse(idx);
FileTaskInfo task = PaddingReceiveTask.SingleOrDefault(m => m.PackageID == pid);
if (task == null || task.TaskList.Count <= index || index < 0)
{
return("");
}
task.TaskList[index].FullPath = _folderBrowserDialog.SelectedPath;
if (Env.ClientConfig.FunctionConfig.Share_UseSameLocationToSave)
{
task.TaskList.ForEach(s => s.FullPath = _folderBrowserDialog.SelectedPath);
}
return(_folderBrowserDialog.SelectedPath);
}
else
{
return("");
}
}
/// <summary>
/// 检测任务是否可以启动
/// </summary>
void StartReceive()
{
if ((Config.TasksMultiReceiveCount > 0 && activeReceiveItems.Count >= Config.TasksMultiReceiveCount) || ReceiveTask.Count == 0)
{
return;
}
//RunCount-Fix thread limit issue
int runCount = 0;
foreach (FileTaskInfo t in ReceiveTask)
{
for (int j = 0; j < t.TaskList.Count; j++)
{
if (t.TaskList[j].State == FileTaskItemState.Scheduled)
{
FileTaskInfo task = t;
FileTaskItem item = task.TaskList[j];
//开始传输
FileReceiveRequiredEventArgs e = new FileReceiveRequiredEventArgs(task, item);
OnFileReceiveRequiring(e);
if (!e.IsHandled)
{
OnFileReceiveRequired(e);
}
runCount++;
//标记状态
MarkReceiveTaskItemState(item, FileTaskItemState.Initializing);
if (activeReceiveItems.Count + runCount >= Config.TasksMultiReceiveCount && Config.TasksMultiReceiveCount > 0)
{
return; //超过数目则退出
}
}
}
}
}
/// <summary>
/// 查询任务信息
/// </summary>
/// <param name="packageId"></param>
/// <param name="taskIndex"></param>
/// <returns></returns>
public FileTaskItem QuerySendTask(ulong packageId, int taskIndex, IPAddress addr)
{
if (!SendTask.ContainsKey(packageId) || taskIndex < 0)
{
return(null);
}
lock (SendTask)
{
FileTaskInfo fti = SendTask[packageId];
if (taskIndex >= fti.TaskList.Count || addr.ToString() != fti.RemoteHost.HostSub.Ipv4Address.Address.ToString())
{
return(null);
}
else
{
FileTaskItem fi = fti.TaskList[taskIndex];
OnSendItemStart(new FileTaskEventArgs(fti, fi));
return(fi);
}
}
}
/// <summary>
/// 添加文件传输任务
/// </summary>
/// <param name="task">任务信息</param>
public void AddSendTask(FileTaskInfo task)
{
if (task == null)
{
throw new ArgumentNullException();
}
if (task.RemoteHost == null || task.TaskList == null || task.TaskList.Count == 0 || task.PackageID == 0)
{
throw new ArgumentException();
}
if (SendTask.ContainsKey(task.PackageID))
{
return;
}
//进行必要的初始化
task.Direction = FileTransferDirection.Send;
task.TaskList.ForEach(s => s.TaskInfo = task); //设置集合关系
SendTask.Add(task.PackageID, task);
OnSendTaskAdded(new FileTaskEventArgs(task));
}
public void ReceiveFileRequired(FileTaskInfo task)
{
if (task == null)
{
return;
}
if (!browser.IsReady())
{
notReadyScriptList.Add(task);
return;
}
if (PaddingReceiveTask == null)
{
PaddingReceiveTask = new List <FileTaskInfo>();
}
if (PaddingReceiveTask.FindIndex(s => s.PackageID == task.PackageID) == -1)
{
PaddingReceiveTask.Add(task); //FIX:重试接收重复包编号错误
}
browser.InvokeScript("receiveFileRequired", task.ToJsonInfo(), Env.ClientConfig.FunctionConfig.Share_UseSameLocationToSave);
}
/// <summary>
/// 将初始化的任务信息转换为JSON格式
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public static string ToJsonInfo(this FileTaskInfo task)
{
System.Text.StringBuilder sb = new StringBuilder();
sb.AppendLine("{");
sb.AppendFormat("pkgid:'{0}',host:'{1}',isretry:{2},", task.PackageID, task.RemoteHost.HostSub.Ipv4Address.ToString(), task.IsRetry ? 1 : 0);
sb.AppendLine("tasks:[");
for (int i = 0; i < task.TaskList.Count; i++)
{
if (i < task.TaskList.Count - 1)
{
sb.Append(task.TaskList[i].ToJsonInfo());
sb.AppendLine(",");
}
else
{
sb.AppendLine(task.TaskList[i].ToJsonInfo());
}
}
sb.AppendLine("]");
sb.AppendLine("}");
return(sb.ToString());
}
/// <summary>
/// 添加文件传输任务
/// </summary>
/// <param name="task">任务信息</param>
public void AddReceiveTask(FileTaskInfo task)
{
if (task == null)
{
throw new ArgumentNullException();
}
if (task.RemoteHost == null || task.TaskList == null || task.TaskList.Count == 0 || task.PackageID == 0)
{
throw new ArgumentException();
}
//进行必要的初始化
task.Direction = FileTransferDirection.Receive;
task.TaskList.ForEach(s => s.TaskInfo = task); //设置集合关系
if (this.ReceiveTask.Contains(task))
{
return;
}
this.ReceiveTask.Add(task);
this.OnReceiveTaskAdded(new FileTaskEventArgs(task));
StartReceive();
}
//发送文件夹
void PerformSendDirectory(TcpClient client, FileTaskInfo task, FileTaskItem item)
{
NetworkStream stream = null;
try
{
stream = client.GetStream();
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
return;
}
string currentDirectory = item.FullPath; //当前处理路径
Stack <string> directoryStack = new Stack <string>(); //文件夹栈
directoryStack.Push("");
bool needUpdateTotal = item.TotalSize == 0; //是否需要在发送的时候更新统计
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Processing);
item.StartTime = DateTime.Now;
using (stream)
{
while (!string.IsNullOrEmpty(currentDirectory) || directoryStack.Count > 0)
{
if (!PerformSendDirectory_SendCreateDirCommand(currentDirectory, stream, task, item))
{
return;
}
if (string.IsNullOrEmpty(currentDirectory))
{
if (directoryStack.Count > 0)
{
currentDirectory = directoryStack.Pop(); //当前是空目录，则向上递归
}
continue;
}
//扫描目录和文件
string[] files = null, directories = null;
try
{
files = System.IO.Directory.GetFiles(currentDirectory);
directories = System.IO.Directory.GetDirectories(currentDirectory);
item.FolderCount += directories.Length;
item.FileCount += files.Length;
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
OnFileSystemOperationError(new FileSystemOperationErrorEventArgs(FileSystemOperationType.QueryDirectory, item.FullPath, task.RemoteHost));
return;
}
//优先发送文件
foreach (var f in files)
{
if (!PerformSendDirectory_SendFilesInDirectory(f, stream, task, item, needUpdateTotal))
{
return;
}
}
//扫描子目录
if (directories.Length > 0)
{
directoryStack.Push("");
Array.ForEach(directories, s => { directoryStack.Push(s); });
currentDirectory = directoryStack.Pop(); //取出一个文件夹来发送
}
else
{
//如果没有子目录，则置空当前目录，以命令流程向上返回
currentDirectory = null;
}
}
if (item.State != FileTaskItemState.Failure)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Finished);
}
}
}
/// <summary>
/// 创建 FileTaskEventArgs class 的新实例
/// </summary>
public FileTaskEventArgs(FileTaskInfo taskInfo)
{
TaskInfo = taskInfo;
IsHandled = false;
}
/// <summary>
/// 创建一个新的 SendTaskExpires 对象.
/// </summary>
public SendTaskExpires(FileTaskInfo task)
{
Task = task;
InitializeComponent();
}
/// <summary>
/// 创建一个新的 SendTaskExpires 对象.
/// </summary>
public SendTaskRelease(FileTaskInfo task)
{
Task = task;
InitializeComponent();
}
//传输文件
bool ProcessFileTransfer(TcpClient client, NetworkStream netStream, FileTaskInfo task, FileTaskItem item, string currentDirectory, string fileName, ulong fileSize, bool updateTotal)
{
FileStream writer = null;
string path = Path.Combine(currentDirectory, fileName);
try
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
writer = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write);
}
catch (Exception)
{
OnFileSystemOperationError(new FileSystemOperationErrorEventArgs(FileSystemOperationType.CreateFile, path, task.RemoteHost));
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
return(false);
}
//初始化传输参数
item.CurrentFileSize = fileSize;
item.CurrentFileTransfered = 0ul;
item.CurrentName = fileName;
if (updateTotal)
{
item.TotalSize += fileSize;
}
item.FileCount++;
using (writer)
{
byte[] buffer = new byte[SendBuffer];
int length = 0;
int readlength = buffer.Length;
if ((ulong)readlength > item.CurrentFileSize)
{
readlength = (int)item.CurrentFileSize;
}
while (item.State != FileTaskItemState.Canceling && client.Connected && item.CurrentFileTransfered < item.CurrentFileSize && (length = ReceiveByBuffer(netStream, buffer, readlength)) > 0)
{
if (!WriteBufferToFile(task.RemoteHost, writer, path, buffer, length))
{
break;
}
item.CurrentFileTransfered += (ulong)length;
item.FinishedSize += (ulong)length;
readlength = buffer.Length;
if ((ulong)readlength > item.CurrentFileSize - item.CurrentFileTransfered)
{
readlength = (int)(item.CurrentFileSize - item.CurrentFileTransfered);
}
}
writer.Close();
System.Diagnostics.Debug.Assert(item.CurrentFileTransfered <= item.CurrentFileSize, string.Format("传输文件异常。{0} 预计长度：{1} ，实际写入 {2}", item.CurrentName, item.CurrentFileSize, item.CurrentFileTransfered));
if (item.CurrentFileTransfered < item.CurrentFileSize)
{
if (item.State != FileTaskItemState.Canceling)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
}
return(false);
}
else
{
item.FinishedFileCount++;
return(true);
}
}
}
/// <summary>
/// 接收文件夹
/// </summary>
/// <param name="client"></param>
/// <param name="task"></param>
/// <param name="item"></param>
void PerformFileReceive_Folder(TcpClient client, FileTaskInfo task, FileTaskItem item)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Initializing);
//创建网络流
NetworkStream netStream = null;
try
{
netStream = client.GetStream();
}
catch (Exception)
{
OnNetworkError(new EventArgs());
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
return;
}
bool updateTotal = item.TotalSize == 0; //是否在更新进度的时候需要更新总数
using (netStream)
{
//发送文件请求
PackedNetworkMessage pnm = MessagePacker.BuildNetworkMessage(Message.Create(task.RemoteHost, task.RemoteHost.HostSub.Ipv4Address, Config.GetRandomTick(), Config.HostName, Config.HostUserName, Consts.Commands.GetDirFiles, 0ul, string.Format("{0:x}:{1:x}:0:", task.PackageID, item.Index), ""));
if (!SendDataInBuffer(netStream, pnm.Data, pnm.Data.Length))
{
return; //发送请求
}
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Processing);
item.StartTime = DateTime.Now;
string filename;
ulong size;
bool isFolder, isRet;
Stack <string> pathStack = new Stack <string>();
string currentPath = item.FullPath;
while (client.Connected && item.State != FileTaskItemState.Canceling && ReadCmdHeader(netStream, task.RemoteHost, out filename, out size, out isFolder, out isRet))
{
if (isRet)
{
if (pathStack.Count > 0)
{
currentPath = pathStack.Pop();
if (pathStack.Count == 0)
{
break; //Fixed: 当当前队列不再有信息时，其实接收已经完成了。因为当前队列中最后一个肯定是文件夹自己。
}
}
else
{
break;
}
}
else if (isFolder)
{
//建立文件夹
if (!ProcessDirCmd(item, ref currentPath, pathStack, filename, updateTotal))
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
return;
}
}
else
{
//传文件
if (!ProcessFileTransfer(client, netStream, task, item, currentPath, filename, size, updateTotal))
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
return;
}
}
}
netStream.Close();
}
if (item.State == FileTaskItemState.Canceling)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Canceled);
}
else if (item.State != FileTaskItemState.Failure)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Finished);
}
}
/// <summary>
/// 发送单个文件
/// </summary>
/// <param name="client"></param>
/// <param name="task"></param>
/// <param name="item"></param>
void PerformSendFile(TcpClient client, FileTaskInfo task, FileTaskItem item)
{
System.IO.FileStream fs = null;
System.Net.Sockets.NetworkStream writer = null;
try
{
writer = client.GetStream();
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
return;
}
try
{
fs = new System.IO.FileStream(item.FullPath, System.IO.FileMode.Open, System.IO.FileAccess.Read);
}
catch (Exception)
{
if (writer != null)
{
writer.Close();
}
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
OnFileSystemOperationError(new FileSystemOperationErrorEventArgs(FileSystemOperationType.OpenFileToSend, item.FullPath, task.RemoteHost));
return;
}
using (fs)
{
//检测断点数据是否正确
if (item.CurrentFileTransfered < 0 || item.CurrentFileTransfered > (ulong)fs.Length)
{
item.CurrentFileTransfered = 0;
}
fs.Seek((long)item.CurrentFileTransfered, System.IO.SeekOrigin.Begin);
//设置当前任务信息
item.CurrentFileSize = (ulong)fs.Length;
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Processing);
item.StartTime = DateTime.Now;
using (writer)
{
byte[] buffer = new byte[SendBuffer]; //缓冲区
while (item.CurrentFileTransfered < item.CurrentFileSize)
{
int bytesRead = fs.Read(buffer, 0, buffer.Length);
try
{
writer.Write(buffer, 0, bytesRead);
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
break;
}
//更新进度
item.CurrentFileTransfered += (ulong)bytesRead;
item.FinishedSize += (ulong)bytesRead;
}
item.FinishedFileCount++;
writer.Close();
}
fs.Close();
//标记任务完成
if (item.State != FileTaskItemState.Failure)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Finished);
}
}
}
//发送要求创建文件命令
bool PerformSendDirectory_SendCreateDirCommand(string path, NetworkStream stream, FileTaskInfo task, FileTaskItem item)
{
string strCMD = string.Format(":{0}:{1}:{2:x}:", string.IsNullOrEmpty(path) ? "." : System.IO.Path.GetFileName(path), 0, (int)(string.IsNullOrEmpty(path) ? Consts.Cmd_FileType_Option.RetParent : Consts.Cmd_FileType_Option.Dir));
byte[] bytes = null;
if (task.RemoteHost.IsEnhancedContractEnabled)
{
bytes = System.Text.Encoding.Unicode.GetBytes(strCMD);
}
else
{
bytes = System.Text.Encoding.Default.GetBytes(strCMD);
}
if (!string.IsNullOrEmpty(path))
{
item.FinishedFolderCount++;
}
try
{
stream.Write(System.Text.Encoding.Default.GetBytes((bytes.Length + 4).ToString("x4")), 0, 4);
stream.Write(bytes, 0, bytes.Length);
return(true);
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
return(false);
}
}
/// <summary>
/// 创建 FileTaskEventArgs class 的新实例
/// </summary>
public FileTaskEventArgs(FileTaskInfo taskInfo, FileTaskItem taskItem)
{
TaskInfo = taskInfo;
TaskItem = taskItem;
IsHandled = false;
}
/// <summary>
/// 接收文件
/// </summary>
/// <param name="client"></param>
/// <param name="task"></param>
/// <param name="item"></param>
void PerformFileReceive_File(TcpClient client, FileTaskInfo task, FileTaskItem item)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Initializing);
//创建文件
System.IO.FileInfo fileinfo = new FileInfo(item.FullPath);
if (fileinfo.Exists)
{
item.CurrentFileTransfered = (ulong)fileinfo.Length;
}
if (item.CurrentFileSize <= item.CurrentFileTransfered)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Finished);
return;
}
//创建文件
System.IO.FileStream writer = null;
try
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(item.FullPath));
writer = fileinfo.OpenWrite();
}
catch (Exception)
{
OnFileSystemOperationError(new FileSystemOperationErrorEventArgs(FileSystemOperationType.CreateFile, item.FullPath, task.RemoteHost));
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
return;
}
//创建网络流
NetworkStream netStream = null;
try
{
netStream = client.GetStream();
}
catch (Exception)
{
OnNetworkError(new EventArgs());
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
return;
}
using (writer)
{
using (netStream)
{
//发送文件请求
PackedNetworkMessage pnm = MessagePacker.BuildNetworkMessage(Message.Create(task.RemoteHost, task.RemoteHost.HostSub.Ipv4Address, Config.GetRandomTick(), Config.HostName, Config.HostUserName, Consts.Commands.GetFileData, 0ul, string.Format("{0:x}:{1:x}:{2}", task.PackageID, item.Index, item.CurrentFileTransfered), ""));
if (!SendDataInBuffer(netStream, pnm.Data, pnm.Data.Length))
{
return; //发送请求
}
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Processing);
item.StartTime = DateTime.Now;
byte[] buffer = new byte[SendBuffer];
int length = buffer.Length;
while (item.State != FileTaskItemState.Canceling && client.Connected && (length = ReceiveByBuffer(netStream, buffer, length)) > 0)
{
if (!WriteBufferToFile(task.RemoteHost, writer, item.FullPath, buffer, length))
{
return;
}
item.CurrentFileTransfered += (ulong)length;
item.FinishedSize += (ulong)length;
//判断还有多少
length = buffer.Length;
ulong restLength = item.CurrentFileSize - item.CurrentFileTransfered;
if (restLength < (ulong)length)
{
length = (int)restLength;
}
}
}
}
//判断是否完成
if (item.State == FileTaskItemState.Canceling)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Canceled);
}
else if (item.CurrentFileTransfered == item.CurrentFileSize)
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Finished);
}
else
{
TaskManager.MarkReceiveTaskItemState(item, FileTaskItemState.Failure);
}
}
/// <summary>
/// 标记一个任务项目状态，并检查任务是否完成
/// </summary>
/// <param name="item">任务条目</param>
/// <param name="state">状态</param>
internal void MarkReceiveTaskItemState(FileTaskItem item, FileTaskItemState state)
{
if (item.State == state)
{
return;
}
if (state == FileTaskItemState.Finished || state == FileTaskItemState.Failure)
{
//退出传输状态
this.activeReceiveItems.Remove(item);
OnTaskItemProgressChanged(new FileTaskEventArgs(item.TaskInfo, item));
this.EnsureReceiveStateUpdateTimerState();
}
item.State = state;
OnTaskItemStateChanged(new FileTaskEventArgs(item.TaskInfo, item));
//是否需要更新状态
if (state == FileTaskItemState.Processing)
{
this.activeReceiveItems.Add(item);
this.EnsureReceiveStateUpdateTimerState();
}
//如果是完成了，那就查找下这个任务是不是全部完成了，如果是的话，那就删掉任务
if ((state == FileTaskItemState.Finished || state == FileTaskItemState.Failure))
{
//检测任务完成
if (item.TaskInfo.TaskList.Count(s => s.State != FileTaskItemState.Finished && s.State != FileTaskItemState.Failure) == 0)
{
FileTaskInfo task = item.TaskInfo;
this.OnReceiveTaskFinished(new FileTaskEventArgs(task));
this.ReceiveTask.Remove(task);
//检测是否有失败的，如果有就将请求重新发送以便重试
for (int i = task.TaskList.Count - 1; i >= 0; i--)
{
if (task.TaskList[i].State != FileTaskItemState.Failure)
{
task.TaskList.RemoveAt(i); //如果是成功的，则移除
}
else
{
task.TaskList[i].State = FileTaskItemState.Scheduled; //重置任务的当前状态
if (!task.TaskList[i].IsFolder)
{
task.TaskList[i].FullPath = System.IO.Path.GetDirectoryName(task.TaskList[i].FullPath);
}
}
}
if (task.TaskList.Count > 0)
{
var e = new FileTaskEventArgs(task);
OnFileReceiveTaskReDroped(e);
if (!e.IsHandled)
{
OnFileReceiveTaskDiscarded(e);
}
}
}
StartReceive();
}
}
/// <summary>
/// 创建一个新的 FileReceiveEventArgs 对象.
/// </summary>
public FileReceiveRequiredEventArgs(FileTaskInfo task, FileTaskItem item)
{
Task = task;
Item = item;
IsHandled = false;
}
//发送文件夹中的文件
bool PerformSendDirectory_SendFilesInDirectory(string path, NetworkStream stream, FileTaskInfo task, FileTaskItem item, bool updateTotal)
{
System.IO.FileInfo fileinfo = new System.IO.FileInfo(path);
if (!fileinfo.Exists)
{
OnFileSystemOperationError(new FileSystemOperationErrorEventArgs(FileSystemOperationType.OpenFileToSend, path, task.RemoteHost));
}
if (updateTotal)
{
item.TotalSize += (ulong)fileinfo.Length;
}
item.CurrentName = fileinfo.Name;
item.CurrentFileTransfered = 0;
item.CurrentFileSize = (ulong)fileinfo.Length;
string strCMD = string.Format(":{0}:{1:x}:{2:x}:", fileinfo.Name, fileinfo.Length, (int)Consts.Cmd_FileType_Option.Regular);
byte[] bytes = null;
if (task.RemoteHost.IsEnhancedContractEnabled)
{
bytes = System.Text.Encoding.Unicode.GetBytes(strCMD);
}
else
{
bytes = System.Text.Encoding.Default.GetBytes(strCMD);
}
try
{
stream.Write(System.Text.Encoding.Default.GetBytes((bytes.Length + 4).ToString("x4")), 0, 4);
stream.Write(bytes, 0, bytes.Length);
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
return(false);
}
//写入文件数据
FileStream reader = null;
try
{
reader = fileinfo.OpenRead();
}
catch (Exception)
{
OnFileSystemOperationError(new FileSystemOperationErrorEventArgs(FileSystemOperationType.OpenFileToSend, path, task.RemoteHost));
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
return(false);
}
using (reader)
{
byte[] buffer = new byte[SendBuffer];
while (item.CurrentFileTransfered < (ulong)reader.Length)
{
int bytesRead = reader.Read(buffer, 0, buffer.Length);
item.CurrentFileTransfered += (ulong)bytesRead;
item.FinishedSize += (ulong)bytesRead;
try
{
stream.Write(buffer, 0, bytesRead);
}
catch (Exception)
{
TaskManager.MarkSendTaskItemState(item, FileTaskItemState.Failure);
return(false);
}
}
reader.Close();
}
item.FinishedFileCount++;
return(true);
}
