Key words for reference: base this

base

The base   keyword is used to access members of the base class from derived classes:  

Calls methods on the base class that have been overridden by other methods.  
Specifies the base class constructor to be invoked when a derived class instance is created.  
Base class access can only be done in a constructor, instance method, or instance property accessor.  

Example:

Invokes a base class method in a derived class.  
//   base   //   accesses the base class member
using   System;

public   class   BaseClass
{
        protected   string   _className   =   "BaseClass";

        public   virtual   void   PrintName()
        {
                Console.WriteLine("Class   Name:   {0}",   _className);
        }
}

class   DerivedClass   :   BaseClass
{
        public   string   _className   =   "DerivedClass";

        public   override   void   PrintName()
        {
                Console.Write("The   BaseClass   Name   is   {0}");
                // call the base class method
                base.PrintName();
                Console.WriteLine("This   DerivedClass   is   {0}",   _className);
        }
}

class   TestApp
{
        public   static   void   Main()
        {
                DerivedClass   dc   =   new   DerivedClass();
                dc.PrintName();
        }
}

/**//*
Console output:
The   BaseClass   Name   is   BaseClass
This   DerivedClass   is   DerivedClass
*/
The base class constructor is called in a derived class.  
//   keywords_base2.cs
using   System;
public   class   BaseClass
{
        int   num;

        public   BaseClass()
        {
                Console.WriteLine("in   BaseClass()");
        }

        public   BaseClass(int   i)
        {
                num   =   i;
                Console.WriteLine("in   BaseClass(int   {0})",   num);
        }
}

public   class   DerivedClass   :   BaseClass
{
        //   the constructor calls   BaseClass.BaseClass ()
        public   DerivedClass()   :   base()
        {
        }

The constructor calls   BaseClass.BaseClass (int   i)
        public   DerivedClass(int   i)   :   base(i)
        {
        }

        static   void   Main()
        {
                DerivedClass   dc   =   new   DerivedClass();
                DerivedClass   dc1   =   new   DerivedClass(1);
        }
}

/**//*
Console output:
in   BaseClass()
in   BaseClass(1)
*/

Note that some

It is wrong to use the   base   keyword from a static method.  
base   is primarily used for the aspect of opposition to object-oriented development, as shown in example 2.  
this
The this   keyword refers to the current instance of the class.

The following are common USES of   this  :

Qualifies members  
hidden by similar names Pass the object as a parameter to other methods  
Declare the indexer  
Example:

  composite example.  
//   this   //   keywords_this.cs
using   System;
class   Employee
{
        private   string   _name;
        private   int   _age;
        private   string[]   _arr   =   new   string[5];

        public   Employee(string   name,   int   age)
        {
              //   name age
                this._name   =   name;
                this._age   =   age;
        }

        public   string   Name
        {
                get   {   return   this._name;   }
        }

        public   int   Age
        {
                get   {   return   this._age;   }
        }

        //   prints employee data
        public   void   PrintEmployee()
        {
            //   passes the Employee object as a parameter to the DoPrint method
                Print.DoPrint(this);
        }

        //   declares the indexer
        public   string   this[int   param]
        {
                get   {   return   _arr[param];   }
                set   {   _arr[param]   =   value;   }
        }

}
class   Print
{
        public   static   void   DoPrint(Employee   e)
        {
                Console.WriteLine("Name:   {0}\nAge:   {1}",   e.Name,   e.Age);
        }
}

class   TestApp
{
        static   void   Main()
        {
                Employee   E   =   new   Employee("Hunts",   21);
                E[0]   =   "Scott";
                E[1]   =   "Leigh";
                E[4]   =   "Kiwis";
                E.PrintEmployee();

                for(int   i=0;   i < 5;   i++)
                {
                        Console.WriteLine("Friends   Name:   {0}",   E[i]);
                }

                Console.ReadLine();
        }
}

/**//*
Console output:
Name:   Hunts
Age:   21
Friends   Name:   Scott
Friends   Name:   Leigh
Friends   Name:  
Friends   Name:  
Friends   Name:   Kiwis
*/