More about "class of" in C#

[Borland]

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;

[Joanna Carter [TeamB]]

Borland a écrit :

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

[Borland]

My apologies to the group, (and Borland) - I didn't even notice that Outlook
Express had re-christened me. I think I have now changed my identity
(File|Identity), but won't know for sure until I post this reply.

In the meantime, many thanks for your comprehensive reply - it was more than
I dared hope for.

I'm a beginner when it comes to C#, and am struggling a bit. I am perhaps
biased - but Delphi does have a certain elegance when it comes to this sort
of stuff that is still hard to beat.

Cheers,
David.
"Joanna Carter [TeamB]" <joa...@nospam.for.me> wrote in message
news:4677...@newsgroups.borland.com...

[David Fallas]

Right - got it now!

[Borland]

Obviously, that didn't work - I'm having as much trouble with OE as C#.

If this doesn't work, I'll ask for expert assistance.

[Joanna Carter [TeamB]]

David Fallas a écrit :

> Right - got it now!

Yaayy!!!

[Joanna Carter [TeamB]]

Borland a écrit :

> I'm a beginner when it comes to C#, and am struggling a bit. I am perhaps
> biased - but Delphi does have a certain elegance when it comes to this sort
> of stuff that is still hard to beat.

The great thing about this group is that you don't just get the C#, you
get the Delphi experience as to how to do the conversion :-)

[David Fallas]

For the sake of completeness for anyone referring to this thread in future -
there is a little bit more to the story if using the first strategy
suggested.

Where there is a requirement to call a static method which has NOT been
overridden in a descendent class, the type.GetMethod() method will not find
it (where type is the descendent's type).

Instead, if it isn't known if the method has been overridden or not, one
needs to check the return from the type.GetMethod("xxxx") call and if null,
call type.BaseType.GetMethod("xxxx") to find the base class' implementation
of the method.

This appears to differ significantly from Delphi which seems to be capable
of finding either a base or overridden method quite happily.

"Joanna Carter [TeamB]" <joa...@nospam.for.me> wrote in message
news:4677...@newsgroups.borland.com...

[Joanna Carter [TeamB]]

David Fallas a écrit :

> For the sake of completeness for anyone referring to this thread in future -
> there is a little bit more to the story if using the first strategy
> suggested.
>
> Where there is a requirement to call a static method which has NOT been
> overridden in a descendent class, the type.GetMethod() method will not find
> it (where type is the descendent's type).
>
> Instead, if it isn't known if the method has been overridden or not, one
> needs to check the return from the type.GetMethod("xxxx") call and if null,
> call type.BaseType.GetMethod("xxxx") to find the base class' implementation
> of the method.

Thanks for that. I only omitted that due to lack of time.

> This appears to differ significantly from Delphi which seems to be
> capable of finding either a base or overridden method quite happily.

Delphi can find derived static methods because they are declared
virtual; something that cannot be done in C#.