Imports System
Imports System.IO
Imports System.Reflection
Imports Microsoft.VisualBasic

Namespace MyNamespace1

    Interface i
        Function MyVar() As Integer
    End Interface
    ' DeclaringType for MyVar is i.

    Class A
        Implements i
        Function MyVar() As Integer Implements i.MyVar
            Return 0
        End Function
    End Class
    ' DeclaringType for MyVar is A.

    Class B
        Inherits A
        Function MyVars() As Integer
            Return 0
        End Function
    End Class
    ' DeclaringType for MyVar is B.

    Class C
        Inherits A
    End Class
    ' DeclaringType for MyVar is A.
End Namespace

Namespace MyNamespace2

    Class A
        Public Overridable Sub M()
        End Sub
    End Class

    Class B
        Inherits A
        Public Overrides Sub M()
        End Sub
    End Class
End Namespace
Class Mymemberinfo

    Public Shared Sub Main()

        Console.WriteLine(ControlChars.Cr & "Reflection.MemberInfo")

        'Get the Type and MemberInfo.
        Dim MyType As Type = Type.GetType("System.IO.BufferedStream")

        Dim Mymemberinfoarray As MemberInfo() = MyType.GetMembers()

        'Get and display the DeclaringType method.
        Console.WriteLine(ControlChars.Cr & "There are {0} members in {1}.", Mymemberinfoarray.Length, MyType.FullName)

        Dim Mymemberinfo As MemberInfo
        For Each Mymemberinfo In Mymemberinfoarray
            Console.WriteLine("The declaring type of {0} is {1}.", Mymemberinfo.Name, Mymemberinfo.DeclaringType.ToString())
        Next Mymemberinfo
    End Sub
End Class

using System;
using System.IO;
using System.Reflection;

namespace MyNamespace1 
{
    interface i 
    {
        int MyVar() ;
    };
    // DeclaringType for MyVar is i.

    class A : i 
    {
        public int MyVar() { return 0; }
    };
    // DeclaringType for MyVar is A.

    class B : A 
    {
        new int MyVar() { return 0; }
    };
    // DeclaringType for MyVar is B.

    class C : A 
    {
    };
    // DeclaringType for MyVar is A.

}

namespace MyNamespace2 
{
    class Mymemberinfo 
    { 

        public static void Main(string[] args) 
        { 

            Console.WriteLine ("\nReflection.MemberInfo");

            //Get the Type and MemberInfo. 
            Type MyType =Type.GetType("System.IO.BufferedStream");
            MemberInfo[] Mymemberinfoarray = MyType.GetMembers();

            //Get and display the DeclaringType method. 
            Console.WriteLine("\nThere are {0} members in {1}.", Mymemberinfoarray.Length, MyType.FullName); 

            foreach (MemberInfo Mymemberinfo in Mymemberinfoarray) 
            {  
                Console.WriteLine("Declaring type of {0} is {1}.", Mymemberinfo.Name, Mymemberinfo.DeclaringType); 
            }
        }
    }
}

namespace MyNamespace3 
{
    class A 
    {
        virtual public void M () {}
    }
    class B: A 
    {
        override public void M () {}
    }
}

using namespace System;
using namespace System::IO;
using namespace System::Reflection;

namespace MyNamespace1
{
   interface class i
   {
      int MyVar();
   };

   // DeclaringType for MyVar is i.
   ref class A: public i
   {
   public:
      virtual int MyVar()
      {
         return 0;
      }

   };

   // DeclaringType for MyVar is A.
   ref class B: public A
   {
   private:
      int MyVar() new
      {
         return 0;
      }
   };

   // DeclaringType for MyVar is B.
   ref class C: public A{};
}

// DeclaringType for MyVar is A.
int main()
{
   Console::WriteLine( "\nReflection.MemberInfo" );

   //Get the Type and MemberInfo. 
   Type^ MyType = Type::GetType( "System.IO.BufferedStream" );
   array<MemberInfo^>^Mymemberinfoarray = MyType->GetMembers();

   //Get and display the DeclaringType method. 
   Console::WriteLine( "\nThere are {0} members in {1}.", Mymemberinfoarray->Length, MyType->FullName );
   System::Collections::IEnumerator^ enum0 = Mymemberinfoarray->GetEnumerator();
   while ( enum0->MoveNext() )
   {
      MemberInfo^ Mymemberinfo = safe_cast<MemberInfo^>(enum0->Current);
      Console::WriteLine( "Declaring type of {0} is {1}.", Mymemberinfo->Name, Mymemberinfo->DeclaringType );
   }
}

namespace MyNamespace3
{
   ref class A
   {
   public:
      virtual void M(){}

   };

   ref class B: public A
   {
   public:
      virtual void M() override {}
   };
}