Change value diagram calculator

DataAccess/DTOs/Converters/BeamShears/BeamShearActionFromDTOConvertStrategy.cs

@@ -29,9 +29,9 @@ namespace DataAccess.DTOs
 
         private void CheckObjects(BeamShearActionDTO source)
         {
-            CheckObject.IsNull(source);
+            CheckObject.ThrowIfNull(source);
-            CheckObject.IsNull(source.ExternalForce);
+            CheckObject.ThrowIfNull(source.ExternalForce);
-            CheckObject.IsNull(source.SupportAction);
+            CheckObject.ThrowIfNull(source.SupportAction);
         }
 
         private void GetNewAction(BeamShearActionDTO source)

DataAccess/DTOs/Converters/BeamShears/BeamShearAxisActionFromDTOConvertStrategy.cs

@@ -18,9 +18,9 @@ namespace DataAccess.DTOs
 
         public override BeamShearAxisAction GetNewItem(BeamShearAxisActionDTO source)
         {
-            CheckObject.IsNull(source);
+            CheckObject.ThrowIfNull(source);
-            CheckObject.IsNull(source.SupportForce);
+            CheckObject.ThrowIfNull(source.SupportForce);
-            CheckObject.IsNull(source.ShearLoads);
+            CheckObject.ThrowIfNull(source.ShearLoads);
             InitializeStrategies();
             GetNewAction(source);
             return NewItem;

DataAccess/DTOs/Converters/BeamShears/BeamShearCalculatorFromDTOConvertStrategy.cs

@@ -18,8 +18,8 @@ namespace DataAccess.DTOs
 
         public override BeamShearCalculator GetNewItem(BeamShearCalculatorDTO source)
         {
-            CheckObject.IsNull(source);
+            CheckObject.ThrowIfNull(source);
-            CheckObject.IsNull(source.InputData);
+            CheckObject.ThrowIfNull(source.InputData);
             GetNewCalculator(source);
             return NewItem;
         }

DataAccess/DTOs/Converters/BeamShears/BeamShearFromDTOConvertStrategy.cs

@@ -16,8 +16,8 @@ namespace DataAccess.DTOs
         public override BeamShear GetNewItem(BeamShearDTO source)
         {
             ChildClass = this;
-            CheckObject.IsNull(source);
+            CheckObject.ThrowIfNull(source);
-            CheckObject.IsNull(source.Repository);
+            CheckObject.ThrowIfNull(source.Repository);
             GetNewBeamShear(source);
             return NewItem;
         }

DataAccess/DTOs/Converters/BeamShears/BeamSpanLoadFromDTOConvertStrategy.cs

@@ -13,7 +13,7 @@ namespace DataAccess.DTOs
 
         public override IBeamSpanLoad GetNewItem(IBeamSpanLoad source)
         {
-            CheckObject.IsNull(source);
+            CheckObject.ThrowIfNull(source);
             if (source is DistributedLoadDTO distributed)
             {
                 ProcessDistributed(distributed);

DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsFromDTOUpdateStrategy.cs

@@ -21,11 +21,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Actions);
+            CheckObject.ThrowIfNull(sourceObject.Actions);
-            CheckObject.IsNull(targetObject.Actions);
+            CheckObject.ThrowIfNull(targetObject.Actions);
             targetObject.Actions.Clear();
             foreach (var action in sourceObject.Actions)
             {

DataAccess/DTOs/Converters/BeamShears/HasBeamShearActionsToDTOUpdateStrategy.cs

@@ -18,11 +18,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Actions);
+            CheckObject.ThrowIfNull(sourceObject.Actions);
-            CheckObject.IsNull(targetObject.Actions);
+            CheckObject.ThrowIfNull(targetObject.Actions);
             targetObject.Actions.Clear();
             foreach (var action in sourceObject.Actions)
             {

DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsFromDTOUpdateStrategy.cs

@@ -20,11 +20,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Calculators);
+            CheckObject.ThrowIfNull(sourceObject.Calculators);
-            CheckObject.IsNull(targetObject.Calculators);
+            CheckObject.ThrowIfNull(targetObject.Calculators);
             targetObject.Calculators.Clear();
             List<ICalculator> calculators = GetCalculators(sourceObject.Calculators);
             targetObject.Calculators.AddRange(calculators);

DataAccess/DTOs/Converters/BeamShears/HasBeamShearCalculatorsToDTOUpdateStrategy.cs

@@ -20,11 +20,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Calculators);
+            CheckObject.ThrowIfNull(sourceObject.Calculators);
-            CheckObject.IsNull(targetObject.Calculators);
+            CheckObject.ThrowIfNull(targetObject.Calculators);
             targetObject.Calculators.Clear();
             List<ICalculator> calculators = GetCalculators(sourceObject.Calculators);
             targetObject.Calculators.AddRange(calculators);

DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsFromDTOUpdateStrategy.cs

@@ -20,11 +20,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Sections);
+            CheckObject.ThrowIfNull(sourceObject.Sections);
-            CheckObject.IsNull(targetObject.Sections);
+            CheckObject.ThrowIfNull(targetObject.Sections);
             targetObject.Sections.Clear();
             foreach (var section in sourceObject.Sections)
             {

DataAccess/DTOs/Converters/BeamShears/HasBeamShearSectionsToDTORenameStrategy.cs

@@ -19,11 +19,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Sections);
+            CheckObject.ThrowIfNull(sourceObject.Sections);
-            CheckObject.IsNull(targetObject.Sections);
+            CheckObject.ThrowIfNull(targetObject.Sections);
             InitializeStrategies();
             targetObject.Sections.Clear();
             foreach (var section in sourceObject.Sections)

DataAccess/DTOs/Converters/BeamShears/HasStirrupsFromDTOUpdateStrategy.cs

@@ -21,11 +21,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Stirrups);
+            CheckObject.ThrowIfNull(sourceObject.Stirrups);
-            CheckObject.IsNull(targetObject.Stirrups);
+            CheckObject.ThrowIfNull(targetObject.Stirrups);
             targetObject.Stirrups.Clear();
             List<IStirrup> stirrups = GetStirrups(sourceObject.Stirrups);
             targetObject.Stirrups.AddRange(stirrups);

DataAccess/DTOs/Converters/BeamShears/HasStirrupsToDTOUpdateStrategy.cs

@@ -21,11 +21,11 @@ namespace DataAccess.DTOs
 
         public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.Stirrups);
+            CheckObject.ThrowIfNull(sourceObject.Stirrups);
-            CheckObject.IsNull(targetObject.Stirrups);
+            CheckObject.ThrowIfNull(targetObject.Stirrups);
             targetObject.Stirrups.Clear();
             List<IStirrup> stirrups = GetStirrups(sourceObject.Stirrups);
             targetObject.Stirrups.AddRange(stirrups);

DataAccess/DTOs/Converters/Forces/FactoredForceTupleFromDTOConvertStrategy.cs

