🚀 go-pugleaf

Borland a �crit :

> Referring to that posting from December last year re "class of"... I 
> understand the use of Activator.CreateInstance(ClassType) as a replacement 
> for the Delphi "class of" for use in a C# abstract class factory, but how 
> would I use that ClassType reference to call a static method (eg public 
> static DoIt()) which has been declared in the Class class?
> 
> In Delphi I would simply retrieve the "class of" reference, (eg ClassClass - 
> class of TClass), and call the function normally - eg 
> TClass(ClassClass).DoIt; 

First, can I ask you to change your posting name from Borland ?

Now, to the matter in hand.

Don't forget that, in C#, static methods cannot be virtual. Therefore, 
you have to redlclare the method in each and every derived class but 
simply calling the static method on the base type will only call that 
method, not the derived one.

However, here is a simple example fo how to create a factory class that 
will call the correct method, depending on the type passed in.

   public class Base
   {
     public static void DoIt(int arg) { }
   }

   public class Derived : Base
   {
     public static void DoIt(int arg) { }
   }

   public static class Factory
   {
     public static void DoIt(Type type, int arg)
     {
       if (!typeof(Base).IsAssignableFrom(type))
         throw new Exception("Type must derive from Base");

       Type[] argTypes = new Type[] { typeof(int) };

       MethodInfo mi = type.GetMethod("DoIt", argTypes);

       object[] args = new object[] { arg };

       mi.Invoke(null, args);
     }
   }

     private void button1_Click(object sender, EventArgs e)
     {
       Type type = typeof(Derived);

       Factory.DoIt(type, 123);
     }

You can also use the idea of a metaclass to achieve a more Delphi-like 
syntax.

   public class Base
   {
     #region metaclass

     public class ClassReference
     {
       #region private members

       private Type internalType;

       #endregion

       public void DoIt(int value)
       {
         MethodInfo methodInfo = internalType.GetMethod("DoIt", 
BindingFlags.Public | BindingFlags.Static);

         object[] args = new object[] { value };

         methodInfo.Invoke(null, args);
       }

       #endregion

       #region constructors

       // default constructor
       private ClassReference(Type type)
       {
         internalType = type;
       }

       #endregion

       #region implicit conversion operator

       public static implicit operator ClassReference(Type input)
       {
         if (!typeof(Shape).IsAssignableFrom(input))
           throw new ArgumentException(String.Format("Type {0} must 
derive from {1}", input.Name, typeof(Base).Name), "input");

         return new ClassReference(input);
       }

       #endregion
     }

     #endregion

     public static void DoIt(int value) {...}
   }

   public class Derived : Base
   {
     public static void DoIt() {...}
   }

This then allows the following calling syntax :

   {
     Base.ClassReference classRef = typeof(Derived);

     classRef.DoIt(123);
   }

Is that what you are looking for ?

Joanna

-- 
Joanna Carter [TeamB]
Consultant Software Engineer