How do I detect parent changed when child property changed?

See more:

properties

I have a class named "Dimensions", like that:

using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

using System.Diagnostics;

namespace Shopdrawing.Reinforcement
{
    public class Dimensions : INotifyPropertyChanged
    {
        //[NotifyParentProperty(true)]
        private double _a;
        public double A
        {
            get { return _a; }
            set {
                _a = value;
                OnPropertyChanged("A");
            }
        }
        public double B { get; set; }
        public double C { get; set; }
        public double D { get; set; }
        public double E { get; set; }
        public double F { get; set; }
        public double R { get; set; }

        public override string ToString()
        {
            return "Dimensions";
        }

        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, e);
        }

        protected void OnPropertyChanged(string propertyName)
        {
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }

    }
}

Any more, I created a based class for all reinforcement bar (using in Civil work)

using System;
using DynamicGeometry;
using System.ComponentModel;
using System.Windows;
using System.Collections.Generic;
using Shopdrawing.Utilities;
using Shopdrawing.Settings;

namespace Shopdrawing.Reinforcement
{
    public interface IBarShape : IEquatable<IBarShape>
    {
        IList<IFigure> Parts { get; set; }
        ViewDirection ViewDirection { get; set; }
        Dimensions Dimensions { get; set; }
        Point InsertPoint { get; set; }
        double Diameter { get; set; }
        double Length { get; set; }
        DrawType DrawType { get; set; }
        Transform Transform { get; set; }
        double Rotate { get; set; }
        void Create();
        void ReDraw();
        void ReCreate();
    }

    public enum DrawType
    { 
        /// <summary>
        /// Dạng đường có độ rộng mặc định
        /// </summary>
        RegularLine = 0,
        /// <summary>
        /// Bề rộng nét bằng đường kính thanh
        /// </summary>
        LineWeight = 1,
        /// <summary>
        /// Dạng không fill
        /// </summary>
        NotFilled = 2
    }

    public class BarShapeBase : CompositeFigure, IBarShape
    {
        public virtual IList<IFigure> Parts { get; set; }
        private ViewDirection _viewDirection = ViewDirection.Front;
        public virtual ViewDirection ViewDirection
        {
            get { return _viewDirection; }
            set {
                if (_viewDirection == value) return;
                _viewDirection = value;
            }
        }
        [TypeConverter(typeof(ExpandableObjectConverter))]
        public virtual Dimensions Dimensions { get; set; }
        public virtual double Length { get; set; }
        private DrawType _drawType = DrawType.RegularLine;
        public DrawType DrawType
        {
            get { return _drawType; }
            set {
                if (_drawType == value) return;
                _drawType = value;
            }
        }
        private Point _insertPoint = new Point(0,0);
        public Point InsertPoint
        {
            get { return _insertPoint; }
            set {
                if (_insertPoint == value) return;
                _insertPoint = value;
            }
        }
        private double _diameter = 1.0;
        public double Diameter
        {
            get { return _diameter; }
            set {
                if (_diameter == value) return;
                _diameter = value;
            }
        }
        private Transform _transform = Transform.Normal;
        public Transform Transform
        {
            get { return _transform; }
            set {
                if (_transform == value) return;
                _transform = value;
            }
        }
        private double _rotate = 0;
        public double Rotate
        {
            get { return _rotate; }
            set {
                if (_rotate == value) return;
                _rotate = value; 
            }
        }
        public double RotateRAD
        {
            get { return Rotate * System.Math.PI / 180; }
        }
        public virtual void Create() { }
        public virtual void ReDraw() { }
        public virtual void ReCreate() { }

        public override IFigureStyle Style
        {
            get
            {
                return DefaultStyles.BarStyle;
            }
            set
            {
                base.Style = value;
            }
        }

        public bool Equals(IBarShape other)
        {
            return object.ReferenceEquals(this, other);
        }

        public IList<IFigure> GetCrossPartDependencies()
        {
            switch (this.ViewDirection)
            {
                case Reinforcement.ViewDirection.Cross:
                    {
                        List<IFigure> result = new List<IFigure>();
                        result.Add(Factory.CreateFreePoint(this.Drawing, InsertPoint));
                        result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint, 0.5 * Diameter, 0)));
                        return result;
                    }
                default: return null;
            }
        }
    }
}

