Differentiate Hiding And Overriding

public virtual string FunctionToOverride()
{
    return "This is from base class FunctionToOverride";
}
public string FunctionToHide()
{
    return "This is from base class FunctionToHide";
}

public override string FunctionToOverride()
{
    return "This is from derived class FunctionToOverride";
}
public new string FunctionToHide()
{
    return "This is from derived class FunctionToHide";
}

private void Page_Load(object sender, System.EventArgs e)
{
    DerivedClass der = new DerivedClass();
    Label1.Text = der.FunctionToOverride();
}

public string FunctionToOverride()
{
    return "This is from base class FunctionToOverride";
}

DerivedClass der = new DerivedClass();
Label1.Text = der.FunctionToHide();

public string FunctionToHide()
{
    return "This is from derived class FunctionToHide";
}

You can still run the program and can produce the same output as just above. So another point we got as if we define 2 exactly similar functions with the same prototype in a base class and derived class, "Hiding" will be the default action performed.

So you listening to the basic differences between hiding and overriding. So here is another one just for you to try. Make the access modifiers of the base class protected and keep that of the derived class unchanged. Then you will find that hiding has no problem after changing the base class access modifier. But the program won't compile if you change the access modifier of the derived class in case of overriding, as it won't allow you to change the access modifier of the base class. This is an important point to care about.

Let me finish this article by explaining one more point in this matter. Just define the following structure in the base class i.e. class with the name "BaseClass".

public struct StructToOverride
{
    string str;
    public string FunctionInStructure()
    {
        str = "This is from base class FunctionInStructure";
        return str;
    }
}

And add the following structure in the derived class i.e. class with the name "DerivedClass".

public struct StructToOverride
{
    public string str;
    public string FunctionInStructure()
    {
        str = "This is from base class FunctionInStructure";
        return str;
    }
}

Now just try to compile the program, and you will fired with an error specifying that the structure is not meant for an override operation.

Then what about hiding? Will they support structures? Just check it by first defining the following structure in the base class.

public struct StructToHide
{
    string str;
    public string FunctionInStructure()
    {
        str = "This is from base class FunctionInStructure";
        return str;
    }
}

Then the following structure in the derived class with the keyword "new" as below.

public new struct StructToHide
{
    string str;
    public string FunctionInStructure()
    {
        str = "This is from derived class FunctionInStructure";
        return str;
    }
}

Now try it from the form load event of the web form as below.

private void Page_Load(object sender, System.EventArgs e)
{
    WebApplication1.DerivedClass.StructToHide struct1 = new WebApplication1.DerivedClass.StructToHide();
    Label1.Text = struct1.FunctionInStructure();
}

You will get messages from the hiding structure. So another point is overriding support methods, properties, and some limited class members. But hiding supports more like that of structures.

My opinion is that feel free to use hiding as I think it's still not widely used. It is very helpful in case u bought a 3rd party control/dll and you want to use that control without some methods of that control/dll. So just hide them and use other functionalities. Besides, you can define your own methods with the same name as those control/dll methods regardless of whether that methods are not defined as virtual/abstract. So let me finish this part and continue your part of finding more.