diff --git a/AIStudio.Wpf.DiagramApp/Views/MainWindow.xaml b/AIStudio.Wpf.DiagramApp/Views/MainWindow.xaml
index d9e15d8..3136027 100644
--- a/AIStudio.Wpf.DiagramApp/Views/MainWindow.xaml
+++ b/AIStudio.Wpf.DiagramApp/Views/MainWindow.xaml
@@ -1062,10 +1062,10 @@
                         <Separator />
                         <TextBlock Margin="5" Text="等大小"/>
                         <UniformGrid Rows="1">
-                            <Fluent:Button Margin="5" ToolTip="等宽" Command="{Binding SameWidthCommand}" CommandParameter="{Binding SelectedItem}" Size="Small" Icon="{iconPacks:FontAwesome Kind=ArrowsAltHSolid}"/>
-                            <Fluent:Button Margin="5" ToolTip="等高" Command="{Binding SameHeightCommand}" CommandParameter="{Binding SelectedItem}" Size="Small" Icon="{iconPacks:FontAwesome Kind=ArrowsAltVSolid}"/>
-                            <Fluent:Button Margin="5" ToolTip="等大小" Command="{Binding SameSizeCommand}" CommandParameter="{Binding SelectedItem}" Size="Small" Icon="{iconPacks:FontAwesome Kind=ArrowsAltSolid}"/>
-                            <Fluent:Button Margin="5" ToolTip="等角度" Command="{Binding SameAngleCommand}" CommandParameter="{Binding SelectedItem}" Size="Small" Icon="{iconPacks:Material Kind=AngleAcute}"/>
+                            <Fluent:Button Margin="5" ToolTip="等宽" Command="{Binding SameWidthCommand}" Size="Small" Icon="{iconPacks:FontAwesome Kind=ArrowsAltHSolid}"/>
+                            <Fluent:Button Margin="5" ToolTip="等高" Command="{Binding SameHeightCommand}" Size="Small" Icon="{iconPacks:FontAwesome Kind=ArrowsAltVSolid}"/>
+                            <Fluent:Button Margin="5" ToolTip="等大小" Command="{Binding SameSizeCommand}" Size="Small" Icon="{iconPacks:FontAwesome Kind=ArrowsAltSolid}"/>
+                            <Fluent:Button Margin="5" ToolTip="等角度" CommandParameter="{Binding SelectedItem}" Size="Small" Icon="{iconPacks:Material Kind=AngleAcute}"/>
                         </UniformGrid>
                     </Fluent:DropDownButton>
 
diff --git a/AIStudio.Wpf.DiagramDesigner/ViewModels/BaseViewModel/DiagramViewModel.cs b/AIStudio.Wpf.DiagramDesigner/ViewModels/BaseViewModel/DiagramViewModel.cs
index 3a89d8d..80b7f0d 100644
--- a/AIStudio.Wpf.DiagramDesigner/ViewModels/BaseViewModel/DiagramViewModel.cs
+++ b/AIStudio.Wpf.DiagramDesigner/ViewModels/BaseViewModel/DiagramViewModel.cs
@@ -1576,7 +1576,7 @@ namespace AIStudio.Wpf.DiagramDesigner
                 try
                 {
                     OffsetX += 10;
-                    OffsetY += 10;                    
+                    OffsetY += 10;
 
                     SerializableObject copyitem = JsonConvert.DeserializeObject<SerializableObject>(clipboardData);
 
@@ -1637,7 +1637,7 @@ namespace AIStudio.Wpf.DiagramDesigner
                                 item.ParentId = mappingOldToNewIDs[item.ParentId];
                         }
                     }
