XML Based Communication library

Hey folks,

unfortunately there is no demo provided by the author of the library. I wrote a small communication between a client and a server by myself. The lib is very easy to use!

If you want to send your own object you muss add a CommSend_XYZ_ class in the CommLib.cs.
Also you have to add a case in the CommProtocol.cs at the "ReadCommand()" method.

I marked with: "// ##### add here a case for your own classes" where you should insert your stuff.

For example i added 2 Classes, CommSendJob and CommSendResponse.

You have to start the server first, following by the client. The client sends a Job with Name, Parameter and Priority. The server returns a Result with jobAccepted and an Error Message someting is wrong with the job.

Feel free to ask anything about my sample. Germans can be happy because my additional comments are in german. Nevertheless it should be easy to understand for everyone.

Okay. Make 2 new console projects, insert the CommLib.cs and the CommProtocol.cs.
One project is the server, the other the Client. Here are the project files: http://www57.zippyshare.com/v/45396257/file.html[^] !!You have to change the serverIP to 127.0.0.1 in the SharedComponents.cs!!!

The Code:

CommProtocol.cs

C#

using System;
using System.Net.Sockets;
using System.IO;
using System.Xml.Serialization;

namespace CommLib
{
	/// <summary>
	/// CommProtocol Class, Handle the communication protocol between server/clients
	/// or clients/clients
	/// </summary>
	public sealed class CommProtocol
	{
		/// <summary>
		/// private constructor to prevent object creation since this is a static class
		/// </summary>
		private CommProtocol()
		{
		}

		/// <summary>
		/// read data from network stream. if connection failed or lost an
		/// InvalidOperationException will be thrown 
		/// </summary>
		/// <param name="stream">network stream </param>
		/// <param name="cmd">command that will be read from the stream</param>
		/// <returns>object associated with command</returns>
		public static object Read(NetworkStream stream,out CommCommand cmd)
		{
            Console.WriteLine("#\tCommProtocol Read()");
			TextReader reader = new StreamReader(stream,System.Text.Encoding.Unicode);
			int xml_size;
			ReadHeader(reader,out xml_size,out cmd);
			if(xml_size < 0 ) 
			{
				throw new InvalidOperationException("user disconnected");
			}
			
			char[] buf = new char[xml_size];
			if(reader.Read(buf,0,xml_size) < xml_size)
			{
				throw new InvalidOperationException("user disconnected");
			}
			
			StringReader xml_reader = new StringReader(new string(buf));
			
			return ReadCommand(xml_reader,cmd);
		}
		
		/// <summary>
		/// write data to the stream. data will be written in the following order
		/// Command type
		/// delimiter ":"
		/// command object size
		/// delimiter ":"
		/// object data in xml format
		/// 
		/// </summary>
		/// <param name="stream">stream to write data into</param>
		/// <param name="o">object to write into the stream, this can be null
		/// for some commands</param>
		/// <param name="cmd">command to write to the stream</param>
		public static void Write(Stream stream, object o,CommCommand cmd)
		{
			StringWriter xml_stream = new StringWriter();
			if(o != null)
			{
				XmlSerializer serializer = new XmlSerializer(o.GetType());
				serializer.Serialize(xml_stream,o);
			}
			int xml_size = xml_stream.GetStringBuilder().Length;
			
			string header = string.Format("${0}:{1}:",xml_size,(short)cmd);
			string tmp_str = header+xml_stream.GetStringBuilder().ToString();
			byte[] buf = System.Text.Encoding.Unicode.GetBytes(tmp_str);
			stream.Write(buf,0,buf.Length);
		}

		/// <summary>
		/// read header from the stream. This header will be used to determine how to
		/// read and desirialize the XML data int Comm object
		/// </summary>
		/// <param name="reader">Text Reader stream</param>
		/// <param name="xml_size">xml object size</param>
		/// <param name="cmd">the command</param>
		private static void ReadHeader(TextReader reader,out int xml_size,out CommCommand cmd)
		{
            Console.WriteLine("#\tCommProtocol ReadHeader()");
			bool done = false;
			char[] one_char = new char[1];
			string xml_size_string = string.Empty;
			string command_string = string.Empty;
			int header_item = 0;
			xml_size = -1;
			cmd = new CommCommand();
			while(!done)
			{
				if(reader.Read(one_char,0,1) < 0) return;
				switch(one_char[0])
				{
					case '$':
						break;
					case ':':
						if(++header_item > 1)//2 header items
							done = true;
						break;
					default:
						if(char.IsNumber(one_char[0]))
						{
							switch(header_item)
							{
								case 0:
									xml_size_string = xml_size_string + one_char[0];
									break;
								case 1:
									command_string = command_string + one_char[0];
									break;
							}
						}
						else
						{
							throw new InvalidOperationException("Protocol Error, Header Corrupted");
						}
						break;
				}
			}
			xml_size = int.Parse(xml_size_string);
			cmd = (CommCommand)int.Parse(command_string);
		}
		
