C# 如何在样式设置器中添加混合行为

How to add a Blend Behavior in a Style Setter

提问by Jobi Joy

I have crated a Blend behavior for Button. How can I set that to all of my Buttons in the app.

我为按钮创建了一个混合行为。如何将其设置为应用程序中的所有按钮。

<Button ...>
  <i:Interaction.Behaviors>
    <local:MyBehavior />
  </i:Interaction.Behaviors>
</Button>

However, when I try:

但是，当我尝试时：

<Style>
  <Setter Property="i:Interaction.Behaviors">
    <Setter.Value>
      <local:MyBehavior />
    </Setter.Value>
  </Setter>
</Style>

I get the error

我收到错误

The property "Behaviors" does not have an accessible setter.

属性“行为”没有可访问的 setter。

回答by Jobi Joy

Behavior code expects a Visual, so we can add it only on a visual. So the only option I could see is to add to one of the element inside the ControlTemplate so as to get the behavior added to the Style and affect on all the instance of a particular control.

行为代码需要一个 Visual，所以我们只能将它添加到一个视觉上。所以我能看到的唯一选择是添加到 ControlTemplate 内的元素之一，以便将行为添加到 Style 并影响特定控件的所有实例。

回答by Rick Sladkey

I had the same problem and I've come up with a solution. I found this question after I solved it and I see that my solution bears a lot in common with Mark's. However, this approach is a little different.

我遇到了同样的问题，我想出了一个解决方案。我在解决这个问题后发现了这个问题，我发现我的解决方案与 Mark 的解决方案有很多共同点。但是，这种方法有点不同。

The main problem is that behaviors and triggers associate with a specific object and so you cannot use the same instance of a behavior for multiple different associated objects. When you define your behavior inline XAML enforces this one-to-one relationship. However, when you try to set a behavior in a style, the style can be re-used for all the objects it applies to and this will throw exceptions in the base behavior classes. In fact the authors went to considerable effort to prevent us from even trying to do this, knowing that it wouldn't work.

主要问题是行为和触发器与特定对象相关联，因此您不能对多个不同的关联对象使用相同的行为实例。当您定义您的行为时，内联 XAML 会强制实施这种一对一关系。但是，当您尝试在样式中设置行为时，该样式可以重新用于它适用的所有对象，这将在基本行为类中引发异常。事实上，作者们付出了相当大的努力来阻止我们甚至尝试这样做，因为他们知道这是行不通的。

The first problem is that we cannot even construct a behavior setter value because the constructor is internal. So we need our own behavior and trigger collection classes.

第一个问题是我们甚至无法构造行为设置器值，因为构造函数是内部的。所以我们需要我们自己的行为和触发集合类。

The next problem is that the behavior and trigger attached properties don't have setters and so they can only be added to with in-line XAML. This problem we solve with our own attached properties that manipulate the primary behavior and trigger properties.

下一个问题是行为和触发器附加属性没有设置器，因此只能使用内联 XAML 添加它们。我们使用我们自己的附加属性来解决这个问题，这些属性操作主要行为和触发属性。

The third problem is that our behavior collection is only good for a single style target. This we solve by utilizing a little-used XAML feature x:Shared="False"which creates a new copy of the resource each time it is referenced.

第三个问题是我们的行为集合只适用于单一的风格目标。我们通过利用一个很少使用的 XAML 功能x:Shared="False"来解决这个问题，该功能在每次引用资源时都会创建一个新的资源副本。

The final problem is that behaviors and triggers are not like other style setters; we don't want to replace the old behaviors with the new behaviors because they could do wildly different things. So if we accept that once you add a behavior you cannot take it away (and that's the way behaviors currently work), we can conclude that behaviors and triggers should be additive and this can be handled by our attached properties.

最后一个问题是行为和触发器不像其他样式设置器；我们不想用新行为替换旧行为，因为它们可以做完全不同的事情。因此，如果我们接受一旦添加行为就无法将其删除（这就是行为当前的工作方式），我们可以得出结论，行为和触发器应该是可加的，这可以由我们的附加属性处理。

Here is a sample using this approach:

这是使用这种方法的示例：