-                    items.AddRange(connectors);                  
+                    items.AddRange(connectors);
                 }
                 catch (Exception e)
                 {
@@ -1792,39 +1792,36 @@ namespace AIStudio.Wpf.DiagramDesigner
         #region 布局
         private void ExecuteAlignTopCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
-            var guid = Guid.NewGuid();
 
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Any())
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Top);
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double top = selectedItems.OrderBy(p => p.Top).Select(p => p.Top).FirstOrDefault();
 
                     foreach (DesignerItemViewModelBase item in selectedItems)
                     {
-                        item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
                         item.Top = top;
                     }
                 },
                  () => {
-                     foreach (DesignerItemViewModelBase item in selectedItems)
+                     foreach (var item in infos)
                      {
-                         item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
-                     }
-                 },
-                 () => {
-                     foreach (DesignerItemViewModelBase item in selectedItems)
-                     {
-                         item.ClearOldValue<double>(nameof(item.Top), guid.ToString());
+                         item.Key.Top = item.Value;
                      }
                  });
             }
@@ -1832,39 +1829,37 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteAlignVerticalCentersCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
-            var guid = Guid.NewGuid();
 
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Any())
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Top);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double mid = selectedItems.Select(p => p.Top + p.ItemHeight / 2).Average();
 
                     foreach (DesignerItemViewModelBase item in selectedItems)
                     {
-                        item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
                         item.Top = mid - item.ItemHeight / 2;
                     }
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        item.ClearOldValue<double>(nameof(item.Top), guid.ToString());
+                        item.Key.Top = item.Value;
                     }
                 });
             }
@@ -1872,40 +1867,37 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteAlignBottomCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            var guid = Guid.NewGuid();
-
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Any())
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Top);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double top = selectedItems.OrderBy(p => p.Top + p.ItemHeight).Select(p => p.Top + p.ItemHeight).LastOrDefault();
 
                     foreach (DesignerItemViewModelBase item in selectedItems)
                     {
-                        item.SetOldValue(item.Top, nameof(item.Top), guid.ToString());
                         item.Top = top - item.ItemHeight;
                     }
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        item.Top = item.GetOldValue<double>(nameof(item.Top), guid.ToString());
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        item.ClearOldValue<double>(nameof(item.Top), guid.ToString());
+                        item.Key.Top = item.Value;
                     }
                 });
             }
@@ -1913,40 +1905,37 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteAlignLeftCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            var guid = Guid.NewGuid();
-
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Any())
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Left);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double left = selectedItems.OrderBy(p => p.Left).Select(p => p.Left).FirstOrDefault();
 
                     foreach (DesignerItemViewModelBase item in selectedItems)
                     {
-                        item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
                         item.Left = left;
                     }
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
+                        item.Key.Left = item.Value;
                     }
                 });
             }
@@ -1954,40 +1943,37 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteAlignHorizontalCentersCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            var guid = Guid.NewGuid();
-
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Any())
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Left);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double mid = selectedItems.Select(p => p.Left + p.ItemWidth / 2).Average();
 
                     foreach (DesignerItemViewModelBase item in selectedItems)
                     {
-                        item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
                         item.Left = mid - item.ItemWidth / 2;
                     }
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
+                        item.Key.Left = item.Value;
                     }
                 });
             }
@@ -1995,40 +1981,37 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteAlignRightCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            var guid = Guid.NewGuid();
-
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Any())
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Left);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double right = selectedItems.OrderBy(p => p.Left + p.ItemWidth).Select(p => p.Left + p.ItemWidth).LastOrDefault();
 
                     foreach (DesignerItemViewModelBase item in selectedItems)
                     {
-                        item.SetOldValue(item.Left, nameof(item.Left), guid.ToString());
                         item.Left = right - item.ItemWidth;
                     }
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        item.Left = item.GetOldValue<double>(nameof(item.Left), guid.ToString());
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        item.ClearOldValue<double>(nameof(item.Left), guid.ToString());
+                        item.Key.Left = item.Value;
                     }
                 });
             }
