ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【WPF】Command 的一些利用方案 [打印本页]
作者: 熊熊出没    时间: 2024-7-28 15:33
标题: 【WPF】Command 的一些利用方案
Command，即命令，具体而言，指的是实现了 ICommand 接口的对象。此接口要求实现者包罗这些成员：
1、CanExecute 方法：确定该命令是否可以执行，若可，返回 true；若不可，返回 false；
2、CanExecuteChanged 变乱：发送命令（命令源）的控件可以订阅此变乱，当命令的可执行性改变时能得到关照；
3、Execute 方法：执行命令时调用此方法。可以将命令逻辑写在此方法中。
命令源（ICommandSource）

发送命令的控件就是命令源，例如常见的菜单项、按钮等。即命令是怎么触发的，这肯定与用户交互有关的。无交互功能的控件一般不必要发送命令。有命令源就会有命令目标，若命令源是发送者，那么命令目标就是命令的接收者（命令最终作用在谁身上）。好比，单击 K 按钮后清空 T 控件中的文本。则，K是命令源，T就是命令目标。这样举例相信大同伴们能够理解，老周就不说太多，理论部分越简朴越好懂。这里没什么玄的，只要你分清角色就行，谁发出，谁接收。
命令必须有触发者，以是，源是必须的，而且，作为命令源的控件要实现 ICommandSource 接口，并实现三个成员：
1、Command： 要发送的命令对象；
2、CommandParameter：命令参数。这个是任意对象，由你自己决定它是啥，好比，你的命令是删除某位员工的数据记录，那么，这个参数可能是员工ID。这个参数是可选的，当你的命令逻辑必要额外数据时才用到，不消默认为 null 就行了；
3、CommandTarget：目标。命令要作用在哪个控件上。其实这个也是可选的，命令可以无目标控件。好比，删除个员工记录，如果知道要删除哪记录，那这里不必要目标控件。固然，如果你的逻辑是要清空文本框的文本，那目标控件是 TextBox。这个取决你的代码逻辑。
像 Button、MenuItem 这些控件，就是命令源，都实现 ICommandSource 接口。
命令逻辑

