La herencia es una de las características fundamentales de la programación orientada a objetos (OOP) que permite crear una nueva clase a partir de una existente. En C#, la herencia funciona al permitir que una clase (la clase hija) herede los miembros y métodos de otra clase (la clase padre). El objetivo principal de la herencia es promover la reutilización del código y establecer una relación entre diferentes clases.

La herencia en C# se logra utilizando el operador ':' que indica que una clase está haciendo uso de la herencia.

Por ejemplo, considera dos clases: Animal (la clase base) y Perro (la clase derivada).

public class Animal  
{  
    public void Comer()  
    {  
        Console.WriteLine("Comiendo...");  
    }  
}  

public class Perro : Animal  
{  
    public void Ladrar()  
    {  
        Console.WriteLine("Ladrando...");  
    }  
} 

En este ejemplo, la clase Perro hereda los métodos de la clase Animal. Esto significa que la clase Perro ahora puede acceder al método Comer() que está definido en la clase Animal.

Perro perro = new Perro();
perro.Comer(); // Comiendo...
perro.Ladrar(); // Ladrado...

Una clase hija podrá acceder a cualquier campo, propiedad o método de la clase padre, siempre que dicho miembro tenga un modificador de acceso public o protected (de hecho, protected sirve específicamente para permitir acceso sólo a la propia clase y a sus clases hijas). También será posible acceder a miembros con modificador de acceso internal que se encuentren en el mismo ensamblado (assembly).

Llamada a constructor de clase padre

Cuando una clase hereda de otra en C#, el constructor de la clase hija debe encargarse de llamar al constructor de la clase padre antes de inicializar sus propios miembros. Esto se hace para garantizar que la inicialización de la clase padre se realice correctamente antes de continuar con la inicialización de la clase hija.

Para llamar al constructor de la clase padre, se utiliza la palabra clave base seguida de los argumentos necesarios para el constructor de la clase padre. La llamada al constructor de la clase padre debe ser la primera instrucción dentro del constructor de la clase hija.

Supongamos que tenemos una clase Person como clase padre:

public class Person
{
    protected string name;

    public Person(string name)
    {
        this.name = name;
    }
}

Y una clase Employee que hereda de Person:

public class Employee : Person
{
    private int employeeId;

    public Employee(string name, int employeeId) : base(name)
    {
        this.employeeId = employeeId;
    }
}

En este ejemplo, la clase Employee tiene su propio constructor que toma dos argumentos: name (que se pasa al constructor de la clase padre) y employeeId. Para asegurarse de que el constructor de la clase padre (Person) se ejecute antes de la inicialización de Employee, llamamos al constructor de la clase padre usando base(name).

De esta manera, al crear una instancia de la clase Employee, se inicializará primero la parte de la clase Person y luego la parte específica de la clase Employee. Esto asegura que todos los miembros de ambas clases estén correctamente inicializados. La llamada al constructor de la clase padre con base es fundamental en el proceso de herencia para mantener la consistencia y coherencia en la jerarquía de clases.

Herencia múltiple a través de interfaces

C# solo permite la herencia simple, lo que significa que una clase en C# solo puede heredar de una única clase padre. Aunque C# no soporta directamente la herencia múltiple como otros lenguajes OOP, puede simularse utilizando interfaces o patrones de diseño.

Una interfaz es una definición de un contrato que especifica los miembros (métodos, propiedades, eventos) que una clase concreta debe implementar. Permite establecer una conexión entre distintas clases, independientemente de su jerarquía de herencia, para asegurar que cumplan cierto conjunto de funcionalidades comunes.

C# permite que una clase implemente múltiples interfaces. Aunque técnicamente no es herencia múltiple, se puede utilizar para obtener un efecto similar.

interface IPadre1  
{  
    void MetodoPadre1();  
}  

interface IPadre2  
{  
    void MetodoPadre2();  
}  

public class Hijo : IPadre1, IPadre2  
{  
    public void MetodoPadre1()  
    {  
        Console.WriteLine("Método de IPadre1");  
    }  

    public void MetodoPadre2()  
    {  
        Console.WriteLine("Método de IPadre2");  
    }  
}  

De esta manera, a pesar de que C# no permite directamente la herencia múltiple, puede lograrse un resultado similar al heredar de múltiples interfaces.