internetten araştırmalarıma göre böyle bir şey herhangi bir yerde yazmıyor, örneğin ben soket üzerinden resim göndericem ama bunun istediğim resim olduğunu anlamam için bir kimlik veya ön ek (tag) lazım. Ben bu tag'ı bu resim byteları ile nasıl birleştirip daha sonra bunu unpack edip resme ulaşacağım? işte bana da bu lazımdı ve bu konu üzerinde birkaç gün ar-ge çalışması yaptım ve çalışmalarım sonuç verdi. İstediğim veriyi istediğim ön ek ve ekstra bilgilerle bağlı soketime sorunsuzca iletebiliyorum. Başka yöntem mutlaka vardır ama ben bildiğim kadarıyla bu kadar yaptım.

Kodlara geçelim,

Şimdi bize ilk önce bir packer lazım, yani tag ve ekstra bilgileri ana veriyle birleştirmek için;

Kod:
///
/// Send any data to connected socket.
///
/// The tag name of message, example: IP, MSGBOX, FILES etc. Then make switch case block for this tags
/// on server or client.
/// Data of your message; any byte array of your data; image, text, file etc.
/// Extra Infos like: file name, max size, directory name etc.
public static byte[] MyDataPacker(string tag, byte[] message, string extraInfos = "null")
{
//This byte packer coded by qH0sT' - 2021 - AndroSpy.
using (MemoryStream ms = new MemoryStream()) // packing için bir memeorystream açıyoruz.
{
//Bu akışta Tag ve ekstra bilgilerimizi verinin önüne yazıyoruz. Sonra bunu Regex ile ayırt edicez.

ms.Write(System.Text.Encoding.UTF8.GetBytes($"|{me ssage.Length}|{extraInfos}>"), 0, System.Text.Encoding.UTF8.GetBytes($"|{message.Len gth}|{extraInfos}>").Length);

ms.Write(message, 0, message.Length); //ardından ana veriyi yazıyoruz; resim, dosya, text mesajlar vs....

ms.Write(System.Text.Encoding.UTF8.GetBytes(""), 0, System.Text.Encoding.UTF8.GetBytes("").Length);
//Sonra bir eof belirteci ekliyoruz verinin tümünü alabilmişmiyiz diye.

ms.Write(System.Text.Encoding.UTF8.GetBytes("SUFFI X"), 0, System.Text.Encoding.UTF8.GetBytes("SUFFIX").Lengt h);
//sokette okuduğumuz byte verilerini split edebilmek için, aynı string.Split gibi düşünün bunu.

return ms.ToArray(); //Paketin son halini geri döndürüyoruz.
}
}
Örnek olarak şunu gönderelim;

Kod:
byte[] resim = MyDataPakcer("RESIM", File.ReadAllBytes("resim.png"));
soket.Send(resim, 0, resim.Lenght, SocketFlag.None);
gelelim okuma kısmına;

Klasik Soket beginreceive-endreceive kısmı.


Kod:
private MemoryStream memos = new MemoryStream(); // verileri yazıp sonra okuyacağımız bir hafıza akışı.

private byte[] dataByte = new byte[1536000]; // tampon bölge
private int blockSize = 1536000 // bu bölgenin uzunluğunu ben ayrı bir değişkende tanımladım.

mySoket.BeginReceive(dataByte, 0, blockSize, SocketFlags.None, endRead, mySoket); // veri okumaya başla.

public async v0id endRead(IAsyncResult ar) // soketin endreceive callback'ini asenkron yaptım unpacker da asenkron Task ya o yüzden ama yapmayabilirsiniz de, normal metod olarak da yazabilirsiniz unpacker'ı da normal metod olarak yaparak.
{
try
{
Socket sckt = (Socket)ar.AsyncState;
int readed = sckt.EndReceive(ar); // klasik soket endreceive operasyonu.
if (readed > 0) // eğer okunan bir veri varsa
{
if (memos != null)
{
memos.Write(dataByte, 0, readed); // soketten okunan veriyi olduğu gibi direkt hafıza akışına yazdırdık.
try
{
// ve bu akışı direkt unpacker'ımıza parametre olarak verdik. Ben soketi de parametre olarak verdim lazım olur diye.
await UnPacker(sckt, memos);
}
catch (Exception) { }

}
}
await Task.Delay(1); // sistemi biraz rahatlatmak için bu, çok da lazım değil.

sckt.BeginReceive(dataByte, 0, blockSize, SocketFlags.None, endRead, sckt); // veri okuma işleminin devir daimi için.


}
catch (Exception) { }
}
Unpacker kodlarım:


Kod:
public async Task UnPacker(Socket sck, MemoryStream ms)
{
//This unpacker coded by qH0sT' - 2021 - AndroSpy.
//string letter = "qwertyuıopğüasdfghjklşizxcvbnmöç1234567890|";
Regex regex = new Regex(@"\|[0-9]+\|.*>"); // tag'ı ve ekstra bilgileri ayırt edeceğimiz regex.

await Task.Run(() =>
{
byte[][] filebytes = Separate(ms.ToArray(), Encoding.UTF8.GetBytes("SUFFIX")); //byteları split ediyoruz.
for (int k = 0; k < filebytes.Length - 1; k++)
{
try
{
//oluşan verilerin hepsini almışmıyız diye kontrol ediyoruz.
string ch = Encoding.UTF8.GetString(new byte[1] { filebytes[k][filebytes[k].Length - 1] });// >
string f = Encoding.UTF8.GetString(new byte[1] { filebytes[k][filebytes[k].Length - 2] });// F>
string o = Encoding.UTF8.GetString(new byte[1] { filebytes[k][filebytes[k].Length - 3] });// OF>
string e = Encoding.UTF8.GetString(new byte[1] { filebytes[k][filebytes[k].Length - 4] });// EOF>
string ch_ = Encoding.UTF8.GetString(new byte[1] { filebytes[k][filebytes[k].Length - 5] });//

bool isContainsEof = (ch_ + e + o + f + ch) == ""; //hepsi gelmişse
if (isContainsEof)
{
List mytagByte = new List();
string temp = "";
for (int p = 0; p < filebytes[k].Length; p++)
{
//if (letter.Contains(Encoding.UTF8.GetString(new byte[1] { filebytes[k][p] }).ToLower()))
//{
temp += Encoding.UTF8.GetString(new byte[1] { filebytes[k][p] });
mytagByte.Add(filebytes[k][p]);
if (regex.IsMatch(temp)) //tagımızı öğreniyoruz.
{
break;
}
//}
}
string whatsTag = Encoding.UTF8.GetString(mytagByte.ToArray()); //tagımızı stringe çevirme işlemi

//gereksiz şeyleri veriden temizleme işlemi
MemoryStream tmpMemory = new MemoryStream();
tmpMemory.Write(filebytes[k], 0, filebytes[k].Length);
tmpMemory.Write(Encoding.UTF8.GetBytes("SUFFIX"), 0, Encoding.UTF8.GetBytes("SUFFIX").Length);
ms.Flush();
ms.Close();
ms.Dispose();
ms = new MemoryStream(RemoveBytes(ms.ToArray(), tmpMemory.ToArray()));
memos = new MemoryStream();
ms.CopyTo(memos);
tmpMemory.Flush();
tmpMemory.Close();
tmpMemory.Dispose();
filebytes[k] = RemoveBytes(filebytes[k], mytagByte.ToArray());
filebytes[k] = RemoveBytes(filebytes[k], Encoding.UTF8.GetBytes(""));

// son olarak veriyi işlediğimiz yer.
DataInvoke(sck, whatsTag, filebytes[k]);
}
}
catch (Exception) { }

}
});
}
public static byte[][] Separate(byte[] source, byte[] separator)
{
var Parts = new List();
var Index = 0;
byte[] Part;
for (var I = 0; I < source.Length; ++I)
{
if (Equals(source, separator, I))
{
Part = new byte[I - Index];
Array.Copy(source, Index, Part, 0, Part.Length);
Parts.Add(Part);
Index = I + separator.Length;
I += separator.Length - 1;
}
}
Part = new byte[source.Length - Index];
Array.Copy(source, Index, Part, 0, Part.Length);
Parts.Add(Part);
return Parts.ToArray();
}
static bool Equals(byte[] source, byte[] separator, int index)
{
for (int i = 0; i < separator.Length; ++i)
if (index + i >= source.Length || source[index + i] != separator[i])
return false;
return true;
}
public static byte[] RemoveBytes(byte[] input, byte[] pattern)
{
if (pattern.Length == 0) return input;
var result = new List();
for (int i = 0; i < input.Length; i++)
{
var patternLeft = i input[i + j] != t).Any()))
{
i += pattern.Length - 1;
}
else
{
result.Add(input[i]);
}
}
return result.ToArray();
}
Kod:
public v0id DataInvoke(Soket sck, string tag, byte[] data)
{
switch(tag.Split('|')[0])
{
case ""
pictureBox1.Image = (Image)new ImageConverter.ConvertFrom(data);
break;
}
}