Then in other class named "Bar", I defined a property Dimensions:

    using System;
using DynamicGeometry;
using System.ComponentModel;
using System.Windows;
using System.Collections.Generic;
using Shopdrawing.Settings;

namespace Shopdrawing.Reinforcement
{
    public partial class Bar : CompositeFigure
    {
        private Transform _transform = Transform.Normal;
        public Transform Transform
        {
            get { return _transform; }
            set 
            { 
                _transform = value;
                RecreateChildren();
            }
        }
        private ViewDirection _viewDirection = ViewDirection.Front;
        //[NotifyParentProperty(true)]
        public ViewDirection ViewDirection
        {
            get { return _viewDirection; }
            set 
            {
                if (value == _viewDirection) return;
                _viewDirection = value;
                //ReCreate();
                RecreateChildren();
            }
        }
        private double _rotate = 0;
        public double Rotate
        {
            get { return _rotate; }
            set { 
            if(_rotate == value) return;
            _rotate = value;
            RecreateChildren();
            }
        }
        private BarShape2D _shape = BarShape2D.Shape00;
        public BarShape2D ShapeCode
        {
            get { return _shape; }
            set 
            { 
                _shape = value;
                Recreate();
            }
        }

        private Dimensions _dimensions = null;
        [TypeConverter(typeof(ExpandableObjectConverter))]
        public Dimensions Dimensions 
        {
            get { return _dimensions; }
            set {
                if (_dimensions == value) return;
                _dimensions = value;
                RecreateChildren();
            }
        }


        public override IFigureStyle Style
        {
            get
            {
                return DefaultStyles.BarStyle;
            }
            set
            {
                base.Style = value;
            }
        }

        private double _step;

        private double _diameter;
        private double _length;
        private double _unitWeight;
        private double _quantities;
        private int _count;
        private int _order;
        
        private string _notes;
        private double _spliceLength;

        /// <summary>
        /// Đường kính thép
        /// </summary>
        [PropertyGridVisible]
        [PropertyGridName("Step")]
        public double Step
        {
            get { return _step; }
            set
            {
                if (value < 0)
                    throw new Exception("Value must grater than or equal 0!");
                _step = value;
            }
        }

        /// <summary>
        /// Lớp bê tông bảo vệ
        /// </summary>
        public double Cover { get; set; }

        #region Public Properties
        public string FullName
        {
            get { return Name + "-" + Diameter; }
        }
        /// <summary>
        /// Đường kính thép
        /// </summary>
        [PropertyGridVisible]
        [PropertyGridName("Diameter")]
        public double Diameter
        {
            get { return _diameter; }
            set
            {
                if (value <= 0)
                    throw new Exception("Value must grater than 0!");
                _diameter = value;
                RecreateChildren();
            }
        }
        /// <summary>
        /// Chiều dài thanh thép
        /// </summary>
        [PropertyGridVisible]
        [PropertyGridName("Length")]
        public double Length
        {
            get 
            {
                //return _length; 
                try
                {
                    var bs = Children[0] as IBarShape;
                    return bs.Length;
                }
                finally
                {
                }
            }
            set
            {
                if (value <= 0)
                    throw new Exception("Value must grater than 0!");
                _length = value;
            }
        }
        /// <summary>
        /// Trọng lượng đơn vị thanh thép
        /// </summary>
        [PropertyGridVisible]
        [PropertyGridName("UnitWeight")]
        public double UnitWeight
        {
            get { return _unitWeight; }
            set
            {
                if (value <= 0)
                    throw new Exception("Value must grater than 0!");
                _unitWeight = value;
            }
        }
        /// <summary>
        /// Khối lượng thanh thép
        /// </summary>
        [PropertyGridVisible]
        [PropertyGridName("Quantities")]
        public double Quantities
        {
            get { return _quantities; }
            set
            {
                if (value <= 0)
                    throw new Exception("Value must grater than 0!");
                _quantities = value;
            }
        }
        /// <summary>
        /// Số lượng thanh thép
        /// </summary>
        [PropertyGridVisible]
        [PropertyGridName("Count")]
        public int Count
        {
            get { return _count; }
            set
            {
                if (value <= 0)
                    throw new Exception("Value must grater than 0!");
                _count = value;
            }
        }

