protected override XamlValueConverter <System.ComponentModel.TypeConverter> LookupTypeConverter()
{
if (typeConverter != null)
{
return(typeConverter);
}
var typeConverterAttrib = UnderlyingType.GetCustomAttribute <Eto.TypeConverterAttribute>();
if (typeConverterAttrib != null)
{
var converterType = Type.GetType(typeConverterAttrib.ConverterTypeName);
if (converterType != null)
{
typeConverter = new EtoValueConverter(converterType, this);
}
}
if (typeof(MulticastDelegate).IsAssignableFrom(UnderlyingType))
{
var context = SchemaContext as EtoXamlSchemaContext;
if (context.DesignMode)
{
return(null);
}
}
if (typeConverter == null)
{
// convert from Eto.TypeConverter to System.ComponentModel.TypeConverter
typeConverter = base.LookupTypeConverter();
}
return(typeConverter);
}
public override TConverterBase GetConverterInstance <TConverterBase>(XamlValueConverter <TConverterBase> converter)
{
if (!MemberAccessPermissionDenied || converter.IsPublic || !IsDefaultConverter(converter))
{
try
{
return(_transparentRuntime.GetConverterInstance(converter));
}
// We don't know if MissingMethodException is due to visibility or not.
// So we fall back to the elevated runtime, but we don't set _memberAccessPermissionDenied.
catch (MissingMethodException)
{
EnsureElevatedRuntime();
}
catch (MethodAccessException)
{
MemberAccessPermissionDenied = true;
}
catch (SecurityException)
{
MemberAccessPermissionDenied = true;
}
}
return(_elevatedRuntime.GetConverterInstance(converter));
}
public override XamlReader DeferredSave(IServiceProvider context,
XamlValueConverter <XamlDeferringLoader> deferringLoader,
object value)
{
if (!MemberAccessPermissionDenied || deferringLoader.IsPublic || !IsDefaultConverter(deferringLoader))
{
try
{
return(_transparentRuntime.DeferredSave(context, deferringLoader, value));
}
catch (XamlException e)
{
// We don't know if MissingMethodException is due to visibility or not.
// So we fall back to the elevated runtime, but we don't set _memberAccessPermissionDenied.
if (e.InnerException is MissingMethodException)
{
EnsureElevatedRuntime();
}
else if (e.InnerException is MethodAccessException)
{
MemberAccessPermissionDenied = true;
}
else
{
throw;
}
}
catch (SecurityException)
{
MemberAccessPermissionDenied = true;
}
}
return(_elevatedRuntime.DeferredSave(context, deferringLoader, value));
}
public override object DeferredLoad(ServiceProviderContext serviceContext,
XamlValueConverter <XamlDeferringLoader> deferringLoader,
XamlReader deferredContent)
{
try
{
XamlDeferringLoader converter = GetConverterInstance(deferringLoader);
if (converter == null)
{
throw new XamlObjectWriterException(SR.Get(SRID.DeferringLoaderInstanceNull, deferringLoader));
}
return(converter.Load(deferredContent, serviceContext));
}
catch (Exception e)
{
// Reset the reader in case our caller catches and retries
IXamlIndexingReader indexingReader = deferredContent as IXamlIndexingReader;
if (indexingReader != null && indexingReader.CurrentIndex >= 0)
{
indexingReader.CurrentIndex = -1;
}
if (CriticalExceptions.IsCriticalException(e) || e is XamlException)
{
throw;
}
throw CreateException(SR.Get(SRID.DeferredLoad), e);
}
}
internal static XamlValueConverter <ValueSerializer> LookupValueSerializer(XamlType targetType, ICustomAttributeProvider provider)
{
if (provider == null)
{
return(null);
}
#if NET46
var a = provider.GetCustomAttribute <ValueSerializerAttribute> (true);
if (a != null)
{
return(new XamlValueConverter <ValueSerializer> (a.ValueSerializerType ?? Type.GetType(a.ValueSerializerTypeName), targetType));
}
if (targetType.BaseType != null)
{
var ret = targetType.BaseType.LookupValueSerializer();
if (ret != null)
{
return(ret);
}
}
if (targetType.UnderlyingType == typeof(string))
{
if (string_value_serializer == null)
{
string_value_serializer = new XamlValueConverter <ValueSerializer> (typeof(StringValueSerializer), targetType);
}
return(string_value_serializer);
}
#endif
return(null);
}
public override XamlReader DeferredSave(IServiceProvider context, XamlValueConverter <XamlDeferringLoader> deferringLoader, object value)
{
if ((!this.MemberAccessPermissionDenied || deferringLoader.IsPublic) || !IsDefaultConverter <XamlDeferringLoader>(deferringLoader))
{
try
{
return(this._transparentRuntime.DeferredSave(context, deferringLoader, value));
}
catch (XamlException exception)
{
if (!(exception.InnerException is MissingMethodException))
{
if (!(exception.InnerException is MethodAccessException))
{
throw;
}
this.MemberAccessPermissionDenied = true;
}
else
{
this.EnsureElevatedRuntime();
}
}
catch (SecurityException)
{
this.MemberAccessPermissionDenied = true;
}
}
return(this._elevatedRuntime.DeferredSave(context, deferringLoader, value));
}
private object CreateObjectWithTypeConverter(ServiceProviderContext serviceContext,
XamlValueConverter <TypeConverter> ts, object value)
{
TypeConverter typeConverter = GetConverterInstance(ts);
object obj;
if (typeConverter != null)
{
//We sometimes ignoreCanConvert for WPFv3 Compatibility (but only if a string is coming in)
if (_ignoreCanConvert && value.GetType() == typeof(string))
{
obj = typeConverter.ConvertFrom(serviceContext, TypeConverterHelper.InvariantEnglishUS, value);
}
else
{
if (typeConverter.CanConvertFrom(value.GetType()))
{
obj = typeConverter.ConvertFrom(serviceContext, TypeConverterHelper.InvariantEnglishUS, value);
}
else
{
//let the value passthrough (to be set as the property value later).
obj = value;
}
}
}
else
{
//let the value passthrough (to be set as the property value later).
obj = value;
}
return(obj);
}
public void ConstructorNullConverterType()
{
// ok
var c = new XamlValueConverter <TypeConverter> (null, XamlLanguage.Int32);
Assert.IsNull(c.ConverterInstance, "#1");
}
public override object DeferredLoad(ServiceProviderContext serviceContext, XamlValueConverter <XamlDeferringLoader> deferringLoader, XamlReader deferredContent)
{
object obj2;
try
{
XamlDeferringLoader converterInstance = this.GetConverterInstance <XamlDeferringLoader>(deferringLoader);
if (converterInstance == null)
{
throw new XamlObjectWriterException(System.Xaml.SR.Get("DeferringLoaderInstanceNull", new object[] { deferringLoader }));
}
obj2 = converterInstance.Load(deferredContent, serviceContext);
}
catch (Exception exception)
{
IXamlIndexingReader reader = deferredContent as IXamlIndexingReader;
if ((reader != null) && (reader.CurrentIndex >= 0))
{
reader.CurrentIndex = -1;
}
if (!CriticalExceptions.IsCriticalException(exception) && !(exception is XamlException))
{
throw this.CreateException(System.Xaml.SR.Get("DeferredLoad"), exception);
}
throw;
}
return(obj2);
}
public void ConstructorNullTargetType()
{
// ok
var c = new XamlValueConverter <TypeConverter> (typeof(Int32Converter), null);
Assert.IsTrue(c.ConverterInstance is Int32Converter, "#1");
}
public void ConverterTargetMismatch()
{
// ok
var c = new XamlValueConverter <TypeConverter> (typeof(Int32Converter), XamlLanguage.String, null);
Assert.IsTrue(c.ConverterInstance is Int32Converter, "#1");
}
private static XamlDirective GetXamlDirective(string name, XamlType xamlType,
XamlValueConverter <TypeConverter> typeConverter, AllowedMemberLocations allowedLocation)
{
XamlDirective result = new XamlDirective(s_xamlNamespaces, name, xamlType,
typeConverter, allowedLocation);
return(result);
}
public void ObjectType()
{
// This test asserts that XamlLanguage.Object.TypeConverter.ConverterType is null for different reason.
var c = new XamlValueConverter <TypeConverter> (typeof(TypeConverter), XamlLanguage.Object, null);
Assert.IsNotNull(c.ConverterInstance, "#1");
Assert.IsNull(XamlLanguage.Object.TypeConverter.ConverterInstance, "#2");
}
public void InconsistentConverterType()
{
Assert.Throws(typeof(XamlSchemaException), () =>
{
var c = new XamlValueConverter <TypeConverter>(typeof(int), XamlLanguage.String, null);
Assert.IsNull(c.ConverterInstance, "#1");
});
}
protected override sealed XamlValueConverter <TypeConverter> LookupTypeConverter()
{
if (type_converter == null)
{
type_converter = base.LookupTypeConverter();
}
return(type_converter);
}
public XamlDirective(IEnumerable<string> xamlNamespaces, string name, XamlType xamlType, XamlValueConverter<TypeConverter> typeConverter, AllowedMemberLocations allowedLocation) : base(name, new MemberReflector(xamlType, typeConverter))
{
if (xamlType == null)
{
throw new ArgumentNullException("xamlType");
}
this._xamlNamespaces = GetReadOnly(xamlNamespaces);
this._allowedLocation = allowedLocation;
}
internal MemberReflector(XamlType type, XamlValueConverter<System.ComponentModel.TypeConverter> typeConverter)
{
this.Type = type;
this._typeConverter.Value = typeConverter;
this._designerSerializationVisibility = DesignerSerializationVisibility.Visible;
this._memberBits = -65440;
this._deferringLoader.Value = null;
this._getter.Value = null;
this._setter.Value = null;
this._valueSerializer.Value = null;
}
protected internal XamlValueConverter <TConverterBase> GetValueConverter <TConverterBase>(Type converterType, XamlType targetType) where TConverterBase : class
{
object obj2;
ReferenceEqualityTuple <Type, XamlType, Type> key = new ReferenceEqualityTuple <Type, XamlType, Type>(converterType, targetType, typeof(TConverterBase));
if (!this.MasterValueConverterList.TryGetValue(key, out obj2))
{
obj2 = new XamlValueConverter <TConverterBase>(converterType, targetType);
obj2 = TryAdd <ReferenceEqualityTuple <Type, XamlType, Type>, object>(this.MasterValueConverterList, key, obj2);
}
return((XamlValueConverter <TConverterBase>)obj2);
}
public XamlDirective(IEnumerable <string> xamlNamespaces, string name, XamlType xamlType,
XamlValueConverter <TypeConverter> typeConverter, AllowedMemberLocations allowedLocation)
: base(name, new MemberReflector(xamlType, typeConverter))
{
if (xamlType == null)
{
throw new ArgumentNullException(nameof(xamlType));
}
_xamlNamespaces = GetReadOnly(xamlNamespaces);
_allowedLocation = allowedLocation;
}
//CreateFromValue is expected to convert the provided value via any applicable converter (on property or type) or provide the original value if there is no converter
public override object CreateFromValue(
ServiceProviderContext serviceContext,
XamlValueConverter <TypeConverter> ts, object value,
XamlMember property)
{
// check for a few common but special case text reps.
if (ts == BuiltInValueConverter.String || ts == BuiltInValueConverter.Object)
{
return(value);
}
return(CreateObjectWithTypeConverter(serviceContext, ts, value));
}
public AvaloniaXamlIlCompilerConfiguration(IXamlTypeSystem typeSystem,
IXamlAssembly defaultAssembly,
XamlLanguageTypeMappings typeMappings,
XamlXmlnsMappings xmlnsMappings,
XamlValueConverter customValueConverter,
XamlIlClrPropertyInfoEmitter clrPropertyEmitter,
XamlIlPropertyInfoAccessorFactoryEmitter accessorFactoryEmitter)
: base(typeSystem, defaultAssembly, typeMappings, xmlnsMappings, customValueConverter)
{
ClrPropertyEmitter = clrPropertyEmitter;
AccessorFactoryEmitter = accessorFactoryEmitter;
AddExtra(ClrPropertyEmitter);
AddExtra(AccessorFactoryEmitter);
}
public void Equality()
{
// ok
var c1 = new XamlValueConverter <TypeConverter> (null, XamlLanguage.Int32);
var c2 = new XamlValueConverter <TypeConverter> (null, XamlLanguage.Int32);
var c3 = new XamlValueConverter <TypeConverter> (typeof(Int32Converter), XamlLanguage.Int32);
var c4 = new XamlValueConverter <TypeConverter> (typeof(Int32Converter), XamlLanguage.Int32, null);
var c5 = new XamlValueConverter <TypeConverter> (typeof(Int32Converter), XamlLanguage.Int32, "Foo");
Assert.IsTrue(c1 == c2, "#1");
Assert.IsFalse(c1 == c3, "#2");
Assert.IsTrue(c3 == c4, "#3");
Assert.IsFalse(c4 == c5, "#4");
}
public XamlDirective (IEnumerable<string> xamlNamespaces, string name, XamlType xamlType, XamlValueConverter<TypeConverter> typeConverter, AllowedMemberLocations allowedLocation)
: base (true, xamlNamespaces != null ? xamlNamespaces.FirstOrDefault () : null, name)
{
if (xamlNamespaces == null)
throw new ArgumentNullException ("xamlNamespaces");
if (xamlType == null)
throw new ArgumentNullException ("xamlType");
type = xamlType;
xaml_namespaces = new List<string> (xamlNamespaces);
AllowedLocation = allowedLocation;
type_converter = typeConverter;
invoker = new DirectiveMemberInvoker (this);
}
public override TConverterBase GetConverterInstance <TConverterBase>(XamlValueConverter <TConverterBase> ts)
{
Type clrType = ts.ConverterType;
if (clrType == null)
{
return(null);
}
object result;
if (!ConverterInstances.TryGetValue(clrType, out result))
{
result = CreateInstanceWithCtor(clrType, null);
ConverterInstances.Add(clrType, result);
}
return((TConverterBase)result);
}
XamlDirective(IEnumerable <string> xamlNamespaces, string name, XamlType xamlType, XamlValueConverter <TypeConverter> typeConverter, AllowedMemberLocations allowedLocation)
: base(true, xamlNamespaces != null ? xamlNamespaces.FirstOrDefault() : null, name)
{
if (xamlNamespaces == null)
{
throw new ArgumentNullException("xamlNamespaces");
}
if (ReferenceEquals(xamlType, null))
{
throw new ArgumentNullException("xamlType");
}
type = xamlType;
xaml_namespaces = new List <string>(xamlNamespaces);
AllowedLocation = allowedLocation;
type_converter = typeConverter;
}
protected virtual XamlValueConverter <TypeConverter> LookupTypeConverter()
{
if (gotTypeConverter)
{
return(cachedTypeConverter);
}
gotTypeConverter = true;
var t = UnderlyingType;
if (t == null)
{
return(null);
}
// equivalent to TypeExtension.
// FIXME: not sure if it should be specially handled here.
if (t == typeof(Type))
{
t = typeof(TypeExtension);
}
var a = GetCustomAttributeProvider();
var ca = a?.GetCustomAttribute <TypeConverterAttribute>(false);
if (ca != null)
{
return(cachedTypeConverter = SchemaContext.GetValueConverter <TypeConverter> (Type.GetType(ca.ConverterTypeName), this));
}
if (t == typeof(object)) // This is a special case. ConverterType is null.
{
return(cachedTypeConverter = SchemaContext.GetValueConverter <TypeConverter> (null, this));
}
// It's still not decent to check CollectionConverter.
var tct = t.GetTypeConverter()?.GetType();
if (tct != null && tct != typeof(TypeConverter)) //*PCL && tct != typeof (CollectionConverter)) //*PCL && tct != typeof (ReferenceConverter))
{
return(cachedTypeConverter = SchemaContext.GetValueConverter <TypeConverter> (tct, this));
}
return(null);
}
public override TConverterBase GetConverterInstance <TConverterBase>(XamlValueConverter <TConverterBase> ts) where TConverterBase : class
{
object obj2;
this.DemandXamlLoadPermission();
Type converterType = ts.ConverterType;
if (converterType == null)
{
return(default(TConverterBase));
}
if (!this.ConverterInstances.TryGetValue(converterType, out obj2))
{
obj2 = this.CreateInstanceWithCtor(converterType, null);
this.ConverterInstances.Add(converterType, obj2);
}
return((TConverterBase)obj2);
}
protected virtual XamlValueConverter <ValueSerializer> LookupValueSerializer()
{
XamlValueConverter <ValueSerializer> result = null;
if (AreAttributesAvailable)
{
Type converterType = _reflector.GetAttributeType(typeof(ValueSerializerAttribute));
if (converterType != null)
{
result = SchemaContext.GetValueConverter <ValueSerializer>(converterType, null);
}
}
if (result == null && Type != null)
{
result = Type.ValueSerializer;
}
return(result);
}
protected virtual XamlValueConverter <System.ComponentModel.TypeConverter> LookupTypeConverter()
{
XamlValueConverter <System.ComponentModel.TypeConverter> valueConverter = null;
if (this.AreAttributesAvailable)
{
System.Type attributeType = this._reflector.GetAttributeType(typeof(TypeConverterAttribute));
if (attributeType != null)
{
valueConverter = this.SchemaContext.GetValueConverter <System.ComponentModel.TypeConverter>(attributeType, null);
}
}
if ((valueConverter == null) && (this.Type != null))
{
valueConverter = this.Type.TypeConverter;
}
return(valueConverter);
}
protected virtual XamlValueConverter <System.Windows.Markup.ValueSerializer> LookupValueSerializer()
{
XamlValueConverter <System.Windows.Markup.ValueSerializer> valueConverter = null;
if (this.AreAttributesAvailable)
{
System.Type attributeType = this._reflector.GetAttributeType(typeof(ValueSerializerAttribute));
if (attributeType != null)
{
valueConverter = this.SchemaContext.GetValueConverter <System.Windows.Markup.ValueSerializer>(attributeType, null);
}
}
if ((valueConverter == null) && (this.Type != null))
{
valueConverter = this.Type.ValueSerializer;
}
return(valueConverter);
}
//CreateFromValue is expected to convert the provided value via any applicable converter (on property or type) or provide the original value if there is no converter
public override object CreateFromValue(
ServiceProviderContext serviceContext,
XamlValueConverter <TypeConverter> ts, object value,
XamlMember property)
{
if (ts == BuiltInValueConverter.Event)
{
string valueString = value as string;
if (valueString != null)
{
object rootObject;
Type delegateType;
EventConverter.GetRootObjectAndDelegateType(serviceContext, out rootObject, out delegateType);
return(CreateDelegate(delegateType, rootObject, valueString));
}
}
return(base.CreateFromValue(serviceContext, ts, value, property));
}
protected override XamlValueConverter <cm.TypeConverter> LookupTypeConverter()
{
if (gotTypeConverter)
{
return(typeConverter);
}
gotTypeConverter = true;
// convert from Eto.TypeConverter to Portable.Xaml.ComponentModel.TypeConverter
var typeConverterAttrib = GetCustomAttribute <EtoTypeConverterAttribute>();
if (typeConverterAttrib == null &&
UnderlyingType.GetTypeInfo().IsGenericType &&
UnderlyingType.GetTypeInfo().GetGenericTypeDefinition() == typeof(Nullable <>))
{
typeConverterAttrib = Nullable.GetUnderlyingType(UnderlyingType).GetTypeInfo().GetCustomAttribute <EtoTypeConverterAttribute>();
}
if (typeConverterAttrib != null)
{
var converterType = Type.GetType(typeConverterAttrib.ConverterTypeName);
if (converterType != null)
{
typeConverter = new EtoValueConverter(converterType, this);
}
}
if (typeof(MulticastDelegate).GetTypeInfo().IsAssignableFrom(UnderlyingType.GetTypeInfo()))
{
var context = SchemaContext as EtoXamlSchemaContext;
if (context.DesignMode)
{
return(null);
}
}
if (typeConverter == null)
{
typeConverter = base.LookupTypeConverter();
}
return(typeConverter);
}
public override XamlReader DeferredSave(IServiceProvider serviceContext,
XamlValueConverter <XamlDeferringLoader> deferringLoader,
object value)
{
try
{
XamlDeferringLoader converter = GetConverterInstance(deferringLoader);
if (converter == null)
{
throw new XamlObjectWriterException(SR.Get(SRID.DeferringLoaderInstanceNull, deferringLoader));
}
return(converter.Save(value, serviceContext));
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e) || e is XamlException)
{
throw;
}
throw CreateException(SR.Get(SRID.DeferredSave), e);
}
}
internal static XamlValueConverter<ValueSerializer> GetValueSerializer(Type targetType)
{
if (!(typeof(string) == targetType))
{
return null;
}
if (object.ReferenceEquals(s_StringSerializer, null))
{
ValueSerializer stringSerializer = ValueSerializer.GetSerializerFor(typeof(string));
s_StringSerializer = new BuiltInValueConverter<ValueSerializer>(stringSerializer.GetType(), () => stringSerializer);
}
return s_StringSerializer;
}
public void ConstructorNullConverterType ()
{
// ok
var c = new XamlValueConverter<TypeConverter> (null, XamlLanguage.Int32);
Assert.IsNull (c.ConverterInstance, "#1");
}
internal static XamlValueConverter<TypeConverter> GetTypeConverter(Type targetType)
{
if (typeof(string) == targetType)
{
return String;
}
if (typeof(object) == targetType)
{
return Object;
}
if (typeof(int) == targetType)
{
return Int32;
}
if (typeof(short) == targetType)
{
if (object.ReferenceEquals(s_Int16, null))
{
s_Int16 = new BuiltInValueConverter<TypeConverter>(typeof(Int16Converter), () => new Int16Converter());
}
return s_Int16;
}
if (typeof(long) == targetType)
{
if (object.ReferenceEquals(s_Int64, null))
{
s_Int64 = new BuiltInValueConverter<TypeConverter>(typeof(Int64Converter), () => new Int64Converter());
}
return s_Int64;
}
if (typeof(uint) == targetType)
{
if (object.ReferenceEquals(s_UInt32, null))
{
s_UInt32 = new BuiltInValueConverter<TypeConverter>(typeof(UInt32Converter), () => new UInt32Converter());
}
return s_UInt32;
}
if (typeof(ushort) == targetType)
{
if (object.ReferenceEquals(s_UInt16, null))
{
s_UInt16 = new BuiltInValueConverter<TypeConverter>(typeof(UInt16Converter), () => new UInt16Converter());
}
return s_UInt16;
}
if (typeof(ulong) == targetType)
{
if (object.ReferenceEquals(s_UInt64, null))
{
s_UInt64 = new BuiltInValueConverter<TypeConverter>(typeof(UInt64Converter), () => new UInt64Converter());
}
return s_UInt64;
}
if (typeof(bool) == targetType)
{
if (object.ReferenceEquals(s_Boolean, null))
{
s_Boolean = new BuiltInValueConverter<TypeConverter>(typeof(BooleanConverter), () => new BooleanConverter());
}
return s_Boolean;
}
if (typeof(double) == targetType)
{
if (object.ReferenceEquals(s_Double, null))
{
s_Double = new BuiltInValueConverter<TypeConverter>(typeof(DoubleConverter), () => new DoubleConverter());
}
return s_Double;
}
if (typeof(float) == targetType)
{
if (object.ReferenceEquals(s_Single, null))
{
s_Single = new BuiltInValueConverter<TypeConverter>(typeof(SingleConverter), () => new SingleConverter());
}
return s_Single;
}
if (typeof(byte) == targetType)
{
if (object.ReferenceEquals(s_Byte, null))
{
s_Byte = new BuiltInValueConverter<TypeConverter>(typeof(ByteConverter), () => new ByteConverter());
}
return s_Byte;
}
if (typeof(sbyte) == targetType)
{
if (object.ReferenceEquals(s_SByte, null))
{
s_SByte = new BuiltInValueConverter<TypeConverter>(typeof(SByteConverter), () => new SByteConverter());
}
return s_SByte;
}
if (typeof(char) == targetType)
{
if (object.ReferenceEquals(s_Char, null))
{
s_Char = new BuiltInValueConverter<TypeConverter>(typeof(CharConverter), () => new CharConverter());
}
return s_Char;
}
if (typeof(decimal) == targetType)
{
if (object.ReferenceEquals(s_Decimal, null))
{
s_Decimal = new BuiltInValueConverter<TypeConverter>(typeof(DecimalConverter), () => new DecimalConverter());
}
return s_Decimal;
}
if (typeof(TimeSpan) == targetType)
{
if (object.ReferenceEquals(s_TimeSpan, null))
{
s_TimeSpan = new BuiltInValueConverter<TypeConverter>(typeof(TimeSpanConverter), () => new TimeSpanConverter());
}
return s_TimeSpan;
}
if (typeof(Guid) == targetType)
{
if (object.ReferenceEquals(s_Guid, null))
{
s_Guid = new BuiltInValueConverter<TypeConverter>(typeof(GuidConverter), () => new GuidConverter());
}
return s_Guid;
}
if (typeof(Type).IsAssignableFrom(targetType))
{
if (object.ReferenceEquals(s_Type, null))
{
s_Type = new BuiltInValueConverter<TypeConverter>(typeof(TypeTypeConverter), () => new TypeTypeConverter());
}
return s_Type;
}
if (typeof(Type[]).IsAssignableFrom(targetType))
{
if (object.ReferenceEquals(s_TypeList, null))
{
s_TypeList = new BuiltInValueConverter<TypeConverter>(typeof(System.Xaml.Replacements.TypeListConverter), () => new System.Xaml.Replacements.TypeListConverter());
}
return s_TypeList;
}
if (typeof(DateTime) == targetType)
{
if (object.ReferenceEquals(s_DateTime, null))
{
s_DateTime = new BuiltInValueConverter<TypeConverter>(typeof(DateTimeConverter2), () => new DateTimeConverter2());
}
return s_DateTime;
}
if (typeof(DateTimeOffset) == targetType)
{
if (object.ReferenceEquals(s_DateTimeOffset, null))
{
s_DateTimeOffset = new BuiltInValueConverter<TypeConverter>(typeof(DateTimeOffsetConverter2), () => new DateTimeOffsetConverter2());
}
return s_DateTimeOffset;
}
if (typeof(CultureInfo).IsAssignableFrom(targetType))
{
if (object.ReferenceEquals(s_CultureInfo, null))
{
s_CultureInfo = new BuiltInValueConverter<TypeConverter>(typeof(CultureInfoConverter), () => new CultureInfoConverter());
}
return s_CultureInfo;
}
if (!typeof(Delegate).IsAssignableFrom(targetType))
{
return null;
}
if (object.ReferenceEquals(s_Delegate, null))
{
s_Delegate = new BuiltInValueConverter<TypeConverter>(typeof(EventConverter), () => new EventConverter());
}
return s_Delegate;
}
private static XamlDirective GetXamlDirective (string name, XamlType xamlType, XamlValueConverter<TypeConverter> typeConverter, AllowedMemberLocations allowedLocation)
{
return new XamlDirective(s_xamlNamespaces, name, xamlType, typeConverter, allowedLocation);
}
protected override sealed XamlValueConverter<TypeConverter> LookupTypeConverter ()
{
if (type_converter == null)
type_converter = base.LookupTypeConverter ();
return type_converter;
}
private object Logic_CreateFromValue(ObjectWriterContext ctx, XamlValueConverter<TypeConverter> typeConverter, object value, XamlMember property, string targetName, IAddLineInfo lineInfo)
{
object obj3;
try
{
obj3 = this.Runtime.CreateFromValue(ctx.ServiceProviderContext, typeConverter, value, property);
}
catch (Exception exception)
{
if (CriticalExceptions.IsCriticalException(exception))
{
throw;
}
string message = System.Xaml.SR.Get("TypeConverterFailed", new object[] { targetName, value });
throw lineInfo.WithLineInfo(new XamlObjectWriterException(message, exception));
}
return obj3;
}
private object Logic_CreateFromValue(ObjectWriterContext ctx, XamlValueConverter<TypeConverter> typeConverter, object value, XamlMember property, string targetName)
{
return this.Logic_CreateFromValue(ctx, typeConverter, value, property, targetName, this);
}
public void ConverterTargetMismatch ()
{
// ok
var c = new XamlValueConverter<TypeConverter> (typeof (Int32Converter), XamlLanguage.String, null);
Assert.IsTrue (c.ConverterInstance is Int32Converter, "#1");
}
public void InconsistentConverterType ()
{
var c = new XamlValueConverter<TypeConverter> (typeof (int), XamlLanguage.String, null);
Assert.IsNull (c.ConverterInstance, "#1");
}
public void Equality ()
{
// ok
var c1 = new XamlValueConverter<TypeConverter> (null, XamlLanguage.Int32);
var c2 = new XamlValueConverter<TypeConverter> (null, XamlLanguage.Int32);
var c3 = new XamlValueConverter<TypeConverter> (typeof (Int32Converter), XamlLanguage.Int32);
var c4 = new XamlValueConverter<TypeConverter> (typeof (Int32Converter), XamlLanguage.Int32, null);
var c5 = new XamlValueConverter<TypeConverter> (typeof (Int32Converter), XamlLanguage.Int32, "Foo");
Assert.IsTrue (c1 == c2, "#1");
Assert.IsFalse (c1 == c3, "#2");
Assert.IsTrue (c3 == c4, "#3");
Assert.IsFalse (c4 == c5, "#4");
}
public void InconsistentConverterType ()
{
var c = new XamlValueConverter<TypeConverter> (typeof (int), XamlLanguage.String, null);
Assert.Throws<XamlSchemaException> (() => { var t = c.ConverterInstance; }, "#1");
}
public void ConstructorNullTargetType ()
{
// ok
var c = new XamlValueConverter<TypeConverter> (typeof (Int32Converter), null);
Assert.IsTrue (c.ConverterInstance is Int32Converter, "#1");
}
public void ObjectType ()
{
// This test asserts that XamlLanguage.Object.TypeConverter.ConverterType is null for different reason.
var c = new XamlValueConverter<TypeConverter> (typeof (TypeConverter), XamlLanguage.Object, null);
Assert.IsNotNull (c.ConverterInstance, "#1");
Assert.IsNull (XamlLanguage.Object.TypeConverter.ConverterInstance, "#2");
}
