Serialize

[djidan]

hi,

i am a newbe to c#, i'm trying to send en custom object from a client to a server, after reading a lot on the web ifound that i need to use:
BinaryFormatter , MemoryStream, and Serialize Function, and Deserialize Function,
but the thing is that when trying to Serialize and then Deserialize on the same project it's working perfectly, but when i send the message to the server and trying to Deserialize i get en exception "Unable to find assembly"...,
i read on the web that i need the two classes (both of the server and the client) need to be able to read the same assembly, telling the truth i don't know what they mean...!

my code is:

client:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Reflection;
 
namespace Client
{
    [Serializable]
    class publicMessage
    {
        public publicMessage(string mTs,Color cTs)
        {
            this.MessageToSend = mTs;
            this.ColorToSend = cTs;
        }
 
        private string messageToSend;
        private Color colorToSend;
 
        #region propertys
        public string MessageToSend
        {
            get { return this.messageToSend; }
            set { this.messageToSend = value; }
        }
        public Color ColorToSend
        {
            get { return this.colorToSend; }
            set { this.colorToSend = value; }
        } 
        #endregion
 
        #region Serialize \ Deserialize
        public static byte[] Serialize(publicMessage toSerialize)
        {
            BinaryFormatter bf = new BinaryFormatter();
            bf.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
 
            //bf.Binder = new VersionConfigToNamespaceAssemblyObjectBinder();
            MemoryStream ms = new MemoryStream();
 
            bf.Serialize(ms, toSerialize);
            ms.Close();
            return ms.GetBuffer();
        }
        public static publicMessage Deserialize(byte[] bytes)
        {
            BinaryFormatter bf = new BinaryFormatter();
            bf.AssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
            //bf.Binder=new VersionConfigToNamespaceAssemblyObjectBinder();
            MemoryStream ms = new MemoryStream();
 
            ms.Write(bytes, 0, bytes.Count());
            ms.Seek(0, 0);
            return (publicMessage)(bf.Deserialize(ms));
        } 
        #endregion
 
        internal sealed class VersionConfigToNamespaceAssemblyObjectBinder : SerializationBinder
        {
            public override Type BindToType(string assemblyName, string typeName)
            {
                Type typeToDeserialize = null;
                try
                {
                    string ToAssemblyName = assemblyName.Split(',')[0];
                    Assembly[] Assemblies = AppDomain.CurrentDomain.GetAssemblies();
                    foreach (Assembly ass in Assemblies)
                    {
                        if (ass.FullName.Split(',')[0] == ToAssemblyName)
                        {
                            typeToDeserialize = ass.GetType(typeName);
                            break;
                        }
                    }
                }
                catch (Exception e)
                {
                    throw e;
                }
                return typeToDeserialize;
            }
        }
    }
}

as you can see i tried also to use a custom binder (i read it on other forum) but it didn't help, i have both on the server and both on the client the same code above, with a change in the namespace.
if someone can help me it will be great.

thank you
idan

[djidan]

hi,
ok never mind, i figure it out my self.
and for the curious one the only thing that i needed to do is to add a reference to the other project of mine (server) in the client project and then make a object from the referenced class get the object from the socket and then convert it to the server class in the client project.
sound's easy hard to figure it out.

thank's anyway

[mldisibio]

Hi djidan,

You found a legitimate workaround, but I just wanted to point out a few things.
1. What you are actually emulating is "Remoting." The Framework has some built in classes under System.Runtime. Remoting that can handle much of the client/server communication infrastructure and the serialization. You would only write your own serialization routines if they needed to be customized. Otherwise, it will serialize your objects for you out of the box.

That said, it could well be that it won't work for you and you need to write your own communication infrastructure. ..there are several ways to do the same thing...just pointing out Remoting.

2. When you think about what you are trying to accomplish, have two seperate and distinct applications, a client and a server, it sort of diminishes that architecture by then publishing the server assembly to the client. It is a legitimate workaround, and is often the easiest setup for initial development. But imagine you were publishing your client to your customers, but you did not want them to have access to your server library?

The workaround is to create a third library with objects you don't mind having public. The client references this library, and thereby the serialization works, and the server references the same library. Often these objects would be interfaces or abstract classes. Just enough for the client to have what it needs to reference the server, but no actual server code that someone could accidentally start using outside your client.