		/// <summary>
		/// read command data from the TextReader stream accordign to the requested command
        ///  ##### add here a case for your own classes
		/// </summary>
		/// <param name="reader">Text reader stream contains the object in XML format</param>
		/// <param name="cmd">the command</param>
		/// <returns>object serialized from the stream</returns>
		private static object ReadCommand(TextReader reader,CommCommand cmd)
		{
            Console.WriteLine("#\tCommProtocol ReadCommand()");
			CommStatus status = new CommStatus();
			try
			{
				XmlSerializer serializer;

				switch(cmd)
				{
					case CommCommand.CommandSendText:
						serializer = new XmlSerializer(typeof(CommSendText));
						CommSendText send_text = serializer.Deserialize(reader) as CommSendText;
						return send_text ;

                    //  ##### add here a case for your own classes
                    case CommCommand.CommandSendJob:
                        serializer = new XmlSerializer(typeof(CommSendJob));
                        CommSendJob send_job = serializer.Deserialize(reader) as CommSendJob;
                        return send_job;

                    case CommCommand.CommandSendResponse:
                        serializer = new XmlSerializer(typeof(CommSendResponse));
                        CommSendResponse send_Response = serializer.Deserialize(reader) as CommSendResponse;
                        return send_Response;
				

					case CommCommand.CommandStatus:
						serializer = new XmlSerializer(typeof(CommStatus));
						status = serializer.Deserialize(reader) as CommStatus;
						return status;
					
					default:
						status.OpStatus = OperationStatus.CommNetworkError;
						return status;
				}
			}
			catch(Exception ex)
			{
				//do nothing since the delegate doen't exist
				//just inform the user
				Console.WriteLine("Exception wile processing command:{0}",ex.Message);
				status.OpStatus = OperationStatus.CommError;
				return status;
			}
		}
	}
}

CommLib.cs

C#

using System;
using System.Collections;

namespace CommLib
{
	/// <summary>
	/// Operation Status enumerator
	/// </summary>
	public enum OperationStatus
	{
		CommSuccess,
		CommNetworkError,
		CommError
	}
	
	/// <summary>
	/// Communication command
	/// this is user for client/server and client/client communication
	/// </summary>
    public enum CommCommand
    {
        CommandNOP,
        CommandSendText,
        CommandStatus,
        CommandSendJob,
        CommandSendResponse
    }


    /// <summary>
    /// Send text command data class
    /// </summary>
    public class CommSendText
    {
        /// <remarks/>
        public string ChatText;
    }

    //  ##### add here a case for your own classes

    /// <summary>
    /// Send Job Status Class
    /// </summary>
    public class CommSendJob
    {
        public string Name;
        public string Para;
        public int Prio;
    }

    /// <summary>
    /// Send Response Status Class
    /// </summary>
    public class CommSendResponse
    {
        public bool JobAccepted;
        public string ErrMessage;
    }

    /// <summary>
    /// the communicatio result status data class
    /// </summary>
    public class CommStatus
    {
        public OperationStatus OpStatus;
        public CommCommand Cmd;
    }

	
}

SharedComponents.cs

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;

namespace SharedComponents
{
    public class ConInfo
    {
        public const string serverIP = "10.106.64.222";
        public const int port = 10000;
    }

}