@@ -2037,235 +2020,222 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteBringForwardCommand(object parameter)
         {
-            List<SelectableDesignerItemViewModelBase> ordered;
-            if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            List<SelectableDesignerItemViewModelBase> ordered = new List<SelectableDesignerItemViewModelBase>();
+            if (parameter is SelectableDesignerItemViewModelBase node)
             {
-                ordered = para.OrderByDescending(p => p.ZIndex).ToList();
+                ordered.Add(node);
+            }
+            else if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            {
+                ordered.AddRange(para.OrderByDescending(p => p.ZIndex));
             }
             else
             {
-                ordered = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
+                ordered.AddRange(SelectedItems.OrderByDescending(p => p.ZIndex));
             }
 
-            List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
-            var guid = Guid.NewGuid();
+            if (ordered.Any())
+            {
+                Dictionary<SelectableDesignerItemViewModelBase, int> infos = ordered.ToDictionary(p => p, p => p.ZIndex);
 
-            DoCommandManager.DoNewCommand(this.ToString(),
-            () => {
-                int count = this.Items.Count;
-                for (int i = 0; i < ordered.Count; i++)
-                {
-                    var item = ordered[i];
-                    int currentIndex = item.ZIndex;
-                    int newIndex = Math.Min(count - 1 - i, currentIndex + 1);
-                    if (currentIndex != newIndex)
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    int count = this.Items.Count;
+                    for (int i = 0; i < ordered.Count; i++)
                     {
-                        item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
-                        item.ZIndex = newIndex;
-                        changeditems.Add(item);
-
-                        IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
-
-                        foreach (var elm in it)
+                        var item = ordered[i];
+                        int currentIndex = item.ZIndex;
+                        int newIndex = Math.Min(count - 1 - i, currentIndex + 1);
+                        if (currentIndex != newIndex)
                         {
-                            if (elm != item)
+                            item.ZIndex = newIndex;
+
+                            IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
+
+                            foreach (var elm in it)
                             {
-                                elm.SetOldValue<int>(elm.ZIndex, nameof(elm.ZIndex), guid.ToString());
-                                elm.ZIndex = currentIndex;
-                                changeditems.Add(elm);
-                                break;
+                                if (elm != item)
+                                {
+                                    elm.ZIndex = currentIndex;
+                                    break;
+                                }
                             }
                         }
                     }
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
-                }
-            });
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.ZIndex = item.Value;
+                    }
+                });
+            }
         }
         private void ExecuteBringToFrontCommand(object parameter)
         {
-            List<SelectableDesignerItemViewModelBase> selectionSorted;
-            if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            List<SelectableDesignerItemViewModelBase> selectionSorted = new List<SelectableDesignerItemViewModelBase>();
+            if (parameter is SelectableDesignerItemViewModelBase node)
             {
-                selectionSorted = para.OrderByDescending(p => p.ZIndex).ToList();
+                selectionSorted.Add(node);
+            }
+            else if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            {
+                selectionSorted.AddRange(para.OrderByDescending(p => p.ZIndex));
             }
             else
             {
-                selectionSorted = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
+                selectionSorted.AddRange(SelectedItems.OrderByDescending(p => p.ZIndex));
             }
 
-            List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
+            if (selectionSorted.Any())
+            {
+                List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
+                Dictionary<SelectableDesignerItemViewModelBase, int> infos = selectionSorted.ToDictionary(p => p, p => p.ZIndex);
 
-            List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
-            var guid = Guid.NewGuid();
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    int i = childrenSorted.Count - 1;
+                    int j = childrenSorted.Count - selectionSorted.Count - 1;
 
-            DoCommandManager.DoNewCommand(this.ToString(),
-            () => {
-                int i = childrenSorted.Count - 1;
-                int j = childrenSorted.Count - selectionSorted.Count - 1;
-
-                foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
-                {
-                    item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
-                    if (selectionSorted.Contains(item))
+                    foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
                     {
-                        item.ZIndex = i--;
+                        if (selectionSorted.Contains(item))
+                        {
+                            item.ZIndex = i--;
+                        }
+                        else
+                        {
+                            item.ZIndex = j--;
+                        }
                     }
-                    else
+                },
+                () => {
+                    foreach (var item in infos)
                     {
-                        item.ZIndex = j--;
+                        item.Key.ZIndex = item.Value;
                     }
-                    changeditems.Add(item);
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
-                }
-            });
+                });
+            }
         }
         private void ExecuteSendBackwardCommand(object parameter)
         {
-            List<SelectableDesignerItemViewModelBase> ordered;
-            if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            List<SelectableDesignerItemViewModelBase> ordered = new List<SelectableDesignerItemViewModelBase>();
+            if (parameter is SelectableDesignerItemViewModelBase node)
             {
-                ordered = para.OrderBy(p => p.ZIndex).ToList();
+                ordered.Add(node);
+            }
+            else if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            {
+                ordered.AddRange(para.OrderBy(p => p.ZIndex));
             }
             else
             {
-                ordered = SelectedItems.OrderBy(p => p.ZIndex).ToList();
+                ordered.AddRange(SelectedItems.OrderBy(p => p.ZIndex));
             }
 
-            int count = this.Items.Count;
+            if (ordered.Any())
+            {
+                Dictionary<SelectableDesignerItemViewModelBase, int> infos = ordered.ToDictionary(p => p, p => p.ZIndex);
 
-            List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
-            var guid = Guid.NewGuid();
-
-            DoCommandManager.DoNewCommand(this.ToString(),
-            () => {
-                for (int i = 0; i < ordered.Count; i++)
-                {
-                    var item = ordered[i];
-                    int currentIndex = item.ZIndex;
-                    int newIndex = Math.Max(i, currentIndex - 1);
-                    if (currentIndex != newIndex)
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    for (int i = 0; i < ordered.Count; i++)
                     {
-                        item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
-                        item.ZIndex = newIndex;
-                        changeditems.Add(item);
-                        IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
-
-                        foreach (var elm in it)
+                        var item = ordered[i];
+                        int currentIndex = item.ZIndex;
+                        int newIndex = Math.Max(i, currentIndex - 1);
+                        if (currentIndex != newIndex)
                         {
-                            if (elm != ordered[i])
-                            {
-                                elm.SetOldValue<int>(elm.ZIndex, nameof(elm.ZIndex), guid.ToString());
-                                elm.ZIndex = currentIndex;
-                                changeditems.Add(elm);
+                            item.ZIndex = newIndex;
+                            IEnumerable<SelectableDesignerItemViewModelBase> it = this.Items.Where(p => p.ZIndex == newIndex);
 
-                                break;
+                            foreach (var elm in it)
+                            {
+                                if (elm != ordered[i])
+                                {
+                                    elm.ZIndex = currentIndex;
+                                    break;
+                                }
                             }
                         }
                     }
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
-                }
-            });
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.ZIndex = item.Value;
+                    }
+                });
+            }
         }
 
         private void ExecuteSendToBackCommand(object parameter)
         {
-            List<SelectableDesignerItemViewModelBase> selectionSorted;
-            if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            List<SelectableDesignerItemViewModelBase> selectionSorted = new List<SelectableDesignerItemViewModelBase>();
+            if (parameter is SelectableDesignerItemViewModelBase node)
             {
-                selectionSorted = para.OrderByDescending(p => p.ZIndex).ToList();
+                selectionSorted.Add(node);
+            }
+            else if (parameter is IEnumerable<SelectableDesignerItemViewModelBase> para)
+            {
+                selectionSorted.AddRange(para.OrderByDescending(p => p.ZIndex));
             }
             else
             {
-                selectionSorted = SelectedItems.OrderByDescending(p => p.ZIndex).ToList();
+                selectionSorted.AddRange(SelectedItems.OrderByDescending(p => p.ZIndex));
             }
 
-            List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
+            if (selectionSorted.Any())
+            {
+                List<SelectableDesignerItemViewModelBase> childrenSorted = Items.OrderByDescending(p => p.ZIndex).ToList();
+                Dictionary<SelectableDesignerItemViewModelBase, int> infos = selectionSorted.ToDictionary(p => p, p => p.ZIndex);
 
-            List<SelectableDesignerItemViewModelBase> changeditems = new List<SelectableDesignerItemViewModelBase>();
-            var guid = Guid.NewGuid();
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    int i = childrenSorted.Count - 1;
+                    int j = selectionSorted.Count - 1;
 
-            DoCommandManager.DoNewCommand(this.ToString(),
-            () => {
-                int i = childrenSorted.Count - 1;
-                int j = selectionSorted.Count - 1;
-
-                foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
-                {
-                    item.SetOldValue<int>(item.ZIndex, nameof(item.ZIndex), guid.ToString());
-                    if (selectionSorted.Contains(item))
+                    foreach (SelectableDesignerItemViewModelBase item in childrenSorted)
                     {
-                        item.ZIndex = j--;
+                        if (selectionSorted.Contains(item))
+                        {
+                            item.ZIndex = j--;
+                        }
+                        else
+                        {
+                            item.ZIndex = i--;
+                        }
                     }
-                    else
+                },
+                () => {
+                    foreach (var item in infos)
                     {
-                        item.ZIndex = i--;
+                        item.Key.ZIndex = item.Value;
                     }
-                    changeditems.Add(item);
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ZIndex = item.GetOldValue<int>(nameof(item.ZIndex), guid.ToString());
-                }
-            },
-            () => {
-                foreach (var item in changeditems)
-                {
-                    item.ClearOldValue<double>(nameof(item.ZIndex), guid.ToString());
-                }
-            });
+                });
+            }
         }
 
         private void ExecuteDistributeHorizontalCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para.Where(p => p.ParentId == Guid.Empty).OrderBy(p => p.Left);
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>().Where(p => p.ParentId == Guid.Empty).OrderBy(p => p.Left);
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            var guid = Guid.NewGuid();
-
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Count > 1)
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Left);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double left = Double.MaxValue;
@@ -2286,7 +2256,6 @@ namespace AIStudio.Wpf.DiagramDesigner
                         double delta = offset - item.Left;
                         foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
                         {
-                            di.SetOldValue(di.Left, nameof(di.Left), guid.ToString());
                             di.Left += delta;
                         }
                         offset = offset + item.ItemWidth + distance;
