C#

[Serializable()]  
public class MyModelObject : ISerializable  
{  
private int a;  
private string b;  

public MyModelObject()  
{  
}  
  
public MyModelObject(int a, string b):base()  
{  
this.a = a;  
this.b = b;  
}  
  
protected MyModelObject(SerializationInfo info, StreamingContext context)  
{  
this.A = info.GetInt32("A");  
this.B = info.GetString("B");  
}  
  
public int A  
{  
get {return this.a;}  
set {this.a = value;}  
}  
  
public string B  
{  
get {return this.b;}  
set {this.b = value;}  
}  
 
void ISerializable.GetObjectData(SerializationInfo info,   
StreamingContext context)  
{  
info.AddValue("A", this.a);  
info.AddValue("B", this.b);  
}  
}

using System.Runtime.Remoting;
using System.Collections;

[Serializable]
public class WidgetCollection:CollectionBase
{
   /// <summary>
   /// Allows indexed access of the Widget item collection
   /// </summary>
   public WidgetItem this[int index]
   {
  get{return (WidgetItem)this.List[index]; }
  set{this.List[index] = value; }
   }
   ///<summary>
   ///  Required Add() method def
   ///</summary>
   public void Add(WidgetItem item)
     {List.Add(item)}
   ///<summary>
   ///  Strong typed key access
   ///</summary>
   public WidgetItem this(string key)
     {return (WidgetItem) List(key)}
 }

 [Serializable]
 public class WidgetItem
 {
      Sprocket internalSprocket
      Spoke    internalSpoke
      DooHickey internalDooHickey
      //public accessors....
      ...
 }

public class WidgetManager:MarshalByRefObject, IWidgetManager
{
   public Widget GetWidget(WidgetKey item)
   {
      WidgetCollection itemList = Server.PopulateWidgets();
      return itemList[item];
   }
}

[Serializable]
public class Sprocket()
{
    ...existing definition
}
[Serializable]
public class Spoke()
{
    ...existing definition
}
[Serializable]
public class DooHickey()
{
    ...existing definition
}

"With the exception of earlier TCP/IP RPC implementations, in which you even had to worry about little-endian/big-endian conversions,
 all current remoting frameworks support the automatic encoding of simple data types into th echosen transfer format.  
The problem starts when you want to pass a copy of an object from server to client.  Java RMI and EJB support these requirements, but COM+ for example, did not.  
The commonly used serializable objects within COM+ were PropertyBags and ADO Recordsets -- but there was no easy way of passing large object structs around. 

In .NET Remoting the encoding/decoding of objects is natively supported.  
You just need to mark such objects with the [Serializable] attribute -OR- implement the interface ISerializable and the rest will be taken care of by the framework.  
This even allows you to pass your objects cross-platform via XML.

The serialization mechanism marshal simple data types and subobjects (which have to be serializable or exist as remote objects),
 and even ensures that circular references (which could result in endless loops when not discovered) don't do any harm.

<sub> -- Ingo Rammer, Advanced .NET Remoting </sub>