@@ -43,9 +43,9 @@ namespace DataAccess.DTOs
 
         private static void CheckObjects(FactoredForceTupleDTO source)
         {
-            CheckObject.IsNull(source);
+            CheckObject.ThrowIfNull(source);
-            CheckObject.IsNull(source.ForceTuple);
+            CheckObject.ThrowIfNull(source.ForceTuple);
-            CheckObject.IsNull(source.CombinationProperty);
+            CheckObject.ThrowIfNull(source.CombinationProperty);
         }
 
         private void InitializeStrategies()

DataAccess/DTOs/Converters/Forces/ForceFactoredListFromDTOConvertStrategy.cs

@@ -47,7 +47,7 @@ namespace DataAccess.DTOs
 
         private void SetForceTuples(ForceFactoredListDTO source, ForceFactoredList newItem)
         {
-            CheckObject.IsNull(newItem.ForceTuples, nameof(newItem.ForceTuples));
+            CheckObject.ThrowIfNull(newItem.ForceTuples, nameof(newItem.ForceTuples));
             newItem.ForceTuples.Clear();
             foreach (var item in source.ForceTuples)
             {

DataAccess/DTOs/Converters/HasForceActionsFromDTOUpdateStrategy.cs

@@ -21,7 +21,7 @@ namespace DataAccess.DTOs
 
         public void Update(IHasForceActions targetObject, IHasForceActions sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.ForceActions.Clear();
             foreach (var item in sourceObject.ForceActions)

DataAccess/DTOs/Converters/HasVisualPropertyFromDTOUpdateStrategy.cs

@@ -20,8 +20,8 @@ namespace DataAccess.DTOs
 
         public void Update(IHasVisualProperty targetObject, IHasVisualProperty sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             convertStrategy = new DictionaryConvertStrategy<PrimitiveVisualProperty, PrimitiveVisualPropertyDTO>(
                 referenceDictionary,

DataAccess/DTOs/Converters/HasVisualPropertyToDTOUpdateStrategy.cs

@@ -20,8 +20,8 @@ namespace DataAccess.DTOs
 
         public void Update(IHasVisualProperty targetObject, IHasVisualProperty sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             convertStrategy = new DictionaryConvertStrategy<PrimitiveVisualPropertyDTO, IPrimitiveVisualProperty>(
                 referenceDictionary,

DataAccess/DTOs/Converters/Materials/HelperMaterialDTOSafetyFactorUpdateStrategy.cs

@@ -28,8 +28,8 @@ namespace DataAccess.DTOs
 
         public void Update(IHelperMaterial targetObject, IHelperMaterial sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             if (sourceObject.SafetyFactors is not null)
             {

DataAccess/DTOs/Converters/Materials/LibMaterialDTOUpdateStrategy.cs

@@ -16,8 +16,8 @@ namespace DataAccess.DTOs
         /// <inheritdoc/>
         public void Update(ILibMaterial targetObject, ILibMaterial sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
         }
     }

DataAccess/DTOs/Converters/NdmCrossSections/HasPrimitivesFromDTOUpdateStrategy.cs

@@ -15,7 +15,7 @@ namespace DataAccess.DTOs.Converters
 
         public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Primitives.Clear();
             foreach (var item in sourceObject.Primitives)

DataAccess/DTOs/Converters/Shapes/Point2DRangeFromDTOConvertStrategy.cs

@@ -34,9 +34,9 @@ namespace DataAccess.DTOs
 
         private static void CheckSourceObject(Point2DRangeDTO source)
         {
-            CheckObject.IsNull(source, ": point range source object");
+            CheckObject.ThrowIfNull(source, ": point range source object");
-            CheckObject.IsNull(source.StartPoint + ": point range start point");
+            CheckObject.ThrowIfNull(source.StartPoint + ": point range start point");
-            CheckObject.IsNull(source.EndPoint + ": point range end point");
+            CheckObject.ThrowIfNull(source.EndPoint + ": point range end point");
         }
 
         private void InitializeStrategies()

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataFromDTOConvertStrategy.cs

@@ -27,14 +27,14 @@ namespace DataAccess.DTOs
             updateStrategy.Update(NewItem, source);
             ProcessPrimitives(source);
             ProcessActions(source);
-            NewItem.Digrams.Clear();
+            NewItem.Diagrams.Clear();
-            foreach (var diagram in source.Digrams)
+            foreach (var diagram in source.Diagrams)
             {
                 if (diagram is not ValueDiagramEntityDTO diagramDTO)
                 {
                     throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(diagram));
                 }
-                NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagramDTO));
+                NewItem.Diagrams.Add(diagramConvertStrategy.Convert(diagramDTO));
             }
             return NewItem;
         }

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramCalculatorInputDataToDTOConvertStrategy.cs

@@ -28,10 +28,10 @@ namespace DataAccess.DTOs
             updateStrategy.Update(NewItem, source);
             ProcessPrimitives(source);
             ProcessActions(source);
-            NewItem.Digrams.Clear();
+            NewItem.Diagrams.Clear();
-            foreach (var diagram in source.Digrams)
+            foreach (var diagram in source.Diagrams)
             {
-                NewItem.Digrams.Add(diagramConvertStrategy.Convert(diagram));
+                NewItem.Diagrams.Add(diagramConvertStrategy.Convert(diagram));
             }
             return NewItem;
         }

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityFromDTOConvertStrategy.cs

@@ -19,11 +19,11 @@ namespace DataAccess.DTOs
             NewItem = new(source.Id);
             InitializeStrategies();
             updateStrategy.Update(NewItem, source);
-            if (source.ValueDigram is not ValueDiagramDTO diagramDTO)
+            if (source.ValueDiagram is not ValueDiagramDTO diagramDTO)
             {
-                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ValueDigram));
+                throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(source.ValueDiagram));
             }
-            NewItem.ValueDigram = diagramConvertStrategy.Convert(diagramDTO);
+            NewItem.ValueDiagram = diagramConvertStrategy.Convert(diagramDTO);
             return NewItem;
         }
 

DataAccess/DTOs/Converters/ValueDiagrams/ValueDiagramEntityToDTOConvertStrategy.cs

@@ -18,7 +18,7 @@ namespace DataAccess.DTOs
             NewItem = new(source.Id);
             InitializeStrategies();
             updateStrategy.Update(NewItem, source);
-            NewItem.ValueDigram = diagramConvertStrategy.Convert(source.ValueDigram);
+            NewItem.ValueDiagram = diagramConvertStrategy.Convert(source.ValueDiagram);
             return NewItem;
         }
 

DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramCalculatorInputDataDTO.cs

@@ -13,7 +13,7 @@ namespace DataAccess.DTOs
         [JsonProperty("StateTermPair")]
         public IStateCalcTermPair StateTermPair { get; set; } = new StateCalcTermPairDTO();
         [JsonProperty("Diagrams")]