命令逻辑就是你的命令要干的活。咱们做个演示。
下面示例将通过命令来删除一条学生记录。Student 类的界说如下：
  1.     public class Student
  2.     {
  3.         public string? Name { get; set; } = string.Empty;
  4.         public int ID { get; set; }
  5.         public int Age { get; set; }
  6.         public string Major { get; set; } = string.Empty;
  7.     }
  9.     public class StudentViewManager
  10.     {
  11.         private static readonly ObservableCollection<Student> _students = new ObservableCollection<Student>();
  13.         static StudentViewManager()
  14.         {
  15.             _students.Add(new Student()
  16.             {
  17. <Window.InputBindings>
  18.     <KeyBinding Gesture="ctrl+shift+1"
  19.                     Command="{StaticResource greenCmd}"
  20.                     CommandTarget="{Binding ElementName=rect}"
  21.                     CommandParameter="0"/>
  22.     <KeyBinding Gesture="ctrl+shift+2"
  23.                     Command="{StaticResource silverCmd}"
  24.                     CommandTarget="{Binding ElementName=rect}"
  25.                     CommandParameter="1"/>
  26.     <KeyBinding Gesture="ctrl+shift+3"
  27.                     Command="{StaticResource redCmd}"
  28.                     CommandTarget="{Binding ElementName=rect}"
  29.                     CommandParameter="2"/>
  30.     <KeyBinding Gesture="CTRL+SHIFT+4"
  31.                     Command="{StaticResource blackCmd}"
  32.                     CommandTarget="{Binding ElementName=rect}"
  33.                     CommandParameter="3"/>
  34. </Window.InputBindings>ID = 1,
  35. <Window.InputBindings>
  36.     <KeyBinding Gesture="ctrl+shift+1"
  37.                     Command="{StaticResource greenCmd}"
  38.                     CommandTarget="{Binding ElementName=rect}"
  39.                     CommandParameter="0"/>
  40.     <KeyBinding Gesture="ctrl+shift+2"
  41.                     Command="{StaticResource silverCmd}"
  42.                     CommandTarget="{Binding ElementName=rect}"
  43.                     CommandParameter="1"/>
  44.     <KeyBinding Gesture="ctrl+shift+3"
  45.                     Command="{StaticResource redCmd}"
  46.                     CommandTarget="{Binding ElementName=rect}"
  47.                     CommandParameter="2"/>
  48.     <KeyBinding Gesture="CTRL+SHIFT+4"
  49.                     Command="{StaticResource blackCmd}"
  50.                     CommandTarget="{Binding ElementName=rect}"
  51.                     CommandParameter="3"/>
  52. </Window.InputBindings>Name = "小陈",
  53. <Window.InputBindings>
  54.     <KeyBinding Gesture="ctrl+shift+1"
  55.                     Command="{StaticResource greenCmd}"
  56.                     CommandTarget="{Binding ElementName=rect}"
  57.                     CommandParameter="0"/>
  58.     <KeyBinding Gesture="ctrl+shift+2"
  59.                     Command="{StaticResource silverCmd}"
  60.                     CommandTarget="{Binding ElementName=rect}"
  61.                     CommandParameter="1"/>
  62.     <KeyBinding Gesture="ctrl+shift+3"
  63.                     Command="{StaticResource redCmd}"
  64.                     CommandTarget="{Binding ElementName=rect}"
  65.                     CommandParameter="2"/>
  66.     <KeyBinding Gesture="CTRL+SHIFT+4"
  67.                     Command="{StaticResource blackCmd}"
  68.                     CommandTarget="{Binding ElementName=rect}"
  69.                     CommandParameter="3"/>
  70. </Window.InputBindings>Age = 20,
  71. <Window.InputBindings>
  72.     <KeyBinding Gesture="ctrl+shift+1"
  73.                     Command="{StaticResource greenCmd}"
  74.                     CommandTarget="{Binding ElementName=rect}"
  75.                     CommandParameter="0"/>
  76.     <KeyBinding Gesture="ctrl+shift+2"
  77.                     Command="{StaticResource silverCmd}"
  78.                     CommandTarget="{Binding ElementName=rect}"
  79.                     CommandParameter="1"/>
  80.     <KeyBinding Gesture="ctrl+shift+3"
  81.                     Command="{StaticResource redCmd}"
  82.                     CommandTarget="{Binding ElementName=rect}"
  83.                     CommandParameter="2"/>
  84.     <KeyBinding Gesture="CTRL+SHIFT+4"
  85.                     Command="{StaticResource blackCmd}"
  86.                     CommandTarget="{Binding ElementName=rect}"
  87.                     CommandParameter="3"/>
  88. </Window.InputBindings>Major = "打老虎专业"
  89.             });
  90.             _students.Add(new Student()
  91.             {
  92. <Window.InputBindings>
  93.     <KeyBinding Gesture="ctrl+shift+1"
  94.                     Command="{StaticResource greenCmd}"
  95.                     CommandTarget="{Binding ElementName=rect}"
  96.                     CommandParameter="0"/>
  97.     <KeyBinding Gesture="ctrl+shift+2"
  98.                     Command="{StaticResource silverCmd}"
  99.                     CommandTarget="{Binding ElementName=rect}"
  100.                     CommandParameter="1"/>
  101.     <KeyBinding Gesture="ctrl+shift+3"
  102.                     Command="{StaticResource redCmd}"
  103.                     CommandTarget="{Binding ElementName=rect}"
  104.                     CommandParameter="2"/>
  105.     <KeyBinding Gesture="CTRL+SHIFT+4"
  106.                     Command="{StaticResource blackCmd}"
  107.                     CommandTarget="{Binding ElementName=rect}"
  108.                     CommandParameter="3"/>
  109. </Window.InputBindings>ID = 2,
  110. <Window.InputBindings>
  111.     <KeyBinding Gesture="ctrl+shift+1"
  112.                     Command="{StaticResource greenCmd}"
  113.                     CommandTarget="{Binding ElementName=rect}"
  114.                     CommandParameter="0"/>
  115.     <KeyBinding Gesture="ctrl+shift+2"
  116.                     Command="{StaticResource silverCmd}"
  117.                     CommandTarget="{Binding ElementName=rect}"
  118.                     CommandParameter="1"/>
  119.     <KeyBinding Gesture="ctrl+shift+3"
  120.                     Command="{StaticResource redCmd}"
  121.                     CommandTarget="{Binding ElementName=rect}"
  122.                     CommandParameter="2"/>
  123.     <KeyBinding Gesture="CTRL+SHIFT+4"
  124.                     Command="{StaticResource blackCmd}"
  125.                     CommandTarget="{Binding ElementName=rect}"
  126.                     CommandParameter="3"/>
  127. </Window.InputBindings>Name = "小张",
  128. <Window.InputBindings>
  129.     <KeyBinding Gesture="ctrl+shift+1"
  130.                     Command="{StaticResource greenCmd}"
  131.                     CommandTarget="{Binding ElementName=rect}"
  132.                     CommandParameter="0"/>
  133.     <KeyBinding Gesture="ctrl+shift+2"
  134.                     Command="{StaticResource silverCmd}"
  135.                     CommandTarget="{Binding ElementName=rect}"
  136.                     CommandParameter="1"/>
  137.     <KeyBinding Gesture="ctrl+shift+3"
  138.                     Command="{StaticResource redCmd}"
  139.                     CommandTarget="{Binding ElementName=rect}"
  140.                     CommandParameter="2"/>
  141.     <KeyBinding Gesture="CTRL+SHIFT+4"
  142.                     Command="{StaticResource blackCmd}"
  143.                     CommandTarget="{Binding ElementName=rect}"
  144.                     CommandParameter="3"/>
  145. </Window.InputBindings>Age = 21,
  146. <Window.InputBindings>
  147.     <KeyBinding Gesture="ctrl+shift+1"
  148.                     Command="{StaticResource greenCmd}"
  149.                     CommandTarget="{Binding ElementName=rect}"
  150.                     CommandParameter="0"/>
  151.     <KeyBinding Gesture="ctrl+shift+2"
  152.                     Command="{StaticResource silverCmd}"
  153.                     CommandTarget="{Binding ElementName=rect}"
  154.                     CommandParameter="1"/>
  155.     <KeyBinding Gesture="ctrl+shift+3"
  156.                     Command="{StaticResource redCmd}"
  157.                     CommandTarget="{Binding ElementName=rect}"
  158.                     CommandParameter="2"/>
  159.     <KeyBinding Gesture="CTRL+SHIFT+4"
  160.                     Command="{StaticResource blackCmd}"
  161.                     CommandTarget="{Binding ElementName=rect}"
  162.                     CommandParameter="3"/>
  163. </Window.InputBindings>Major = "铺地砖专业"
  164.             });
  165.             _students.Add(new Student()
  166.             {
  167. <Window.InputBindings>
  168.     <KeyBinding Gesture="ctrl+shift+1"
  169.                     Command="{StaticResource greenCmd}"
  170.                     CommandTarget="{Binding ElementName=rect}"
  171.                     CommandParameter="0"/>
  172.     <KeyBinding Gesture="ctrl+shift+2"
  173.                     Command="{StaticResource silverCmd}"
  174.                     CommandTarget="{Binding ElementName=rect}"
  175.                     CommandParameter="1"/>
  176.     <KeyBinding Gesture="ctrl+shift+3"
  177.                     Command="{StaticResource redCmd}"
  178.                     CommandTarget="{Binding ElementName=rect}"
  179.                     CommandParameter="2"/>
  180.     <KeyBinding Gesture="CTRL+SHIFT+4"
  181.                     Command="{StaticResource blackCmd}"
  182.                     CommandTarget="{Binding ElementName=rect}"
  183.                     CommandParameter="3"/>
  184. </Window.InputBindings>ID = 3,
  185. <Window.InputBindings>
  186.     <KeyBinding Gesture="ctrl+shift+1"
  187.                     Command="{StaticResource greenCmd}"
  188.                     CommandTarget="{Binding ElementName=rect}"
  189.                     CommandParameter="0"/>
  190.     <KeyBinding Gesture="ctrl+shift+2"
  191.                     Command="{StaticResource silverCmd}"
  192.                     CommandTarget="{Binding ElementName=rect}"
  193.                     CommandParameter="1"/>
  194.     <KeyBinding Gesture="ctrl+shift+3"
  195.                     Command="{StaticResource redCmd}"
  196.                     CommandTarget="{Binding ElementName=rect}"
  197.                     CommandParameter="2"/>
  198.     <KeyBinding Gesture="CTRL+SHIFT+4"
  199.                     Command="{StaticResource blackCmd}"
  200.                     CommandTarget="{Binding ElementName=rect}"
  201.                     CommandParameter="3"/>
  202. </Window.InputBindings>Name = "吕布",
  203. <Window.InputBindings>
  204.     <KeyBinding Gesture="ctrl+shift+1"
  205.                     Command="{StaticResource greenCmd}"
  206.                     CommandTarget="{Binding ElementName=rect}"
  207.                     CommandParameter="0"/>
  208.     <KeyBinding Gesture="ctrl+shift+2"
  209.                     Command="{StaticResource silverCmd}"
  210.                     CommandTarget="{Binding ElementName=rect}"
  211.                     CommandParameter="1"/>
  212.     <KeyBinding Gesture="ctrl+shift+3"
  213.                     Command="{StaticResource redCmd}"
  214.                     CommandTarget="{Binding ElementName=rect}"
  215.                     CommandParameter="2"/>
  216.     <KeyBinding Gesture="CTRL+SHIFT+4"
  217.                     Command="{StaticResource blackCmd}"
  218.                     CommandTarget="{Binding ElementName=rect}"
  219.                     CommandParameter="3"/>
  220. </Window.InputBindings>Age = 23,
  221. <Window.InputBindings>
  222.     <KeyBinding Gesture="ctrl+shift+1"
  223.                     Command="{StaticResource greenCmd}"
  224.                     CommandTarget="{Binding ElementName=rect}"
  225.                     CommandParameter="0"/>
  226.     <KeyBinding Gesture="ctrl+shift+2"
  227.                     Command="{StaticResource silverCmd}"
  228.                     CommandTarget="{Binding ElementName=rect}"
  229.                     CommandParameter="1"/>
  230.     <KeyBinding Gesture="ctrl+shift+3"
  231.                     Command="{StaticResource redCmd}"
  232.                     CommandTarget="{Binding ElementName=rect}"
  233.                     CommandParameter="2"/>
  234.     <KeyBinding Gesture="CTRL+SHIFT+4"
  235.                     Command="{StaticResource blackCmd}"
  236.                     CommandTarget="{Binding ElementName=rect}"
  237.                     CommandParameter="3"/>
  238. </Window.InputBindings>Major = "坑义父专业户"
  239.             });
  240.         }
  242.         public static ObservableCollection<Student> Students
  243.         {
  244.             get { return _students; }
  245.         }
  246.     }
