internal TriggerCondition(BindingBase binding, LogicalOp logicalOp, object value, string sourceName)
 {
     Property = null;
     Binding = binding;
     LogicalOp = logicalOp;
     Value = value;
     SourceName = sourceName;
     SourceChildIndex = 0;
     BindingValueCache = new BindingValueCache(null, null);
 }
        // Check for match, after converting the reference value to the type
        // of the state value.  (Used by data triggers)
        internal bool ConvertAndMatch(object state)
        {
            // convert the reference value to the type of 'state',
            // provided the reference value is a string and the
            // state isn't null or a string.  (Otherwise, we can
            // compare the state and reference values directly.)
            object referenceValue = Value;
            string referenceString = referenceValue as String;
            Type stateType = (state != null) ? state.GetType() : null;

            if (referenceString != null && stateType != null &&
                stateType != typeof(String))
            {
                // the most recent type and value are cached in the
                // TriggerCondition, since it's very likely the
                // condition's Binding produces the same type of
                // value every time.  The cached values can be used
                // on any thread, so we must synchronize access.
                BindingValueCache bindingValueCache = BindingValueCache;
                Type cachedType = bindingValueCache.BindingValueType;
                object cachedValue = bindingValueCache.ValueAsBindingValueType;

                if (stateType != cachedType)
                {
                    // the cached type isn't the current type - refresh the cache

                    cachedValue = referenceValue; // in case of failure
                    TypeConverter typeConverter = DefaultValueConverter.GetConverter(stateType);
                    if (typeConverter != null && typeConverter.CanConvertFrom(typeof(String)))
                    {
                        // PreSharp uses message numbers that the C# compiler doesn't know about.
                        // Disable the C# complaints, per the PreSharp documentation.
                        #pragma warning disable 1634, 1691

                        // PreSharp complains about catching NullReference (and other) exceptions.
                        // It doesn't recognize that IsCritical[Application]Exception() handles these correctly.
                        #pragma warning disable 56500

                        try
                        {
                            cachedValue = typeConverter.ConvertFromString(null, System.Windows.Markup.TypeConverterHelper.InvariantEnglishUS, referenceString);
                        }
                        catch (Exception ex)
                        {
                            if (CriticalExceptions.IsCriticalApplicationException(ex))
                                throw;
                            // if the conversion failed, just use the unconverted value
                        }
                        catch // non CLS compliant exception
                        {
                            // if the conversion failed, just use the unconverted value
                        }

                        #pragma warning restore 56500
                        #pragma warning restore 1634, 1691
                    }

                    // cache the converted value
                    bindingValueCache = new BindingValueCache(stateType, cachedValue);
                    BindingValueCache = bindingValueCache;
                }

                referenceValue = cachedValue;
            }

            return Match(state, referenceValue);
        }
 internal TriggerCondition(DependencyProperty dp, LogicalOp logicalOp, object value, string sourceName)
 {
     Property = dp;
     Binding = null;
     LogicalOp = logicalOp;
     Value = value;
     SourceName = sourceName;
     SourceChildIndex = 0;
     BindingValueCache = new BindingValueCache(null, null);
 }