Наследование функций C# и использование возможности повторного использования

(Примечание. В этом ответе предполагается, что вы действительно хотите иметь разные реализации Draw() для производных классов. Если вам не нужно этого делать, вы можете использовать один из других ответов на свой вопрос!)

Вы можете ввести промежуточный базовый класс abstract, который реализует функциональность:

public interface IShapes
{
    public void Draw();
}

public abstract class ShapesBase : IShapes
{
    public virtual void Draw()
    {
        Console.WriteLine(GetType().FullName?.Substring(GetType().FullName.IndexOf('.') + 1) + " - Draw");
    }
}

public class Square : ShapesBase
{
    public override void Draw()
    {
        base.Draw();
    }
}

public class Circle : ShapesBase
{
    public override void Draw()
    {
        base.Draw();
    }
}

Обратите внимание: если вы переопределите метод Draw(), вы ДОЛЖНЫ помнить о необходимости вызова базового метода, иначе вы не получите желаемый результат (я предполагаю, что ваши конкретные классы обычно захотят реализовать Draw().

Если вы вообще опустите реализации Draw() из конкретных классов, это все равно будет работать:

public interface IShapes
{
    public void Draw();
}

public abstract class ShapesBase : IShapes
{
    public virtual void Draw()
    {
        Console.WriteLine(GetType().FullName?.Substring(GetType().FullName.IndexOf('.') + 1) + " - Draw");
    }
}

public class Square : ShapesBase
{
}

public class Circle : ShapesBase
{
}

Но обычно вы переопределяете виртуальные методы.

Кстати, если вы хотите заставить производные классы реализовать какой-то метод Draw(), вы можете использовать другой подход. Вы можете ввести абстрактный метод DrawImpl(), который должны реализовать производные классы и который вызывается из конкретной реализации Draw() абстрактного базового класса.

Этот подход также имеет то преимущество, что производным классам не нужно помнить о вызове версии базового класса:

public interface IShapes
{
    public void Draw();
}

public abstract class ShapesBase : IShapes
{
    protected abstract void DrawCore();

    public void Draw()
    {
        Console.WriteLine(GetType().FullName?.Substring(GetType().FullName.IndexOf('.') + 1) + " - Draw");
        DrawCore();
    }
}

public class Square : ShapesBase
{
    protected override void DrawCore()
    {
        Console.WriteLine("Square.DrawCore()");
    }
}

public class Circle : ShapesBase
{
    protected override void DrawCore()
    {
        Console.WriteLine("Circle.DrawCore()");
    }
}

Этот подход также работает, если вы хотите сделать переопределение метода DrawCore() необязательным, но при этом получить желаемый результат, просто объявив DrawCore() как virtual вместо abstract:

public interface IShapes
{
    public void Draw();
}

public abstract class ShapesBase : IShapes
{
    protected virtual void DrawCore()
    {
        // Do nothing.
    }

    public void Draw()
    {
        Console.WriteLine(GetType().FullName?.Substring(GetType().FullName.IndexOf('.') + 1) + " - Draw");
        DrawCore();
    }
}

public class Square : ShapesBase
{
}

public class Circle : ShapesBase
{
}

Это может быть полезно, если необходимо переопределить DrawCore() только для некоторых производных классов.

В зависимости от вашей целевой платформы вам могут подойти «методы интерфейса по умолчанию»:

using System;
public interface IShapes
{
    public void Draw()
    {
    
    Console.WriteLine(GetType().FullName?.Substring(GetType().FullName.IndexOf('.') + 1) + " - Draw");
    }
}
public class Square : IShapes {}
public class Circle : IShapes {}

Используйте общий метод расширения. Это также позволяет вам использовать typeof<T> вместо this.GetType(), что разрешается во время компиляции. Кроме того, я почти уверен, что вы можете просто использовать Name (вместо синтаксического анализа FullName), который дает неполное имя.

static class ShapeExtensions
{
    static void Draw<T>(this T shape) where T : IShapes
    {
        Console.WriteLine(typeof(T).Name + " - Draw");
    }
}

Обратите внимание, что typeof(T) даст вам только тип переменной (который определяется во время компиляции), а не экземпляр (который определяется во время выполнения). Итак, если у вас есть List<IShapes>, он всегда будет печатать IShapes - Draw. Если вам нужен тип среды выполнения экземпляра, вы все равно можете использовать GetType().

static void Draw<T>(this T shape) where T : IShapes
{
    Console.WriteLine(shape.GetType().Name + " - Draw");
}

Вы называете это точно так же.

shapes.ForEach((s) => 
{
    s.Draw();
});