<Grid>
    <Grid.Resources>
        <sys:String x:Key="stringResource1">stringResource1</sys:String>
        <local:Triggers x:Key="debugTriggers" x:Shared="False">
            <i:EventTrigger EventName="MouseLeftButtonDown">
                <local:DebugAction Message="DataContext: {0}" MessageParameter="{Binding}"/>
                <local:DebugAction Message="ElementName: {0}" MessageParameter="{Binding Text, ElementName=textBlock2}"/>
                <local:DebugAction Message="Mentor: {0}" MessageParameter="{Binding Text, RelativeSource={RelativeSource AncestorType={x:Type FrameworkElement}}}"/>
            </i:EventTrigger>
        </local:Triggers>
        <Style x:Key="debugBehavior" TargetType="FrameworkElement">
            <Setter Property="local:SupplementaryInteraction.Triggers" Value="{StaticResource debugTriggers}"/>
        </Style>
    </Grid.Resources>
    <StackPanel DataContext="{StaticResource stringResource1}">
        <TextBlock Name="textBlock1" Text="textBlock1" Style="{StaticResource debugBehavior}"/>
        <TextBlock Name="textBlock2" Text="textBlock2" Style="{StaticResource debugBehavior}"/>
        <TextBlock Name="textBlock3" Text="textBlock3" Style="{StaticResource debugBehavior}"/>
    </StackPanel>
</Grid>

The example uses triggers but behaviors work the same way. In the example, we show:

该示例使用触发器，但行为的工作方式相同。在示例中，我们显示：

• the style can be applied to multiple text blocks
• several types of data binding all work correctly
• a debug action that generates text in the output window

• 样式可以应用于多个文本块
• 几种类型的数据绑定都可以正常工作
• 在输出窗口中生成文本的调试操作

Here's an example behavior, our DebugAction. More properly it is an action but through the abuse of language we call behaviors, triggers and actions "behaviors".

这是一个示例行为，我们的DebugAction. 更准确地说，它是一种行为，但通过滥用语言，我们将行为、触发器和行为称为“行为”。

public class DebugAction : TriggerAction<DependencyObject>
{
    public string Message
    {
        get { return (string)GetValue(MessageProperty); }
        set { SetValue(MessageProperty, value); }
    }

    public static readonly DependencyProperty MessageProperty =
        DependencyProperty.Register("Message", typeof(string), typeof(DebugAction), new UIPropertyMetadata(""));

    public object MessageParameter
    {
        get { return (object)GetValue(MessageParameterProperty); }
        set { SetValue(MessageParameterProperty, value); }
    }

    public static readonly DependencyProperty MessageParameterProperty =
        DependencyProperty.Register("MessageParameter", typeof(object), typeof(DebugAction), new UIPropertyMetadata(null));

    protected override void Invoke(object parameter)
    {
        Debug.WriteLine(Message, MessageParameter, AssociatedObject, parameter);
    }
}

Finally, our collections and attached properties to make this all work. By analogy with Interaction.Behaviors, the property you target is called SupplementaryInteraction.Behaviorsbecause by setting this property, you will add behaviors to Interaction.Behaviorsand likewise for triggers.

最后，我们的集合和附加属性使这一切正常工作。与 类比Interaction.Behaviors，您的目标属性被调用，SupplementaryInteraction.Behaviors因为通过设置此属性，您将向Interaction.Behaviors触发器添加行为，同样地为触发器添加行为。

public class Behaviors : List<Behavior>
{
}

public class Triggers : List<TriggerBase>
{
}

public static class SupplementaryInteraction
{
    public static Behaviors GetBehaviors(DependencyObject obj)
    {
        return (Behaviors)obj.GetValue(BehaviorsProperty);
    }

    public static void SetBehaviors(DependencyObject obj, Behaviors value)
    {
        obj.SetValue(BehaviorsProperty, value);
    }

    public static readonly DependencyProperty BehaviorsProperty =
        DependencyProperty.RegisterAttached("Behaviors", typeof(Behaviors), typeof(SupplementaryInteraction), new UIPropertyMetadata(null, OnPropertyBehaviorsChanged));

