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:
Show quoteHide quoteWell, 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:
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:

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

Events in C#
Windows service timeout
DateTime.Now.ToString("t") not printing what I expect
Bug in C# compiler
Nested Iterators & C# 3.0 yeilds problems?