@@ -2294,21 +2263,9 @@ namespace AIStudio.Wpf.DiagramDesigner
 
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
-                        {
-                            di.Left = di.GetOldValue<double>(nameof(di.Left), guid.ToString());
-                        }
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
-                        {
-                            di.ClearOldValue<double>(nameof(di.Left), guid.ToString());
-                        }
+                        item.Key.Left = item.Value;
                     }
                 });
             }
@@ -2316,20 +2273,24 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteDistributeVerticalCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para.Where(p => p.ParentId == Guid.Empty).OrderBy(p => p.Top);
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>().Where(p => p.ParentId == Guid.Empty).OrderBy(p => p.Top);
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            var guid = Guid.NewGuid();
-
-            if (selectedItems.Count() > 1)
+            if (selectedItems.Count > 1)
             {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Top);
+
                 DoCommandManager.DoNewCommand(this.ToString(),
                 () => {
                     double top = Double.MaxValue;
@@ -2350,28 +2311,15 @@ namespace AIStudio.Wpf.DiagramDesigner
                         double delta = offset - item.Top;
                         foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
                         {
-                            di.SetOldValue(di.Top, nameof(di.Top), guid.ToString());
                             di.Top += +delta;
                         }
                         offset = offset + item.ItemHeight + distance;
                     }
                 },
                 () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
