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