    private static void OnPropertyBehaviorsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var behaviors = Interaction.GetBehaviors(d);
        foreach (var behavior in e.NewValue as Behaviors) behaviors.Add(behavior);
    }

    public static Triggers GetTriggers(DependencyObject obj)
    {
        return (Triggers)obj.GetValue(TriggersProperty);
    }

    public static void SetTriggers(DependencyObject obj, Triggers value)
    {
        obj.SetValue(TriggersProperty, value);
    }

    public static readonly DependencyProperty TriggersProperty =
        DependencyProperty.RegisterAttached("Triggers", typeof(Triggers), typeof(SupplementaryInteraction), new UIPropertyMetadata(null, OnPropertyTriggersChanged));

    private static void OnPropertyTriggersChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var triggers = Interaction.GetTriggers(d);
        foreach (var trigger in e.NewValue as Triggers) triggers.Add(trigger);
    }
}

and there you have it, fully-functional behaviors and triggers applied through styles.

有了它，功能齐全的行为和通过样式应用的触发器。

回答by Jonathan Allen

I couldn't find the original article but I was able to recreate the effect.

我找不到原始文章，但我能够重新创建效果。

#region Attached Properties Boilerplate

    public static readonly DependencyProperty IsActiveProperty = DependencyProperty.RegisterAttached("IsActive", typeof(bool), typeof(ScrollIntoViewBehavior), new PropertyMetadata(false, OnIsActiveChanged));

    public static bool GetIsActive(FrameworkElement control)
    {
        return (bool)control.GetValue(IsActiveProperty);
    }

    public static void SetIsActive(
      FrameworkElement control, bool value)
    {
        control.SetValue(IsActiveProperty, value);
    }

    private static void OnIsActiveChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var behaviors = Interaction.GetBehaviors(d);
        var newValue = (bool)e.NewValue;

        if (newValue)
        {
            //add the behavior if we don't already have one
            if (!behaviors.OfType<ScrollIntoViewBehavior>().Any())
            {
                behaviors.Add(new ScrollIntoViewBehavior());
            }
        }
        else
        {
            //remove any instance of the behavior. (There should only be one, but just in case.)
            foreach (var item in behaviors.ToArray())
            {
                if (item is ScrollIntoViewBehavior)
                    behaviors.Remove(item);
            }
        }
    }


    #endregion

<Style TargetType="Button">
    <Setter Property="Blah:ScrollIntoViewBehavior.IsActive" Value="True" />
</Style>

回答by Bill

The article Introduction to Attached Behaviors in WPFimplements an attached behavior using Style only, and may also be related or helpful.

文章在WPF介绍附加行为实现了只用样式附加的行为，也可以与或有帮助。

The technique in the "Introduction to Attached Behaviors" article avoids the Interactivity tags altogether, using on Style. I don't know if this is just because it is a more dated technique, or, if that still confers some benefits where one should prefer it in some scenarios.

“附加行为简介”一文中的技术完全避免了交互性标签，使用了样式。我不知道这是否仅仅是因为它是一种更过时的技术，或者，如果在某些情况下人们应该更喜欢它，它是否仍然带来一些好处。

回答by Roman Dvoskin

1.Create Attached Property

1.创建附加属性

public static class DataGridCellAttachedProperties
{
    //Register new attached property
    public static readonly DependencyProperty IsSingleClickEditModeProperty =
        DependencyProperty.RegisterAttached("IsSingleClickEditMode", typeof(bool), typeof(DataGridCellAttachedProperties), new UIPropertyMetadata(false, OnPropertyIsSingleClickEditModeChanged));

    private static void OnPropertyIsSingleClickEditModeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var dataGridCell = d as DataGridCell;
        if (dataGridCell == null)
            return;

        var isSingleEditMode = GetIsSingleClickEditMode(d);
        var behaviors =  Interaction.GetBehaviors(d);
        var singleClickEditBehavior = behaviors.SingleOrDefault(x => x is SingleClickEditDataGridCellBehavior);

        if (singleClickEditBehavior != null && !isSingleEditMode)
            behaviors.Remove(singleClickEditBehavior);
        else if (singleClickEditBehavior == null && isSingleEditMode)
        {
            singleClickEditBehavior = new SingleClickEditDataGridCellBehavior();
            behaviors.Add(singleClickEditBehavior);
        }
    }

    public static bool GetIsSingleClickEditMode(DependencyObject obj)
    {
        return (bool) obj.GetValue(IsSingleClickEditModeProperty);
    }

    public static void SetIsSingleClickEditMode(DependencyObject obj, bool value)
    {
        obj.SetValue(IsSingleClickEditModeProperty, value);
    }
}

2.Create a Behavior

2.创建行为

