public static void SetBindingObject(FrameworkElement obj, BindingMode mode, object source, DependencyProperty dp, string propertyName)
        {
            Type propertyType = source.GetType().GetProperty(propertyName).PropertyType;
            PropertyInfo info = source.GetType().GetProperty("RangeList");
            FANumberRangeRule rangeRule = null;
            if (info != null)
            {
                object value = info.GetValue(source, null);
                if (value != null)
                {
                    FALibrary.Utility.SerializableDictionary<string, FARange> dic =
                        (FALibrary.Utility.SerializableDictionary<string, FARange>)value;
                    if (dic.ContainsKey(propertyName))
                    {
                        rangeRule = new FANumberRangeRule(propertyType);
                        rangeRule.Range = dic[propertyName];
                        obj.Tag = rangeRule;
                        obj.Style = (Style)App.Current.Resources["TextBoxErrorStyle"];
                    }
                }
            }

            Binding bd = new Binding(propertyName);
            bd.Source = source;
            bd.Mode = mode;
            bd.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
            if (rangeRule != null)
            {
                bd.NotifyOnValidationError = true;
                bd.ValidationRules.Add(rangeRule);
            }

            obj.SetBinding(dp, bd);
        }

 public static BindingExpressionBase SetBinding(this FrameworkElement target, DependencyProperty dp, object source, string path, BindingMode bindingMode)
 {
     Binding b = new Binding(path);
     b.Source = source;
     b.Mode = bindingMode;
     return BindingOperations.SetBinding(target, dp, b);
 }

 public XamlBindingDefinition(Control target, PerspexProperty targetProperty, PropertyPath sourcePropertyPath, BindingMode bindingMode)
 {
     this.target = target;
     this.targetProperty = targetProperty;
     this.sourcePropertyPath = sourcePropertyPath;
     this.bindingMode = bindingMode;
 }

 public BindingExpression(BindingMode mode, Binding.Parsing.Expressions.BindingPathExpression path, RedwoodProperty sourceProperty = null, RedwoodBindable source = null)
 {
     Path = path;
     Mode = mode;
     SourceProperty = sourceProperty ?? Controls.RedwoodControl.DataContextProperty;
     Source = source;
 }

 public DenomTemplateColumnDefinition(string columnName, string displayMember, string headerName, DenomColumnDataType columnDataType = DenomColumnDataType.Text, string alignment = "left", string width = "auto", bool isEditable = false, bool calculationRequired = false, string formula = "", string calculationOn = "", bool totalRequired = false, string footerText = "", bool isReadOnly = false, bool isVisible = true, bool allowDecimal = false, bool allowNegativeValue = false, bool spinnerRequired = false, string seed = "1", int decimalPlaces = 0, bool currencySymbolRequired = false, CurrencySymbolPositionType currencySymbolPosition= CurrencySymbolPositionType.Header, BindingMode bindingType= BindingMode.OneWay)
 {
     this.ColumnName = columnName;
     this.DisplayMember = displayMember;
     this.Width = width;
     this.ColumnDataType = columnDataType;
     this.Alignment = alignment;
     this.HeaderName = headerName;
     this.IsEditable = isEditable;
     this.CalculationRequired = calculationRequired;
     this.Formula = formula;
     this.CalculationOn= calculationOn;
     this.TotalRequired = totalRequired;
     this.FooterText = footerText;
     this.IsReadOnly = isReadOnly;
     this.IsVisible = isVisible;
     this.AllowDecimal = allowDecimal;
     this.AllowNegativeValue = allowNegativeValue;
     this.SpinnerRequired = spinnerRequired;
     this.Seed = seed;
     this.DecimalPlaces = decimalPlaces;
     this.CurrencySymbolRequired = currencySymbolRequired;
     this.CurrencySymbolPosition = currencySymbolPosition;
     this.BindingType = bindingType;
 }

 public XamlBindingDefinition(Control target, PerspexProperty targetProperty, PropertyPath sourcePropertyPath, BindingMode bindingMode)
 {
     _target = target;
     _targetProperty = targetProperty;
     _sourcePropertyPath = sourcePropertyPath;
     _bindingMode = bindingMode;
 }

        private static void BindParameter(FrameworkElement target, Parameter parameter, string elementName, string path, BindingMode bindingMode)
        {
            var element = elementName == "$this"
                ? target
                : ExtensionMethods.GetNamedElementsInScope(target).FindName(elementName);
            if (element == null)
                return;

            if(string.IsNullOrEmpty(path))
                path = ConventionManager.GetElementConvention(element.GetType()).ParameterProperty;

            var binding = new Binding(path) {
                Source = element,
                Mode = bindingMode
            };

            #if SILVERLIGHT
            var expression = (BindingExpression)BindingOperations.SetBinding(parameter, Parameter.ValueProperty, binding);

            var field = element.GetType().GetField(path + "Property", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
            if (field == null)
                return;

            ConventionManager.ApplySilverlightTriggers(element, (DependencyProperty)field.GetValue(null), x => expression);
            #else
            binding.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;
            BindingOperations.SetBinding(parameter, Parameter.ValueProperty, binding);
            #endif
        }

 public static void SetBindingObject(FrameworkElement obj, BindingMode mode, object source, DependencyProperty dp, string propertyName)
 {
     Binding bd = new Binding(propertyName);
     bd.Source = source;
     bd.Mode = mode;
     obj.SetBinding(dp, bd);
 }

 protected Binder(IChangable source, IChangable target, BindingMode mode)
 {
     _source = source;
     _target = target;
     _sourceIsUsed = mode == BindingMode.OneWay || mode == BindingMode.TwoWay;
     _targetIsUsed = mode == BindingMode.OneWayToSource || mode == BindingMode.TwoWay;
 }

 public XamlBindingDefinition(
     string sourcePropertyPath, 
     BindingMode bindingMode)
 {
     SourcePropertyPath = sourcePropertyPath;
     BindingMode = bindingMode;
 }

 public static void BindProperty(Control control, object source, string path,
     DependencyProperty property, BindingMode mode)
 {
     var binding = new Binding(path);
     binding.Source = source;
     binding.Mode = mode;
     control.SetBinding(property, binding);
 }

 public UnitTestSettings(BindingMode bindingMode, AssertMode assertMode, bool moduleInit, bool methodInit, bool defaultTestStub)
 {
     BindingMode = bindingMode;
     AssertMode = assertMode;
     ModuleInit = moduleInit;
     MethodInit = methodInit;
     DefaultTestStubInNewModule = defaultTestStub;
 }

 /// <summary>
 /// Initializes a new BindingInfo with a path, a source binding RelativeSourceMode, and an optional converter. 
 /// </summary>
 /// <param name="path">The path to the source member.</param>
 /// <param name="bindingMode">The binding direction.</param>
 /// <param name="relativeSourceMode">The source RelativeSourceMode.</param>
 /// <param name="converterType">An optional converter.</param>
 /// <param name="converterParameter">An optional converter parameter.</param>
 internal BindingInfo(string path, BindingMode bindingMode, RelativeSourceMode relativeSourceMode, Type converterType = null,
     object converterParameter = null)
 {
     Path = path;
     RelativeSourceMode = relativeSourceMode;
     ConverterType = converterType;
     ConverterParameter = converterParameter;
 }

 /// <summary>
 /// バインディングを追加します。
 /// </summary>
 public Binding Add(object bindableTarget, string bindingPropertyName,
                    object dataSource, string dataSourcePropertyName,
                    BindingMode mode, string format = null)
 {
     return Add(
         bindableTarget, bindingPropertyName,
         dataSource, dataSourcePropertyName,
         mode, format, null, null);
 }

 public DependencyWatcher(
     Dependency[] dependencies, 
     BindingMode mode,
     BindindErrorOptions errorOptions
 ) {
     _dependencies = dependencies;
     _mode = mode;
     _errorOptions = errorOptions;
 }

        public BindingNode(string elementName, string path, BindingMode mode)
        {
            if (string.IsNullOrWhiteSpace(path))
                throw new ArgumentNullException(nameof(path));

            this.elementName = elementName;
            this.path = path;
            this.mode = mode;
        }

        public static BindingExpressionBase SetBinding(DependencyObject target, DependencyProperty targetProperty, DependencyObject source, DependencyProperty sourceProperty, BindingMode mode, IValueConverter converter)
        {
            Binding binding = new Binding(sourceProperty.Name);
            binding.Source = source;
            binding.Converter = converter;
            binding.Mode = mode;

            return BindingOperations.SetBinding(target, targetProperty, binding);
        }

 public IndexerBinding(
     IAvaloniaObject source,
     AvaloniaProperty property,
     BindingMode mode)
 {
     Source = source;
     Property = property;
     Mode = mode;
 }

 /// <summary>
 /// Merges the metadata with the base metadata.
 /// </summary>
 /// <param name="baseMetadata">The base metadata to merge.</param>
 /// <param name="property">The property to which the metadata is being applied.</param>
 public virtual void Merge(
     PropertyMetadata baseMetadata, 
     AvaloniaProperty property)
 {
     if (_defaultBindingMode == BindingMode.Default)
     {
         _defaultBindingMode = baseMetadata.DefaultBindingMode;
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ApplicableBinding"/> class.
 /// </summary>
 /// <param name="elementDescription">The element description.</param>
 /// <param name="dependencyProperty">The dependency property.</param>
 /// <param name="path">The path.</param>
 /// <param name="mode">The mode.</param>
 /// <param name="validate">Inidicates whether or not to turn on validation for the binding.</param>
 /// <param name="checkTemplate">if set to <c>true</c> [check item template].</param>
 /// <param name="converter">The value converter to apply.</param>
 public ApplicableBinding(ElementDescription elementDescription, DependencyProperty dependencyProperty, string path, 
     BindingMode mode, bool validate, bool checkTemplate, IValueConverter converter)
 {
     this.elementDescription = elementDescription;
     this.dependencyProperty = dependencyProperty;
     this.path = path;
     this.mode = mode;
     this.validate = validate;
     this.checkTemplate = checkTemplate;
     this.converter = converter;
 }