-        public List<IValueDiagramEntity> Digrams { get; } = [];
+        public List<IValueDiagramEntity> Diagrams { get; } = [];
         [JsonProperty("CheckStrainLimits")]
         public bool CheckStrainLimit { get; set; } = true;
         [JsonProperty("ForceActions")]

DataAccess/DTOs/DTOEntities/ValueDiagrams/ValueDiagramEntityDTO.cs

@@ -12,7 +12,7 @@ namespace DataAccess.DTOs
         [JsonProperty("IsTaken")]
         public bool IsTaken { get; set; }
         [JsonProperty("ValueDiagram")]
-        public IValueDiagram ValueDigram { get; set; }
+        public IValueDiagram ValueDiagram { get; set; }
 
 
         public ValueDiagramEntityDTO(Guid id)

StructureHelper/Infrastructure/UI/Resources/ItemEditPanels.xaml

@@ -37,10 +37,22 @@
                 <RowDefinition Height="auto"/>
                 <RowDefinition Height="*"/>
             </Grid.RowDefinitions>
-            <StackPanel Height="25" Orientation="Horizontal" HorizontalAlignment="Right" Visibility="{Binding ShowButtons, Converter={StaticResource BooleanToVisibilityConverter}}">
+            <StackPanel Height="27" Orientation="Horizontal" HorizontalAlignment="Right" Visibility="{Binding ShowButtons, Converter={StaticResource BooleanToVisibilityConverter}}">
-                <Button Content="Select All" Command="{Binding SelectAllCommand}"/>
+                <Button Margin="0,0,2,0" Command="{Binding SelectAllCommand}" ToolTip="Select all">
-                <Button Content="Unselect All" Command="{Binding UnSelectAllCommand}"/>
+                    <Viewbox Width="24" Height="24">
-                <Button Content="Invert Selection" Command="{Binding InvertSelectionCommand}"/>
+                        <ContentControl ContentTemplate="{StaticResource SelectAll}"/>
+                    </Viewbox>
+                </Button>
+                <Button Margin="0,0,2,0" Command="{Binding UnSelectAllCommand}" ToolTip="Unselect all">
+                    <Viewbox Width="24" Height="24">
+                        <ContentControl ContentTemplate="{StaticResource DeSelectAll}"/>
+                    </Viewbox>
+                </Button>
+                <Button Margin="0,0,2,0" Command="{Binding InvertSelectionCommand}"  ToolTip="Invert selection">
+                    <Viewbox Width="24" Height="24">
+                        <ContentControl ContentTemplate="{StaticResource InvertSelection}"/>
+                    </Viewbox>
+                </Button>
             </StackPanel>
             <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Visible">
                 <ListBox ItemsSource="{Binding CollectionItems}" SelectedItem="SelectedItem" HorizontalAlignment="Stretch">

StructureHelper/Properties/AssemblyInfo.cs

@@ -49,5 +49,5 @@ using System.Windows;
 // Можно задать все значения или принять номера сборки и редакции по умолчанию 
 // используя "*", как показано ниже:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("2025.07.23.01")]
+[assembly: AssemblyVersion("2025.11.17.01")]
-[assembly: AssemblyFileVersion("2025.07.23.01")]
+[assembly: AssemblyFileVersion("2025.11.17.01")]

StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramCalculatorInputDataViewModel.cs

@@ -32,7 +32,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr
             this.inputData = inputData;
             this.repository = repository;
             StateCalcTermPairViewModel = new(inputData.StateTermPair);
-            ValueDiagramsViewModel = new(inputData.Digrams);
+            ValueDiagramsViewModel = new(inputData.Diagrams);
             CombinationViewModel = SourceTargetFactory.GetSourceTargetVM(repository.ForceActions, inputData.ForceActions);
             PrimitivesViewModel = SourceTargetFactory.GetSourceTargetVM(repository.Primitives, inputData.Primitives);
         }

StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramEntityViewModel.cs

@@ -31,7 +31,7 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr
         public ValueDiagramEntityViewModel(IValueDiagramEntity valueDiagramEntity)
         {
             this.valueDiagramEntity = valueDiagramEntity;
-            ValueDiagram = new(valueDiagramEntity.ValueDigram);
+            ValueDiagram = new(valueDiagramEntity.ValueDiagram);
         }
     }
 }

StructureHelper/Windows/CalculationWindows/CalculatorsViews/ValueDiagrams/ValueDiagramsViewModel.cs

@@ -19,9 +19,9 @@ namespace StructureHelper.Windows.CalculationWindows.CalculatorsViews.ValueDiagr
                 IsTaken = true,
                 Name = "New Value Diagram"
             };
-            NewItem.ValueDigram.StepNumber = 50;
+            NewItem.ValueDiagram.StepNumber = 50;
-            NewItem.ValueDigram.Point2DRange.StartPoint.Y = 0.25;
+            NewItem.ValueDiagram.Point2DRange.StartPoint.Y = 0.25;
-            NewItem.ValueDigram.Point2DRange.EndPoint.Y = - 0.25;
+            NewItem.ValueDiagram.Point2DRange.EndPoint.Y = - 0.25;
             base.AddMethod(parameter);
         }
         public override void EditMethod(object parameter)

StructureHelper/Windows/Graphs/GraphView.xaml

@@ -8,7 +8,7 @@
         xmlns:uc="clr-namespace:StructureHelper.Windows.UserControls"
         d:DataContext="{d:DesignInstance local:GraphViewModel}"
         mc:Ignorable="d"
-        Title="Graph" Height="650" Width="1000" MinHeight="500" MinWidth="600" MaxHeight="1100" MaxWidth="1800" WindowStartupLocation="CenterScreen">
+        Title="Graph" Height="750" Width="1200" MinHeight="500" MinWidth="600" MaxHeight="1100" MaxWidth="1800" WindowStartupLocation="CenterScreen">
     <DockPanel>
         <ToolBarTray DockPanel.Dock="Top">
             <ToolBar>
@@ -57,7 +57,7 @@
         </ToolBarTray>
         <Grid x:Name="MainGrid">
             <Grid.ColumnDefinitions>
-                <ColumnDefinition MinWidth="250"/>
+                <ColumnDefinition MinWidth="300"/>
                 <ColumnDefinition Width="Auto"/>
                 <ColumnDefinition Width="5*"/>
             </Grid.ColumnDefinitions>

StructureHelper/Windows/MainWindow/CrossSections/ValueDiagramLogic.cs

@@ -83,7 +83,8 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
                 }
 
             }
-            data[pointPrimitives.Count, 0] = GetDistance(startPoint, endPoint);
+            double fullLength = GetDistance(startPoint, endPoint);
+            data[pointPrimitives.Count, 0] = fullLength;
             data[pointPrimitives.Count, 1] = endPoint.X;
             data[pointPrimitives.Count, 2] = endPoint.Y;
 
