Простой векторный графический редактор (разбор полётов)

    class Figure
    {
        public Matrix Transform { get; set; }
        public Geometry Geometry { get; set; }
        public Style Style { get; set; }
        public Renderer Renderer { get; set; }
    }

    abstract class Geometry
    {
        public abstract GraphicsPath Path { get; }
    }

    class Style
    {
        public Border BorderStyle { get; set; }
        public Fill FillStyle { get; set; }
    }

    class Renderer
    {
        public virtual void Render(Graphics gr, Figure fig)
        {
            using (var path = fig.GetTransformedPath())
            {
                if (fig.Style.FillStyle.Draw)
                using (var brush = fig.Style.FillStyle.GetBrush(fig)) 
                    gr.FillPath(brush, path);
 
                if (fig.Style.BorderStyle.Draw)
                using (var pen = fig.Style.BorderStyle.GetPen(fig))
                    gr.DrawPath(pen, path);
            }
        }
    }

        public Pen GetPen(Figure figure)
        {
            return figure.Style.BorderStyle.GetPen(figure);
        }

        public GraphicsPath GetTransformedPath()
        {
            return Geometry.Path;
        }

        public GraphicsPath GetTransformedPath()
        {
            var path = (GraphicsPath)Geometry.Path.Clone();
            path.Transform(Transform);
            return path;
        }

    class Fill
    {
        public Color Color { get; set; } = Color.White;
        public bool Draw { get; set; } = true;
 
        public virtual Brush GetBrush(Figure fig)
        {
            return new SolidBrush(Color);
        }
    }
 
    class Border
    {
        public Color Color { get; set; } = Color.Black;
        public bool Draw { get; set; } = true;
        public float Width { get; set; } = 1;
 
        public virtual Pen GetPen(Figure fig)
        {
            return new Pen(Color, Width);
        }
    }

    /// <summary>
    /// Строит компоненты фигуры
    /// </summary>
    class FigureBuilder
    {
        public void BuildSquareGeometry(Figure fig)
        {
            var path = new GraphicsPath();
            path.AddRectangle(new RectangleF(-0.5f, -0.5f, 1, 1));
 
            fig.Geometry = new PrimitiveGeometry(path);
        }
 
        //и т.д. для всех примитивных фигур
        //todo
    }

    /// <summary>
    /// Содержит геометрию фиксированной формы
    /// </summary>
    class PrimitiveGeometry : Geometry
    {
        GraphicsPath path;
        public override GraphicsPath Path {get { return path; }}
 
        internal PrimitiveGeometry(GraphicsPath path)
        {
            this.path = path;
        }
    }

    /// <summary>
    /// Содержит текст
    /// </summary>
    class TextGeometry : Geometry
    {
        public string Text { get; set; }
        public string FontName { get; set; } = "Arial";
        public float FontSize { get; set; } = 14;
 
        private GraphicsPath path = new GraphicsPath();
 
        public override GraphicsPath Path
        {
            get
            {
                path.Reset();
                path.AddString(Text ?? "", new FontFamily(FontName), 0, FontSize, Point.Empty, StringFormat.GenericTypographic);
                return path;
            }
        }
 
        internal TextGeometry()
        {
        }
    }

[TestMethod]
public void CreateCircleFigureTestMethod()
{
    var builder = new FigureBuilder();
    var circle = new Figure()
    {
        Style = new Style()
        {
            BorderStyle = new Border(),
            FillStyle = new Fill()
        },
        Transform = new Matrix(),
        Renderer = new Renderer()
    };
    // настраиваем геометрию на круг
    builder.BuildCircleGeometry(circle);
    // проверим, что все внутренние классы были подключены
    CheckInternalClassesConnection(circle);
    // пробуем отрисовывать
    using (var pictbox = new PictureBox())
    {
        using (var canvas = pictbox.CreateGraphics())
        {
            circle.Renderer.Render(canvas, circle);
        }
    }
}

    var circle = new Figure()
    {
        Style = new Style()
        {
            BorderStyle = new Border(),
            FillStyle = new Fill()
        },
        Transform = new Matrix(),
        Renderer = new Renderer()
    };

    class Figure
    {
        public Matrix Transform { get; set; } = new Matrix();
        public Geometry Geometry { get; set; }
        public Style Style { get; set; } = new Style();
        public Renderer Renderer { get; set; } = new Renderer();
    }

/// <summary>
/// Сериализуемая обертка над GraphicsPath
/// </summary>
[Serializable]
public class SerializableGraphicsPath : ISerializable
{
    public GraphicsPath Path = new GraphicsPath();
 
    public SerializableGraphicsPath()
    {
    }
 
    private SerializableGraphicsPath(SerializationInfo info, StreamingContext context)
    {
        if (info.MemberCount > 0)
        {
            var points = (PointF[])info.GetValue("p", typeof(PointF[]));
            var types = (byte[])info.GetValue("t", typeof(byte[]));
            Path = new GraphicsPath(points, types);
        }
        else
            Path = new GraphicsPath();
    }
 
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        if (Path.PointCount <= 0) return;
        info.AddValue("p", Path.PathPoints);
        info.AddValue("t", Path.PathTypes);
    }
}

/// <summary>
/// Свойство возвращает путь, построенный по данным строки и свойств шрифта
/// </summary>
public override GraphicsPath Path
{
    get
    {
        // сброс пути. TODO: зачем?
        //_path.Reset();
        _serializablePath.Path.Reset();
        // добавляем в путь текстовую строку
        //_path.AddString(Text ?? "", 
        //    new FontFamily(FontName), 0, FontSize, Bounds,
        //                   StringFormat.GenericTypographic);
        _serializablePath.Path.AddString(Text ?? "",
            new FontFamily(FontName), 0, FontSize, Bounds,
                            StringFormat.GenericTypographic);
        // возвращаем настроенный путь
        //return _path;
        return _serializablePath.Path;
    }
}

var path = (GraphicsPath)serializablePath;