So fügen Sie eine Mischung Verhalten in einem Stil-Setter

Ich hatte das gleiche problem und ich habe zu einer Lösung zu kommen. Ich fand diese Frage, nachdem ich es gelöst und ich sehe, dass meine Lösung birgt viele Gemeinsamkeiten mit Mark. Dieser Ansatz ist jedoch ein wenig anders.

Das Hauptproblem ist, dass behaviors und Trigger zuordnen, mit einem spezifischen Objekt und so kann man nicht mit derselben Instanz von einem Verhalten für mehrere andere verbundene Objekte. Wenn Sie definieren Ihr Verhalten der inline-XAML setzt diese eins-zu-eins-Beziehung. Jedoch, wenn Sie versuchen, ein Verhalten, ein Stil, der Stil kann immer wieder verwendet werden für alle Objekte gilt, und das werfen von Ausnahmen in der Basis-Klassen Verhalten. In der Tat, die Autoren gingen erhebliche Mühe, uns daran zu hindern, auch nur zu versuchen, dies zu tun, zu wissen, dass es nicht funktionieren würde.

Das erste problem ist, dass wir uns nicht selbst konstruieren, ein Verhalten setter-Wert, da der Konstruktor ist eine interne. Also müssen wir unser eigenes Verhalten auslösen und die collection-Klassen.

Das nächste problem ist, dass das Verhalten auslösen und die angefügte Eigenschaften nicht haben, setter und so Sie können nur Hinzugefügt werden, mit in-line-XAML. Dieses problem lösen wir mit unserem eigenen angehängten Eigenschaften zu manipulieren, dass das primäre Verhalten und trigger-Eigenschaften.

Das Dritte problem ist, dass unser Verhalten-Sammlung ist nur für einen einzigen Stil Ziel. Dies lösen wir durch den Einsatz einer wenig genutzten XAML-Funktion x:Shared="False" legt eine neue Kopie der Ressource, die jedes mal verwiesen wird.

Das Letzte problem ist, dass behaviors und Trigger sind nicht wie andere Stil-setter; wir wollen nicht, um die alten zu ersetzen Verhaltensweisen, die mit den neuen Verhaltensweisen, weil Sie tun könnten völlig unterschiedliche Dinge. Also, wenn wir akzeptieren, dass, wenn Sie ein Verhalten hinzufügen, können Sie nicht nehmen Sie es Weg (und die Möglichkeit, die Verhaltensweisen, die derzeit in Arbeit), können wir schließen, dass Verhaltensweisen und löst sein sollte, additive und diese können behandelt werden, indem Sie unsere angefügte Eigenschaften.

Hier ist ein Beispiel für die Verwendung dieses Ansatzes:

<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>

Verwendet das Beispiel löst aber Verhaltensweisen auf die gleiche Weise arbeiten. Im Beispiel zeigen wir:

• der Stil kann angewendet werden, um mehrere text-Blöcke
• mehrere Arten der Datenbindung, die alle arbeiten korrekt
• eine debug-Aktion, erzeugt text in der Ausgabe-Fenster

Hier ein Beispiel für ein Verhalten, unsere DebugAction. Richtig es ist eine Aktion, die aber durch den Missbrauch der Sprache bezeichnen wir Verhaltensweisen, von Auslösern und Handlungen "Verhaltensweisen".

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);
    }
}

Schließlich, unsere Kollektionen und die angefügten Eigenschaften dieser alle Arbeit. Durch Analogie mit Interaction.Behaviorsdie Immobilie, die Sie Ziel genannt SupplementaryInteraction.Behaviors weil durch das festlegen dieser Eigenschaft, die Sie hinzufügen Verhaltensweisen zu Interaction.Behaviors und ebenfalls für Trigger.

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);
    }
}

und dort haben Sie es, voll funktionsfähige Verhaltensweisen und löst durch Stile angewendet.

InformationsquelleAutor der Antwort Rick Sladkey

Summierung Antworten und diesen tollen Artikel Mischung Verhaltensweisen im Stilekam ich zu diesem generischen kurze und bequeme Lösung:

Ich aus einer generischen Klasse, die vererbt werden könnte durch irgendein Verhalten.

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 könnte man einfach wiederverwenden es mit vielen Komponenten wie diese:

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

Und in XAML genug zu erklären:

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

Also im Grunde die AttachableForStyleBehavior Klasse gemacht xaml Dinge, die Registrierung der Instanz von Verhalten für jede Komponente in der Art. Für mehr details, siehe bitte den link.

InformationsquelleAutor der Antwort Roma Borodov

Konnte ich nicht finden die original-Artikel, aber ich war in der Lage, neu zu erstellen die Wirkung.

#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>

InformationsquelleAutor der Antwort Jonathan Allen

Verhalten der code erwartet eine Visuelle, so können wir hinzufügen, dass es nur auf einer visuellen. So ist die einzige option, die ich sehen konnte, ist das hinzufügen zu einem element innerhalb der ControlTemplate-so wie man das Verhalten Hinzugefügt, um den Stil und die Auswirkungen auf die Instanz eines bestimmten Steuerelements.

InformationsquelleAutor der Antwort Jobi Joy

Ich mag den Ansatz gezeigt, indem die Antworten von Roman Dvoskin und Jonathan Allen in diesem thread. Als ich zuerst lernen, dass die Technik, obwohl ich profitierte von diesem blog-post die weitere Erklärung über die Technik. Und alles zu sehen im Kontext, hier die gesamte source-code für die Klasse, von der der Autor spricht darüber in seinem blog-post.

InformationsquelleAutor der Antwort Jason Frank