public class SingleClickEditDataGridCellBehavior:Behavior<DataGridCell>
        {
            protected override void OnAttached()
            {
                base.OnAttached();
                AssociatedObject.PreviewMouseLeftButtonDown += DataGridCellPreviewMouseLeftButtonDown;
            }

            protected override void OnDetaching()
            {
                base.OnDetaching();
                AssociatedObject.PreviewMouseLeftButtonDown += DataGridCellPreviewMouseLeftButtonDown;
            }

            void DataGridCellPreviewMouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
            {
                 DataGridCell cell = sender as DataGridCell;
                if (cell != null && !cell.IsEditing && !cell.IsReadOnly)
                {
                    if (!cell.IsFocused)
                    {
                        cell.Focus();
                    }
                    DataGrid dataGrid = LogicalTreeWalker.FindParentOfType<DataGrid>(cell); //FindVisualParent<DataGrid>(cell);
                    if (dataGrid != null)
                    {
                        if (dataGrid.SelectionUnit != DataGridSelectionUnit.FullRow)
                        {
                            if (!cell.IsSelected)
                                cell.IsSelected = true;
                        }
                        else
                        {
                            DataGridRow row =  LogicalTreeWalker.FindParentOfType<DataGridRow>(cell); //FindVisualParent<DataGridRow>(cell);
                            if (row != null && !row.IsSelected)
                            {
                                row.IsSelected = true;
                            }
                        }
                    }
                }
            }    
        }

3.Create a Style and set the attached property

3.创建Style并设置附加属性

        <Style TargetType="{x:Type DataGridCell}">
            <Setter Property="Behaviors:DataGridCellAttachedProperties.IsSingleClickEditMode" Value="True"/>
        </Style>

回答by Jason Frank

I like the approach shown by the answers by Roman Dvoskin and Jonathan Allen in this thread. When I was first learning that technique though, I benefited from this blog postwhich provides more explanation about the technique. And to see everything in context, here is the entire source codefor the class that the author talks about in his blog post.

我喜欢 Roman Dvoskin 和 Jonathan Allen 在此线程中的答案所展示的方法。不过，当我第一次学习该技术时，我从这篇博客文章中受益，它提供了有关该技术的更多解释。为了在上下文中查看所有内容，这里是作者在他的博客文章中谈到的类的完整源代码。

回答by Andi

I have another idea, to avoid the creation of a attached property for every behavior:

我有另一个想法，以避免为每个行为创建附加属性：

1. Behavior creator interface:

   public interface IBehaviorCreator
   {
       Behavior Create();
   }
   

2. Small helper collection:

   public class BehaviorCreatorCollection : Collection<IBehaviorCreator> { }
   

3. Helper class which attaches the behavior:

   public static class BehaviorInStyleAttacher
   {
       #region Attached Properties
   
       public static readonly DependencyProperty BehaviorsProperty =
           DependencyProperty.RegisterAttached(
               "Behaviors",
               typeof(BehaviorCreatorCollection),
               typeof(BehaviorInStyleAttacher),
               new UIPropertyMetadata(null, OnBehaviorsChanged));
   
       #endregion
   
       #region Getter and Setter of Attached Properties
   
       public static BehaviorCreatorCollection GetBehaviors(TreeView treeView)
       {
           return (BehaviorCreatorCollection)treeView.GetValue(BehaviorsProperty);
       }
   
       public static void SetBehaviors(
           TreeView treeView, BehaviorCreatorCollection value)
       {
           treeView.SetValue(BehaviorsProperty, value);
       }
   
       #endregion
   
       #region on property changed methods
   
       private static void OnBehaviorsChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
       {
           if (e.NewValue is BehaviorCreatorCollection == false)
               return;
   
           BehaviorCreatorCollection newBehaviorCollection = e.NewValue as BehaviorCreatorCollection;
   
           BehaviorCollection behaviorCollection = Interaction.GetBehaviors(depObj);
           behaviorCollection.Clear();
           foreach (IBehaviorCreator behavior in newBehaviorCollection)
           {
               behaviorCollection.Add(behavior.Create());
           }
       }
   
       #endregion
   }
   

4. Now your behavior, which implements IBehaviorCreator:

   public class SingleClickEditDataGridCellBehavior:Behavior<DataGridCell>, IBehaviorCreator
   {
       //some code ...
   
       public Behavior Create()
       {
           // here of course you can also set properties if required
           return new SingleClickEditDataGridCellBehavior();
       }
   }
   