@@ -91,7 +92,7 @@ namespace StructureHelper.Windows.MainWindow.CrossSections
             data[pointPrimitives.Count + 1, 1] = startPoint.X;
             data[pointPrimitives.Count + 1, 2] = startPoint.Y;
 
-            data[pointPrimitives.Count, 0] = 0.0;
+            data[pointPrimitives.Count + 2, 0] = 0.0;
             data[pointPrimitives.Count + 2, 1] = startPoint.X;
             data[pointPrimitives.Count + 2, 2] = startPoint.Y;
             for (int j = 0; j < resultFuncs.Count; j++)

StructureHelper/Windows/PrimitivePropertiesWindow/SelectPrimitivesView.xaml

@@ -13,6 +13,7 @@
             <RowDefinition Height="*"/>
             <RowDefinition Height="35"/>
         </Grid.RowDefinitions>
+        <!--ItemEditPanels-->
         <ContentControl ContentTemplate="{StaticResource ResourceKey=SelectItems}" Content="{Binding Items}"/>
         <ContentControl Grid.Row="1" ContentTemplate="{StaticResource OkCancelButtons}" Content="{Binding}"/>
     </Grid>

StructureHelperCommon/Infrastructures/Interfaces/BaseUpdateStrategy.cs

@@ -12,7 +12,7 @@ namespace StructureHelperCommon.Infrastructures.Interfaces
         public abstract void Update(T targetObject, T sourceObject);
         public void Check(T targetObject, T sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
         }
     }

StructureHelperCommon/Infrastructures/Interfaces/CheckEntityLogic.cs

@@ -0,0 +1,21 @@
+using StructureHelperCommon.Models;
+
+namespace StructureHelperCommon.Infrastructures.Interfaces
+{
+    public abstract class CheckEntityLogic<TEntity> : ICheckEntityLogic<TEntity> where TEntity : class
+    {
+        public TEntity Entity { get; set; }
+
+        public virtual string CheckResult { get; set; } = string.Empty;
+
+        public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public abstract bool Check();
+
+        public virtual void TraceMessage(string errorString)
+        {
+            CheckResult += errorString + "\n";
+            TraceLogger?.AddMessage(errorString);
+        }
+    }
+}

StructureHelperCommon/Infrastructures/Interfaces/HasForceActionUpdateCloningStrategy.cs

