The documentation says:

System.Type.DeclaringType
~~~~~~~~~~~~~~~~~~~~~~~~~~
public override System.Type DeclaringType [ get]
Member of System.Type

Summary:
Gets the class that declares this member.


System.Type.ReflectedType
~~~~~~~~~~~~~~~~~~~~~~~~~~
public override System.Type ReflectedType [ get]
Member of System.Type

Summary:
Gets the class object that was used to obtain this member.



Looks like the first one gets the class where the guy is declared
whereas the second one gets the object instance name. I thought so too
until I tried several examples and each of them produced the same
output. The last example I just tried was:



using System;

namespace GetCallingMethodName
{
class Client
{
[STAThread]
static void Main(string[] args)
{
try
{
BarBase bar = new Bar();
bar.DoBar();
}
catch(Exception ex)
{
Console.WriteLine(ex.ToString());
}

}
}
}






using System;

namespace GetCallingMethodName
{
interface IBar
{
void DoBar();
}
}





using System;

namespace GetCallingMethodName
{
/// <summary>
/// Summary description for Bar.
/// </summary>
public class Bar: BarBase
{
public Bar(): base()
{
//Nothing
}

/*public override void DoBar()
{
Foo f = new Foo();
f.DoFoo();
return;
}*/
}
}




using System;

namespace GetCallingMethodName
{
public class BarBase: IBar
{
public BarBase()
{

}

public virtual void DoBar()
{
Foo f = new Foo();
f.DoFoo();
return;
}
}
}



using System;
using System.Diagnostics;

namespace GetCallingMethodName
{
/// <summary>
/// Summary description for Foo.
/// </summary>
public class Foo
{
public Foo()
{
//Nothing
}

public void DoFoo()
{
Console.WriteLine("Doing foo.\n");

StackTrace trace = new StackTrace();
int count = trace.FrameCount;
Console.WriteLine("StackFrame.FrameCount: " + count.ToString() +
"\n\n");

if (count == 1)
return; /* if no one called. Impossible, actually! */

for (int i = 1; i < count; i++)
{
StackFrame frame = trace.GetFrame(i);
Console.WriteLine("DeclaringType: " +
frame.GetMethod().DeclaringType.ToString());
Console.WriteLine("ReflectedType.FullName: " +
frame.GetMethod().ReflectedType.FullName.ToString());
Console.WriteLine("MemberType: " +
frame.GetMethod().MemberType.ToString());
Console.WriteLine("Name: " + frame.GetMethod().Name.ToString());
Console.WriteLine("ToString(): " + frame.GetMethod().ToString());


Console.WriteLine();
}
throw new Exception("Foo happened. Flee!");
}
}
}

Sathyaish wrote:
> The documentation says:
>
> System.Type.DeclaringType
> ~~~~~~~~~~~~~~~~~~~~~~~~~~
> public override System.Type DeclaringType [ get]
> Member of System.Type
>
> Summary:
> Gets the class that declares this member.
>
>
> System.Type.ReflectedType
> ~~~~~~~~~~~~~~~~~~~~~~~~~~
> public override System.Type ReflectedType [ get]
> Member of System.Type
>
> Summary:
> Gets the class object that was used to obtain this member.
>
>
>
> Looks like the first one gets the class where the guy is declared
> whereas the second one gets the object instance name. I thought so too
> until I tried several examples and each of them produced the same
> output.

Well, using reflector, in 1.1, you can see that the implementation of
both of these properties is "return this;", so I don't think you'll
ever see a difference for them. In fact, a quick search through other
inheritors of MemberInfo, all of them either access an internal object
of type MemberInfo and use it's implementation, or they have the same
code.

I cannot find any implemented types with different implementations, so
I don't believe there'll ever be a difference.

Damien

Gah! Why am I always so lazy to never open Reflector before I post a
question?

Thanks!

Sathyaish wrote:
> Gah! Why am I always so lazy to never open Reflector before I post a
> question?
>
> Thanks!

Because it gives me an excuse to open Reflector and look at something
different. I've never even seen these properties before, but now if I
ever do start working with them, I'll already know something about them
- so it gives me a chance to learn :-)

Damien

Sathyaish wrote:

> System.Type.DeclaringType

> Summary:
> Gets the class that declares this member.
>
> System.Type.ReflectedType

> Summary:
> Gets the class object that was used to obtain this member.
>
> Looks like the first one gets the class where the guy is declared
> whereas the second one gets the object instance name.

No. ReflectedType has nothing to do with instances. It is the Type
that a particular MemberInfo belongs to. If DeclaringType !=
ReflectedType, the member is inherited; you will get a different
MemberInfo if you query a derived type than if you query the base
type, even if you are looking at the same member.

Try running this code:

// begin snippet
using System;
using System.Reflection;

namespace Inheritance
{
class Program
{
static void Main(string[] args)
{
Type B = typeof(Base);
MethodInfo BaseFoo = B.GetMethod("Foo");
Console.WriteLine(
"In Base, DeclaringType = {0}, ReflectedTyped = {1}",
BaseFoo.DeclaringType.Name,
BaseFoo.ReflectedType.Name);

Type D = typeof(Derived);
MethodInfo DerivedFoo = D.GetMethod("Foo");
Console.WriteLine(
"In Derived, DeclaringType = {0}, ReflectedTyped = {1}",
DerivedFoo.DeclaringType.Name,
DerivedFoo.ReflectedType.Name);

Console.WriteLine(BaseFoo != DerivedFoo);

Console.ReadLine();
}
}

class Base
{
public virtual void Foo() { }
}

class Derived : Base { }
}
// end snippet

--

..NET 2.0 for Delphi Programmers www.midnightbeach.com/.net
Delphi skills make .NET easy to learn In print, in stores.