5. And now use it in xaml:

   <Style TargetType="{x:Type DataGridCell}">
     <Setter Property="helper:BehaviorInStyleAttacher.Behaviors" >
       <Setter.Value>
         <helper:BehaviorCreatorCollection>
           <behaviors:SingleClickEditDataGridCellBehavior/>
         </helper:BehaviorCreatorCollection>
       </Setter.Value>
     </Setter>
   </Style>
   

1. 行为创建者界面：

   public interface IBehaviorCreator
   {
       Behavior Create();
   }
   

2. 小帮手合集：

   public class BehaviorCreatorCollection : Collection<IBehaviorCreator> { }
   

3. 附加行为的助手类：

   public static class BehaviorInStyleAttacher
   {
       #region Attached Properties
   
       public static readonly DependencyProperty BehaviorsProperty =
           DependencyProperty.RegisterAttached(
               "Behaviors",
               typeof(BehaviorCreatorCollection),
               typeof(BehaviorInStyleAttacher),
               new UIPropertyMetadata(null, OnBehaviorsChanged));
   
       #endregion
   
       #region Getter and Setter of Attached Properties
   
       public static BehaviorCreatorCollection GetBehaviors(TreeView treeView)
       {
           return (BehaviorCreatorCollection)treeView.GetValue(BehaviorsProperty);
       }
   
       public static void SetBehaviors(
           TreeView treeView, BehaviorCreatorCollection value)
       {
           treeView.SetValue(BehaviorsProperty, value);
       }
   
       #endregion
   
       #region on property changed methods
   
       private static void OnBehaviorsChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
       {
           if (e.NewValue is BehaviorCreatorCollection == false)
               return;
   
           BehaviorCreatorCollection newBehaviorCollection = e.NewValue as BehaviorCreatorCollection;
   
           BehaviorCollection behaviorCollection = Interaction.GetBehaviors(depObj);
           behaviorCollection.Clear();
           foreach (IBehaviorCreator behavior in newBehaviorCollection)
           {
               behaviorCollection.Add(behavior.Create());
           }
       }
   
       #endregion
   }
   

4. 现在你的行为，它实现了 IBehaviorCreator：

   public class SingleClickEditDataGridCellBehavior:Behavior<DataGridCell>, IBehaviorCreator
   {
       //some code ...
   
       public Behavior Create()
       {
           // here of course you can also set properties if required
           return new SingleClickEditDataGridCellBehavior();
       }
   }
   

5. 现在在 xaml 中使用它：

   <Style TargetType="{x:Type DataGridCell}">
     <Setter Property="helper:BehaviorInStyleAttacher.Behaviors" >
       <Setter.Value>
         <helper:BehaviorCreatorCollection>
           <behaviors:SingleClickEditDataGridCellBehavior/>
         </helper:BehaviorCreatorCollection>
       </Setter.Value>
     </Setter>
   </Style>
   

回答by Roma Borodov

Summing answers and this great article Blend Behaviors in Styles, I came to this generic short and convinient solution:

总结答案和这篇很棒的文章Blend Behaviors in Styles，我找到了这个通用的简短而方便的解决方案：

I made generic class, which could be inherited by any behavior.

我创建了泛型类，它可以被任何行为继承。

public class AttachableForStyleBehavior<TComponent, TBehavior> : Behavior<TComponent>
        where TComponent : System.Windows.DependencyObject
        where TBehavior : AttachableForStyleBehavior<TComponent, TBehavior> , new ()
    {
        public static DependencyProperty IsEnabledForStyleProperty =
            DependencyProperty.RegisterAttached("IsEnabledForStyle", typeof(bool),
            typeof(AttachableForStyleBehavior<TComponent, TBehavior>), new FrameworkPropertyMetadata(false, OnIsEnabledForStyleChanged)); 

        public bool IsEnabledForStyle
        {
            get { return (bool)GetValue(IsEnabledForStyleProperty); }
            set { SetValue(IsEnabledForStyleProperty, value); }
        }

        private static void OnIsEnabledForStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            UIElement uie = d as UIElement;

            if (uie != null)
            {
                var behColl = Interaction.GetBehaviors(uie);
                var existingBehavior = behColl.FirstOrDefault(b => b.GetType() ==
                      typeof(TBehavior)) as TBehavior;

                if ((bool)e.NewValue == false && existingBehavior != null)
                {
                    behColl.Remove(existingBehavior);
                }

                else if ((bool)e.NewValue == true && existingBehavior == null)
                {
                    behColl.Add(new TBehavior());
                }    
            }
        }
    }