复制代码
 然后，界说一个实现 ICommand 接口的类。
  1.     public class DelStuCommand : ICommand
  2.     {
  3.         public event EventHandler? CanExecuteChanged;
  5.         public bool CanExecute(object? parameter)
  6.         {
  7.             return !(StudentViewManager.Students.Count == 0);
  8.         }
  10.         public void Execute(object? parameter)
  11.         {
  12.             Student? s = parameter as Student;
  13.             if (s == null)
  14. <Window.InputBindings>
  15.     <KeyBinding Gesture="ctrl+shift+1"
  16.                     Command="{StaticResource greenCmd}"
  17.                     CommandTarget="{Binding ElementName=rect}"
  18.                     CommandParameter="0"/>
  19.     <KeyBinding Gesture="ctrl+shift+2"
  20.                     Command="{StaticResource silverCmd}"
  21.                     CommandTarget="{Binding ElementName=rect}"
  22.                     CommandParameter="1"/>
  23.     <KeyBinding Gesture="ctrl+shift+3"
  24.                     Command="{StaticResource redCmd}"
  25.                     CommandTarget="{Binding ElementName=rect}"
  26.                     CommandParameter="2"/>
  27.     <KeyBinding Gesture="CTRL+SHIFT+4"
  28.                     Command="{StaticResource blackCmd}"
  29.                     CommandTarget="{Binding ElementName=rect}"
  30.                     CommandParameter="3"/>
  31. </Window.InputBindings>return;
  33.             StudentViewManager.Students.Remove(s);
  34.         }
  35.     }