+                    foreach (var item in infos)
                     {
-                        foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
-                        {
-                            di.Top = di.GetOldValue<double>(nameof(di.Top), guid.ToString());
-                        }
-                    }
-                },
-                () => {
-                    foreach (DesignerItemViewModelBase item in selectedItems)
-                    {
-                        foreach (DesignerItemViewModelBase di in SelectionService.GetGroupMembers(item))
-                        {
-                            di.ClearOldValue<double>(nameof(di.Top), guid.ToString());
-                        }
+                        item.Key.Top = item.Value;
                     }
                 });
             }
@@ -2381,37 +2329,73 @@ namespace AIStudio.Wpf.DiagramDesigner
         #region 移动
         private void ExecuteLeftMoveCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            foreach (var item in selectedItems.OfType<DesignerItemViewModelBase>())
+            if (selectedItems.Any())
             {
-                item.Left -= 0.5;
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Left);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems)
+                    {
+                        item.Left -= 0.5;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.Left = item.Value;
+                    }
+                });
             }
         }
 
         private void ExecuteRightMoveCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            foreach (var item in selectedItems.OfType<DesignerItemViewModelBase>())
+            if (selectedItems.Any())
             {
-                item.Left += 0.5;
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Left);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems)
+                    {
+                        item.Left += 0.5;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.Left = item.Value;
+                    }
+                });
             }
         }
 