        #endregion

        #region Constructors
        public Bar()
        {
        
        }
        public Bar(Drawing drawing)
        {
            Drawing = drawing;
        }
        public Bar(double length)
        {
            Length = length;
        }
        #endregion

        #region Public voids
        public double GetQuantities()
        {
            return Count * Length * UnitWeight;
        }

        /// <summary>
        /// Vẽ lại thanh trong trường hợp hình dạng thay đổi
        /// </summary>
        public void Recreate()
        {
            foreach (IFigure f in Children)
            {
                f.OnRemovingFromCanvas(Drawing.Canvas);
            }
            Children.Clear();
            CreateBar();

            foreach (IFigure f in Children)
            {
                f.OnAddingToCanvas(Drawing.Canvas);
            }
        }

        /// <summary>
        /// Trong trường hợp hình dạng không thay đổi
        /// </summary>
        public void RecreateChildren()
        {
            foreach (var c in Children)
            {
                if (c is IBarShape)
                {
                    var bs = c as IBarShape;
                    bs.Rotate = this.Rotate;
                    bs.Dimensions = this.Dimensions;
                    bs.Diameter = this.Diameter;
                    bs.ViewDirection = this.ViewDirection;
                    bs.Transform = this.Transform;
                    bs.ReCreate();
                }
            }
        }

        #endregion

        #region Override
        public override string ToString()
        {
            return "Bar";
        }
        public override IFigure HitTest(Point point)
        {
            //double epsilon = ToLogical(Shape.StrokeThickness / 2 + DynamicGeometry.Math.CursorTolerance);
            if (DynamicGeometry.Math.IsPointOnPolygonalChain(Dependencies.ToPoints(), point, 5, false))
            {
                return this;
            }
            return null;
        }
        #endregion
    }
}

This is class BarShape13

Class: BarShape13.cs

using System;
using System.Collections.Generic;
using DynamicGeometry;
using Shopdrawing.Utilities;
using System.Windows;
using System.ComponentModel;
using M = System.Math;

namespace Shopdrawing.Reinforcement
{
    /// <summary>
    /// 
    /// </summary>
    public class BarShape13 : BarShapeBase
    {
        public BarShape13(Drawing drawing, Dimensions dimensions, ViewDirection viewDirection)
        {
            Drawing = drawing;
            Dimensions = dimensions;
            ViewDirection = viewDirection;

            Parts = new List<IFigure>();
        }

        #region overrides
        public override double Length
        {
            get
            {
                return this.Dimensions.A + this.Dimensions.B + this.Dimensions.C;
            }
        }
        public override void Create()
        {
            Parts.Clear();
            Dependencies.Clear();
            Children.Clear();
            // Part1
            // Chú ý khi gọi phương thức GetPart1Dependencies()
            // ứng với trường hợp Transform = Rotate180, Rotate90CCW, Rotate90CW
            // Thì góc Rotate đã bị thay đổi 1 lần
            // Do đó trong phương thức GetPart1Dependencies()
            // khi thay đổi góc Rotate chỉ thay đổi 1/2 là đủ
            if (GetPart1Dependencies() != null)
            {
                var part1 = Factory.CreateSegment(Drawing, GetPart1Dependencies());
                part1.Style = base.Style;
                if (part1 != null) Parts.Add(part1);
            }
            // Part2
            if (GetPart2Dependencies() != null)
            {
                var part2 = Factory.CreateArc(Drawing, GetPart2Dependencies());
                part2.Clockwise = ArcPartClockWise;
                part2.Style = base.Style;
                if (part2 != null) Parts.Add(part2);
            }
            // Part3
            if (GetPart3Dependencies() != null)
            {
                var part3 = Factory.CreateSegment(Drawing, GetPart3Dependencies());
                part3.Style = base.Style;
                if (part3 != null) Parts.Add(part3);
            }

            // Cross Part
            if (GetCrossPartDependencies() != null)
            {
                var crossPart = Factory.CreateCircle(Drawing, GetCrossPartDependencies());
                crossPart.Style = base.Style;
                Parts.Add(crossPart);
            }

            if (Parts != null)
            {
                foreach (IFigure f in Parts)
                {
                    Children.Add(f);
                    foreach (IPoint p in f.Dependencies)
                        Dependencies.Add(p);
                }
            }
        }