复制代码
执行此命令必要参数，好让它知道要删除哪条学生记录。
下面 XAML 中，ListBox 控件表现学生列表，按钮引用上述命令对象。
  1.     <Grid>
  2.         <Grid.RowDefinitions>
  3.             <RowDefinition/>
  4.             <RowDefinition Height="auto"/>
  5.         </Grid.RowDefinitions>
  6.         <Grid.Resources>
  7.             <local:DelStuCommand x:Key="cmd"/>
  8.         </Grid.Resources>
  9.         <Button Content="删除" Grid.Row="1" Command="{StaticResource cmd}"
  10. <Window.InputBindings>
  11.     <KeyBinding Gesture="ctrl+shift+1"
  12.                     Command="{StaticResource greenCmd}"
  13.                     CommandTarget="{Binding ElementName=rect}"
  14.                     CommandParameter="0"/>
  15.     <KeyBinding Gesture="ctrl+shift+2"
  16.                     Command="{StaticResource silverCmd}"
  17.                     CommandTarget="{Binding ElementName=rect}"
  18.                     CommandParameter="1"/>
  19.     <KeyBinding Gesture="ctrl+shift+3"
  20.                     Command="{StaticResource redCmd}"
  21.                     CommandTarget="{Binding ElementName=rect}"
  22.                     CommandParameter="2"/>
  23.     <KeyBinding Gesture="CTRL+SHIFT+4"
  24.                     Command="{StaticResource blackCmd}"
  25.                     CommandTarget="{Binding ElementName=rect}"
  26.                     CommandParameter="3"/>
  27. </Window.InputBindings>CommandParameter="{Binding ElementName=tc, Path=SelectedItem}"/>
  28.         <ListBox x:Name="tc" Grid.Row="0">
  29.             <ItemsControl.ItemTemplate>
  30. <Window.InputBindings>
  31.     <KeyBinding Gesture="ctrl+shift+1"
  32.                     Command="{StaticResource greenCmd}"
  33.                     CommandTarget="{Binding ElementName=rect}"
  34.                     CommandParameter="0"/>
  35.     <KeyBinding Gesture="ctrl+shift+2"
  36.                     Command="{StaticResource silverCmd}"
  37.                     CommandTarget="{Binding ElementName=rect}"
  38.                     CommandParameter="1"/>
  39.     <KeyBinding Gesture="ctrl+shift+3"
  40.                     Command="{StaticResource redCmd}"
  41.                     CommandTarget="{Binding ElementName=rect}"
  42.                     CommandParameter="2"/>
  43.     <KeyBinding Gesture="CTRL+SHIFT+4"
  44.                     Command="{StaticResource blackCmd}"
  45.                     CommandTarget="{Binding ElementName=rect}"
  46.                     CommandParameter="3"/>
  47. </Window.InputBindings><DataTemplate DataType="local:Student">
  48. <Window.InputBindings>
  49.     <KeyBinding Gesture="ctrl+shift+1"
  50.                     Command="{StaticResource greenCmd}"
  51.                     CommandTarget="{Binding ElementName=rect}"
  52.                     CommandParameter="0"/>
  53.     <KeyBinding Gesture="ctrl+shift+2"
  54.                     Command="{StaticResource silverCmd}"
  55.                     CommandTarget="{Binding ElementName=rect}"
  56.                     CommandParameter="1"/>
  57.     <KeyBinding Gesture="ctrl+shift+3"
  58.                     Command="{StaticResource redCmd}"
  59.                     CommandTarget="{Binding ElementName=rect}"
  60.                     CommandParameter="2"/>
  61.     <KeyBinding Gesture="CTRL+SHIFT+4"
  62.                     Command="{StaticResource blackCmd}"
  63.                     CommandTarget="{Binding ElementName=rect}"
  64.                     CommandParameter="3"/>
  65. </Window.InputBindings>    <TextBlock>
  66. <Window.InputBindings>
  67.     <KeyBinding Gesture="ctrl+shift+1"
  68.                     Command="{StaticResource greenCmd}"
  69.                     CommandTarget="{Binding ElementName=rect}"
  70.                     CommandParameter="0"/>
  71.     <KeyBinding Gesture="ctrl+shift+2"
  72.                     Command="{StaticResource silverCmd}"
  73.                     CommandTarget="{Binding ElementName=rect}"
  74.                     CommandParameter="1"/>
  75.     <KeyBinding Gesture="ctrl+shift+3"
  76.                     Command="{StaticResource redCmd}"
  77.                     CommandTarget="{Binding ElementName=rect}"
  78.                     CommandParameter="2"/>
  79.     <KeyBinding Gesture="CTRL+SHIFT+4"
  80.                     Command="{StaticResource blackCmd}"
  81.                     CommandTarget="{Binding ElementName=rect}"
  82.                     CommandParameter="3"/>
  83. </Window.InputBindings>        <Run Text="{Binding Name}"/>
  84. <Window.InputBindings>
  85.     <KeyBinding Gesture="ctrl+shift+1"
  86.                     Command="{StaticResource greenCmd}"
  87.                     CommandTarget="{Binding ElementName=rect}"
  88.                     CommandParameter="0"/>
  89.     <KeyBinding Gesture="ctrl+shift+2"
  90.                     Command="{StaticResource silverCmd}"
  91.                     CommandTarget="{Binding ElementName=rect}"
  92.                     CommandParameter="1"/>
  93.     <KeyBinding Gesture="ctrl+shift+3"
  94.                     Command="{StaticResource redCmd}"
  95.                     CommandTarget="{Binding ElementName=rect}"
  96.                     CommandParameter="2"/>
  97.     <KeyBinding Gesture="CTRL+SHIFT+4"
  98.                     Command="{StaticResource blackCmd}"
  99.                     CommandTarget="{Binding ElementName=rect}"
  100.                     CommandParameter="3"/>
  101. </Window.InputBindings>        <Span> | </Span>
  102. <Window.InputBindings>
  103.     <KeyBinding Gesture="ctrl+shift+1"
  104.                     Command="{StaticResource greenCmd}"
  105.                     CommandTarget="{Binding ElementName=rect}"
  106.                     CommandParameter="0"/>
  107.     <KeyBinding Gesture="ctrl+shift+2"
  108.                     Command="{StaticResource silverCmd}"
  109.                     CommandTarget="{Binding ElementName=rect}"
  110.                     CommandParameter="1"/>
  111.     <KeyBinding Gesture="ctrl+shift+3"
  112.                     Command="{StaticResource redCmd}"
  113.                     CommandTarget="{Binding ElementName=rect}"
  114.                     CommandParameter="2"/>
  115.     <KeyBinding Gesture="CTRL+SHIFT+4"
  116.                     Command="{StaticResource blackCmd}"
  117.                     CommandTarget="{Binding ElementName=rect}"
  118.                     CommandParameter="3"/>
  119. </Window.InputBindings>        <Run Text="{Binding Major}" Foreground="Blue"/>
  120. <Window.InputBindings>
  121.     <KeyBinding Gesture="ctrl+shift+1"
  122.                     Command="{StaticResource greenCmd}"
  123.                     CommandTarget="{Binding ElementName=rect}"
  124.                     CommandParameter="0"/>
  125.     <KeyBinding Gesture="ctrl+shift+2"
  126.                     Command="{StaticResource silverCmd}"
  127.                     CommandTarget="{Binding ElementName=rect}"
  128.                     CommandParameter="1"/>
  129.     <KeyBinding Gesture="ctrl+shift+3"
  130.                     Command="{StaticResource redCmd}"
  131.                     CommandTarget="{Binding ElementName=rect}"
  132.                     CommandParameter="2"/>
  133.     <KeyBinding Gesture="CTRL+SHIFT+4"
  134.                     Command="{StaticResource blackCmd}"
  135.                     CommandTarget="{Binding ElementName=rect}"
  136.                     CommandParameter="3"/>
  137. </Window.InputBindings>    </TextBlock>
  138. <Window.InputBindings>
  139.     <KeyBinding Gesture="ctrl+shift+1"
  140.                     Command="{StaticResource greenCmd}"
  141.                     CommandTarget="{Binding ElementName=rect}"
  142.                     CommandParameter="0"/>
  143.     <KeyBinding Gesture="ctrl+shift+2"
  144.                     Command="{StaticResource silverCmd}"
  145.                     CommandTarget="{Binding ElementName=rect}"
  146.                     CommandParameter="1"/>
  147.     <KeyBinding Gesture="ctrl+shift+3"
  148.                     Command="{StaticResource redCmd}"
  149.                     CommandTarget="{Binding ElementName=rect}"
  150.                     CommandParameter="2"/>
  151.     <KeyBinding Gesture="CTRL+SHIFT+4"
  152.                     Command="{StaticResource blackCmd}"
  153.                     CommandTarget="{Binding ElementName=rect}"
  154.                     CommandParameter="3"/>
  155. </Window.InputBindings></DataTemplate>
  156.             </ItemsControl.ItemTemplate>
  157.         </ListBox>               
  158.     </Grid>
复制代码
Button 类实现了 ICommandSource 接口，通过 CommandParameter 属性指定要通报给命令的参数。
运行步伐后，在 ListBox 中选择一项，然后点“删除”按钮。

删除后，只剩下两项。重复以下操纵，当所有记录都删除后，“删除”按钮就会被禁用。

从这个示例可以了解到，命令可以把某种行为封装为一个单独的整体。这样能增加其可复用性，按钮、菜单、工具栏按钮都可以利用同一个命令，实现相同的功能。
路由命令与 CommandBinding

实现 ICommand 接口虽然简朴易用，但它也有一个题目：如果我的步伐里有许多命令逻辑，那我就要界说许多命令类。好比像这样的，你岂不是要界说几十个命令类。