@@ -2435,46 +2419,83 @@ namespace AIStudio.Wpf.DiagramDesigner
 
         private void ExecuteDownMoveCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            foreach (var item in selectedItems.OfType<DesignerItemViewModelBase>())
+            if (selectedItems.Any())
             {
-                item.Top += 0.5;
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Top);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems.OfType<DesignerItemViewModelBase>())
+                    {
+                        item.Top += 0.5;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.Top = item.Value;
+                    }
+                });
             }
         }
 
         protected virtual void ExecuteCenterMoveCommand(object parameter)
         {
-            IEnumerable<DesignerItemViewModelBase> selectedItems;
-            if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                selectedItems = para;
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
             }
             else
             {
-                selectedItems = this.SelectedItems.OfType<DesignerItemViewModelBase>();
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
             }
 
-            foreach (var item in selectedItems.OfType<DesignerItemViewModelBase>())
+            if (selectedItems.Any())
             {
-                item.Left = (PageSize.Width - item.ItemWidth) / 2;
-                item.Top = (PageSize.Height - item.ItemHeight) / 2;
-            }
+                Dictionary<DesignerItemViewModelBase, PointBase> infos = selectedItems.ToDictionary(p => p, p => p.TopLeft);
 
-            FitViewModel = new FitViewModel() { BoundingRect = DiagramViewModelHelper.GetBoundingRectangle(selectedItems) };
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    //ToDo,整体移动到中心，而不是单个移动到中心
+                    foreach (var item in selectedItems.OfType<DesignerItemViewModelBase>())
+                    {
+                        item.Left = (PageSize.Width - item.ItemWidth) / 2;
+                        item.Top = (PageSize.Height - item.ItemHeight) / 2;
+                    }
+
+                    FitViewModel = new FitViewModel() { BoundingRect = DiagramViewModelHelper.GetBoundingRectangle(selectedItems) };
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.TopLeft = item.Value;
+                    }
+
+                    FitViewModel = new FitViewModel() { BoundingRect = DiagramViewModelHelper.GetBoundingRectangle(selectedItems) };
+                });
+            }
         }
 
