Abstract class vs Interface in our days

Adding on to what @P a u l mentioned in regards used in conjunction with each other an example for allowing overriding ToString this can not be done with an interface but can with an abstract class.

public abstract class Human  
{  
    public string FirstName { get; set; }  
    public string MiddleName { get; set; }  
    public string LastName { get; set; }  
    public abstract override string ToString();   
  
}  

Interface

public interface IBase  
{  
    public int Id { get;  }  
}  

Model

public class Employer : Human, IBase  
{  
    public int EmployerIdentifier { get; set; }  
    public int Id => EmployerIdentifier;  
    public override string ToString() => $"{LastName}";  
}  

Also if say some models only implement one interface and not the abstract class we can do if (person is IBase current and Human human)

Another use is when working with generics with complex methods where in the following we constrain to a EF Core DbContext and a class which implements a specific interface. In this code we only want models from EF Core to get their navigation properties.

public class EntityHelpers  
{  
    public static List<NavigationItem> NavigationInformationForModel<TEntity, TContext>(string connectionString)  
        where TContext : DbContext  
        where TEntity : class,  
        IBaseEntity  
    {  
          
        var type = typeof(DbContextOptionsBuilder<>).MakeGenericType(typeof(TContext));  
        DbContextOptionsBuilder builder = (DbContextOptionsBuilder)Activator.CreateInstance(type);  
        builder!.UseSqlServer(connectionString);  
        var context = (DbContext)Activator.CreateInstance(typeof(TContext), builder.Options);  
        return context!.Model.GetEntityTypes().Where(x => x.ClrType == typeof(TEntity))  
            .Select(entityType => new NavigationItem(  
                entityType.ClrType.Name,  
                entityType.GetNavigations().Select(x => x.PropertyInfo)))  
            .Where(x => !x.Name.Contains("`"))  
            .ToList();  
    }  
  
  
    public static List<NavigationItem> GetNavigationInformation<TContext>(string connectionString)   
        where TContext : DbContext,   
        IBaseEntity  
    {  
  
        var type = typeof(DbContextOptionsBuilder<>).MakeGenericType(typeof(TContext));  
        DbContextOptionsBuilder builder = (DbContextOptionsBuilder)Activator.CreateInstance(type);  
        builder!.UseSqlServer(connectionString);  
        var context = (DbContext)Activator.CreateInstance(typeof(TContext), builder.Options);  
        return context!.Model.GetEntityTypes()  
            .Select(entityType => new NavigationItem(  
                entityType.ClrType.Name,  
                entityType.GetNavigations().Select(x => x.PropertyInfo)))  
            .Where(x => !x.Name.Contains("`"))  
            .ToList();  
    }  
}  

abstract classes are to define a common base class for inheritance, without implementing any actual methods.

because c# does not support multiple inheritance, interfaces are the solution. a class can inherit from one base class, but it can implement many interfaces. interfaces can only be implemented. an interface can not inherit from another interface.

due to issues with inheritance chains, inheritance is often considered an anti-pattern, interface design is recommend instead. with interface design you define contacts that define properties and methods. then classes must implement. other languages use protocols/traits which are slight more feature rich than interfaces.

one past advantage with classes, was you could define default behavior, and interfaces were abstract (no implementations). But modern C# allows default implemations for interfaces.

so my recommendation is to avoid class inheritance (and never more than 1 deep, that is only inherit from base), but rather use interfaces and extension methods to extend classes.