这样就引出 RoutedCommand 类的用途了。
RoutedCommand 类实现了 ICommand 接口，它封装了一些通用逻辑，具体逻辑将以变乱的方式处置惩罚。RoutedCommand 类的变乱均来自 CommandManager 类所注册的路由（隧道）变乱。即
1、CanExecute 和 PreviewCanExecute 变乱：当要确定命令是否能够执行时会发生该变乱。Preview 开头的表示隧道变乱。可能有大同伴不太记得这个名词。其实，路由变乱和隧道变乱本质一样，只是通报的方向不同。挖隧道的时间是不是从外头往里面钻？以是，隧道变乱就是从外层元素往里面传播；路由变乱就相反，从里向外传播。
2、Executed 和 PreviewExecuted 变乱：咱们可以处置惩罚这变乱，然后将自己要实现的命令逻辑写上即可。
可见，有了 RoutedCommand，咱们就不必要界说一堆命令类了，而是全用它，代码逻辑在 Executed 变乱中写。这里也包括 RoutedUICommand  命令，这个类只不过多了个 Text 属性，用来指定关联的文本罢了，文本会表现在菜单上。
不过，咱们在利用时不会直接去处置惩罚 RoutedCommand 类的变乱，而是共同另一个类—— CommandBinding 来利用。有了它，变乱才能冒泡（或下沉），也就是可向上或向下传播。传播的路径是从目标对象（Command Target）开始，到末了能捕捉到变乱的 CommandBindings 竣事。这个不理解不紧张，后面咱们用例子说明。
 
下面咱们再做一个示例。这个例子中，咱们用四个菜单项来改变矩形的颜色。
由于现在用的是 RoutedCommand 类，我们不必要界说命令类了，以是能在 XAML 文档中直接把命令声明在资源中。
  1.     <Window.Resources>
  2.         
  3.         <RoutedCommand x:Key="greenCmd" />
  4.         <RoutedCommand x:Key="silverCmd" />
  5.         <RoutedCommand x:Key="redCmd" />
  6.         <RoutedCommand x:Key="blackCmd" />
  7.     </Window.Resources>
复制代码
我们界说一组菜单，以及一个矩形。
  1.     <Window.Resources>
  2.         
  3.         <RoutedCommand x:Key="greenCmd" />
  4.         <RoutedCommand x:Key="silverCmd" />
  5.         <RoutedCommand x:Key="redCmd" />
  6.         <RoutedCommand x:Key="blackCmd" />
  7.     </Window.Resources>    <Window.Resources>
  8.         
  9.         <RoutedCommand x:Key="greenCmd" />
  10.         <RoutedCommand x:Key="silverCmd" />
  11.         <RoutedCommand x:Key="redCmd" />
  12.         <RoutedCommand x:Key="blackCmd" />
  13.     </Window.Resources>    <Window.Resources>
  14.         
  15.         <RoutedCommand x:Key="greenCmd" />
  16.         <RoutedCommand x:Key="silverCmd" />
  17.         <RoutedCommand x:Key="redCmd" />
  18.         <RoutedCommand x:Key="blackCmd" />
  19.     </Window.Resources><Window.InputBindings>
  20.     <KeyBinding Gesture="ctrl+shift+1"
  21.                     Command="{StaticResource greenCmd}"
  22.                     CommandTarget="{Binding ElementName=rect}"
  23.                     CommandParameter="0"/>
  24.     <KeyBinding Gesture="ctrl+shift+2"
  25.                     Command="{StaticResource silverCmd}"
  26.                     CommandTarget="{Binding ElementName=rect}"
  27.                     CommandParameter="1"/>
  28.     <KeyBinding Gesture="ctrl+shift+3"
  29.                     Command="{StaticResource redCmd}"
  30.                     CommandTarget="{Binding ElementName=rect}"
  31.                     CommandParameter="2"/>
  32.     <KeyBinding Gesture="CTRL+SHIFT+4"
  33.                     Command="{StaticResource blackCmd}"
  34.                     CommandTarget="{Binding ElementName=rect}"
  35.                     CommandParameter="3"/>
  36. </Window.InputBindings>
复制代码
网格分两行，上面是菜单，下面是矩形。每个菜单项的 Command 属性已经引用了所需的命令对象。CommandTarget 属性通过绑定引用矩形对象。这里要注意，Target 要求的是实现 IInputElement 接口的范例。可见，不是所有对象都能充当目标的。Rectangle 类可以作为命令目标。
这时不要直接处置惩罚 RoutedCommand 类的变乱，而是要借助 CommandBinding。UIElement 的子类都继承 CommandBindings 聚集，以是放心用，大部分界面元素都可以用。本例中，我们在 Grid 上写 CommandBinding。
  1.     <Window.Resources>
  2.         
  3.         <RoutedCommand x:Key="greenCmd" />
  4.         <RoutedCommand x:Key="silverCmd" />
  5.         <RoutedCommand x:Key="redCmd" />
  6.         <RoutedCommand x:Key="blackCmd" />
  7.     </Window.Resources>    <Window.Resources>
  8.         
  9.         <RoutedCommand x:Key="greenCmd" />
  10.         <RoutedCommand x:Key="silverCmd" />
  11.         <RoutedCommand x:Key="redCmd" />
  12.         <RoutedCommand x:Key="blackCmd" />
  13.     </Window.Resources><Window.InputBindings>
  14.     <KeyBinding Gesture="ctrl+shift+1"
  15.                     Command="{StaticResource greenCmd}"
  16.                     CommandTarget="{Binding ElementName=rect}"
  17.                     CommandParameter="0"/>
  18.     <KeyBinding Gesture="ctrl+shift+2"
  19.                     Command="{StaticResource silverCmd}"
  20.                     CommandTarget="{Binding ElementName=rect}"
  21.                     CommandParameter="1"/>
  22.     <KeyBinding Gesture="ctrl+shift+3"
  23.                     Command="{StaticResource redCmd}"
  24.                     CommandTarget="{Binding ElementName=rect}"
  25.                     CommandParameter="2"/>
  26.     <KeyBinding Gesture="CTRL+SHIFT+4"
  27.                     Command="{StaticResource blackCmd}"
  28.                     CommandTarget="{Binding ElementName=rect}"
  29.                     CommandParameter="3"/>
  30. </Window.InputBindings><Window.InputBindings>
  31.     <KeyBinding Gesture="ctrl+shift+1"
  32.                     Command="{StaticResource greenCmd}"
  33.                     CommandTarget="{Binding ElementName=rect}"
  34.                     CommandParameter="0"/>
  35.     <KeyBinding Gesture="ctrl+shift+2"
  36.                     Command="{StaticResource silverCmd}"
  37.                     CommandTarget="{Binding ElementName=rect}"
  38.                     CommandParameter="1"/>
  39.     <KeyBinding Gesture="ctrl+shift+3"
  40.                     Command="{StaticResource redCmd}"
  41.                     CommandTarget="{Binding ElementName=rect}"
  42.                     CommandParameter="2"/>
  43.     <KeyBinding Gesture="CTRL+SHIFT+4"
  44.                     Command="{StaticResource blackCmd}"
  45.                     CommandTarget="{Binding ElementName=rect}"
  46.                     CommandParameter="3"/>
  47. </Window.InputBindings>……<Window.InputBindings>
  48.     <KeyBinding Gesture="ctrl+shift+1"
  49.                     Command="{StaticResource greenCmd}"
  50.                     CommandTarget="{Binding ElementName=rect}"
  51.                     CommandParameter="0"/>
  52.     <KeyBinding Gesture="ctrl+shift+2"
  53.                     Command="{StaticResource silverCmd}"
  54.                     CommandTarget="{Binding ElementName=rect}"
  55.                     CommandParameter="1"/>
  56.     <KeyBinding Gesture="ctrl+shift+3"
  57.                     Command="{StaticResource redCmd}"
  58.                     CommandTarget="{Binding ElementName=rect}"
  59.                     CommandParameter="2"/>
  60.     <KeyBinding Gesture="CTRL+SHIFT+4"
  61.                     Command="{StaticResource blackCmd}"
  62.                     CommandTarget="{Binding ElementName=rect}"
  63.                     CommandParameter="3"/>
  64. </Window.InputBindings><Window.InputBindings>
  65.     <KeyBinding Gesture="ctrl+shift+1"
  66.                     Command="{StaticResource greenCmd}"
  67.                     CommandTarget="{Binding ElementName=rect}"
  68.                     CommandParameter="0"/>
  69.     <KeyBinding Gesture="ctrl+shift+2"
  70.                     Command="{StaticResource silverCmd}"
  71.                     CommandTarget="{Binding ElementName=rect}"
  72.                     CommandParameter="1"/>
  73.     <KeyBinding Gesture="ctrl+shift+3"
  74.                     Command="{StaticResource redCmd}"
  75.                     CommandTarget="{Binding ElementName=rect}"
  76.                     CommandParameter="2"/>
  77.     <KeyBinding Gesture="CTRL+SHIFT+4"
  78.                     Command="{StaticResource blackCmd}"
  79.                     CommandTarget="{Binding ElementName=rect}"
  80.                     CommandParameter="3"/>
  81. </Window.InputBindings>
