C#

Jacob D Dixon wrote:

I get the idea, you implement a interface, you inherit a class..

<br />
#region Libraries<br />
using System;<br />
using System.Collections.Generic;<br />
using System.Reflection;<br />
#endregion<br />
<br />
namespace Utilities<br />
{<br />
    // T is the type of the object containing the method to be invoked.<br />
    // R is the type of the return value expected.<br />
    // Methods that fail to return a value, or are declared as void,<br />
    // will return default(R), which in many cases (depending on typeof(R)) will be null.<br />
    public class DynamicMethodInvocation<T, R><br />
    {<br />
        // The methodParameterValues dictionary requires the parameter's name as the key<br />
        // and the parameter's value as the object. If ParameterValues == null, no<br />
        // parameters are passed to the method invocation.<br />
        public R Invoke(string MethodName, IDictionary<string, object> methodParameterValues)<br />
        {<br />
            return Invoke(MethodName, methodParameterValues, null);<br />
        }<br />
<br />
        // constructorParameters are the parameters required by the object T's constructor<br />
        // if any. If T's constructor requires no parameters pass null, or use the<br />
        // overload.<br />
        public R Invoke(string MethodName, IDictionary<string, object> methodParameterValues, object[] constructorParameters)<br />
        {<br />
            T instance = (T)Activator.CreateInstance(typeof(T), constructorParameters);<br />
            MethodInfo mi = instance.GetType().GetMethod(MethodName);<br />
            if (methodParameterValues != null)<br />
            {<br />
                ParameterInfo[] parameters = mi.GetParameters();<br />
                object[] values = (object[])Array.CreateInstance(typeof(object), parameters.Length);<br />
                foreach (ParameterInfo parameter in parameters)<br />
                {<br />
                    values[parameter.Position] = methodParameterValues[parameter.Name];<br />
                }<br />
                return (R)mi.Invoke(instance, values);<br />
            }<br />
            else<br />
            {<br />
                return (R)mi.Invoke(instance, null);<br />
            }<br />
        }<br />
    }<br />
}<br />

TYourBase = class(TObject)
protected
  procedure WriteToStream(AStream : TMemoryStream); virtual;
  procedure ReadFromStream(AStream : TMemoryStream); virtual;
public
  function ToStream : TMemoryStream;
  procedure FromStream(AStream : TMemoryStream);
end;

procedure TYourBase.WriteToStream(AStream : TMemoryStream); 
begin
  // do some basic writing to the stream...
end;

procedure TYourBase.ReadFromStream(AStream : TMemoryStream); 
begin
  // do some basic reading from the stream...
end;

function TYourBase.ToStream : TMemoryStream;
begin
  Result := TMemoryStream.Create;
  WriteToStream(Result);
end;

procedure TYourBase.FromStream(AStream : TMemoryStream);
begin
  // maybe do some checks here...
  ReadFromStream(AStream);
end;

TSomeDescendant = class(TYourBase)
protected
  procedure WriteToStream(AStream : TMemoryStream); override;
  procedure ReadFromStream(AStream : TMemoryStream); override;
public
  SomeString : String;
  SomeInteger : Integer;
  SomeFloat : Real;
end;

procedure TSomeDescendant.WriteToStream(AStream : TMemoryStream); 
begin
  // You would want to call this because the ancestor will most probably 
  // have done it's own bit of writing to the stream...
  inherited WriteToStream(AStream); 
  // Now write your class specific stuff...
  AStream.WriteString(SomeString);
  AStream.WriteInteger(SomeInteger);
  AStream.WriteFloat(SomeFloat);
end;

procedure TSomeDescendant.ReadFromStream(AStream : TMemoryStream);
begin
  // You would want to call this because the ancestor will most probably 
  // have done it's own bit of reading from the stream...
  inherited ReadFromStream(AStream); 
  // Now write your class specific stuff...
  SomeString := AStream.ReadString;
  SomeInteger := AStream.ReadInteger;
  SomeFloat := AStream.ReadFloat;
end;

var
  LSomeObject : TSomeDescendant;
  LStream : TMemoryStream;
begin
  // Initialise the descendant class...
  LSomeObject := TSomeDescendant.Create;
  LSomeObject.SomeString := 'test';
  LSomeObject.SomeInteger := 1;
  LSomeObject.SomeFloat := 5.5;
  // let's stream the object...
  LStream := LSomeObject.ToStream;
  // now free the object...
  FreeAndNil(LSomeObject);
  // recreate the object and load it from the stream...
  LSomeObject := TSomeDescendant.Create;
  LSomeObject.FromStream(LStream);
end;