.Net Core, exchange with 1C over TCP / IP between different devices

public class ToShare Exchange
{
public static readonly Encoding CurrentEncoder; // = Encoding.GetEcry (1251);

static toSharingPTSP ()
{

// Here is the feature of .Net Core
// Need to register provider
// and set it up according to “System.Text.Encoding.CodePages”
Encoding.RegisterProvider (CodePagesEncodingProvider.Instance);
// CurrentEncoder = Encoding.GetEncoding ("windows-1251");
// Since we are using Ruslish, we use encoding 1251.
CurrentEncoder = Encoding.GetEncoding (1251);

}

public static byte [] ExpandData (byte [] an array of DataFor a Team)
{
var memStream = new MemoryStream (array of data for a command);
var DecompressStream = new MemoryStream ();
using (GZipStream gzipStream = new GZipStream (memStream, CompressionMode.Decompress, false))
{

Byte [] buffer = new Byte [1 << 16];
int h;
while ((h = gzipStream.Read (buffer, 0, buffer.Length))> 0)
{
DecompressStream.Write (buffer, 0, h);
}
}
return DecompressStream.ToArray ();
}

//
public static byte [] CompressData (byte [] Value)
{
var memStream = new MemoryStream ();
memStream.Position = 0;
using (GZipStream gzipStream = new GZipStream (memStream, CompressionMode.Compress))
{
gzipStream.Write (Value, 0, Value.Length);
gzipStream.Flush ();
}
return memStream.ToArray ();

}

// Classic read from NetworkStream knowing the size of the data received
private static byte [] ArrayBytovIzStrim (NetworkStream stream, int size of Array)
{
byte [] result = new byte [Size of array];
int number of Characters read = 0;
while (array size> number of counted characters)
{
Number of CountedCharacters + = Stream. Read (result, Number of CountedCharacters, Size of Array - Number of CountedCharacters);
}

return result;
}

public static void RecordBit arrayVStream (NetworkStream stream, byte [] Array)
{

stream.Write (Array, 0, Array.Length);
}

// Read 1 byte from the stream and convert to bool
public static bool ReadBool (NetworkStream stream)
{
return BitConverter.ToBoolean (Massive ByteString (stream, 1), 0);
}

// Convert bool to 1 byte and write to stream
public static void Write (NetworkStream stream, bool Value)
{
Write a Massive ByteStream (stream, BitConverter.GetBytes (Value));

}

// Read 4 bytes from the stream and convert to int
public static Int32 ReadInt32 (NetworkStream stream)
{
return BitConverter.ToInt32 (Massive ByteString (stream, 4), 0);
}

// Convert int to 4 bytes and write to stream
public static void Write (NetworkStream Stream, Int32 Value)
{
Write a Massive ByteStream (stream, BitConverter.GetBytes (Value));

}

// Read the string. First comes the size of the data int
// then read the data and get the string using encoding 1251
public static string ReadString (NetworkStream stream)
{
int Size of Data = ReadInt32 (stream);
if (Size of Data == 0) return "";

return CurrentEncoder.GetString (Massive Bytes from Stream (stream, Data Size));
}

// Write the string. First, write the size of the string, then convert to byte [] using encoding 1251.
public static void Write (NetworkStream stream, string Value)
{
if (Value.Length == 0)
{
Write (stream, 0);
return;
}
byte [] result = CurrentEncoder.GetBytes (Value);
Write (stream, result.Length);
Record a Massive Byte Stream (stream, result);

}

// See WriteCompressedString is an inverse operation.
public static string ReadCompressedString (NetworkStream stream)
{
// int Size of Data = ReadInt32 (stream);
// return CurrentEncoder.GetString (ArrayBytHizStream (stream, Data Size));
bool This is a Compressed Line = ReadBool (stream);

if (! This is a Compressed String) return ReadString (stream);

int SizeDataTelements = BitConverter.ToInt32 (Massive BytesStream (stream, 4), 0);
byte [] array of data for a command = array of bytes from a stream (stream, size of data for a command);
DatasetDataCommand = ExpandData (DatasetDataCommand);
return CurrentEncoder.GetString (data array for a command);

}

// Trying to compress the GZIP string. If the size of the compressed data is less than the original, then we write the compressed data.
// otherwise original
// Write the data in the following sequence
// bool data compression flag
// int data size
// byte [] data
public static void WriteCompressedString (NetworkStream stream, string Value)
{
if (Value.Length == 0)
{
Write (false);
Write (stream, 0);
return;
}

byte [] result = CurrentEncoder.GetBytes (Value);
var CompressedData = CompressData (result);
if (result.Length> CompressedData.Length)
{
Write (true);
Write (stream, CompressedDanned.Length);
Record a Massive Byte Stream (Stream, Compressed Data);
}
else
{
Write (false);
Write (stream, result.Length);
Record a Massive Byte Stream (stream, result);
}


}

// Send data to the server
// string Command name of the method that will process the data
// string Data For a Team this is serialized data as a string
// bool There isAnswer sign of the function or procedure of the data processing method
public static void SendCommand (NetworkStream strim, string Command, string DataFor the Team, bool YesReply)
{
Write (strim, there is an answer);
Write (strim, command);
WriteCompressedString (strim, data for a command);
}

// Read data from the client
public static Message Structure Accept Command (NetworkStream strim)
{
bool YesReply = ReadBool (strim);
string Command = ReadString (strim);
string DataForCommands = ReadCompressedString (strim);
return new Message Structure (Command, Command Information, There Is An Answer);
}
}