复制代码
在利用 CommandBinding 时，注意 Command 所引用的命令时你要用的，这里就是要和四个菜单项所引用的命令同等，不然，CanExecute 和 Executed 变乱不起作用（命令不能正确触发）。如果变乱逻辑相同，可以共用一个 handler，好比上面的，CanExecute 变乱就共用一个处置惩罚方法。
接下来，我们处置惩罚一下这些变乱。
  1. private void OnGreenCmdExe(object sender, ExecutedRoutedEventArgs e)
  2. {
  3.     Rectangle rect = (Rectangle)e.OriginalSource;
  4.     rect.Fill = new SolidColorBrush(Colors.Green);
  5. }
  7. private void OnSilverCmdExe(object sender, ExecutedRoutedEventArgs e)
  8. {
  9.     Rectangle rect = (Rectangle)e.OriginalSource;
  10.     rect.Fill = new SolidColorBrush(Colors.Silver);
  11. }
  13. private void OnRedCmdExe(object sender, ExecutedRoutedEventArgs e)
  14. {
  15.     Rectangle rect = (Rectangle)e.OriginalSource;
  16.     rect.Fill = new SolidColorBrush(Colors.Red);
  17. }
  19. private void OnBlackCmdExe(object sender, ExecutedRoutedEventArgs e)
  20. {
  21.     Rectangle rect = (Rectangle)e.OriginalSource;
  22.     rect.Fill = new SolidColorBrush(Colors.Black);
  23. }
  25. private void OnRectCanExecut(object sender, CanExecuteRoutedEventArgs e)
  26. {
  27.     e.CanExecute = (e.OriginalSource != null && e.OriginalSource is Rectangle);
  28. }
复制代码
在 OnRectCanExecut 方法，本例的判断方式是只要命令目标不为空，而且是矩形对象，就答应执行命令。e.CanExecute 属性就是用来设置一个布尔值，以表示能不能执行命令。
代码很简朴，老周不多表明了。重点说的是，引发这些变乱的源头是 Command Target。即 OriginalSource 引用的就是 Rectangle。变乱路径是从目标对象开始向上冒泡的——说人话就是从 Rectangle 开始向上找 CommandBinding，不管是哪个条理上的 CommandBinding，只要变乱和命令是匹配的，就会触发。
我们不妨这样改，把 Grid 下的后两个 CommandBinding 向上移，移到 Window 对象下。
  1.     <Window.Resources>
  2.         
  3.         <RoutedCommand x:Key="greenCmd" />
  4.         <RoutedCommand x:Key="silverCmd" />
  5.         <RoutedCommand x:Key="redCmd" />
  6.         <RoutedCommand x:Key="blackCmd" />
  7.     </Window.Resources>    <Window.Resources>
  8.         
  9.         <RoutedCommand x:Key="greenCmd" />
  10.         <RoutedCommand x:Key="silverCmd" />
  11.         <RoutedCommand x:Key="redCmd" />
  12.         <RoutedCommand x:Key="blackCmd" />
  13.     </Window.Resources><Window.InputBindings>
  14.     <KeyBinding Gesture="ctrl+shift+1"
  15.                     Command="{StaticResource greenCmd}"
  16.                     CommandTarget="{Binding ElementName=rect}"
  17.                     CommandParameter="0"/>
  18.     <KeyBinding Gesture="ctrl+shift+2"
  19.                     Command="{StaticResource silverCmd}"
  20.                     CommandTarget="{Binding ElementName=rect}"
  21.                     CommandParameter="1"/>
  22.     <KeyBinding Gesture="ctrl+shift+3"
  23.                     Command="{StaticResource redCmd}"
  24.                     CommandTarget="{Binding ElementName=rect}"
  25.                     CommandParameter="2"/>
  26.     <KeyBinding Gesture="CTRL+SHIFT+4"
  27.                     Command="{StaticResource blackCmd}"
  28.                     CommandTarget="{Binding ElementName=rect}"
  29.                     CommandParameter="3"/>
  30. </Window.InputBindings><Window.InputBindings>
  31.     <KeyBinding Gesture="ctrl+shift+1"
  32.                     Command="{StaticResource greenCmd}"
  33.                     CommandTarget="{Binding ElementName=rect}"
  34.                     CommandParameter="0"/>
  35.     <KeyBinding Gesture="ctrl+shift+2"
  36.                     Command="{StaticResource silverCmd}"
  37.                     CommandTarget="{Binding ElementName=rect}"
  38.                     CommandParameter="1"/>
  39.     <KeyBinding Gesture="ctrl+shift+3"
  40.                     Command="{StaticResource redCmd}"
  41.                     CommandTarget="{Binding ElementName=rect}"
  42.                     CommandParameter="2"/>
  43.     <KeyBinding Gesture="CTRL+SHIFT+4"
  44.                     Command="{StaticResource blackCmd}"
  45.                     CommandTarget="{Binding ElementName=rect}"
  46.                     CommandParameter="3"/>
  47. </Window.InputBindings>……<Window.InputBindings>
  48.     <KeyBinding Gesture="ctrl+shift+1"
  49.                     Command="{StaticResource greenCmd}"
  50.                     CommandTarget="{Binding ElementName=rect}"
  51.                     CommandParameter="0"/>
  52.     <KeyBinding Gesture="ctrl+shift+2"
  53.                     Command="{StaticResource silverCmd}"
  54.                     CommandTarget="{Binding ElementName=rect}"
  55.                     CommandParameter="1"/>
  56.     <KeyBinding Gesture="ctrl+shift+3"
  57.                     Command="{StaticResource redCmd}"
  58.                     CommandTarget="{Binding ElementName=rect}"
  59.                     CommandParameter="2"/>
  60.     <KeyBinding Gesture="CTRL+SHIFT+4"
  61.                     Command="{StaticResource blackCmd}"
  62.                     CommandTarget="{Binding ElementName=rect}"
  63.                     CommandParameter="3"/>
  64. </Window.InputBindings>……   