There are a lot of aspects to Remoting, too many for a short forum response. If anything I have mentioned peaks your interest, I suggest a good book on remoting, such as "Microsoft .NET Remoting" by Scott McLean.

The issue you are dealing with, if you were to google it or read about it, is "Remoting" and "Metadata dependency."

[djidan]

Hi mldisibio,

Thank you for your reply, about the issue of to put the code of the server in the client project, i already thought about what you said, and i wasn't sure what i need to do, if i need to link the client.exe to the server or to link the server.exe to the client, or to build a new project (as you said) and write the code that are relevent to both sides, and to give reference to both sides, there is somthing about what you saing that if i will realse the program "Client" as a new program to a lot of users they will be able to see my code, so i will listen to your advise and create a new project.
I have just one question is there any other way to that, or it's hard to explain on a forum?

thank's anyway

idan
p.s: not djidan

[mldisibio]

Besides Scott McLean, another good remoting author is Ingo Rammer. You can find his website at thinktecture and some specific articles and facts at thinktecture - Resources. In particular, the .Net Remoting Best Practices pdf. As he notes, the syntax is dated to the 1.1 Framework, but the principles still apply. Some of the examples use SOAP, but the same architecture applies to straight binary serialization, which is what your are using.
At this site, you will find some sample source code which accompanies his book: Advanced .NET Remoting book. In the Chapter 3 samples, you the "Singleton Objects" sample presents three very simple sample classes:

- the server class "MyRemoteObject "

using System;
using System.Runtime.Remoting;
using General;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
 
namespace Server{
  class MyRemoteObject: MarshalByRefObject, IMyRemoteObject
  {
    int myvalue;
    public MyRemoteObject()   {
      Console.WriteLine("MyRemoteObject.Constructor: New Object created");
    }
 
    public MyRemoteObject(int startvalue)     {
      Console.WriteLine("MyRemoteObject.Constructor: .ctor called with {0}",startvalue);
      myvalue = startvalue;
    }
 
    public void setValue(int newval)    {
      Console.WriteLine("MyRemoteObject.setValue(): old {0} new {1}",myvalue,newval);
      myvalue = newval;
    }
    public int getValue()     {
      Console.WriteLine("MyRemoteObject.getValue(): current {0}",myvalue);
      return myvalue;
    }
  }
 
  class ServerStartup {
    static void Main(string[] args)   {
      Console.WriteLine ("ServerStartup.Main(): Server started");
 
      HttpChannel chnl = new HttpChannel(1234);
      ChannelServices.RegisterChannel(chnl);
      RemotingConfiguration.RegisterWellKnownServiceType(
          typeof(MyRemoteObject),
          "MyRemoteObject.soap", 
          WellKnownObjectMode.Singleton);
 
      // the server will keep running until keypress.
      Console.ReadLine();
    }
  }
}

- the go-between class "IRemoteObj ect" which both the client and server have a reference to:

using System;
namespace General{
  public interface IMyRemoteObject  {
    void setValue(int newval);
    int getValue();
  }
}

- and the client class "Client"

using System;
using System.Runtime.Remoting;
using General;
using System.Runtime.Remoting.Channels.Http;
using System.Runtime.Remoting.Channels;
namespace Client
{
  class Client
  {
    static void Main(string[] args)
    {
      HttpChannel channel = new HttpChannel();
      ChannelServices.RegisterChannel(channel);     
      IMyRemoteObject obj = 
      (IMyRemoteObject) Activator.GetObject(typeof(IMyRemoteObject), "http://localhost:1234/MyRemoteObject.soap");
      Console.WriteLine("Client.Main(): Reference to rem.obj. acquired");
 
      int tmp = obj.getValue();
 
      Console.WriteLine("Client.Main(): Original server side value: {0}",tmp);
      Console.WriteLine("Client.Main(): Will set value to 42");
      obj.setValue(42);
      tmp = obj.getValue();
      Console.WriteLine("Client.Main(): New server side value {0}", tmp);
      Console.ReadLine();
    } 
  }
}

Again, the syntax to register the channels needs to be updated for 2.0, you don't need to use SOAP, but you get the basic idea. Your "clients" would only have access to the IRemoteObject interface. They could not do anything with it - they could not create a new instance, nor even mistakenly use it to directly access the server. However, it contains all the metadata needed by for the client to understand and deserialize the server object.