Построение схемы и ее расчёт

    /// <summary>
    /// Умеет себя рисовать
    /// </summary>
    public interface IDrawable
    {
        void Paint(Graphics gr);
    }
 
    /// <summary>
    /// Умеет себя перемещать
    /// </summary>
    public interface IDragable
    {
        bool Hit(Point point);
        void Drag(Point offset);
        IDragable StartDrag(Point p);
        void EndDrag();
    }

    /// <summary>
    /// Панель, которая умеет отображать IDrawable и перемещать IDragable
    /// </summary>
    public class DragPanel : UserControl
    {
        IEnumerable<object> model;
        Point offset;
        private Point mouseDown;
        IDragable dragged;
 
        public DragPanel()
        {
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.ResizeRedraw | ControlStyles.Selectable, true);
        }
 
        public void Build(IEnumerable<object> model)
        {
            this.model = model;
        }
 
        protected override void OnPaint(PaintEventArgs e)
        {
            if (model == null) return;
 
            e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            e.Graphics.TranslateTransform(offset.X, offset.Y);
 
            //отрисовываем объекты
            foreach (var obj in model.OfType<IDrawable>())
                obj.Paint(e.Graphics);
        }
 
        Point ToClient(Point p)
        {
            return p.Sub(offset);
        }
 
        protected override void OnMouseDown(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                mouseDown = e.Location;
                var p = ToClient(e.Location);
                //ищем объект под мышкой
                var hitted = model.OfType<IDragable>().FirstOrDefault(n => n.Hit(p));
                if (hitted != null)
                    dragged = hitted.StartDrag(p);//начинаем тащить
            }
        }
 
        protected override void OnMouseMove(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                var shift = new Point(e.Location.X - mouseDown.X, e.Location.Y - mouseDown.Y);
                mouseDown = e.Location;
                //
                if (dragged != null)
                    dragged.Drag(shift);//двигаем объект
                else
                    offset = new Point(offset.X + shift.X, offset.Y + shift.Y);//сдвигаем канвас
 
                Invalidate();
            }
        }
 
        protected override void OnMouseUp(MouseEventArgs e)
        {
            base.OnMouseUp(e);
            if(dragged != null)
                dragged.EndDrag();
            dragged = null;
            Invalidate();
        }
    }

    /// <summary>
    /// Элемент модели, задающий надежность. 
    /// Может быть связан с другими эелемнтами.
    /// </summary>
    public class Node : IDrawable, IDragable
    {
        public GraphicsPath Path {get; set;}
        public Point Location;
        public virtual Color BorderColor => Color.Lime;
        public virtual Color FillColor => Color.FromArgb(30, Color.White);
        public object Tag { get; set; }
        public Model Model { get;set;}
        public virtual bool AcceptPin => true;
 
        public Pin Pin { get;set;}
        public List<Node> Linked { get; set; } = new List<Node>();
 
        public Node(Model model)
        {
            this.Model = model;
            Path = Helper.GetRoundedRectangle(new Rectangle(-50, -30, 100, 60), 20);
 
            Pin = new Pin(this) {RelativeLocation = new Point(50, 0)};
        }
 
        public virtual void Paint(Graphics gr)
        {
            foreach (var linked in Linked)
                gr.DrawLink(linked.Pin.Location, Location.Sub(new Point(50, 0)));
 
            var state = gr.Save();
            gr.TranslateTransform(Location.X, Location.Y);
            gr.FillPath(FillColor.Brush(), Path);
            gr.DrawPath(BorderColor.Pen(), Path);
            Path.DrawHalo(gr, BorderColor, BorderColor.Pen());
            var rect = Path.GetBounds();
            rect.Inflate(-5, -5);
            if(Tag != null)
                gr.DrawString(Tag.ToString(), Helper.Font, Brushes.White, rect, new StringFormat {Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Center});
            gr.Restore(state);
 
            if (Pin != null)
                Pin.Paint(gr);
        }
 
        public bool Hit(Point p)
        {
            if (Pin != null && Pin.Hit(p))
                return true;
 
            return Path.IsVisible(p.Sub(Location));
        }
 
        public void Drag(Point offset)
        {
            Location = Location.Add(offset);
        }
 
        public IDragable StartDrag(Point p)
        {
            //если кликнули на пин - тянем пин
            if (Pin != null && Pin.Hit(p))
                return Pin;
 
            //тянем себя
            return this;
        }
 
        const float GRID_STEP = 20;
 
        public void EndDrag()
        {
            //выравниваем по сетке
            Location = new Point((int)(GRID_STEP * Math.Round(Location.X/GRID_STEP)), (int)(GRID_STEP*Math.Round(Location.Y/GRID_STEP)));
        }
    }

    /// <summary>
    /// Элемент соединяющий ноды
    /// </summary>
    public class Pin : IDrawable, IDragable
    {
        public Node Parent { get; set; }
        public Point RelativeLocation { get;set;}
        public GraphicsPath Path { get; set; }
        public Color BorderColor { get; set; } = Color.Navy;
        public Color FillColor { get; set; } = Color.DeepSkyBlue;
 
        private Point drag;
 
        public Point Location
        {
            get { return Parent.Location.Add(RelativeLocation); }
        }
 
        public Pin(Node parent)
        {
            Parent = parent;
            Path = new GraphicsPath();
            Path.AddEllipse(new Rectangle(-5, -5, 10, 10));
        }
 
        public void Paint(Graphics gr)
        {
            if (drag != Point.Empty)
                gr.DrawLink(Location, Location.Add(drag));
 
            var state = gr.Save();
            gr.TranslateTransform(Location.X, Location.Y);
            gr.FillPath(FillColor.Brush(), Path);
            gr.DrawPath(BorderColor.Pen(), Path);
            if (drag != Point.Empty)
            {
                gr.DrawEllipse(BorderColor.Pen(), drag.X - 5, drag.Y - 5, 10, 10);
                gr.FillEllipse(FillColor.Brush(), drag.X - 5, drag.Y - 5, 10, 10);
            }
            gr.Restore(state);
        }
 
        public bool Hit(Point point)
        {
            return Path.IsVisible(point.Sub(Location));
        }
 
        public void Drag(Point offset)
        {
            drag = drag.Add(offset);
        }
 
        public IDragable StartDrag(Point p)
        {
            return this;
        }
 
        public void EndDrag()
        {
            var p = Location.Add(drag);
            //ищем целевой объект
            foreach (var node in Parent.Model.OfType<Node>())
            if(node != Parent && node.AcceptPin)
            {
                if (node.Hit(p))
                    node.Linked.Add(Parent);
            }
            drag = Point.Empty;
        }
    }

    /// <summary>
    /// Конечный нод. 
    /// Считает итоговую надежность системы.
    /// </summary>
    public class FinishNode : Node
    {
        public override Color BorderColor => Color.SkyBlue;
 
        public FinishNode(Model model) : base(model)
        {
        }
 
        public override void Paint(Graphics gr)
        {
            if (Linked.Count == 0)
            {
                Tag = "Finish";
            }
            else
            {
                var p = Calc(this);
                Tag = string.Format("P = {0:0.00}", p);
            }
 
            base.Paint(gr);
        }
 
        private static float Calc(Node node)
        {
            if (!(node.Tag is float))
            {
                if (node.Linked.Count == 0) return 1;
                return node.Linked.Min(n => Calc(n));//ищем минимум среди входящих
            }
            else
            {
                var p = (float)node.Tag;
                if (node.Linked.Count == 0) return p;
                return p * node.Linked.Min(n => Calc(n));//ищем минимум среди входящих, умножаем на свою вероятность
            }
        }
    }