复制代码
运行后，你会发现，四个菜单都能用。

从 Rectangle 开始向上冒泡，先是在 Grid 元素上找到两个 CommandBinding，匹配，用之；再往上，在 Window 元素上又找到两个，匹配，用之。以是，末了就是四个都能用。因此，路由是以 Rectangle 为起点向上冒泡，直到 Window 对象。
其实，上面几个 Executed 变乱也可以归并到一个方法中处置惩罚，只要用 CommandParameter 区分哪种颜色就行。
  1. private void OnCmdExecuted(object sender, ExecutedRoutedEventArgs e)
  2. {
  3.      Rectangle rect = (Rectangle)e.OriginalSource;
  4.      // 获取参数值
  5.      int val = Convert.ToInt32(e.Parameter);
  6.      // 根据参数选择颜色
  7.      SolidColorBrush brush = new();
  8.      switch (val)
  9.      {
  10.          case 0:
  11.              brush.Color = Colors.Green;
  12.              break;
  13.          case 1:
  14.              brush.Color = Colors.Silver;
  15.              break;
  16.          case 2:
  17.              brush.Color = Colors.Red;
  18.              break;
  19.          case 3:
  20.              brush.Color = Colors.Black;
  21.              break;
  22.          default:
  23.              brush.Color = Colors.Blue;
  24.              break;
  25.      }
  26.      rect.Fill = brush;
  27. }
复制代码
在 XAML 文档中，替换前面设置的变乱 handler，并在菜单项中设置 CommandParameter。
  1. [/code][code]
复制代码
指定快捷按键

命令的好处不只是可以多个源共享代码逻辑，还支持快捷键绑定。这就要用到 InputBinding 对象了，仔细看，发现这个类实现了 ICommandSource 接口。
  1. public class InputBinding : System.Windows.Freezable, System.Windows.Input.ICommandSource
复制代码
因此，它也可以与命令关联，只要 InputBinding 被触发，关联的命令也会执行。下面咱们为上面的示例添加快捷键。
  1. <Window.InputBindings>
  2.     <KeyBinding Gesture="ctrl+shift+1"
  3.                     Command="{StaticResource greenCmd}"
  4.                     CommandTarget="{Binding ElementName=rect}"
  5.                     CommandParameter="0"/>
  6.     <KeyBinding Gesture="ctrl+shift+2"
  7.                     Command="{StaticResource silverCmd}"
  8.                     CommandTarget="{Binding ElementName=rect}"
  9.                     CommandParameter="1"/>
  10.     <KeyBinding Gesture="ctrl+shift+3"
  11.                     Command="{StaticResource redCmd}"
  12.                     CommandTarget="{Binding ElementName=rect}"
  13.                     CommandParameter="2"/>
  14.     <KeyBinding Gesture="CTRL+SHIFT+4"
  15.                     Command="{StaticResource blackCmd}"
  16.                     CommandTarget="{Binding ElementName=rect}"
  17.                     CommandParameter="3"/>
  18. </Window.InputBindings>
复制代码
UIElement 类的派生类都继承了 InputBindings 聚集，通常我们是把 InputBinding 放到窗口的聚集中。现实上这里可以把 InputBinding 写在 Grid.InputBindings 中。前面咱们提过，变乱是从 Target 对象向上冒泡的，以是在窗口上界说 InputBinding 或 CommandBinding，可以尽可能地捕捉到命令变乱。
InputBinding 只是基类，它有两个派生类—— KeyBinding，MouseBinding。不消老周表明，看名识类，你都猜到它们是干吗用的了。示例中用到的是快捷键，以是用 KeyBinding。快捷键在 XAML 中有两种声明方法：
1、如本例所示，直接设置 Gesture 属性。利用按键的字符串形式，不分巨细写，按键之间用“+”连接，如 Ctrl + C。这种方法把修改键和普通键一起界说，方便好用；
2、修改键和按键分开界说。纵然用 Key 和 Modifiers 属性，Key 指定普通键，如“G”；Modifiers 指定修改键，如 "Ctrl + Alt"。因此，本示例的快捷键也可以这样界说：
  1. [/code]这里的 Key 属性比较特别，不能直接写“4”，因为无法从字符串“4”转换为 Key 枚举，会报错，可以指定为“D4”、“D5”等。这里所指定的数字键是大键盘区域的数字（QWERTYUIOP 上面那排），不是右边小键盘的数字键。小键盘要用"NumPad4"。小数字键盘跟有些修改键组合后无效，经老周测试，Shift、Alt、Win这些键都无效，Ctrl 可以。以是，还是用字母键靠谱些，也不消区分巨细键盘区域。
  2. [b]重点：Key + Modifiers 方式与 Gesture 方式只能二选一，不能同时利用，会产生歧义[/b]。
  3. [size=5]CommandTarget 为什么是可选的[/size]
  5. 前面提到，命令目标是可选的，可以不指定，为什么呢？这就要看命令源的处置惩罚方式了。我们可以看看 WPF 内部的处置惩罚。
  6. [code]internal static bool CanExecuteCommandSource(ICommandSource commandSource){    ICommand command = commandSource.Command;    if (command != null)    {        object parameter = commandSource.CommandParameter;        IInputElement target = commandSource.CommandTarget;        RoutedCommand routed = command as RoutedCommand;        if (routed != null)        {            if (target == null)            {<Window.InputBindings>
  7.     <KeyBinding Gesture="ctrl+shift+1"
  8.                     Command="{StaticResource greenCmd}"
  9.                     CommandTarget="{Binding ElementName=rect}"
  10.                     CommandParameter="0"/>
  11.     <KeyBinding Gesture="ctrl+shift+2"
  12.                     Command="{StaticResource silverCmd}"
  13.                     CommandTarget="{Binding ElementName=rect}"
  14.                     CommandParameter="1"/>
  15.     <KeyBinding Gesture="ctrl+shift+3"
  16.                     Command="{StaticResource redCmd}"
  17.                     CommandTarget="{Binding ElementName=rect}"
  18.                     CommandParameter="2"/>
  19.     <KeyBinding Gesture="CTRL+SHIFT+4"
  20.                     Command="{StaticResource blackCmd}"
  21.                     CommandTarget="{Binding ElementName=rect}"
  22.                     CommandParameter="3"/>
  23. </Window.InputBindings>target = commandSource as IInputElement;            }            return routed.CanExecute(parameter, target);        }        else        {            return command.CanExecute(parameter);        }    }    return false;}