So you could simply reuse it with lot of components like this:

所以你可以简单地将它与许多像这样的组件重用：

public class ComboBoxBehaviour : AttachableForStyleBehavior<ComboBox, ComboBoxBehaviour>
    { ... }

And in XAML enough to declare:

在 XAML 中足以声明：

 <Style TargetType="ComboBox">
            <Setter Property="behaviours:ComboBoxBehaviour.IsEnabledForStyle" Value="True"/>

So basicly the AttachableForStyleBehavior class made xaml things, registering the instance of behavior for each component in style. For more details, please see the link.

所以基本上 AttachableForStyleBehavior 类制作了 xaml 东西，以样式为每个组件注册行为实例。欲知更多详情，请参阅链接。

回答by AnjumSKhan

Declare individual behavior/trigger as Resources :

将个人行为/触发器声明为 Resources ：

<Window.Resources>

    <i:EventTrigger x:Key="ET1" EventName="Click">
        <ei:ChangePropertyAction PropertyName="Background">
            <ei:ChangePropertyAction.Value>
                <SolidColorBrush Color="#FFDAD32D"/>
            </ei:ChangePropertyAction.Value>
        </ei:ChangePropertyAction>
    </i:EventTrigger>

</Window.Resources>

Insert them in the collection :

将它们插入集合中：

<Button x:Name="Btn1" Content="Button">

        <i:Interaction.Triggers>
             <StaticResourceExtension ResourceKey="ET1"/>
        </i:Interaction.Triggers>

</Button>

回答by technopriest

Based on thisanswer I made a simpler solution, with just one class needed and there is no need to implement something else in your behaviors.

基于这个答案，我做了一个更简单的解决方案，只需要一个类，不需要在你的行为中实现其他东西。

public static class BehaviorInStyleAttacher
{
    #region Attached Properties

    public static readonly DependencyProperty BehaviorsProperty =
        DependencyProperty.RegisterAttached(
            "Behaviors",
            typeof(IEnumerable),
            typeof(BehaviorInStyleAttacher),
            new UIPropertyMetadata(null, OnBehaviorsChanged));

    #endregion

    #region Getter and Setter of Attached Properties

    public static IEnumerable GetBehaviors(DependencyObject dependencyObject)
    {
        return (IEnumerable)dependencyObject.GetValue(BehaviorsProperty);
    }

    public static void SetBehaviors(
        DependencyObject dependencyObject, IEnumerable value)
    {
        dependencyObject.SetValue(BehaviorsProperty, value);
    }

    #endregion

    #region on property changed methods

    private static void OnBehaviorsChanged(DependencyObject depObj, DependencyPropertyChangedEventArgs e)
    {
        if (e.NewValue is IEnumerable == false)
            return;

        var newBehaviorCollection = e.NewValue as IEnumerable;

        BehaviorCollection behaviorCollection = Interaction.GetBehaviors(depObj);
        behaviorCollection.Clear();
        foreach (Behavior behavior in newBehaviorCollection)
        {
            // you need to make a copy of behavior in order to attach it to several controls
            var copy = behavior.Clone() as Behavior;
            behaviorCollection.Add(copy);
        }
    }

    #endregion
}

and the sample usage is

示例用法是

<Style TargetType="telerik:RadComboBox" x:Key="MultiPeriodSelectableRadComboBox">
    <Setter Property="AllowMultipleSelection" Value="True" />
    <Setter Property="behaviors:BehaviorInStyleAttacher.Behaviors">
        <Setter.Value>
            <collections:ArrayList>
                <behaviors:MultiSelectRadComboBoxBehavior
                        SelectedItems="{Binding SelectedPeriods}"
                        DelayUpdateUntilDropDownClosed="True"
                        SortSelection="True" 
                        ReverseSort="True" />
            </collections:ArrayList>
        </Setter.Value>
    </Setter>
</Style>

Don't forget to add this xmlns to use ArrayList:

不要忘记添加此 xmlns 以使用 ArrayList：

xmlns:collections="clr-namespace:System.Collections;assembly=mscorlib"