Preface
NetShare, a network communication sharing library, is used to ensure the standardization and unity of data packets between clients and servers. The client and server use this library together to improve the accuracy and security of packet serialization and deserialization, and is used to meet different communication data needs.
NetShare: DataPacket (generic data packet)
using System;
using ;
using ;
namespace NetShare
{
/// <summary>
/// General data packet /// </summary>
[KnownType(typeof(PCDataPacket)), KnownType(typeof(PSDataPacket)), KnownType(typeof(ServerDataPacket))]
[DataContract]
public class DataPacket
{
/// <summary>
/// The IPEndPoint string content of the current data sending end (ip address: port number) /// </summary>
[DataMember]
public string mLocalEndPointStr;
/// <summary>
/// Other contents sent by the current data sender /// </summary>
[DataMember]
public string mContent;
/// <summary>
/// Convert the current packet instance to a byte array /// </summary>
/// <returns>Byte array</returns> public virtual byte[] ToBytes()
{
return <byte>();
}
/// <summary>
/// Convert the specified byte array into a DataPacket object /// </summary>
/// <param name="bytes">Specified byte array</param> /// <param name="type">DataPacket derived class types</param> /// <returns>DataPacket object or null</returns> public static DataPacket ToObject(byte[] bytes, Type type)
{
if (bytes?.Length > 0 && type != null && (typeof(DataPacket)))
{
using (MemoryStream ms = new MemoryStream(bytes))
{
DataContractSerializer serializer = new DataContractSerializer(type);
object obj = (ms);
if (obj != null && ().Equals(type)) return (DataPacket)obj;
};
}
return null;
}
/// <summary>
/// Convert the specified byte array into a DataPacket derived class (data package) object /// </summary>
/// <typeparam name="T">DataPacket derived class type</typeparam> /// <param name="bytes">Specified byte array</param> /// <returns>DataPacket derived class (packet) object or null</returns> public static T ToObject<T>(byte[] bytes) where T : DataPacket
{
if (bytes?.Length > 0)
{
using (MemoryStream ms = new MemoryStream(bytes))
{
DataContractSerializer serializer = new DataContractSerializer(typeof(T));
object obj = (ms);
if (obj != null && obj is T t) return t;
};
}
return null;
}
}
}NetShare: ClientDataPacket (client packet)
using ;
using ;
namespace NetShare
{
/// <summary>
/// Client data packet /// </summary>
[DataContract]
public class ClientDataPacket : DataPacket
{
/// <summary>
/// The name of the current client /// </summary>
[DataMember]
public string mClientName;
/// <summary>
/// Constructor /// </summary>
public ClientDataPacket()
{
mLocalEndPointStr = ;
mContent = ;
mClientName = ;
}
/// <summary>
/// Convert client packet instances to byte arrays /// </summary>
/// <returns>Byte array</returns> public override byte[] ToBytes()
{
using (MemoryStream ms = new MemoryStream())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(ClientDataPacket));
(ms, this);
return ();
}
}
/// <summary>
/// The string content of the client packet /// </summary>
/// <returns>String content</returns> public override string ToString()
{
return $"[LocalEndPointStr:{mLocalEndPointStr},ClientName:{mClientName},Content:{mContent}]";
}
}
}NetShare: ServerDataPacket (server data packet)
using ;
using ;
namespace NetShare
{
/// <summary>
/// Server data packet /// </summary>
[DataContract]
public class ServerDataPacket : DataPacket
{
/// <summary>
/// Constructor /// </summary>
public ServerDataPacket()
{
mLocalEndPointStr = ;
mContent = ;
}
/// <summary>
/// Convert server packet instances into byte arrays /// </summary>
/// <returns>Byte array</returns> public override byte[] ToBytes()
{
using (MemoryStream ms = new MemoryStream())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(ServerDataPacket));
(ms, this);
return ();
}
}
/// <summary>
/// String content of server packet /// </summary>
/// <returns>String content</returns> public override string ToString()
{
return $"[LocalEndPointStr:{mLocalEndPointStr},Content:{mContent}]";
}
}
}NetShare: PCDataPacket (Private Chat Channel Client Data Package)
using ;
using ;
namespace NetShare
{
/// <summary>
/// Private chat channel client data package /// </summary>
[DataContract]
public class PCDataPacket : ClientDataPacket
{
/// <summary>
/// Name of the target client /// </summary>
[DataMember]
public string mDestinationClientName;
/// <summary>
/// Constructor /// </summary>
public PCDataPacket()
{
mDestinationClientName = ;
}
/// <summary>
/// Convert private chat channel client packet instance to byte array /// </summary>
/// <returns>Byte array</returns> public override byte[] ToBytes()
{
using (MemoryStream ms = new MemoryStream())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(PCDataPacket));
(ms, this);
return ();
}
}
}
}NetShare: PSDataPacket (Private Chat Channel Server Data Package)
using System;
using ;
using ;
namespace NetShare
{
/// <summary>
/// Private chat channel server data packet /// </summary>
[DataContract]
public class PSDataPacket : ServerDataPacket
{
/// <summary>
/// Collection of client names that have been connected to the server /// </summary>
[DataMember]
public string[] mClientNames;
/// <summary>
/// Constructor /// </summary>
public PSDataPacket()
{
mClientNames = <string>();
}
/// <summary>
/// Convert server packet instances of private chat channel into byte array /// </summary>
/// <returns>Byte array</returns> public override byte[] ToBytes()
{
using (MemoryStream ms = new MemoryStream())
{
DataContractSerializer serializer = new DataContractSerializer(typeof(PSDataPacket));
(ms, this);
return ();
}
}
}
}This is the article about the use examples of C#’s network communication sharing library NetShare. For more related C# network sharing content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!