/// <summary>
/// Processes the value.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="context">The context.</param>
/// <returns>
/// The <see cref="object" /> representing the processed value.
/// </returns>
internal virtual object ProcessValue(
object value,
DittoProcessorContext context)
{
if (value != null && !ValueType.IsInstanceOfType(value))
{
throw new ArgumentException("Expected a value argument of type " + ValueType + " but got " + value.GetType(), "value");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (!ContextType.IsInstanceOfType(context))
{
throw new ArgumentException("Expected a context argument of type " + ContextType + " but got " + context.GetType(), "context");
}
Value = value;
Context = context;
var ctx = new DittoCacheContext(this, context.Content, context.TargetType, context.PropertyDescriptor, context.Culture);
return(this.GetCacheItem(ctx, this.ProcessValue));
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, System.Globalization.CultureInfo culture)
{
if (_chainedConverter != null)
{
try { value = _chainedConverter.ConvertBack(value, typeof(object), parameter, culture); }
catch (Exception e)
{
EquationTokenizer.ThrowQuickConverterEvent(new ChainedConverterExceptionEventArgs(ConvertExpression, value, typeof(object), parameter, culture, true, _chainedConverter, this, e));
return(new object[targetTypes.Length].Select(o => value).ToArray());
}
if (value == DependencyProperty.UnsetValue || value == System.Windows.Data.Binding.DoNothing)
{
return(new object[targetTypes.Length].Select(o => value).ToArray());
}
}
object[] ret = new object[_convertBack.Length];
if (ValueType != null && !ValueType.IsInstanceOfType(value))
{
for (int i = 0; i < ret.Length; ++i)
{
ret[i] = System.Windows.Data.Binding.DoNothing;
}
return(ret);
}
for (int i = 0; i < _convertBack.Length; ++i)
{
try { ret[i] = _convertBack[i](value, _values); }
catch (Exception e)
{
LastException = e;
++ExceptionCount;
if (Debugger.IsAttached)
{
Console.WriteLine("QuickMultiConverter Exception (\"" + ConvertBackExpression[i] + "\") - " + e.Message + (e.InnerException != null ? " (Inner - " + e.InnerException.Message + ")" : ""));
}
EquationTokenizer.ThrowQuickConverterEvent(new RuntimeMultiConvertExceptionEventArgs(ConvertBackExpression[i], ConvertBackExpressionDebugView[i], null, _pIndices, value, _values, parameter, this, e));
ret[i] = DependencyProperty.UnsetValue;
}
ret[i] = CastResult(ret[i], targetTypes[i]);
}
if (_fromDataContainers != null)
{
foreach (var container in _fromDataContainers)
{
container.Value = null;
}
}
return(ret);
}
protected object DeserializeOneOrPass(object value) => ValueType.IsInstanceOfType(value)
? value
: DeserializeOne((string)value);
public override bool IsValid(object val) => IsNullable && val == null || ValueType.IsInstanceOfType(val);
private object DoConversion(object value, Type targetType, object parameter, Func <object, object[], object, object> func, bool convertingBack, CultureInfo culture)
{
if (convertingBack)
{
if (_chainedConverter != null)
{
try { value = _chainedConverter.ConvertBack(value, targetType, parameter, culture); }
catch (Exception e)
{
EquationTokenizer.ThrowQuickConverterEvent(new ChainedConverterExceptionEventArgs(ConvertExpression, value, targetType, parameter, culture, true, _chainedConverter, this, e));
return(DependencyProperty.UnsetValue);
}
if (value == DependencyProperty.UnsetValue || value == System.Windows.Data.Binding.DoNothing)
{
return(value);
}
}
if (ValueType != null && !ValueType.IsInstanceOfType(value))
{
return(System.Windows.Data.Binding.DoNothing);
}
}
else
{
if (value == DependencyProperty.UnsetValue || _namedObjectType.IsInstanceOfType(value) || (PType != null && !PType.IsInstanceOfType(value)))
{
return(DependencyProperty.UnsetValue);
}
}
object result = value;
if (func != null)
{
try { result = func(result, _values, parameter); }
catch (Exception e)
{
LastException = e;
++ExceptionCount;
if (Debugger.IsAttached)
{
Console.WriteLine("QuickMultiConverter Exception (\"" + (convertingBack ? ConvertBackExpression : ConvertExpression) + "\") - " + e.Message + (e.InnerException != null ? " (Inner - " + e.InnerException.Message + ")" : ""));
}
if (convertingBack)
{
EquationTokenizer.ThrowQuickConverterEvent(new RuntimeSingleConvertExceptionEventArgs(ConvertBackExpression, ConvertBackExpressionDebugView, null, value, _values, parameter, this, e));
}
else
{
EquationTokenizer.ThrowQuickConverterEvent(new RuntimeSingleConvertExceptionEventArgs(ConvertExpression, ConvertExpressionDebugView, value, null, _values, parameter, this, e));
}
return(DependencyProperty.UnsetValue);
}
finally
{
var dataContainers = convertingBack ? _fromDataContainers : _toDataContainers;
if (dataContainers != null)
{
foreach (var container in dataContainers)
{
container.Value = null;
}
}
}
}
if (result == DependencyProperty.UnsetValue || result == System.Windows.Data.Binding.DoNothing)
{
return(result);
}
if (!convertingBack && _chainedConverter != null)
{
try { result = _chainedConverter.Convert(result, targetType, parameter, culture); }
catch (Exception e)
{
EquationTokenizer.ThrowQuickConverterEvent(new ChainedConverterExceptionEventArgs(ConvertExpression, result, targetType, parameter, culture, false, _chainedConverter, this, e));
return(DependencyProperty.UnsetValue);
}
}
if (result == DependencyProperty.UnsetValue || result == System.Windows.Data.Binding.DoNothing || result == null || targetType == null || targetType == typeof(object))
{
return(result);
}
if (targetType == typeof(string))
{
return(result.ToString());
}
Func <object, object> cast;
if (!castFunctions.TryGetValue(targetType, out cast))
{
ParameterExpression par = Expression.Parameter(typeof(object));
cast = Expression.Lambda <Func <object, object> >(Expression.Convert(Expression.Dynamic(Binder.Convert(CSharpBinderFlags.ConvertExplicit, targetType, typeof(object)), targetType, par), typeof(object)), par).Compile();
castFunctions.TryAdd(targetType, cast);
}
if (cast != null)
{
try
{
result = cast(result);
}
catch
{
castFunctions[targetType] = null;
}
}
return(result);
}
public bool IsValid(object value) => IsNullable && value == null || ValueType.IsInstanceOfType(value);