Server:
Program.cs

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CommLib;
using SharedComponents;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace ca_xmlotcp_server
{
    class Program
    {
        static void Main(string[] args)
        {

            // Erstellen eines neuen Listeners an Anschluss 10000
            TcpListener listener = new TcpListener(IPAddress.Any,
            ConInfo.port);

            Console.WriteLine("Initialisiere Anschluss.");
            listener.Start();
            Console.WriteLine("Warte auf eingehende Verbindungsanforderungen...");



            try
            {
                // Auf eingehende Verbindungsanforderung warten 
                // und einen für die Kommunikation initalisierten TcpClient zurückgeben. 
                TcpClient client = listener.AcceptTcpClient();
                Console.WriteLine("Connection accepted.");

                // Den Netzwerk-Stream abrufen.
                NetworkStream stream = client.GetStream();
                CommCommand cmd = new CommCommand();

                // Stream einlesen
                object outputString = CommProtocol.Read(stream, out cmd);
                Console.WriteLine("ObjectString: "+outputString+" Command: "+cmd);

                // hier case auf cmd:
                Console.WriteLine(((CommSendJob)outputString).Name);
                Console.WriteLine(((CommSendJob)outputString).Para);
                Console.WriteLine(((CommSendJob)outputString).Prio);
                Console.WriteLine();

                // Response von Server an Client
                // Response erstellen
                CommSendResponse resToSend = new CommSendResponse();
                resToSend.JobAccepted = false;
                resToSend.ErrMessage = "keine Routine hier vorhanden";
                // Response senden
                CommProtocol.Write(stream, resToSend, CommCommand.CommandSendResponse);


                // Den Verbindungs-Socket schließen.
                client.Close();
                Console.WriteLine("Connection closed.");

                // Den zugrundeliegenden Socket schließen (das Abhören neuer Anforderungen stoppen).
                listener.Stop();
                Console.WriteLine("Listener gestoppt.");


            }
            catch (Exception err)
            {
                Console.WriteLine(err.ToString());

            }

            Console.Read();
        }
    }
    
}

Client:
Program.cs

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CommLib;
using System.Net.Sockets;
using System.Net;
using SharedComponents;

namespace ca_xmlotcp_client
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Started!");

            // Job erstellen
            CommSendJob jobToSend = new CommSendJob();
            jobToSend.Name = "Jobname";
            jobToSend.Para = "cpu = 4";
            jobToSend.Prio = 1;
            
            // TCP Verbindung aufbauen
            TcpClient client = new TcpClient();
            Console.WriteLine("Verbindungsversuch mit Server " +
                    "über Anschluss 10000.");

            // Zu Server connecten
            client.Connect(IPAddress.Parse(ConInfo.serverIP), ConInfo.port);
            Console.WriteLine("Verbindung hergestellt.");
                
             // Den Netzwerk-Stream aufbauen              
             NetworkStream stream = client.GetStream();
             Console.WriteLine("Stream initialisiert!");

             // Job senden
             CommProtocol.Write(stream, jobToSend, CommCommand.CommandSendJob);

             // Response empfangen
             CommCommand cmd = new CommCommand();
             object outputString = CommProtocol.Read(stream, out cmd);
             Console.WriteLine(((CommSendResponse)outputString).JobAccepted);
             Console.WriteLine(((CommSendResponse)outputString).ErrMessage);

             Console.WriteLine("Trenne Verbindung...");
             // Den Verbindungs-Socket schließen.
             client.Close();
             Console.WriteLine("Anschluss geschlossen.");
             Console.Read();

        }
    }

}

Btw, i know that the post is 10 years old. But this is the best library i could find.

Could you please put a simple demo file please. I'm trying to integrate your code to mine but I'm having some problems.

thanks

any code sample I cant get a working app.. out of it =(
i tried James Bengard code gets nothing

modified on Monday, December 1, 2008 4:31 AM

search for picture chat c# here at code project. Is a good example on how to use NetworkStream class / TcpClient, etc.

Hi Hesham, I have this problem with two part (a Linux server side and Window client on the other side) to work on and I am a very beginner on XML. Your article kind of solve my problem on the client window side. What I am trying to do is to store a struct into XML file and send it across the ethnet to the Linux server and then parse the data into the appropriate structure. If I serialize the XML file one C#, is there a way to deserialize it on C programing? or could you recommand a way to do this problem. Thanks very much

my email is tmn114@yahoo.com.

Nothing to say

hello
I don't know development under linux that much but you have some solutions:
1- use linux development tools (java (NetBeans), C++ KDevelop,etc.)
2- Use DotNet development tools for linux (mono program)
3- Use GrassHopper to develop dotnet and deploy in linux http://dev.mainsoft.com/
4- Use google to find c library for XML parsing under linux

my sugeestions would be mono or java (netbeans)

good luck Smile | :)

Hesham

Hello,
First, I must appreciate the good work you have done. But I am having a problem, when a client sends more than one commands at a time, then on the server side I have written some code like this to read these commands

