DeclaringType vs. ReflectedType


S

Sathyaish

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!");
}
}
}
 
Ad

Advertisements

D

Damien

Sathyaish said:
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
 
S

Sathyaish

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

Thanks!
 
D

Damien

Sathyaish said:
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
 
Ad

Advertisements

J

Jon Shemitz

Sathyaish said:
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
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Top