复制代码
如果命令是 RoutedCommand，且目标是存在的，就触发 CanExe 变乱；如果未指定目标，则将命令源作为目标。
如果命令不是 RoutedCommand，则直接无视目标。
以是，总的来说，Target 就是可选的。不过，对于非路由的命令，默认会把键盘焦点所在的控件视为目标。
现在，老周相信大同伴们都会利用命令了。在现实利用中，你还可以把命令直接封装进 Model 范例中，好比作为一个公共属性。MVVM不是很喜欢这样用的吗？这样封装确实很方便的，尤其是你有N个窗口，这些窗口可能都出现一个“编辑员工信息”的菜单或按钮。如果你的员工信息模子中直接封装了命令，在命令的逻辑中打开编辑对话框。这样就省了许多重复代码了，而且这 N 个窗口的代码也变得轻便了，你甚至都不消给按钮们处置惩罚 Click 变乱。
----------------------------------------------------------------------------------------------------------------------------------------------
末了，表明一下老周最近写水文为什么效率这么低。因为老周最近很光荣，经朋友先容，以 A 公司员工的名义，被派遣到 B 集团总部的开辟部分。就类似于外包之类了吧，就是过去那边干一段时间。这关系很复杂吧。其实老周本来是不想去的，但还是给朋友 45% 的体面（唉，人最可悲的就是总觉得体面可以当饭吃），就答应了，趁便赚点生存费。包吃不包住，来回就用网约车。因为这“一段时间”太模糊，租房子欠好弄，交押金什么的，时间又不确定，咋整。以是，只好打车，费用找他们公司报销。
如果你常被外派的话，可能知道这活是欠好干的。你想想，人家为什么要找你上门？就是因为他们自己办理不了题目，你过去就是负责啃硬骨头的。由于签了保密协议，老周不能说是什么项目。总之项目很大，TM的复杂，紧张帮他们做优化。他们的办公室跟菜市场似的，天天很热闹，上班可以走来走去，谈天扯蛋。氛围不错，你到处逛领导也不管，反正你得完成进度。老周大抵估算，一张桌子坐 8 个人，办公室很大，有6列17行，能坐 6*17*8 个人，整栋楼有 2313 人（听见他们广播中是这样说的），不知道算不算我们外包人员。想想他们的开辟团队有多大了。
毕竟是大集团公司，在东南亚和欧洲有许多个生产基地。以是他们的开辟团队本来设立是为子公司的工厂开辟软件系统的。不过，在食堂听内部人员说，这几年他们除了自己集团内的项目，表面的杂七杂八的项目也接，项目许多，而且很乱，大家都干得很无语，经常都分不清哪个项目跟哪个项目。一个项目还建了许多分支，许多版本。刚到那边的时间，也把老周整得很无语，项目名称都是【三个字母+数字+一个字母】表示，末了一个字母表示版天职支。看任务文档，然后在源码服务器上找项目都找得头晕。
本来以为这样的大公司，代码应该写得很规范的。谁曾想，他们完全就是“能运行就好，其他免谈”，代码是真的写得一团乱，甚至都不知道经过多少手了，看里面的解释，最早有 2013 年的修改记录。而且解释里面是繁、中文，英文，日文，还有其他不知道什么鸟文的都有。早先我还以为是乱码。估计什么越南语都有。这实打实的是混血代码。
说实话，外派到别人的大团队里真的很郁闷。他们自己人一个圈子，喜欢欺负新人。固然，不是物理上的欺负，毕竟老周小时间跟江湖骗子练过两年的，真打起来的话，老周可以一打五。老周指的是他们总把些难搞的任务交给你做——也是意料之中的。以是，根据老周多年忽悠人的履历，外派到其他公司一定要学会“装糊涂”。
啥意思呢？不是叫你装傻子，而且要装菜。你不能体现得像个大神，不然他们会丢更多的硬骨头让你啃（人不如狗，现在狗都不啃骨头了）。以是你要装成菜鸟，但不能太菜。派出公司在先容时肯定会吹牛你有多少个世纪的开辟履历的，如果装得太小白，他们就会发现你是不想干活，故意装。装要装得有点菜，不能太菜。好比，某个东西老周其实用 30 分钟就能做出来的，我硬要做他个2小时。本来一天能完事的，非要做个两天。如果司理问，就说“这个 RadGridView 控件和 WinForm 是不兼容的，如果换 UI，要处置惩罚1、2、3、4……” 总之，有很大的难度，必要不可预估的时间去完成。三天能搞好的，就说一个星期。拖拖进度，可以减轻负担。因为老周很累，白天打车过去帮别人搞项目，晚上归去还要改别的两个项目。白天脑筋嗡嗡响，晚上脑筋嗞嗞响。
放慢速度来做，等派遣约定的时间到了，直接闪退。反正一两个月，拖拖拉拉就扛过了。没须要玩命给别人好印象的，反正跟他们没混熟就走人了，谁人菜市场一样的办公室那么大，谁记得你啊。
本日的水文就写到这儿了，明天又要去菜市场混日子了，还有一个半月，很快就熬过去。
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4