while(true)
{
if(netStream.DataAvailable)
{
object obj = CommLib.Read(netStream, out cmd);
}
}

The problem here is that only one command is read and the commands which are followed are discarded. Does anyone have any idea on how to do it?

I have one more question, why have you made all the methods static? We could create instances of this class and we would not have to create StreamReader every time for reading the same network stream. Just wondering...

This code seems great for serializing and sending objects over TCP/IP. Thanks!

However I'm having a problem with it right now...

When my client connects to the server, the server sends the client 16 messages in quick succession.

The first 2 messages come across ok. After that I get 10 more read attempts which all fail with the exception (Protocol Error, Header Corrupted). (so total reads only equal 12, which makes me think this is a message length problem)

Has anyone had this problem or know why it might be happening?

Confused... Confused | :confused:

Many thanks!!

could you send the code to me to review

Hi there,

Once again nice article. The problem I mentioned is because when packets are sent in quick succession, they can start to get fragmented and not all sent in burst. So basically Read returns before the whole message has been received.

To remedy this, I do the following in Read after I have read the xml_size in the header.

int totalRead = 0;
while(totalRead < xml_size)
{
char[] buf_temp = new char[xml_size-totalRead];
int numRead = reader.Read(buf_temp,0,xml_size-totalRead);
if( numRead <= 0)
{
throw new InvalidOperationException("user disconnected");
}
for(int i=totalRead; i < totalRead+numRead;i++)
buf[i]=buf_temp[i-totalRead];
totalRead+=numRead;
}

Thanks for the kewl article!

Big Grin | :-D

Since there was no formal sample, I was wondering if you could help clear this up for me, or let me know if what I am trying to do is way off track.

Server Code:
using System;
using System.Net.Sockets;
using System.Xml;
using CommLib;

namespace StreamServer
{
public class AsynchIOServer
{
public static void Main(string[] args)
{
TcpListener tcpListener = new TcpListener(8001); tcpListener.Start();
Socket socketForClient = tcpListener.AcceptSocket();

if(socketForClient.Connected)
{
Console.WriteLine("Client Connected");
NetworkStream networkStream = new NetworkStream(socketForClient);
CommSendText cmd = new CommSendText();
cmd.ChatText = "Hello from Mars";

CommProtocol.Write(networkStream,cmd,CommCommand.CommandSendText);

networkStream.Close();

}

socketForClient.Close();

Console.WriteLine("Exiting...");
}
}
}
=======End

The Client:
using System;
using System.Net.Sockets;
using CommLib;

namespace StreamClient
{
public class Client
{
static void Main(string[] args)
{
TcpClient socketForServer;

try
{
socketForServer = new TcpClient("localhost",8001);
}
catch
{
Console.WriteLine("Failed to connect to server at {0}:8001","localhost");
return;
}

NetworkStream networkStream = socketForServer.GetStream();

try
{
CommCommand cmd = new CommCommand();
object outputString = CommProtocol.Read(networkStream,out cmd);
Console.WriteLine(outputString.Equals(cmd));

switch(cmd)
{
case CommCommand.CommandStatus:
Console.WriteLine("Recieved CommandStatus");
break;
case CommCommand.CommandSendText:
Console.WriteLine("Recieved CommandSendText");
break;
default:
Console.WriteLine("Nothing");
break;
}
Console.WriteLine("Client Message");
}
catch
{
Console.WriteLine("Exception reading from Server");
}

networkStream.Close();
}
}
}
====End Client

What I don't understand is how to get the text "Hello from Mars" that is being sent.

Thanks in advance

This can be only if the client is listenning for specific port for incoming messages from server.
This can be done if client act as a server and client at the same time.
This can be done by creating two threads at tht client side:
1- Thread for sending messages to the server (client thread)
2- Thread for recieving messages from the server (server thread)

If you need detailed help just tell me. D'Oh! | :doh:

Hesham

To output the text that was sent, do the following.

<br />
object outputString = CommProtocol.Read(networkStream,out cmd);<br />
Console.WriteLine(((CommSendText)outputString).ChatText);<br />

That will output the text. I really wish this guy had included a sample! make like a lot easier. The code is very good though.

-- Cyonix

Is this how i could go about setting up a simple chat program?...(going to be client to client). I'm not sure if im right in my approach though.

Connect()
{
initialize tcpclient and network stream and get stream from tcpclient. do a beginread on network stream
}

