c#异步文件传输功能
服务器端：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Runtime.InteropServices;
using System.IO;
namespace RecvFileServer
{
/// <summary>
/// 本文件主要处理多文件传输，首先做单文件传输，然后做多文件进行传输，今天完成对多文件发送.今天一定要写完成对多文件传输.能够进行测试成功
/// </summary>
[StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
struct SendFileMessage
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public char[] fileName;
/// <summary>
/// 传递的包类型。1 代表发送要创建的文件，2. 代表为第一条数据,但不是最后一条数据 3. 为中间传输数据，并非为最后一个，4. 代表文件最后一条数据 5. 第一条也是最后一条文件数据
/// 1. 首先能够实现基本的单文件传输，单文件传输以后，便可以实现基本的多文件传输。
/// </summary>
public char typeMessage;
//有效数据长度
public int effDataLength;
//有效数据
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
public byte[] effData;
}
public class StateObject
{
// Client socket.
public Socket workSocket = null;
// Size of receive buffer.
public const int BufferSize = 1037;
// Receive buffer.
public byte[] buffer = new byte[BufferSize];
//在此处,每个socket有对应额的一个FileStream
}
public class AsynchronousSocketServer
{
public static FileStream writefile;
public static ManualResetEvent allDone = new ManualResetEvent(false);
private static Socket serverSocket;
public static void StartAsynchronousSocket()
{
Console.WriteLine("服务器启动成功");
IPAddress ipAddress = IPAddress.Parse("192.168.0.40");
IPEndPoint ipEndPoint = new IPEndPoint(ipAddress, 8083);
serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
serverSocket.Bind(ipEndPoint);
serverSocket.Listen(1000);
while (true)
{
allDone.Reset();
serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), serverSocket);
allDone.WaitOne();
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static void AcceptCallback(IAsyncResult ar)
{
//在此处输出连接到的ip地址。当连接成功的时候，进行接收数据。handle指代的是连接到的client的socket
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
allDone.Set();
StateObject states = new StateObject();
states.workSocket = handler;
handler.BeginReceive(states.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(RecvCallback), states);
}
public static void RecvCallback(IAsyncResult ar)
{
//在此处进行设置一下，将其中的放入进去
String content = String.Empty;
//获取StateObject实例，并获取StateObject中的socket
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.workSocket;
//从client socket接收数据
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
//判断读写的数据是否完成。如果没有，继续读写,如何判断是否接受完成呢？不能够使用EOF呢
if (bytesRead == 1037)
{
//获取传输到的数据,并转为Unicode字符，以便支持中文.在此处进行开始获取得到的数据，然后将获取到的数据转变为结构体类型
SendFileMessage sfm = new SendFileMessage();
sfm = (SendFileMessage)ByteToStruct(state.buffer, typeof(SendFileMessage));
Console.WriteLine(sfm.typeMessage);
//此处暂时把1去掉，改用在读取第一次的时候进行创建
if (sfm.typeMessage == '1')
{
}
else if (sfm.typeMessage == '2') //2 代表的是文件对应的第一次，需要打开对应的文件，是否需要在SocketState中进行呢？
{
//每个客户端的连接可以的，依次放入其中呢。对每个客户进行的连接，我们都需要设置并将其中的连接放入到里面。现在都先放入debug文件目录下
String strPath = new String(sfm.fileName);
writefile = new FileStream(strPath + ".jpg", FileMode.OpenOrCreate);
writefile.Write(sfm.effData, 0, sfm.effDataLength);
}
else if (sfm.typeMessage == '3')
{
//如何根据其中的设置来进行。重新写发送部分，先能够成功接收一张<1K，=1K,>1K的文件;
writefile.Write(sfm.effData, 0, sfm.effDataLength);
}
else if (sfm.typeMessage == '4')
{
//代表最后一段数据，接受后写入到文件中，然后将文件关闭.每次打开后关闭，打开后关闭.在此处判断并将设置出来
writefile.Write(sfm.effData, 0, sfm.effDataLength);
writefile.Close();
}
else if (sfm.typeMessage =='5')
{
//如果此处为5代表文件大小小于1024字节，可以打开文件并进行存储.打开文件，把获取到的数据保存到新建的文件夹中.在此处接收成功。
//单文件进行传输，并将文件放入到里面
string strPath = new String(sfm.fileName);
writefile = new FileStream(strPath + ".jpg", FileMode.OpenOrCreate);
writefile.Write(sfm.effData, 0, sfm.effDataLength);
writefile.Close();
}
}
}
//使用异步接收，继续接收数据,将接收到的数据写入到文件中去，并将数据放入文件中去。成功接收两张图片。一个是<1024,一个是>1024并且余数！=0
handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(RecvCallback), state);
}
public static byte[] StructToBytes(object structObj, int size)
{
int len = Marshal.SizeOf(structObj);
byte[] bytes = new byte[size];
IntPtr structPtr = Marshal.AllocHGlobal(size);
//将结构体拷到分配好的内存空间。
Marshal.StructureToPtr(structObj, structPtr, false);
//从内存空间拷贝到byte 数组欧拉模型外的另一种相机模型UVN系统。编写
Marshal.Copy(structPtr, bytes, 0, size);
//释放内存空间，为每个部分做大量的要求，并把其中的要求放入进去，背面消除方式。FreeHGlobal.
Marshal.FreeHGlobal(structPtr);
return bytes;
}
public static object ByteToStruct(byte[] bytes, Type type)
{
int size = Marshal.SizeOf(type);
if (size > bytes.Length)
{
return null;
}
//分配结构体空间，并把结构体AllocHGlobal(size);
IntPtr structPtr = Marshal.AllocHGlobal(size);
//将byte数组拷贝到分配好的内存空间
Marshal.Copy(bytes, 0, structPtr, size);
//将内存空间转换为目标结构体
object obj = Marshal.PtrToStructure(structPtr, type);
//释放内存空间。
Marshal.FreeHGlobal(structPtr);
return obj;
}
}
}
客户端：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.IO;
using System.Runtime.InteropServices;
namespace SendFileClient
{
[StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]
struct SendFileMessage
{
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public char[] fileName;
//传递的包类型。1 代表发送要创建的文件，2. 代表为第一条数据 3. 为中间传输数据，并非为最后一个，4. 代表文件最后一条数据 5.第一条也是最后一条文件数据
public char typeMessage;
//有效数据长度
public int effDataLength;
//有效数据
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
public byte[] effData;
}
class AsynchronousSocketClient
{
public static ManualResetEvent allDone = new ManualResetEvent(false);
public static Socket client;
public static void StartAsynchronousSocket()
{
IPAddress ipAddress = IPAddress.Parse("192.168.0.40");
IPEndPoint ipPoint = new IPEndPoint(ipAddress, 8083);
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
client.BeginConnect(ipPoint, new AsyncCallback(ConnectCallBack), client);
allDone.WaitOne();
while (true)
{
allDone.Reset();
SendFile(client, "zhl.jpg", "20101112");
SendFile(client, "jnvc.jpg", "20101113");
allDone.WaitOne();
}
}
public static void ConnectCallBack(IAsyncResult args)
{
Socket client = (Socket)args.AsyncState;
client.EndConnect(args);
Console.WriteLine("Socket connected to {0}", client.RemoteEndPoint.ToString());
allDone.Set();
}
public static void Send(Socket handler, String data)
{
// Convert the string data to byte data using ASCII encoding.
byte[] byteData = Encoding.Unicode.GetBytes(data);
// Begin sending the data to the remote device.此处发生错误？是否是因为其进行呢??
handler.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback(SendCallback), handler);
}
public static void Send(Socket handler, byte[] byteData)
{
handler.BeginSend(byteData, 0, byteData.Length, 0,
new AsyncCallback(SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar)
{
try
{
Socket handler = (Socket)ar.AsyncState;
int bytesSent = handler.EndSend(ar);
Console.WriteLine("Sent {0} bytes to server.", bytesSent);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public static void SendFile(Socket client, String filePath,String serverFileName)
{
byte[] sendByteMessage = new byte[1037];
FileInfo fileInfo = new FileInfo(filePath);
int fileSize = (int)(fileInfo.Length);
FileStream afile = new FileStream(filePath, FileMode.Open);
SendFileMessage sfm = new SendFileMessage();
byte[] sendDataByte = new byte[1037];
byte[] dataByte = new byte[1024];
int i = (int)fileSize / 1024;
int yu = (int)fileSize % 1024;
//< = 1024 byte，则一次性把文件发送到服务器端
//>1024 byte的 时候，余数为0和不为0的情况，如果余数为0
if (fileSize <= 1024)
{
//在此处写入到2.jpg
afile.Seek(0, SeekOrigin.Begin);
afile.Read(dataByte, 0, fileSize);
sfm.effData = dataByte;
sfm.effDataLength = fileSize;
sfm.fileName = (serverFileName.ToCharArray());
sfm.typeMessage = '5';
sendDataByte = StructToBytes(sfm, 1037);
Send(client, sendDataByte);
afile.Close();
}
else
{
if (yu != 0)
{
//余数不为0，则把其中的数据放入其中
for (int j = 0; j < i; j++)
{
//重新为sendByteMessage赋值。文件数据大小必须要符合要求。不然会报错。使用光照引擎来进行
sfm.fileName = serverFileName.ToCharArray();
if (j == 0)
{
sfm.typeMessage = '2';
sfm.fileName = serverFileName.ToCharArray();
sfm.effDataLength = 1024;
}
else
sfm.typeMessage = '3';
afile.Seek(j * 1024, SeekOrigin.Begin);
afile.Read(dataByte, 0, 1024);
sfm.effData = dataByte;
sendByteMessage = StructToBytes(sfm,1037);
Send(client, sendByteMessage);
//全部数据发送。一定是要再接收数据.判断其中的数据，放入到里面中
}
int seekNum = i * 1024;
long operNum = (long)seekNum;
afile.Seek(operNum, SeekOrigin.Begin);
afile.Read(dataByte, 0, yu);
//在此处重新组合sfm，然后发送次文件到sfm
sfm.typeMessage='4';
//在此处要把sfm转变为struct类型
sendByteMessage = StructToBytes(sfm, 1037);
Send(client, sendByteMessage);
afile.Close();
}
else
{
for (int j = 0; j < i; j++)
{
afile.Seek(j * 1024, SeekOrigin.Begin);
afile.Read(dataByte, 0, 1024);
}
afile.Close();
}
}
}
private static void AsynchronousFileSendCallback(IAsyncResult ar)
{
Socket client = (Socket)ar.AsyncState;
client.EndSendFile(ar);
}
//当时怎么做的呢？的确是呢，可以呢？
public static byte[] StructToBytes(object structObj, int size)
{
int len = Marshal.SizeOf(structObj);
byte[] bytes = new byte[size];
IntPtr structPtr = Marshal.AllocHGlobal(size);
//将结构体拷到分配好的内存空间
Marshal.StructureToPtr(structObj, structPtr, false);
//从内存空间拷贝到byte数组
Marshal.Copy(structPtr, bytes, 0, size);
//释放内存空间，基于8bit
Marshal.FreeHGlobal(structPtr);
return bytes;
}
public static object ByteToStruct(byte[] bytes, Type type)
{
int size = Marshal.SizeOf(type);
if (size > bytes.Length)
{
return null;
}
//分配结构体
IntPtr structPtr = Marshal.AllocHGlobal(size);
//将byte数组拷贝到分配好的内存空间
Marshal.Copy(bytes, 0, structPtr, size);
//将内存空间转换为目标结构体
object obj = Marshal.PtrToStructure(structPtr,type);
//释放内存空间 定向光源和点光源
Marshal.FreeHGlobal(structPtr);
return obj;
}
}
}