Update strategy were changed

StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs

@@ -14,6 +14,8 @@ namespace StructureHelperCommon.Models.Forces
         readonly IUpdateStrategy<IForceAction> forceUpdateStrategy = new ForceActionUpdateStrategy();
         public void Update(IAction targetObject, IAction sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
+
             CheckObject.CompareTypes(targetObject, sourceObject);
             targetObject.Name = sourceObject.Name;
             if (targetObject is IForceAction forceAction)

StructureHelperCommon/Models/Forces/Logics/FactorCombinationUpdateStrategy.cs

@@ -13,6 +13,7 @@ namespace StructureHelperCommon.Models.Forces
         readonly IUpdateStrategy<IForceTuple> tupleUpdateStrategy = new ForceTupleUpdateStrategy();
         public void Update(IForceCombinationByFactor targetObject, IForceCombinationByFactor sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
             tupleUpdateStrategy.Update(targetObject.FullSLSForces, sourceObject.FullSLSForces);
             targetObject.ULSFactor = sourceObject.ULSFactor;

StructureHelperCommon/Models/Forces/Logics/ForceActionUpdateStrategy.cs

@@ -19,6 +19,7 @@ namespace StructureHelperCommon.Models.Forces
         private readonly IUpdateStrategy<IForceCombinationList> forceListUpdateStrategy = new ForceCombinationListUpdateStrategy();
         public void Update(IForceAction targetObject, IForceAction sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
             targetObject.SetInGravityCenter = sourceObject.SetInGravityCenter;
             pointStrategy.Update(targetObject.ForcePoint, sourceObject.ForcePoint);

StructureHelperCommon/Models/Forces/Logics/ForceCombinationListUpdateStrategy.cs

@@ -12,10 +12,10 @@ namespace StructureHelperCommon.Models.Forces
     {
         public void Update(IForceCombinationList targetObject, IForceCombinationList sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
-            var forcesList = new List<IDesignForceTuple>(sourceObject.DesignForces);
             targetObject.DesignForces.Clear();
-            foreach (var item in forcesList)
+            foreach (var item in sourceObject.DesignForces)
             {
                 targetObject.DesignForces.Add((IDesignForceTuple)item.Clone());
             }

StructureHelperCommon/Models/Forces/Logics/ForcePairUpdateStrategy.cs

@@ -15,6 +15,7 @@ namespace StructureHelperCommon.Models.Forces
         private readonly IUpdateStrategy<IForceTuple> tupleUpdateStrategy = new ForceTupleUpdateStrategy();
         public void Update(IDesignForcePair targetObject, IDesignForcePair sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
             targetObject.LimitState = sourceObject.LimitState;
             tupleUpdateStrategy.Update(targetObject.LongForceTuple, sourceObject.LongForceTuple);

StructureHelperCommon/Models/Forces/Logics/ForceTupleUpdateStrategy.cs

@@ -13,6 +13,7 @@ namespace StructureHelperCommon.Models.Forces
     {
         public void Update(IForceTuple targetObject, IForceTuple sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.IsNull(targetObject, ": target object ");
             CheckObject.IsNull(sourceObject, ": source object ");
 

StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialPartialFactorUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperCommon.Models.Materials.Libraries
     {
         public void Update(IMaterialPartialFactor targetObject, IMaterialPartialFactor sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.LimitState = sourceObject.LimitState;
             targetObject.StressState = sourceObject.StressState;
             targetObject.CalcTerm = sourceObject.CalcTerm;

StructureHelperCommon/Models/Materials/Libraries/Logics/MaterialSafetyFactorUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperCommon.Models.Materials.Libraries
     {
         public void Update(IMaterialSafetyFactor targetObject, IMaterialSafetyFactor sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.Take = sourceObject.Take;
             targetObject.Description = sourceObject.Description;

StructureHelperCommon/Models/Sections/Logics/CompressedMemberUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperCommon.Models.Sections
     {
         public void Update(ICompressedMember targetObject, ICompressedMember sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Buckling = sourceObject.Buckling;
             targetObject.GeometryLength = sourceObject.GeometryLength;
             targetObject.LengthFactorX = sourceObject.LengthFactorX;

StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperCommon.Models.Shapes
     {
         public void Update(ICircleShape targetObject, ICircleShape sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Diameter = sourceObject.Diameter;
         }
     }

StructureHelperCommon/Models/Shapes/Logics/LineShapeUpdateStrategy.cs

@@ -13,6 +13,7 @@ namespace StructureHelperCommon.Models.Shapes
         readonly PointShapeUpdateStrategy pointUpdateStrategy = new();
         public void Update(ILineShape targetObject, ILineShape sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             pointUpdateStrategy.Update(targetObject.StartPoint, sourceObject.StartPoint);
             pointUpdateStrategy.Update(targetObject.EndPoint, sourceObject.EndPoint);
         }

StructureHelperCommon/Models/Shapes/Logics/PointShapeUpdateStrategy.cs

@@ -13,6 +13,7 @@ namespace StructureHelperCommon.Models.Shapes.Logics
         /// <inheritdoc />
         public void Update(IPoint2D targetObject, IPoint2D sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.X = sourceObject.X;
             targetObject.Y = sourceObject.Y;
         }

StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperCommon.Models.Shapes
     {
         public void Update(IRectangleShape targetObject, IRectangleShape sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Width = sourceObject.Width;
             targetObject.Height = sourceObject.Height;
             targetObject.Angle = sourceObject.Angle;

StructureHelperLogics/Models/Materials/Logics/ConcreteLibUpdateStrategy.cs

@@ -12,6 +12,7 @@ namespace StructureHelperLogics.Models.Materials
         LibMaterialUpdateStrategy libUpdateStrategy = new LibMaterialUpdateStrategy();
         public void Update(IConcreteLibMaterial targetObject, IConcreteLibMaterial sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             libUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.TensionForULS = sourceObject.TensionForULS;
             targetObject.TensionForSLS = sourceObject.TensionForSLS;

StructureHelperLogics/Models/Materials/Logics/ElasticUpdateStrategy.cs

@@ -12,6 +12,7 @@ namespace StructureHelperLogics.Models.Materials
     {
         public void Update(IElasticMaterial targetObject, IElasticMaterial sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Modulus = sourceObject.Modulus;
             targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
             targetObject.TensileStrength = sourceObject.TensileStrength;

StructureHelperLogics/Models/Materials/Logics/FRUpdateStrategy.cs

@@ -12,6 +12,7 @@ namespace StructureHelperLogics.Models.Materials
     {
         public void Update(IFRMaterial targetObject, IFRMaterial sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Modulus = sourceObject.Modulus;
             targetObject.CompressiveStrength = sourceObject.CompressiveStrength;
             targetObject.TensileStrength = targetObject.TensileStrength;

StructureHelperLogics/Models/Materials/Logics/LibMaterialUpdateStrategy.cs

@@ -12,10 +12,10 @@ namespace StructureHelperLogics.Models.Materials
     {
         public void Update(ILibMaterial targetObject, ILibMaterial sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.MaterialEntity = sourceObject.MaterialEntity;
-            var tmpSafetyFactors = new List<IMaterialSafetyFactor>(sourceObject.SafetyFactors);
             targetObject.SafetyFactors.Clear();
-            foreach (var item in tmpSafetyFactors)
+            foreach (var item in sourceObject.SafetyFactors)
             {
                 targetObject.SafetyFactors.Add(item.Clone() as IMaterialSafetyFactor);
             }

StructureHelperLogics/Models/Materials/Logics/MaterialUpdateStrategy.cs

@@ -19,6 +19,7 @@ namespace StructureHelperLogics.Models.Materials
         private readonly IUpdateStrategy<IReinforcementLibMaterial> reinforcementStrategy = new ReinforcementLibUpdateStrategy();
         public void Update(IHeadMaterial targetObject, IHeadMaterial sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.Color = sourceObject.Color;
             targetObject.HelperMaterial = sourceObject.HelperMaterial.Clone() as IHelperMaterial;

StructureHelperLogics/Models/Materials/Logics/ReinforcementLibUpdateStrategy.cs

@@ -12,6 +12,7 @@ namespace StructureHelperLogics.Models.Materials
         LibMaterialUpdateStrategy libUpdateStrategy = new LibMaterialUpdateStrategy();
         public void Update(IReinforcementLibMaterial targetObject, IReinforcementLibMaterial sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             libUpdateStrategy.Update(targetObject, sourceObject);
         }
     }

StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/ForceCalculatorUpdateStrategy.cs

@@ -10,6 +10,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces.Logics
         static readonly CompressedMemberUpdateStrategy compressedMemberUpdateStrategy = new();
         public void Update(IForceCalculator targetObject, IForceCalculator sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.LimitStatesList.Clear();
             targetObject.LimitStatesList.AddRange(sourceObject.LimitStatesList);

StructureHelperLogics/NdmCalculations/Analyses/Logics/CalculatorUpdateStrategy.cs

@@ -17,6 +17,7 @@ namespace StructureHelperLogics.NdmCalculations.Analyses.Logics
     {
         public void Update(ICalculator targetObject, ICalculator sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
             if (targetObject is IForceCalculator force)
             {

StructureHelperLogics/NdmCalculations/Primitives/Logics/BaseUpdateStrategy.cs

@@ -16,14 +16,15 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
         readonly ForceTupleUpdateStrategy tupleUpdateStrategy = new();
         readonly VisualPropsUpdateStrategy visualPropsUpdateStrategy = new();
 
-        public void Update(INdmPrimitive target, INdmPrimitive source)
+        public void Update(INdmPrimitive targetObject, INdmPrimitive sourceObject)
         {
-            target.Name = source.Name;
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            if (source.HeadMaterial != null) target.HeadMaterial = source.HeadMaterial;
+            targetObject.Name = sourceObject.Name;
-            target.Triangulate = source.Triangulate;
+            if (sourceObject.HeadMaterial != null) targetObject.HeadMaterial = sourceObject.HeadMaterial;
-            pointShapeUpdateStrategy.Update(target.Center, source.Center);
+            targetObject.Triangulate = sourceObject.Triangulate;
-            visualPropsUpdateStrategy.Update(target.VisualProperty, source.VisualProperty);
+            pointShapeUpdateStrategy.Update(targetObject.Center, sourceObject.Center);
-            tupleUpdateStrategy.Update(target.UsersPrestrain, source.UsersPrestrain);
+            visualPropsUpdateStrategy.Update(targetObject.VisualProperty, sourceObject.VisualProperty);
+            tupleUpdateStrategy.Update(targetObject.UsersPrestrain, sourceObject.UsersPrestrain);
         }
 
     }

StructureHelperLogics/NdmCalculations/Primitives/Logics/CircleUpdateStrategy.cs

@@ -16,6 +16,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
 
         public void Update(CirclePrimitive targetObject, CirclePrimitive sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);
             divisionPropsUpdateStrategy.Update(targetObject, sourceObject);
             shapeUpdateStrategy.Update(targetObject, sourceObject);

StructureHelperLogics/NdmCalculations/Primitives/Logics/DivisionPropsUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
     {
         public void Update(IHasDivisionSize targetObject, IHasDivisionSize sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.NdmMaxSize = sourceObject.NdmMaxSize;
             targetObject.NdmMinDivision = sourceObject.NdmMinDivision;
             targetObject.ClearUnderlying = sourceObject.ClearUnderlying;

StructureHelperLogics/NdmCalculations/Primitives/Logics/NdmPrimitiveUpdateStrategy.cs

@@ -9,6 +9,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
     {
         public void Update(INdmPrimitive targetObject, INdmPrimitive sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             CheckObject.CompareTypes(targetObject, sourceObject);
             if (targetObject is PointPrimitive point)
             {

StructureHelperLogics/NdmCalculations/Primitives/Logics/PointUpdateStrategy.cs

@@ -13,6 +13,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
         static readonly BaseUpdateStrategy basePrimitiveUpdateStrategy = new();
         public void Update(PointPrimitive targetObject, PointPrimitive sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.Area = sourceObject.Area;
         }

StructureHelperLogics/NdmCalculations/Primitives/Logics/RebarUpdateStrategy.cs

@@ -12,6 +12,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
         static readonly BaseUpdateStrategy basePrimitiveUpdateStrategy = new();
         public void Update(RebarPrimitive targetObject, RebarPrimitive sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.Area = sourceObject.Area;
             targetObject.HostPrimitive = sourceObject.HostPrimitive;

StructureHelperLogics/NdmCalculations/Primitives/Logics/RectangleUpdateStrategy.cs

@@ -15,6 +15,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
         static readonly RectangleShapeUpdateStrategy shapeUpdateStrategy = new();
         public void Update(RectanglePrimitive targetObject, RectanglePrimitive sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             basePrimitiveUpdateStrategy.Update(targetObject, sourceObject);
             divisionPropsUpdateStrategy.Update(targetObject, sourceObject);
             shapeUpdateStrategy.Update(targetObject, sourceObject);

StructureHelperLogics/NdmCalculations/Primitives/Logics/VisualPropsUpdateStrategy.cs

@@ -11,6 +11,7 @@ namespace StructureHelperLogics.NdmCalculations.Primitives
     {
         public void Update(IVisualProperty targetObject, IVisualProperty sourceObject)
         {
+            if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.IsVisible = sourceObject.IsVisible;
             targetObject.Color = sourceObject.Color;
             targetObject.SetMaterialColor = sourceObject.SetMaterialColor;