OnRead(Asynchresult...)
{
collect bytes into a buffer until recieving zero...then do something with that data? or do i call your read function...not sure how to use your read function

display recieved text
}

Onbutton_sendmessage_clicked()
{
use your send function and network stream to send message
}

Hi I think you all right, I should add a sample to make it clear.
I will try to post the sample before the end of this week. D'Oh! | :doh:

any chanve you could put this sample please?

thanks a lot!

Hi, i'm using ur classe, and haveing this error ... "There is an error in XML document(3,2)" (3 and 2 r exemple)

Do u know where that comes from ?

Need more information about how you get this error.
Sample code will be nice Confused | :confused:

Ok so, this message occured when my client (or server) receive a message, and try to Deserialize it:
this line (ln 147 in CommProtocol.cs) -> CommSendTxt send_text = serializer.Deserialize(reader) as CommSendTxt;

I have tried to send many different type of object (string, xmldocument) by changing ur src but I always have this type of error.

This is the code that i'm using to send a msg :

Type ObjectType = xmlMsg.GetType();<br />
CommLib.CommProtocol.Write(myNetworkStream, xmlMsg,CommLib.CommCommand.CommandSendTxt);

And to receive it :

TcpClient newClient = new TcpClient(_ip,_port);<br />
NetworkStream myNetworkStream = newClient.GetStream();<br />
CommLib.CommCommand cmd = new CommLib.CommCommand();<br />
Object o = CommLib.CommProtocol.Read(myNetworkStream, out cmd);

I hope that u will say " OOHHH yeeahh i know this bug, u just have to ..." Cry | :((

I'm on this problem for 3 days, and just found ur library yesterday, but steel have my problem :-/

If u have some free time i can send u all the source.

Thx a lot for ur response Wink | ;)

Oh i forget to paste the entire error message :

Erreur de connection : System.InvalidOperationException: There is an error in XML document (2, 15). ---> System.Xml.XmlException: /* HERE there are various message, it depends of what is the type of object ... and it s not always the same message for the same type */ The root element is missing.
at System.Xml.XmlTextReader.ParseTag()
at System.Xml.XmlTextReader.ParseRoot()
at System.Xml.XmlTextReader.Read()
at System.Xml.XmlReader.ReadElementString()
at System.Xml.Serialization.XmlSerializationReader.ReadNullableString()
at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationReader1.Read2_string()
--- Fin de la trace de la pile d'exception interne ---
at System.Xml.Serialization.XmlSerializer.Deserialize(XmlReader xmlReader, String encodingStyle)
at System.Xml.Serialization.XmlSerializer.Deserialize(Stream stream)
at CorrectFileChecker.Reseau.client() in d:\travail-ecole\projets\i1b\chef d'oeuvre\test\correctfilechecker\correctfilechecker\reseau.cs:line 195 System.Xml.XmlException: La déclaration XML est inattendue. Ligne 2, position 24.
at System.Xml.XmlTextReader.ParseTag()
at System.Xml.XmlTextReader.ParseRoot()
at System.Xml.XmlTextReader.Read()
at System.Xml.XmlReader.ReadElementString()
at System.Xml.Serialization.XmlSerializationReader.ReadNullableString()
at Microsoft.Xml.Serialization.GeneratedAssembly.XmlSerializationReader1.Read2_string()

hope that u will able to see the problem :-/

ok, you can send me the source, it will be easier

Hi

I am trying to import CommLib.dll into Visual C++ 6.0 using this statement
#import "C:\Documents and Settings\Developer\Desktop\TCPIP\New Folder\XML_Communication_library_src\CommLib\bin\Debug\CommLib.dll"

Erorr is :

fatal error C1083: Cannot open type library file: 'C:\Documents and Settings\Developer\Desktop\TCPIP\New Folder\XML_Communication_library_src\CommLib\bin\Debug\CommLib.dll': Error loading type library/DLL.

Can you help me how to solve this problem.

Thanks

Regards
Asif Iqbal

Hi again,
as a beginning, you are using the CommandText to send a different data specified to this command.
For each new class type you want to transfer you should create a new command and handle this command in the server/client according to its command.

This is the main idea of the project

If this is not help you can sent your source code to me and I will modify it to understand it more.

Suspicious | :suss:

Hesha

hi how did you solve this problem .1 got same error.
thank you for answers..

XML Based Communication library

Introduction

Background

Using the code

License

Comments and Discussions