        /// <summary>
        /// Thay đổi dependencies
        /// </summary>
        public override void ReDraw()
        {
        }
        /// <summary>
        /// Get dependencies for part1
        /// </summary>
        /// <returns></returns>
        protected IList<IFigure> GetPart1Dependencies()
        {
            switch (ViewDirection)
            {
                case Reinforcement.ViewDirection.Front:
                    {
                        switch (Transform)
                        {
                            case Reinforcement.Transform.Normal:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, InsertPoint)); // Điểm chèn ban đầu
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(this.Dimensions.C - 0.5 * this.Dimensions.B) * M.Cos(RotateRAD), 
                                        -(this.Dimensions.C - 0.5 * this.Dimensions.B) * M.Sin(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.FlipHorizontal:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, InsertPoint)); // Điểm chèn ban đầu
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        (this.Dimensions.C - 0.5 * this.Dimensions.B) * M.Cos(RotateRAD),
                                        (this.Dimensions.C - 0.5 * this.Dimensions.B) * M.Sin(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.FlipVertical:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, InsertPoint)); // Điểm chèn ban đầu
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint, 
                                        -(this.Dimensions.C -0.5*Dimensions.B)* M.Cos(RotateRAD),
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.Rotate180:
                                {
                                    Rotate += 90; // Gọi phương thức này 2 lần
                                    goto case Reinforcement.Transform.Normal;
                                }
                            case Reinforcement.Transform.Rotate90CCW:
                                {
                                    Rotate += 45; // Gọi phương thức này 2 lần
                                    goto case Reinforcement.Transform.Normal;
                                }
                            case Reinforcement.Transform.Rotate90CW:
                                {
                                    Rotate += -45; // Gọi phương thức này 2 lần
                                    goto case Reinforcement.Transform.Normal;
                                }
                            default: return null;
                        }
                    }
                default: return null;
            }
        }
        /// <summary>
        /// Get dependencies for part2
        /// </summary>
        /// <returns></returns>
        protected IList<IFigure> GetPart2Dependencies()
        {
            switch (ViewDirection)
            {
                case Reinforcement.ViewDirection.Front:
                    {
                        switch (Transform)
                        {
                            case Reinforcement.Transform.Normal:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint, 
                                        -(Dimensions.C - 0.5*Dimensions.B)*M.Cos(RotateRAD) + 0.5*Dimensions.B*M.Sin(RotateRAD),
                                        -(Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - 0.5 * Dimensions.B * M.Cos(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD),
                                        -(Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) + Dimensions.B * M.Sin(RotateRAD),
                                        -(Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - Dimensions.B * M.Cos(RotateRAD)))); 
                                    return result;
                                }
                            case Reinforcement.Transform.FlipHorizontal:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        (this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) + 0.5*this.Dimensions.B * M.Sin(RotateRAD),
                                        (this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - 0.5*this.Dimensions.B * M.Cos(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(Drawing, PointsHelper.Offset(InsertPoint,
                                        (Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD),
                                        (Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint, 
                                        (this.Dimensions.C -0.5*Dimensions.B)* M.Cos(RotateRAD) + this.Dimensions.B * M.Sin(RotateRAD),
                                        (this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - this.Dimensions.B * M.Cos(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.FlipVertical:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) - 0.5*Dimensions.B*M.Sin(RotateRAD),
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) + 0.5 * Dimensions.B * M.Cos(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD),
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) - Dimensions.B * M.Sin(RotateRAD),
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) + Dimensions.B * M.Cos(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.Rotate180:
                                {
                                    goto case Reinforcement.Transform.Normal;
                                }
                            case Reinforcement.Transform.Rotate90CCW:
                                {
                                    goto case Reinforcement.Transform.Normal;
                                }
                            case Reinforcement.Transform.Rotate90CW:
                                {
                                    goto case Reinforcement.Transform.Normal;
                                }
                            default: return null;
                        }
                    }
                default: return null;
            }
            
        }
        /// <summary>
        /// Trả về chiều vẽ cho các đối tượng Arc thuộc hình dạng này
        /// </summary>
        protected bool ArcPartClockWise
        {
            get 
            {
                switch (Transform)
                { 
                    case Reinforcement.Transform.FlipVertical:
                    case Reinforcement.Transform.FlipHorizontal:
                        return true;
                    case Reinforcement.Transform.Normal:
                    case Reinforcement.Transform.Rotate180:
                    case Reinforcement.Transform.Rotate90CCW:
                    case Reinforcement.Transform.Rotate90CW:
                        return false;

                    default: return false;
                
                }
            }
        
        }
        /// <summary>
        /// Get dependencies for part3
        /// </summary>
        /// <returns></returns>
        protected IList<IFigure> GetPart3Dependencies()
        {
            switch (ViewDirection)
            {
                case Reinforcement.ViewDirection.Front:
                    {
                        switch (Transform)
                        {
                            case Reinforcement.Transform.Normal:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                            -(Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) + Dimensions.B * M.Sin(RotateRAD),
                                            -(Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - Dimensions.B * M.Cos(RotateRAD))));

                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                            -(Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) + Dimensions.B * M.Sin(RotateRAD) + (Dimensions.A - 0.5*Dimensions.B)*M.Cos(RotateRAD),
                                            -(Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - Dimensions.B * M.Cos(RotateRAD) + (Dimensions.A - 0.5 * Dimensions.B) * M.Sin(RotateRAD))));

                                    return result;
                                }
                            case Reinforcement.Transform.FlipHorizontal:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        (this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) + this.Dimensions.B * M.Sin(RotateRAD),
                                        (this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) - this.Dimensions.B * M.Cos(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint, this.Dimensions.C * M.Cos(RotateRAD) + this.Dimensions.B * M.Sin(RotateRAD) - this.Dimensions.A * M.Cos(RotateRAD),
                                        this.Dimensions.C * M.Sin(RotateRAD) - this.Dimensions.B * M.Cos(RotateRAD) - this.Dimensions.A * M.Sin(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.FlipVertical:
                                {
                                    List<IFigure> result = new List<IFigure>();
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) - Dimensions.B * M.Sin(RotateRAD),
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) + Dimensions.B * M.Cos(RotateRAD))));
                                    result.Add(Factory.CreateFreePoint(this.Drawing, PointsHelper.Offset(InsertPoint,
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Cos(RotateRAD) - Dimensions.B * M.Sin(RotateRAD)
                                        + (Dimensions.A + 0.5*Dimensions.B)*M.Cos(RotateRAD),
                                        -(this.Dimensions.C - 0.5 * Dimensions.B) * M.Sin(RotateRAD) + Dimensions.B * M.Cos(RotateRAD)
                                        + (Dimensions.A + 0.5 * Dimensions.B) * M.Sin(RotateRAD))));
                                    return result;
                                }
                            case Reinforcement.Transform.Rotate180:
                                {
                                    goto case Reinforcement.Transform.Normal;
                                }
                            case Reinforcement.Transform.Rotate90CCW:
                                {
                                    goto case Reinforcement.Transform.Normal;
                                }
                            case Reinforcement.Transform.Rotate90CW:
                                {
                                    goto case Reinforcement.Transform.Normal;
                                }
                            default: return null;
                        }
                    }
                default: return null;
            }
        }

        public override void ReCreate()
        {
            if (Parts != null)
            {
                foreach (IFigure part in Parts)
                {
                    part.OnRemovingFromCanvas(Drawing.Canvas);
                }
                Parts.Clear();
            }
            Dependencies.Clear();
            Children.Clear();
            Create();
            foreach (IFigure part in Parts)
            {
                part.OnAddingToCanvas(Drawing.Canvas);

                foreach (IPoint p in part.Dependencies)
                    Dependencies.Add(p);
            }
            UpdateVisual();
        }

        public override string ToString()
        {
            return "BarShape13";
        }
    }
        #endregion

}

What's I want here: when Dimensions property of "Bar" class changed, I want to call method RecreateChildren(), but it seem not working.

Can anyone help me on this?
Thanks!