@@ -21,9 +21,9 @@ namespace StructureHelperCommon.Infrastructures.Interfaces
 
         public void Update(IHasForceActions targetObject, IHasForceActions sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.ForceActions.Clear();
             foreach (var force in sourceObject.ForceActions)

StructureHelperCommon/Models/Analyses/AnalysisUpdateStrategy.cs

@@ -12,7 +12,7 @@ namespace StructureHelperCommon.Models.Analyses
     {
         public void Update(IAnalysis targetObject, IAnalysis sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject, "Analysis Properties");
+            CheckObject.ThrowIfNull(targetObject, sourceObject, "Analysis Properties");
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.Tags = sourceObject.Tags;

StructureHelperCommon/Models/Analyses/DateVersionUpdateStrategy.cs

@@ -13,8 +13,8 @@ namespace StructureHelperCommon.Models.Analyses
     {
         public void Update(IDateVersion targetObject, IDateVersion sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
             targetObject.DateTime = sourceObject.DateTime;
         }

StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearActionUpdateStrategy.cs

@@ -8,14 +8,14 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions
         private IUpdateStrategy<IBeamShearAxisAction> axisActionUpdateStrategy;
         public void Update(IBeamShearAction targetObject, IBeamShearAction sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.ExternalForce = sourceObject.ExternalForce.Clone() as IFactoredForceTuple;
             InitializeStrategies();
-            CheckObject.IsNull(sourceObject.SupportAction);
+            CheckObject.ThrowIfNull(sourceObject.SupportAction);
-            CheckObject.IsNull(targetObject.SupportAction);
+            CheckObject.ThrowIfNull(targetObject.SupportAction);
             axisActionUpdateStrategy.Update(targetObject.SupportAction, sourceObject.SupportAction);
         }
 

StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearAxisActionUpdateStrategy.cs

@@ -12,15 +12,15 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions
         private IUpdateStrategy<IFactoredCombinationProperty> combinationUpdateStrategy;
         public void Update(IBeamShearAxisAction targetObject, IBeamShearAxisAction sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             InitializeStrategies();
             targetObject.Name = sourceObject.Name;
             targetObject.SupportForce = sourceObject.SupportForce.Clone() as IFactoredForceTuple;
-            CheckObject.IsNull(targetObject.ShearLoads);
+            CheckObject.ThrowIfNull(targetObject.ShearLoads);
             targetObject.ShearLoads.Clear();
-            CheckObject.IsNull(sourceObject.ShearLoads);
+            CheckObject.ThrowIfNull(sourceObject.ShearLoads);
             foreach (var item in sourceObject.ShearLoads)
             {
                 IBeamSpanLoad beamShearLoad = item.Clone() as IBeamSpanLoad;

StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadBaseUpdateStrategy.cs

@@ -9,14 +9,14 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions
         private IUpdateStrategy<IFactoredCombinationProperty> combinationUpdateStrategy;
         public void Update(IBeamSpanLoad targetObject, IBeamSpanLoad sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.LoadRatio = sourceObject.LoadRatio;
             targetObject.RelativeLoadLevel = sourceObject.RelativeLoadLevel;
-            CheckObject.IsNull(sourceObject.CombinationProperty);
+            CheckObject.ThrowIfNull(sourceObject.CombinationProperty);
-            CheckObject.IsNull(targetObject.CombinationProperty);
+            CheckObject.ThrowIfNull(targetObject.CombinationProperty);
             combinationUpdateStrategy ??= new FactoredCombinationPropertyUpdateStrategy();
             combinationUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty);
         }

StructureHelperCommon/Models/Forces/BeamShearActions/BeamShearLoadUpdateStrategy.cs

@@ -15,8 +15,8 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions
         private IUpdateStrategy<IDistributedLoad> distributedLoadUpdateStrategy;
         public void Update(IBeamSpanLoad targetObject, IBeamSpanLoad sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             InitializeStrategies();
             UpdateObjects(targetObject, sourceObject);

StructureHelperCommon/Models/Forces/BeamShearActions/ConcentratedForceUpdateStrategy.cs

@@ -8,8 +8,8 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions
         private IUpdateStrategy<IBeamSpanLoad> baseUpdateStrategy;
         public void Update(IConcentratedForce targetObject, IConcentratedForce sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             InitializeStrategies();
             baseUpdateStrategy.Update(targetObject, sourceObject);

StructureHelperCommon/Models/Forces/BeamShearActions/DistributedLoadUpdateStrategy.cs

@@ -8,8 +8,8 @@ namespace StructureHelperCommon.Models.Forces.BeamShearActions
         private IUpdateStrategy<IBeamSpanLoad> baseUpdateStrategy;
         public void Update(IDistributedLoad targetObject, IDistributedLoad sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             InitializeStrategies();
             baseUpdateStrategy.Update(targetObject, sourceObject);

StructureHelperCommon/Models/Forces/Logics/ActionUpdateStrategy.cs

@@ -10,8 +10,8 @@ namespace StructureHelperCommon.Models.Forces
         public void Update(IAction targetObject, IAction sourceObject)
         {
             forceUpdateStrategy ??= new ForceActionUpdateStrategy();
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             if (targetObject is IForceAction forceAction)

StructureHelperCommon/Models/Forces/Logics/CheckForceActionsLogic.cs

@@ -1,10 +1,6 @@
-using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
-using StructureHelperCommon.Infrastructures.Interfaces;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace StructureHelperCommon.Models.Forces.Logics
 {
@@ -15,6 +11,17 @@ namespace StructureHelperCommon.Models.Forces.Logics
         public string CheckResult => checkResult;
 
         public IShiftTraceLogger? TraceLogger { get; set; }
+
+        public CheckForceActionsLogic(IShiftTraceLogger? traceLogger)
+        {
+            TraceLogger = traceLogger;
+        }
+
+        public CheckForceActionsLogic()
+        {
+            
+        }
+
         public IEnumerable<IForceAction> Entity { get; set; }
 
         public bool Check()

StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyCloningStrategy.cs

@@ -24,7 +24,7 @@ namespace StructureHelperCommon.Models.Forces
 
         public IColumnFileProperty GetClone(IColumnFileProperty sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (updateStrategy is null)
             {
                 updateStrategy = new ColumnFilePropertyUpdateStrategy();

StructureHelperCommon/Models/Forces/Logics/ColumnFilePropertyUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Forces
     {
         public void Update(IColumnFileProperty targetObject, IColumnFileProperty sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.SearchingName = sourceObject.SearchingName;

StructureHelperCommon/Models/Forces/Logics/ColumnedFilePropertyUpdateStrategy.cs

@@ -14,8 +14,8 @@ namespace StructureHelperCommon.Models.Forces
         /// <inheritdoc/>
         public void Update(IColumnedFileProperty targetObject, IColumnedFileProperty sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             UpdateObjects(targetObject, sourceObject);
         }
@@ -26,8 +26,8 @@ namespace StructureHelperCommon.Models.Forces
             targetObject.GlobalFactor = sourceObject.GlobalFactor;
             targetObject.SkipRowBeforeHeaderCount = sourceObject.SkipRowBeforeHeaderCount;
             targetObject.SkipRowHeaderCount = sourceObject.SkipRowHeaderCount;
-            CheckObject.IsNull(targetObject.ColumnProperties);
+            CheckObject.ThrowIfNull(targetObject.ColumnProperties);
-            CheckObject.IsNull(sourceObject.ColumnProperties);
+            CheckObject.ThrowIfNull(sourceObject.ColumnProperties);
             targetObject.ColumnProperties.Clear();
             foreach (var item in sourceObject.ColumnProperties)
             {

StructureHelperCommon/Models/Forces/Logics/DesignForceTupleUpdateStrategy.cs

@@ -24,8 +24,8 @@ namespace StructureHelperCommon.Models.Forces.Logics
 
         public void Update(IDesignForceTuple targetObject, IDesignForceTuple sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.LimitState = sourceObject.LimitState;
             targetObject.CalcTerm = sourceObject.CalcTerm;

StructureHelperCommon/Models/Forces/Logics/FactoredCombinationPropertyUpdateStrategy.cs

@@ -7,8 +7,8 @@ namespace StructureHelperCommon.Models.Forces.Logics
     {
         public void Update(IFactoredCombinationProperty targetObject, IFactoredCombinationProperty sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.LimitState = sourceObject.LimitState;
             targetObject.ULSFactor = sourceObject.ULSFactor;

StructureHelperCommon/Models/Forces/Logics/FactoredForceTupleUpdateStrategy.cs

@@ -12,12 +12,12 @@ namespace StructureHelperCommon.Models.Forces
     {
         public void Update(IFactoredForceTuple targetObject, IFactoredForceTuple sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(sourceObject.ForceTuple);
+            CheckObject.ThrowIfNull(sourceObject.ForceTuple);
             targetObject.ForceTuple = sourceObject.ForceTuple.Clone() as IForceTuple;
-            CheckObject.IsNull(sourceObject.CombinationProperty);
+            CheckObject.ThrowIfNull(sourceObject.CombinationProperty);
             targetObject.CombinationProperty = sourceObject.CombinationProperty.Clone() as IFactoredCombinationProperty;
         }
     }

StructureHelperCommon/Models/Forces/Logics/ForceActionBaseUpdateStrategy.cs

@@ -25,8 +25,8 @@ namespace StructureHelperCommon.Models.Forces
 
         public void Update(IForceAction targetObject, IForceAction sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.SetInGravityCenter = sourceObject.SetInGravityCenter;

StructureHelperCommon/Models/Forces/Logics/ForceActionUpdateStrategy.cs

@@ -42,8 +42,8 @@ namespace StructureHelperCommon.Models.Forces
 
         public void Update(IForceAction targetObject, IForceAction sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             forceActionUpdateStrategy.Update(targetObject, sourceObject);
             UpdateChildProperties(targetObject, sourceObject);

StructureHelperCommon/Models/Forces/Logics/ForceCombinationFromFileUpdateStrategy.cs

@@ -30,14 +30,14 @@ namespace StructureHelperCommon.Models.Forces
 
         public void Update(IForceCombinationFromFile targetObject, IForceCombinationFromFile sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             InitializeLogics();
             baseUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.SkipWrongRows = sourceObject.SkipWrongRows;
-            CheckObject.IsNull(targetObject.CombinationProperty, "Target object combination property");
+            CheckObject.ThrowIfNull(targetObject.CombinationProperty, "Target object combination property");
-            CheckObject.IsNull(sourceObject.CombinationProperty, "Source object combination property");
+            CheckObject.ThrowIfNull(sourceObject.CombinationProperty, "Source object combination property");
             combinationPropertyUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty);
             targetObject.ForceFiles.Clear();
             foreach (var file in sourceObject.ForceFiles)

StructureHelperCommon/Models/Forces/Logics/ForceCombinationListUpdateStrategy.cs

@@ -25,7 +25,7 @@ namespace StructureHelperCommon.Models.Forces
 
         public void Update(IForceCombinationList targetObject, IForceCombinationList sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.DesignForces.Clear();
             foreach (var item in sourceObject.DesignForces)

StructureHelperCommon/Models/Forces/Logics/ForceFactoredListUpdateStrategy.cs

@@ -34,15 +34,15 @@ namespace StructureHelperCommon.Models.Forces
         }
         public void Update(IForceFactoredList targetObject, IForceFactoredList sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             forceActionUpdateStrategy.Update(targetObject, sourceObject);
-            CheckObject.IsNull(sourceObject.CombinationProperty);
+            CheckObject.ThrowIfNull(sourceObject.CombinationProperty);
-            CheckObject.IsNull(targetObject.CombinationProperty);
+            CheckObject.ThrowIfNull(targetObject.CombinationProperty);
             propertyUpdateStrategy.Update(targetObject.CombinationProperty, sourceObject.CombinationProperty);
-            CheckObject.IsNull(sourceObject.ForceTuples);
+            CheckObject.ThrowIfNull(sourceObject.ForceTuples);
-            CheckObject.IsNull(targetObject.ForceTuples);
+            CheckObject.ThrowIfNull(targetObject.ForceTuples);
             targetObject.ForceTuples.Clear();
             foreach (var item in sourceObject.ForceTuples)
             {

StructureHelperCommon/Models/Forces/Logics/ForceTupleUpdateStrategy.cs

@@ -13,7 +13,7 @@ namespace StructureHelperCommon.Models.Forces
     {
         public void Update(IForceTuple targetObject, IForceTuple sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Mx = sourceObject.Mx;
             targetObject.My = sourceObject.My;

StructureHelperCommon/Models/Forces/Logics/HasForceCombinationUpdateStrategy.cs

@@ -7,7 +7,7 @@ namespace StructureHelperCommon.Models.Forces.Logics
     {
         public void Update(IHasForceActions targetObject, IHasForceActions sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject, "Interface IHasForceCombination");
+            CheckObject.ThrowIfNull(targetObject, sourceObject, "Interface IHasForceCombination");
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.ForceActions.Clear();
             targetObject.ForceActions.AddRange(sourceObject.ForceActions);

StructureHelperCommon/Models/Forces/Logics/UniformlyDisributedLoadUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Forces
     {
         public void Update(IDistributedLoad targetObject, IDistributedLoad sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.LoadValue = sourceObject.LoadValue;

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

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Materials.Libraries
     {
         public void Update(IMaterialPartialFactor targetObject, IMaterialPartialFactor sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.LimitState = sourceObject.LimitState;
             targetObject.StressState = sourceObject.StressState;

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

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Materials.Libraries
     {
         public void Update(IMaterialSafetyFactor targetObject, IMaterialSafetyFactor sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Name = sourceObject.Name;
             targetObject.Take = sourceObject.Take;

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

@@ -13,8 +13,8 @@ namespace StructureHelperCommon.Models.Materials.Libraries
         private IUpdateStrategy<IMaterialSafetyFactor> baseUpdateStrategy = new MaterialSafetyFactorBaseUpdateStrategy();
         public void Update(IMaterialSafetyFactor targetObject, IMaterialSafetyFactor sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             baseUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.PartialFactors.Clear();

StructureHelperCommon/Models/Projects/FileVersionUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Projects
     {
         public void Update(IFileVersion targetObject, IFileVersion sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
             targetObject.VersionNumber = sourceObject.VersionNumber;
             targetObject.SubVersionNumber = sourceObject.SubVersionNumber;

StructureHelperCommon/Models/Projects/ProjectUpdateStrategy.cs

@@ -26,8 +26,8 @@ namespace StructureHelperCommon.Models.Projects
 
         public void Update(IProject targetObject, IProject sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.VisualAnalyses.Clear();
             foreach (var item in sourceObject.VisualAnalyses)

StructureHelperCommon/Models/Shapes/Logics/CircleShapeUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Shapes
     {
         public void Update(ICircleShape targetObject, ICircleShape sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Diameter = sourceObject.Diameter;
         }

StructureHelperCommon/Models/Shapes/Logics/LinePolygonShapeUpdateStrategy.cs

@@ -10,7 +10,7 @@ namespace StructureHelperCommon.Models.Shapes
 
         public void Update(ILinePolygonShape targetObject, ILinePolygonShape sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
 
             // Update simple properties

StructureHelperCommon/Models/Shapes/Logics/Point2DRangeUpdateStrategy.cs

@@ -8,12 +8,12 @@ namespace StructureHelperCommon.Models.Shapes
         private IUpdateStrategy<IPoint2D> pointUpdateStrategy;
         public void Update(IPoint2DRange targetObject, IPoint2DRange sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
-            CheckObject.IsNull(targetObject.StartPoint, ": range start point");
+            CheckObject.ThrowIfNull(targetObject.StartPoint, ": range start point");
             pointUpdateStrategy ??= new Point2DUpdateStrategy();
             pointUpdateStrategy.Update(targetObject.StartPoint, sourceObject.StartPoint);
-            CheckObject.IsNull(targetObject.EndPoint, ": range end point");
+            CheckObject.ThrowIfNull(targetObject.EndPoint, ": range end point");
             pointUpdateStrategy.Update(targetObject.EndPoint, sourceObject.EndPoint);
         }
     }

StructureHelperCommon/Models/Shapes/Logics/Point2DUpdateStrategy.cs

@@ -19,8 +19,8 @@ namespace StructureHelperCommon.Models.Shapes
         /// <inheritdoc />
         public void Update(IPoint2D targetObject, IPoint2D sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.X = sourceObject.X;
             targetObject.Y = sourceObject.Y;

StructureHelperCommon/Models/Shapes/Logics/RectangleShapeUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.Shapes
     {
         public void Update(IRectangleShape targetObject, IRectangleShape sourceObject)
         {
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Width = sourceObject.Width;
             targetObject.Height = sourceObject.Height;

StructureHelperCommon/Models/Shapes/Logics/ShapeUpdateStrategy.cs

@@ -13,8 +13,8 @@ namespace StructureHelperCommon.Models.Shapes
     {
         public void Update(IShape targetObject, IShape sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             if (sourceObject is IRectangleShape sourceRectangle)
             {

StructureHelperCommon/Models/Shapes/Logics/VertexUpdateStrategy.cs

@@ -14,7 +14,7 @@ namespace StructureHelperCommon.Models.Shapes
 
         public void Update(IVertex targetObject, IVertex sourceObject)
         {
-            CheckObject.IsNull(targetObject, sourceObject);
+            CheckObject.ThrowIfNull(targetObject, sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             if (UpdateChildren == true)
             {

StructureHelperCommon/Models/States/StateCalcTermPairUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.States
     {
         public void Update(IStateCalcTermPair targetObject, IStateCalcTermPair sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.LimitState = sourceObject.LimitState;
             targetObject.CalcTerm = sourceObject.CalcTerm;

StructureHelperCommon/Models/VisualProperties/PrimitiveVisualPropertyUpdateStrategy.cs

@@ -8,8 +8,8 @@ namespace StructureHelperCommon.Models.VisualProperties
     {
         public void Update(IPrimitiveVisualProperty targetObject, IPrimitiveVisualProperty sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.IsVisible = sourceObject.IsVisible;
             targetObject.Color = sourceObject.Color;

StructureHelperCommon/Models/WorkPlanes/WorkPlanePropertyUpdateStrategy.cs

@@ -12,8 +12,8 @@ namespace StructureHelperCommon.Models.WorkPlanes
     {
         public void Update(IWorkPlaneProperty targetObject, IWorkPlaneProperty sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.AxisLineThickness = sourceObject.AxisLineThickness;
             targetObject.GridSize = sourceObject.GridSize;

StructureHelperCommon/Services/CheckObject.cs

@@ -24,7 +24,7 @@ namespace StructureHelperCommon.Services
         /// <exception cref="StructureHelperException"></exception>
         public static void CompareTypes(object targetObject, object sourceObject)
         {
-            IsNull(targetObject, sourceObject);
+            ThrowIfNull(targetObject, sourceObject);
             if (targetObject.GetType() != sourceObject.GetType())
             {
                 throw new StructureHelperException
@@ -32,10 +32,10 @@ namespace StructureHelperCommon.Services
             }
         }
 
-        public static void IsNull(object targetObject, object sourceObject, string senderName = "")
+        public static void ThrowIfNull(object targetObject, object sourceObject, string senderName = "")
         {
-            IsNull(targetObject,$"{senderName} target object");
+            ThrowIfNull(targetObject,$"{senderName} target object");
-            IsNull(sourceObject, $"{senderName} source object");
+            ThrowIfNull(sourceObject, $"{senderName} source object");
         }
 
         /// <summary>
@@ -44,7 +44,7 @@ namespace StructureHelperCommon.Services
         /// <param name="item">Checked object</param>
         /// <param name="message">Message while error occur</param>
         /// <exception cref="StructureHelperException"></exception>
-        public static void IsNull(object item, string message = "")
+        public static void ThrowIfNull(object item, string message = "")
         {
             if (item is null)
             {

StructureHelperCommon/Services/Exports/EntitiesToDxfExportLogic.cs

@@ -12,7 +12,6 @@ namespace StructureHelperCommon.Services.Exports
 {
     public class EntitiesToDxfExportLogic : IExportToFileLogic
     {
-        private const double metresToMillimeters = 1000.0;
         private IGetDxfLayerLogic layerLogic = new GetDxfLayerLogic();
         public List<(EntityObject entity, LayerNames layerName)> Entities { get; set; } = [];
 

StructureHelperCommon/Services/Exports/GetDxfLayerLogic.cs

@@ -9,6 +9,7 @@ namespace StructureHelperCommon.Services.Exports
         private const string PrimitivesLayer = "STR-PRM";
         private const string OpeningsLayer = "STR-OPN";
         private const string RebarLayer = "STR-REB";
+        private const string PointLayer = "STR-PNT";
         private const string LayerNameIsUnKnown = ": Layer name is unknown";
         public Layer GetOrCreateLayer(DxfDocument dxf, LayerNames layerName)
         {
@@ -29,6 +30,7 @@ namespace StructureHelperCommon.Services.Exports
             if (layerName == LayerNames.StructiralPrimitives) { return PrimitivesLayer; }
             else if (layerName == LayerNames.StructuralOpenings) { return OpeningsLayer; }
             else if (layerName == LayerNames.StructuralRebars) { return RebarLayer; }
+            else if (layerName == LayerNames.StructuralPoints) { return PointLayer; }
             else
             {
                 throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(layerName) + LayerNameIsUnKnown);
@@ -40,6 +42,7 @@ namespace StructureHelperCommon.Services.Exports
             if (layerName == LayerNames.StructiralPrimitives) { return AciColor.Blue; }
             else if (layerName == LayerNames.StructuralOpenings) { return AciColor.DarkGray; }
             else if (layerName == LayerNames.StructuralRebars) { return AciColor.Magenta; }
+            else if (layerName == LayerNames.StructuralPoints) { return AciColor.Green; }
             else
             {
                 throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(layerName) + LayerNameIsUnKnown);

StructureHelperCommon/Services/Exports/ShapesExportToDxfLogic.cs

@@ -10,7 +10,8 @@ namespace StructureHelperCommon.Services.Exports
     {
         StructiralPrimitives,
         StructuralOpenings,
-        StructuralRebars
+        StructuralRebars,
+        StructuralPoints
     }
     public class ShapesExportToDxfLogic : IExportToFileLogic
     {

StructureHelperLogics/Models/Analyses/BeamShearAnalysisUpdateStrategy.cs

@@ -14,8 +14,8 @@ namespace StructureHelperLogics.Models.Analyses
 
         public void Update(IBeamShearAnalysis targetObject, IBeamShearAnalysis sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
             InitialzeStrategies();
             analysisUpdateStrategy.Update(targetObject, sourceObject);

StructureHelperLogics/Models/Analyses/CrossSectionNdmAnalysisUpdateStrategy.cs

@@ -32,8 +32,8 @@ namespace StructureHelperLogics.Models.Analyses
 
         public void Update(ICrossSectionNdmAnalysis targetObject, ICrossSectionNdmAnalysis sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
             analysisUpdateStrategy.Update(targetObject, sourceObject);
             targetObject.VersionProcessor.Versions.Clear();

StructureHelperLogics/Models/BeamShears/BeamShearUpdateStrategy.cs

@@ -14,11 +14,11 @@ namespace StructureHelperLogics.Models.BeamShears
         IUpdateStrategy<IBeamShearRepository> repositoryUpdateStrategy;
         public void Update(IBeamShear targetObject, IBeamShear sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Repository);
+            CheckObject.ThrowIfNull(sourceObject.Repository);
-            CheckObject.IsNull(targetObject.Repository);
+            CheckObject.ThrowIfNull(targetObject.Repository);
             InitializeStrategies();
             clearStrategy.Process(targetObject.Repository);
             repositoryUpdateStrategy.Update(targetObject.Repository, sourceObject.Repository);

StructureHelperLogics/Models/BeamShears/Logics/BeamShearReporitoryClearStrategy.cs

@@ -10,13 +10,13 @@ namespace StructureHelperLogics.Models.BeamShears
     {
         public void Process(IBeamShearRepository entity)
         {
-            CheckObject.IsNull(entity.Calculators);
+            CheckObject.ThrowIfNull(entity.Calculators);
             entity.Calculators.Clear();
-            CheckObject.IsNull(entity.Actions);
+            CheckObject.ThrowIfNull(entity.Actions);
             entity.Actions.Clear();
-            CheckObject.IsNull(entity.Sections);
+            CheckObject.ThrowIfNull(entity.Sections);
             entity.Sections.Clear();
-            CheckObject.IsNull(entity.Stirrups);
+            CheckObject.ThrowIfNull(entity.Stirrups);
             entity.Stirrups.Clear();
         }
     }

StructureHelperLogics/Models/BeamShears/Logics/BeamShearRepositoryAddUpdateStrategy.cs

@@ -11,8 +11,8 @@ namespace StructureHelperLogics.Models.BeamShears
     {
         public void Update(IBeamShearRepository targetObject, IBeamShearRepository sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
             targetObject.Actions.AddRange(sourceObject.Actions);
             targetObject.Sections.AddRange(sourceObject.Sections);

StructureHelperLogics/Models/BeamShears/Logics/BeamShearSectionUpdateStrategy.cs

@@ -16,8 +16,8 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public void Update(IBeamShearSection targetObject, IBeamShearSection sourceObject)
         {
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             Check(targetObject, sourceObject);
             InitializeStrategies();
@@ -36,12 +36,12 @@ namespace StructureHelperLogics.Models.BeamShears
 
         private static void Check(IBeamShearSection targetObject, IBeamShearSection sourceObject)
         {
-            CheckObject.IsNull(sourceObject.Shape, "Source object shape");
+            CheckObject.ThrowIfNull(sourceObject.Shape, "Source object shape");
-            CheckObject.IsNull(targetObject.Shape, "Target object shape");
+            CheckObject.ThrowIfNull(targetObject.Shape, "Target object shape");
-            CheckObject.IsNull(sourceObject.ConcreteMaterial, "Source concrete material");
+            CheckObject.ThrowIfNull(sourceObject.ConcreteMaterial, "Source concrete material");
-            CheckObject.IsNull(targetObject.ConcreteMaterial, "Target concrete material");
+            CheckObject.ThrowIfNull(targetObject.ConcreteMaterial, "Target concrete material");
-            CheckObject.IsNull(sourceObject.ReinforcementMaterial, "Source reinforcement material");
+            CheckObject.ThrowIfNull(sourceObject.ReinforcementMaterial, "Source reinforcement material");
-            CheckObject.IsNull(targetObject.ReinforcementMaterial, "Target reinforcement material");
+            CheckObject.ThrowIfNull(targetObject.ReinforcementMaterial, "Target reinforcement material");
         }
 
         private void InitializeStrategies()

StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorCloneStrategy.cs

@@ -15,8 +15,8 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public IBeamShearCalculator GetClone(IBeamShearCalculator sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             InitializeStrategies();
             BeamShearCalculator calculator = new(Guid.NewGuid());
             updateStrategy.Update(calculator, sourceObject);

StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/BeamShearCalculatorInputDataCloneStrategy.cs

@@ -21,8 +21,8 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public IBeamShearCalculatorInputData GetClone(IBeamShearCalculatorInputData sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
             InitializeStrategies();
             BeamShearCalculatorInputData inputData = new(Guid.NewGuid());
             actionUpdateStrategy.Update(inputData, sourceObject);

StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasActionsUpdateCloneStrategy.cs

@@ -14,9 +14,9 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Actions.Clear();
             foreach (var item in sourceObject.Actions)

StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasCalculatorsUpdateCloneStrategy.cs

@@ -17,9 +17,9 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Calculators.Clear();
             foreach (var calculator in sourceObject.Calculators)

StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasSectionsUpdateCloneStrategy.cs

@@ -14,9 +14,9 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Sections.Clear();
             foreach (var item in sourceObject.Sections)

StructureHelperLogics/Models/BeamShears/Logics/CloneStrategies/HasStirrupsUpdateCloneStrategy.cs

@@ -15,9 +15,9 @@ namespace StructureHelperLogics.Models.BeamShears
 
         public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
         {
-            CheckObject.IsNull(cloningStrategy);
+            CheckObject.ThrowIfNull(cloningStrategy);
-            CheckObject.IsNull(sourceObject);
+            CheckObject.ThrowIfNull(sourceObject);
-            CheckObject.IsNull(targetObject);
+            CheckObject.ThrowIfNull(targetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; }
             targetObject.Stirrups.Clear();
             foreach (var item in sourceObject.Stirrups)

StructureHelperLogics/Models/BeamShears/Logics/GetInclinedSectionListLogic.cs

@@ -74,8 +74,8 @@ namespace StructureHelperLogics.Models.BeamShears
 
         private void Check()
         {
-            CheckObject.IsNull(BeamShearSection);
+            CheckObject.ThrowIfNull(BeamShearSection);
-            CheckObject.IsNull(DesignRangeProperty);
+            CheckObject.ThrowIfNull(DesignRangeProperty);
         }
 
         private void GetShapeParameters()

StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearActionUpdateStrategy.cs

@@ -8,11 +8,11 @@ namespace StructureHelperLogics.Models.BeamShears
     {
         public void Update(IHasBeamShearActions targetObject, IHasBeamShearActions sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Actions);
+            CheckObject.ThrowIfNull(sourceObject.Actions);
-            CheckObject.IsNull(targetObject.Actions);
+            CheckObject.ThrowIfNull(targetObject.Actions);
             targetObject.Actions.Clear();
             targetObject.Actions.AddRange(sourceObject.Actions);
         }

StructureHelperLogics/Models/BeamShears/Logics/HasBeamShearSectionUpdateStrategy.cs

@@ -13,11 +13,11 @@ namespace StructureHelperLogics.Models.BeamShears
     {
         public void Update(IHasBeamShearSections targetObject, IHasBeamShearSections sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Sections);
+            CheckObject.ThrowIfNull(sourceObject.Sections);
-            CheckObject.IsNull(targetObject.Sections);
+            CheckObject.ThrowIfNull(targetObject.Sections);
             targetObject.Sections.Clear();
             targetObject.Sections.AddRange(sourceObject.Sections);
         }

StructureHelperLogics/Models/BeamShears/Logics/HasStirrupsUpdateStrategy.cs

@@ -8,11 +8,11 @@ namespace StructureHelperLogics.Models.BeamShears
     {
         public void Update(IHasStirrups targetObject, IHasStirrups sourceObject)
         {
-            CheckObject.IsNull(sourceObject, ErrorStrings.SourceObject);
+            CheckObject.ThrowIfNull(sourceObject, ErrorStrings.SourceObject);
-            CheckObject.IsNull(targetObject, ErrorStrings.TargetObject);
+            CheckObject.ThrowIfNull(targetObject, ErrorStrings.TargetObject);
             if (ReferenceEquals(targetObject, sourceObject)) { return; };
-            CheckObject.IsNull(sourceObject.Stirrups);
+            CheckObject.ThrowIfNull(sourceObject.Stirrups);
-            CheckObject.IsNull(targetObject.Stirrups);
+            CheckObject.ThrowIfNull(targetObject.Stirrups);
             targetObject.Stirrups.Clear();
             targetObject.Stirrups.AddRange(sourceObject.Stirrups);
         }