What really is the purpose of “base” keyword in c#?

Question

Thus for used base class for some commom reusable methods in every page of my application...

public class BaseClass:System.Web.UI.Page
{
   public string Get         


        

Answer 1

The real purpose of the “base” keyword in c# is as follows: suppose you want to call only the parent class' parameterized constructor - then you can use base and pass the parameters, please see below example...

Example -

 class Clsparent
{
    public Clsparent()
    {
        Console.WriteLine("This is Clsparent class constructor");
    }
    public Clsparent(int a, int b)
    {
        Console.WriteLine("a value is=" + a + " , b value is=" + b);
    }
}
class Clschild : Clsparent
{
    public Clschild() : base(3, 4)
    {
        Console.WriteLine("This is Clschild class constructor");
    }
}
class Program
{
    static void Main(string[] args)
    {
        Clschild objclschild = new Clschild();
        Console.Read();
    }
}

Answer 2

You will use base keyword when you override a functionality but still want the overridden functionality to occur also.

example:

 public class Car
 {
     public virtual bool DetectHit() 
     { 
         detect if car bumped
         if bumped then activate airbag 
     }
 }


 public class SmartCar : Car
 {
     public override bool DetectHit()
     {
         bool isHit = base.DetectHit();

         if (isHit) { send sms and gps location to family and rescuer }

         // so the deriver of this smart car 
         // can still get the hit detection information
         return isHit; 
     }
 }


 public sealed class SafeCar : SmartCar
 {
     public override bool DetectHit()
     {
         bool isHit = base.DetectHit();

         if (isHit) { stop the engine }

         return isHit;
     }
 }

Answer 3

If you have the same member in class and it's super class, the only one way to call member from super class - using base keyword:

protected override void OnRender(EventArgs e)
{
   // do something

   base.OnRender(e);

   // just OnRender(e); will bring a StakOverFlowException
   // because it's equal to this.OnRender(e);
}

Answer 4

The base keyword is used to access members in the base class that have been overridden (or hidden) by members in the subclass.

For example:

public class Foo
{
    public virtual void Baz()
    {
        Console.WriteLine("Foo.Baz");
    }
}

public class Bar : Foo
{
    public override void Baz()
    {
        Console.WriteLine("Bar.Baz");
    }

    public override void Test()
    {
        base.Baz();
        Baz();
    }
}

Calling Bar.Test would then output:

Foo.Baz;
Bar.Baz;

Answer 5

Base is used in two ways.

1. Base with functions
2. Base with variables.

Base with functions

When base is used with functions the purpose of it is to call the parent class with parameters when parent class is inherited by the child class. I will explain that with an example.

1. In the following example console prints..

parameter is 1, This is child constructor

2. Now if you removed base(parameter), then console prints..

This is Parent Constructor, This is child constructor

When you instantiate an object from child class, the constructor is called as soon as it's instantiated. When you inherit the parent class from child class, both constructors in parent, and child classes are called because both are instantiated. When using base() you directly call the constructor in the parent class. So if it says base(), it means the constructor in parent class without any parameters, when using base(parameter), it means the constructor in the parent class with a parameter. This is a sort of function overloading. The type of parameter variable used inside of the base() brackets is defined by parameters list of the function used with base (in the following instance it's child(int parameter))

using System;

class Parent
{
    public Parent()
    {
        Console.WriteLine("This is Parent Constructor");
    }
    public Parent(int parameter)
    {
        Console.WriteLine("parameter is " + parameter);
    }
}

class Child : Parent
{
    public Child(int parameter): base(parameter)
    {
        Console.WriteLine("This is child constructor");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Child childObject = new Child(1);
    }
}

Demo https://repl.it/@donqq/baseKeyword#main.cs

---

Base with variables.

1. In the following example, console prints..

Parent, Child.

In the following example, if you use base keyword, it means you address to the parent class inherited by the child class. If you use this, you address to the class itself, which means the child class as you instantiated the child class, and thereby calling its constructor. So when you use base.value it means you refer to the variable in the parent class, and when you refer to the this.value it means you refer to the variable in the child class. You can distinguish to which variable you refer to with this base, this keywords when both have same names. remember you can't use base, this keywords in the class outside of a function. You have to use them inside of a function to refer to a variable initialised in the global level. Also you can't use them to refer to a local variable initialised inside of a function.

using System;

class Parent
{
    public string value = "Parent";
}

class Child : Parent
{
    public string value = "Child";

    public Child() {
      Console.WriteLine(base.value);
      Console.WriteLine(this.value);
    }

}

class Program
{
    static void Main(string[] args)
    {
        Child childObject = new Child();
    }
}

Demo https://repl.it/@donqq/Base-Class

Answer 6

Generally, we are using the base class to reuse the property or methods in child class of the base class, so we no need to repeat the same property and methods again in the child class.

Now, we use the base keyword to call a constructor or method from base class directly.

Example

public override void ParentMethod() 
  {
     base.ParentMethod(); //call the parent method

     //Next code.
  }

2) Example

class child: parent
{
    public child() : base(3, 4) //if you have parameterised constructor in base class
    {

    }
}