private void Send() //Send 버튼을 눌렀을 때 thrsend 쓰레드 안에서 돌아갈 함수
{
try
{
while (ConnectedToServer) //서버에 연결되어 있을 때
{
buttonstream.Position = 0; //파일의 인덱스를 맨앞으로 이동시키고
FileInfo fi = new FileInfo(openFileDialog.FileName);
Fp = new FilePacket();
Fp.FileName = fi.Name; //파일의 경로를 생각한 짧은 경로를 얻어오기위해 FileInfo 사용
Fp.FileSize = fi.Length; //파일의 길이를 FileSize로 입력
Invoke(new MethodInvoker(delegate() //Control을 건드리는 부분 --> Invoke 사용
{
ProgressBar.Minimum = 0; // 초기값 0
ProgressBar.Maximum = (int)(buttonstream.Length / Fp.FileData.Length) + 1; //보내야 하는 횟수
ProgressBar.Value = 0; // 현재 값 0
}
));
for (int i = 0; i < (int)(buttonstream.Length / Fp.FileData.Length) + 1; i++)
{ //파일의 크기를 버퍼의 크기로 나누고 나머지부분 전송을 위해 + 1번만큼 더 전송함
buttonstream.Read(Fp.FileData, 0, Fp.FileData.Length); //파일을 버퍼에 읽어와서
Fp.Type = 0; //보통의 파일 전송 타입
Packet.Serialize(Fp).CopyTo(this.SendBuffer, 0); //SendBuffer로 Serialize
NetStream.Write(SendBuffer, 0, SendBuffer.Length); //네트워크 스트림에 쓴다
NetStream.Flush(); //보낸다
ClearBuffer(SendBuffer); //SendBuffer의 모든 index를 0으로 초기화
Invoke(new MethodInvoker(delegate() //Control을 건드리는 부분
{
ProgressBar.Value++; //Value를 증가시킴(Progressbar 수치 증가)
}
));
}
//파일 전송 끝
buttonstream.Dispose();
buttonstream.Close(); //
FileTextBox.Clear(); //파일스트림을 닫아주고, 파일경로 텍스트박스 초기화
Invoke(new MethodInvoker(delegate() //컨트롤을 건드리는 부분
{
ListViewItem item = new ListViewItem(new string[] { fi.Name, fi.Length.ToString() });
listView.Items.Add(item); //전송을 완료하면 서버의 경로에 이 파일도 저장되므로
}
));
threader = new Thread(new ThreadStart(Receive)); //Abort되었던 쓰레드를 다시 생성해줌
threader.Start(); //시작
thrsender.Abort(); //전송 쓰레드 Abort
}
}
catch
{//쓰레드가 중단되었습니다. 같은 무시할 수 있는 오류를 깔끔히 처리하기 위해서 비워둠
}
}
public void sendFile(string sender, string path)
{
FileInfo fileInfo = null;
try
{
fileInfo = new FileInfo(path);
}
catch (Exception exc)
{
Console.WriteLine("Fehler beim Lesen der Dateiinfo! - {0}", exc.Message);
return;
}
if (fileInfo.Exists)
{
var filePacket = new FilePacket
{
Size = fileInfo.Length,
CreationTime = fileInfo.CreationTime,
LastAccessTime = fileInfo.LastAccessTime,
LastWriteTime = fileInfo.LastWriteTime,
Name = fileInfo.Name,
Receiver = sender
};
var filePacketBytes = this.serialize(filePacket);
var filePacketSizeBytes = BitConverter.GetBytes(filePacketBytes.Length);
var clientStream = this.client.GetStream();
using (var memoryStream = new MemoryStream())
{
memoryStream.Write(filePacketSizeBytes, 0, filePacketSizeBytes.Length);
memoryStream.WriteByte((byte)Core.PacketType.File);
memoryStream.Write(filePacketBytes, 0, filePacketBytes.Length);
memoryStream.WriteTo(clientStream);
}
byte[] buffer = new byte[this.client.SendBufferSize];
using (var fileStream = new FileStream(path, FileMode.Open))
{
fileStream.Seek(0, SeekOrigin.Begin);
int size = 0;
while ((size = fileStream.Read(buffer, 0, buffer.Length)) > 0)
{
clientStream.Write(buffer, 0, size);
}
}
}
else
{
Console.WriteLine("Die Datei '{0}' existiert nicht!", fileInfo.FullName);
}
}
// Methoden
public Core()
{
this.receivedBufferOffset = 0;
this.currentPacketSize = 0;
this.currentPacketType = PacketType.Invalid;
this.packetStream = new MemoryStream();
this.currentFilePacket = null;
this.receivedFileSize = 0;
}
private void OnSaveMapCommand(Client client, string command, string[] args)
{
if (!_enabled)
{
return;
}
FilePacket mapData = Packet.Create(PacketType.FILE) as FilePacket;
mapData.Bytes = Encoding.UTF8.GetBytes(this.m_map.ToJson());
mapData.Name = args.Length == 0 ? this.m_map.Name : args[0];
client.SendToClient(mapData);
}
/// <summary>
/// 获取文件服务信息
/// </summary>
/// <param name="id">类型ID</param>
/// <param name="dataArray">原始字节数组</param>
private void GetFileServertMessage(TypeIdentification id, byte[] dataArray)
{
try
{
var message = new FilePacket(dataArray);
switch (id)
{
case TypeIdentification.F_FR_NA_1_NR:
{
FileServerArrived(this,
new TransmitEventArgs <TypeIdentification, FilePacket>(id, message));
break;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 文件数据包
/// </summary>
/// <param name="packet">文件包</param>
private void SendFileServerMessage(FilePacket packet)
{
try
{
packet.TransmitSequenceNumber = appMessageManager.TransmitSequenceNumber;
packet.ReceiveSequenceNumber = appMessageManager.RealReceiveSequenceNumber;
packet.ASDU.AppDataPublicAddress = appMessageManager.ASDUADdress;
var id = TypeIdentification.F_FR_NA_1_NR;//文件服务
eventTypeIDManager.AddEventProcess(new EventProperty(id));
var frame = packet;
var array = frame.GetAPDUDataArray();
MainTypeIProcess(array, array.Length, appMessageManager.WaitTime, id);
appMessageManager.UpdateTransmitSequenceNumber();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SendFileServerMessage");
}
}
public override void DoLoginedHandlerWork(HttpContext context)
{
Message jsonMessage;
bool isUpdate = false;
//检查用户有没有更新报表权限，
if (CommonOperRightHelper.CheckMenuCode(base.loginOperator, "gxbbmb"))
{
isUpdate = context.Request.Form["isUpdate"] == null ? false : bool.Parse(context.Request.Form["isUpdate"].ToString());
}
string strUploadPath = string.Format("{0}\\ReportTemplate\\{1}\\{2}\\{3}\\",
context.Server.MapPath("~"), base.loginOperator.CompanyID, base.loginOperator.OperID, System.DateTime.Now.ToString("yyyyMMdd"));
jsonMessage = new Message()
{
Result = false, TxtMessage = "权限验证失败，可能原因:\n1、数据中心通讯失败。\n2、系统管理员未与您分配对应操作权限。"
};
string fileName = string.Empty;
//创建路径记录上传者账号信息
if (CommonOperRightHelper.CheckMenuCode(base.loginOperator, "drbbmb"))
{
if (context.Request.Files != null && context.Request.Files.Count == 1)
{
if (!Directory.Exists(strUploadPath))
{
Directory.CreateDirectory(strUploadPath);
}
HttpPostedFile postedFile = context.Request.Files[0];
fileName = strUploadPath + System.Web.HttpUtility.UrlDecode(Path.GetFileName(postedFile.FileName));
if (fileName != "" && Path.GetExtension(fileName) == ".pkf")
{
try
{
postedFile.SaveAs(fileName);
FilePacket pft = new FilePacket(fileName);
pft.OpenPacket(strUploadPath);
pft = null;
ImportReport(strUploadPath, isUpdate);
string ShowInfo = string.Empty;
ShowInfo += string.Format("成功{0}个。<br>", success);
int i = 0;
foreach (string tmp in successName)
{
i++;
ShowInfo += string.Format("{0}、【{1}】", i, tmp);
}
if (failed > 0)
{
ShowInfo += string.Format("<br>失败{0}个。<br>", failed);
i = 0;
foreach (string tmp in failedReasons)
{
i++;
ShowInfo += string.Format("{0}、【{1}】", i, tmp);
}
}
jsonMessage = new Message()
{
Result = true, TxtMessage = ShowInfo
};
}
catch (Exception ex)
{
jsonMessage = new Message()
{
Result = false, TxtMessage = ex.Message
};
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
}
}
}
context.Response.Write(JSon.TToJson <Message>(jsonMessage));
}
private void Receive()
{
try
{
int count = 1; //현재 파일의 인덱스
int nRead = 0; //총 전송 횟수
while (ConnectedToServer)
{
this.NetStream.Read(this.ReadBuffer, 0, this.ReadBuffer.Length); //읽어오고
Packet p = (Packet)Packet.Deserialize(this.ReadBuffer); //해독해서
switch (p.Type) //타입에 따라 나눈다
{
case 0: //보통의 파일 전송일 때
{
Fp = (FilePacket)p; //파일을 보내기 위한 클래스로 다운캐스팅
nRead = (int)Fp.FileSize / Fp.FileData.Length + 1; //파일을 받아야 하는 횟수
int fileIndex = 1; //파일 중복 시 앞에 번호를 붙여주기 위한 인덱스
string fileName = PathTextBox.Text + "\\" + Fp.FileName;
if (count == 1) //파일의 첫부분을 받았다면
{
while (File.Exists(fileName)) //파일이 있는지 확인하고
{
fileName = PathTextBox.Text + "\\" + "(" + fileIndex.ToString() + ")" + Fp.FileName;
fileIndex++; //앞에 번호를 붙여 파일 이름이 겹치지 않도록 해준다
}
f = new FileStream(fileName, FileMode.Create, FileAccess.Write);
//중복되지 않는 파일 이름을 얻은 후 파일스트림을 생성한다(생성으로)
}
f.Write(Fp.FileData, 0, Fp.FileData.Length);
this.Invoke(new MethodInvoker(delegate() //컨트롤 건드리는 부분
{
this.ProgressBar.Maximum = nRead; //최대전송횟수로 초기화
this.ProgressBar.Minimum = 0; //최소는 0
this.ProgressBar.Value = count; //count는 현재 몇번 받았는지 나타냄
count++;
}
));
if (count > nRead) //count==nRead일 때 파일을 모두 받음
//따라서 count++을 한 직후 count>nRead 라면 파일을 다 받았으므로
{
count = 1; //count를 다시 1로 초기화하고
f.Dispose();
f.Close(); //파일의 인덱스는 파일이 닫지 않으면 유지되기 때문에
//파일의 전송을 모두 끝낸 시점에서 닫아준다.
}
break;
}
case 1: //리스트뷰에 파일을 띄우기 위한 Type일 때
{
Fl = (FileList)p; //리스트 뷰에 파일을 띄우기 위한 클래스로 다운캐스팅
this.Invoke(new MethodInvoker(delegate() //컨트롤을 건드리는 부분
{
ListViewItem item = new ListViewItem(new string[] { Fl.FileName, Fl.FileSize.ToString() });
listView.Items.Add(item); //아이템을 파일이름, 사이즈로 생성 후 Add
}));
break;
}
case 2: //파일을 달라는 request일 때-->클라이언트에서는 받을 일 없음
{
break;
}
}
}
}
/*
* catch (SocketException) //처음에 서버 연결이 끊겼을 때 자동으로 Disconnect 버튼이
* { //Connect 버튼으로 바뀌도록 하기 위해 만든 코드였는데,
* Cli = null; //서버와 연결이 끊길 때 발생하는 Exception이
* NetStream = null; //SocketException 아니라 밑의 IOException이라는 것을 알고 주석처리하였다.
* if (f != null)
* f.Close();
* ConnectedToServer = false;
*
* Invoke(new MethodInvoker(delegate ()
* {
* ConnectBtn.Text = "Connect";
* ConnectBtn.ForeColor = Color.Black;
* listView.Items.Clear();
* }));
*
* threader.Abort();
* }*/
catch (System.IO.IOException) //서버와의 연결이 끊겼을 경우 or IO 예외가 발생했을 경우
{
Cli = null;
NetStream = null; //넷스트림과 클라이언트를 널로만듬
if (f != null)
{
f.Close(); //파일스트림이 널이 아니라면 닫고
}
ConnectedToServer = false; //서버와 연결상태를 거짓으로 설정
Invoke(new MethodInvoker(delegate() //컨트롤을 건드리는 부분
{
ConnectBtn.Text = "Connect"; //버튼의 텍스트를 Connect로
ConnectBtn.ForeColor = Color.Black; //색깔을 검정색으로
listView.Items.Clear(); //리스트뷰를 비움
}));
threader.Abort(); //리시브 쓰레드 종료
thrsender.Abort(); //보내는 쓰레드 종료
}
catch
{//쓰레드가 중단되었습니다. 같은 무시할 수 있는 오류를 깔끔히 처리하기 위해서 비워둠
}
}
private void Receive() //전송이 오면 받는 함수-> 쓰레드로 돌아감
{
try
{
int count = 1; //현재 파일의 받고 있는 부분
int nRead = 0; //파일을 몇번 전송해야 하는가
while (CliConnected) //클라이언트가 서버에 연결되어 있는 동안
{
this.NetStream.Read(this.ReadBuffer, 0, this.ReadBuffer.Length); //전송이 온 경우 네트워크 스트림을 읽고
Packet p = (Packet)Packet.Deserialize(this.ReadBuffer); //해독한 후
switch (p.Type) //타입에 따라 행동한다
{
case 0: //보통의 파일 전송타입일 때
{
Fp = (FilePacket)p; //파일 전송을 위한 클래스로 다운캐스팅
nRead = (int)Fp.FileSize / Fp.FileData.Length + 1; //몇 번 보내야 하는가
int fileIndex = 1; //파일 이름의 중복을 처리하기 위한 변수
string fileName = PathTextBox.Text + "\\" + Fp.FileName; //파일 이름을 저장하고
if (count == 1) //파일의 첫부분을 받았을 때
{
while (File.Exists(fileName)) //파일의 이름이 존재한다면
{
fileName = PathTextBox.Text + "\\" + "(" + fileIndex.ToString() + ")" + Fp.FileName;
fileIndex++; //파일 이름이 중복될 경우 앞에 번호를 붙이는 식으로 중복을 피함
}
f = new FileStream(fileName, FileMode.Create, FileAccess.Write); //중복되지 않는 파일 이름으로 파일을 생성
}
f.Write(Fp.FileData, 0, Fp.FileData.Length); //파일에 데이터를 쓴다
//이 때 파일 안에서의 position은 파일을 닫지 않으면 계속 이어서 쓸 수 있기 때문에
//파일의 끝부분을 받았을 때 파일스트림을 닫아준다
this.Invoke(new MethodInvoker(delegate() //컨트롤을 건드리는 부분
{
this.ProceedTextBox.Text = this.ProceedTextBox.Text + "\r\nFile Receive.... " + count + "/" + nRead + " Done\r\n";
this.ProceedTextBox.Select(ProceedTextBox.Text.Length, 0);
this.ProceedTextBox.ScrollToCaret(); // 현재 전송된 부분 / 전체 전송 부분 을 출력하고, 텍스트박스의 가장 밑으로 스크롤한다
count++;
}));
if (count > nRead) //count = nRead일 때가 마지막 전송이므로, count가 nRead보다 커진다면
{
count = 1; //다른 파일을 받을 수 있도록 count = 1로 초기화 해주고
f.Dispose();
f.Close(); //파일을 다 썼으므로 파일을 닫는다.
}
break;
}
case 1: //파일의 리스트 Type일 때-->서버가 받을 일 없음
{
break;
}
case 2: //파일을 달라는 request일 때
{
try
{
Rq = (Request)p; //요청 클래스를 받아서 다운캐스팅
f = new FileStream(PathTextBox.Text + "\\" + Rq.FileName, FileMode.Open, FileAccess.Read);
//파일 이름을 받았고, 경로도 알고 있기 때문에 파일스트림 생성 가능
Fp = new FilePacket(); //파일 전송을 위한 클래스 인스턴스 생성
Fp.Type = 0; //타입은 보통의 파일 전송
Fp.FileName = Rq.FileName; //파일 이름
Fp.FileSize = f.Length; //파일 크기
for (int i = 0; i < (int)(f.Length / Fp.FileData.Length) + 1; i++)
{ //파일 크기를 나누고 버퍼의 크기로 나누고, 나머지부분을 한번 더 전송하기 위해 +1을 함
f.Read(Fp.FileData, 0, Fp.FileData.Length); //파일의 데이터를 버퍼의 크기만큼 읽어와 버퍼에 넣어줌
Packet.Serialize(Fp).CopyTo(this.SendBuffer, 0); //Serialize해서 SendBuffer에 넣어줌
NetStream.Write(SendBuffer, 0, SendBuffer.Length); //네트워크 스트림에 쓰고
NetStream.Flush(); //보냄
ClearBuffer(SendBuffer); //버퍼를 초기화 한다
}
f.Dispose();
f.Close(); //파일 읽기가 끝났으므로 파일을 닫아준다.
}
catch (Exception ex)
{
}
break;
}
}
}
}
catch (Exception ex)
{//예상되는 무시해도 되는 오류들을 깔끔히 처리하기 위해 catch문을 비워두었다.ex)쓰레드가 중단되었습니다
}
}
private void parseReceivedBuffer(int receivedSize)
{
//////////////////////////////////////////////////////
// ------------------------------------------------ //
// | Paketgröße | Pakettyp | Paket | Dateibytes | //
// ------------------------------------------------ //
// | 4 Bytes | 1 Byte | X Bytes | X Bytes | //
// ------------------------------------------------ //
//////////////////////////////////////////////////////
// Wenn gerade kein Paket gelesen wird
if (this.currentPacketType == PacketType.Invalid)
{
// Wenn die empfangen Bytes nicht ausreichen, um die Paketgröße und den Pakettyp zu lesen
if (receivedSize < sizeof(int) + sizeof(byte))
{
this.receivedBufferOffset = receivedSize;
// Weiter empfangen...
}
// Paketgröße und Pakettyp lesen
else
{
this.currentPacketSize = BitConverter.ToInt32(this.receivedBuffer, this.receivedBufferOffset);
if (Enum.IsDefined(typeof(PacketType), this.receivedBuffer[this.receivedBufferOffset + sizeof(int)]))
{
this.currentPacketType = (PacketType)this.receivedBuffer[this.receivedBufferOffset + sizeof(int)];
int offset = sizeof(int) + sizeof(byte);
// Wenn noch mehr gelesen werden kann
if (receivedSize - offset > 0)
{
this.receivedBufferOffset += offset;
this.parseReceivedBuffer(receivedSize - offset);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
else
{
this.currentPacketSize = 0;
Console.WriteLine("Empfangener Pakettyp '{0}' ist ungültig!", this.receivedBuffer[this.receivedBufferOffset + sizeof(int)]);
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
}
// Dateipaket lesen
else if (this.currentPacketType == PacketType.File)
{
// Wenn das ganze Paket gelesen werden kann
if (receivedSize >= this.currentPacketSize)
{
// Alle Bytes des Pakets in den Stream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, this.currentPacketSize);
// Paket ist fertig!
// Wenn gültiges Paket: Datei empfangen, sonst zurück setzen
try
{
this.currentFilePacket = Newtonsoft.Json.JsonConvert.DeserializeObject <FilePacket>(Encoding.UTF8.GetString(this.packetStream.ToArray()));
this.currentPacketType = PacketType.FileData;
//Console.WriteLine(Encoding.UTF8.GetString(this.packetStream.ToArray()));
//Console.WriteLine("Dateipaket empfangen");
this.ReceiveFileInfo(this.currentFilePacket.Receiver, this.currentFilePacket.Name, this.currentFilePacket.Size);
}
catch
{
this.currentPacketType = PacketType.Invalid;
Console.WriteLine("Dateipaket fehlerhaft!");
}
// Paketstream für nächstes Paket zurücksetzen
this.packetStream.Position = 0;
this.packetStream.SetLength(0);
// Wenn noch mehr Bytes gelesen werden können
if (receivedSize > this.currentPacketSize)
{
this.receivedBufferOffset += this.currentPacketSize;
this.parseReceivedBuffer(receivedSize - this.currentPacketSize);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
this.currentPacketSize = 0;
}
// Wenn ein Teil des Pakets gelesen werden kann
else
{
// Verfügbare Bytes in den Paketstream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, receivedSize);
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
// Datei lesen
else if (this.currentPacketType == PacketType.FileData)
{
// Wenn die Datei noch empfangen wird
if (this.receivedFileSize < this.currentFilePacket.Size)
{
long restSize = this.currentFilePacket.Size - this.receivedFileSize;
// Wenn die fehlenden Bytes vorhanden sind
if (receivedSize >= restSize)
{
byte[] fileBuffer = new byte[restSize];
Array.Copy(this.receivedBuffer, this.receivedBufferOffset, fileBuffer, 0, restSize);
//Console.WriteLine("{0} Bytes der Datei empfangen", restSize);
//Console.WriteLine("Datei komplett empfangen");
// Callback für Dateiverarbeitung
this.receivedFileSize += restSize;
this?.ReceiveFile(this.currentFilePacket.Receiver, fileBuffer, this.receivedFileSize, this.currentFilePacket.Size);
this.currentPacketSize = 0;
this.currentPacketType = PacketType.Invalid;
this.currentFilePacket = null;
this.receivedFileSize = 0;
// Wenn noch mehr Bytes gelesen werden können
if (receivedSize > restSize)
{
this.receivedBufferOffset += (int)restSize;
this.parseReceivedBuffer(receivedSize - (int)restSize);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
else
{
byte[] fileBuffer = new byte[receivedSize];
Array.Copy(this.receivedBuffer, this.receivedBufferOffset, fileBuffer, 0, receivedSize);
//Console.WriteLine("{0} Bytes der Datei empfangen", receivedSize);
// Callback für Dateiverarbeitung
this?.ReceiveFile(this.currentFilePacket.Receiver, fileBuffer, this.receivedFileSize, this.currentFilePacket.Size);
this.receivedFileSize += receivedSize;
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
else
{
Console.WriteLine("WIE BIN ICH HIER HIN GEKOMMEN???");
System.Diagnostics.Debugger.Break();
}
}
// Objekt lesen
else if (this.currentPacketType == PacketType.Object)
{
// Wenn das ganze Paket gelesen werden kann
if (receivedSize >= this.currentPacketSize)
{
// Alle Bytes des Pakets in den Stream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, this.currentPacketSize);
// Paket ist fertig!
//Console.WriteLine("Dateipaket empfangen");
//if (this.name == null)
//{
// try
// {
// var data = (Newtonsoft.Json.Linq.JObject)this.deserialize(this.packetStream.ToArray());
// if (data["$ConnectionInfoName"] != null)
// {
// this.name = (string)data["$ConnectionInfoName"];
// Console.WriteLine("{0} hat sich verbunden", this.name);
// }
// else
// {
// throw new Exception("Es sollte erst ein Name an den Server geschickt werden!");
// }
// }
// catch
// {
// }
//}
//else
{
var data = (JObject)this.deserialize(this.packetStream.ToArray());
foreach (var pair in data)
{
//this.ReceiveObject?.Invoke(pair.Key, JsonConvert.DeserializeObject(pair.Value.ToString()));
if (pair.Key != "Receiver")
{
this.ReceiveObject?.Invoke(data["Receiver"].ToString(), pair.Key, pair.Value.ToString());
}
}
}
// Pakettyp und Paketstream für nächstes Paket zurücksetzen
this.currentPacketType = PacketType.Invalid;
this.packetStream.Position = 0;
this.packetStream.SetLength(0);
// Wenn noch mehr Bytes gelesen werden können
if (receivedSize > this.currentPacketSize)
{
this.receivedBufferOffset += this.currentPacketSize;
this.parseReceivedBuffer(receivedSize - this.currentPacketSize);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
this.currentPacketSize = 0;
}
// Wenn ein Teil des Pakets gelesen werden kann
else
{
// Verfügbare Bytes in den Paketstream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, receivedSize);
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
}
