WPF Extensibility Hacks or WEX - Includes EventTrigger, ReactiveTrigger, InvokeMethodAction, InvokeCommandAction etc.

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Wex.Lib.Interactions
{
    /// <summary>
    /// Action to set a property value
    /// </summary>
    public class PropertyAction : TargettedTriggerAction
    {

        private DependencyProperty targetDP;

        /// <summary>
        /// The type of this property action
        /// </summary>
        public PropertyActionEnum Action
        {
            get { return (PropertyActionEnum)GetValue(ActionProperty); }
            set { SetValue(ActionProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Action.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ActionProperty =
            DependencyProperty.Register("Action", typeof(PropertyActionEnum), typeof(PropertyAction), new PropertyMetadata(PropertyActionEnum.Set));

        
        
        
        /// <summary>
        /// The value to set
        /// </summary>
        public object Value
        {
            get { return (object)GetValue(ValueProperty); }
            set { SetValue(ValueProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Value.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ValueProperty =
            DependencyProperty.Register("Value", typeof(object), typeof(PropertyAction), new PropertyMetadata(null));


        /// <summary>
        /// Name of the property to set
        /// </summary>
        public string Property
        {
            get { return (string)GetValue(PropertyProperty); }
            set { SetValue(PropertyProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Property.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty PropertyProperty =
            DependencyProperty.Register("Property", typeof(string), typeof(PropertyAction), new PropertyMetadata(string.Empty));


        /// <summary>
        /// Internal initialize
        /// </summary>
        internal override void InternalInitialize()
        {
            base.InternalInitialize();
            targetDP =DependencyPropertyHelper.RegisterForNotification<PropertyAction>(this, Target, this.Property, (s, a) =>
            { if (Action == PropertyActionEnum.Get) Value = a.NewValue; }, true);

        }

        /// <summary>
        /// Invoke the value conditionally
        /// </summary>
        /// <param name="parameter"></param>
        internal override void InvokeConditional(object parameter)
        {
            if (Action == PropertyActionEnum.Set)
                    SetValue(targetDP, Value);
        }
    }

    /// <summary>
    /// Get the type of the property action
    /// </summary>
    public enum PropertyActionEnum
    {
        Get,
        Set
    }
}