-
-
-        public void UpdateZIndex()
+        protected void UpdateZIndex()
         {
             List<SelectableDesignerItemViewModelBase> ordered = Items.OrderBy(p => p.ZIndex).ToList();
 
@@ -2488,46 +2509,146 @@ namespace AIStudio.Wpf.DiagramDesigner
         #region 大小
         private void ExecuteSameSizeCommand(object parameter)
         {
-            if (parameter is DesignerItemViewModelBase designerItem)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
-                {
-                    item.ItemWidth = designerItem.ItemWidth;
-                    item.ItemHeight = designerItem.ItemHeight;
-                }
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
+            }
+            else
+            {
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
+            }
+
+            if (selectedItems.Count > 1)
+            {
+                Dictionary<DesignerItemViewModelBase, SizeBase> infos = selectedItems.ToDictionary(p => p, p => p.Size);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems)
+                    {
+                        item.ItemWidth = selectedItems.FirstOrDefault().ItemWidth;
+                        item.ItemHeight = selectedItems.FirstOrDefault().ItemHeight;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.Size = item.Value;
+                    }                   
+                });
             }
         }
 
         private void ExecuteSameWidthCommand(object parameter)
         {
-            if (parameter is DesignerItemViewModelBase designerItem)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
-                {
-                    item.ItemWidth = designerItem.ItemWidth;
-                }
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
+            }
+            else
+            {
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
+            }
+
+            if (selectedItems.Count > 1)
+            {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.ItemWidth);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems)
+                    {
+                        item.ItemWidth = selectedItems.FirstOrDefault().ItemWidth;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.ItemWidth = item.Value;
+                    }
+                });
             }
         }
 
         private void ExecuteSameHeightCommand(object parameter)
         {
-            if (parameter is DesignerItemViewModelBase designerItem)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
-                {
-                    item.ItemHeight = designerItem.ItemHeight;
-                }
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
+            }
+            else
+            {
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
+            }
+
+            if (selectedItems.Count > 1)
+            {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.ItemHeight);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems)
+                    {
+                        item.ItemHeight = selectedItems.FirstOrDefault().ItemHeight;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.ItemHeight = item.Value;
+                    }
+                });
             }
         }
 
         private void ExecuteSameAngleCommand(object parameter)
         {
-            if (parameter is DesignerItemViewModelBase designerItem)
+            List<DesignerItemViewModelBase> selectedItems = new List<DesignerItemViewModelBase>();
+            if (parameter is DesignerItemViewModelBase node)
             {
-                foreach (var item in SelectedItems.OfType<DesignerItemViewModelBase>())
-                {
-                    item.Angle = designerItem.Angle;
-                }
+                selectedItems.Add(node);
+            }
+            else if (parameter is IEnumerable<DesignerItemViewModelBase> para)
+            {
+                selectedItems.AddRange(para);
+            }
+            else
+            {
+                selectedItems.AddRange(SelectedItems.OfType<DesignerItemViewModelBase>());
+            }
+
+            if (selectedItems.Count > 1)
+            {
+                Dictionary<DesignerItemViewModelBase, double> infos = selectedItems.ToDictionary(p => p, p => p.Angle);
+
+                DoCommandManager.DoNewCommand(this.ToString(),
+                () => {
+                    foreach (var item in selectedItems)
+                    {
+                        item.Angle = selectedItems.FirstOrDefault().Angle;
+                    }
+                },
+                () => {
+                    foreach (var item in infos)
+                    {
+                        item.Key.Angle = item.Value;
+                    }
+                });
             }
         }
 
@@ -2624,7 +2745,7 @@ namespace AIStudio.Wpf.DiagramDesigner
             }
         }
 
-        public bool BelongToSameGroup(IGroupable item1, IGroupable item2)
+        private bool BelongToSameGroup(IGroupable item1, IGroupable item2)
         {
             IGroupable root1 = SelectionService.GetGroupRoot(item1);
             IGroupable root2 = SelectionService.GetGroupRoot(item2);
@@ -2647,7 +2768,7 @@ namespace AIStudio.Wpf.DiagramDesigner
                 return true;
             }
             else if (DiagramOption.ShortcutOption.Copy(e))
-            {              
+            {
                 return Copy(null) != null;
             }
             else if (DiagramOption.ShortcutOption.Paste(e))