public ConvertFrom ( ITypeDescriptorContext context, |
||
context | ITypeDescriptorContext | |
culture | ||
value | object | |
return | object |
/// <inheritdoc /> public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args) { System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType); if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertFrom(value.GetType())) { try { result = converter.ConvertFrom(null, args.Culture, value); return(true); } catch { } } converter = TypeDescriptor.GetConverter(value.GetType()); if (converter.GetType() != typeof(System.ComponentModel.TypeConverter) && converter.CanConvertTo(destinationType)) { try { result = converter.ConvertTo(null, args.Culture, value, destinationType); return(true); } catch { } } result = null; return(false); }
private static bool InnerConvertObjectToType(object obj, Type type, bool throwOnError, out object convertedObject) { Type originalType = obj.GetType(); OriginalTypeConverter converter = TypeDescriptor.GetConverter(type); if (converter.CanConvertFrom(originalType)) { try { convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, obj); return(true); } catch { if (throwOnError) { throw; } convertedObject = null; return(false); } } if (converter.CanConvertFrom(typeof(string)) && !(obj is DateTime)) { try { string text = TypeDescriptor.GetConverter(originalType).ConvertToInvariantString(obj); convertedObject = converter.ConvertFromInvariantString(text); return(true); } catch { if (throwOnError) { throw; } convertedObject = null; return(false); } } if (type.IsInstanceOfType(obj)) { convertedObject = obj; return(true); } if (throwOnError) { throw new InvalidOperationException(); } convertedObject = null; return(false); }
/// <summary> /// 转换简单类型 /// </summary> /// <param name="value"></param> /// <param name="type"></param> /// <returns></returns> private static object ConvertObj(object value, Type type) { object returnValue; if ((value == null) || type.IsInstanceOfType(value)) { return(value); } string str = value as string; if ((str != null) && (str.Length == 0)) { return(null); } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type); bool flag = converter.CanConvertFrom(value.GetType()); if (!flag) { converter = TypeDescriptor.GetConverter(value.GetType()); } if (!flag && !converter.CanConvertTo(type)) { throw new InvalidOperationException("无法转换成类型:" + value.ToString() + "==>" + type); } try { returnValue = flag ? converter.ConvertFrom(null, null, value) : converter.ConvertTo(null, null, value, type); } catch (Exception e) { throw new InvalidOperationException("类型转换出错:" + value.ToString() + "==>" + type, e); } return(returnValue); }
private object GetValue(DateTime dateTime, Type type, TypeConverter converter) { if (type.IsAssignableFrom(typeof(DateTime))) return dateTime; else return converter.ConvertFrom(dateTime); }
void TypeConverters() { System.ComponentModel.TypeConverter testConverter = System.ComponentModel.TypeDescriptor.GetConverter(typeof(System.Drawing.Color)); System.Drawing.Color result = (System.Drawing.Color)testConverter.ConvertFrom("cyan"); var alt = System.Drawing.Color.FromName("cyan"); Console.WriteLine(result); Console.WriteLine(alt == result); }
private static SqlDbType GetDBType(Type theType) { SqlParameter p1 = new SqlParameter(); System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(p1.DbType); if (tc.CanConvertFrom(theType)) { p1.DbType = (DbType)tc.ConvertFrom(theType.Name); } else { //Try brute force try { p1.DbType = (DbType)tc.ConvertFrom(theType.Name); } catch { } //Do Nothing } return(p1.SqlDbType); }
private void SetValueFromConverter(string newValue, Type targetType, TypeConverter converter) { if (!converter.CanConvertFrom(targetType) && string.IsNullOrEmpty(newValue)) { this.Value = null; } else { this.Value = converter.ConvertFrom(newValue); } }
public static T ConvertType <T>(string value) { if (typeof(T).IsEnum) { return((T)Enum.Parse(typeof(T), value)); } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(typeof(T)); if (converter != null && converter.CanConvertFrom(value.GetType())) { return((T)converter.ConvertFrom(value)); } else { return((T)Convert.ChangeType(value, typeof(T))); } }
//------------------------------------------------------------------------------------------------- public static object ConvertType(string value, Type type) { if (type.IsEnum) { return(Enum.Parse(type, value)); } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertFrom(value.GetType())) { return(converter.ConvertFrom(value)); } else { return(Convert.ChangeType(value, type)); } }
private static object ConvertSimpleType(CultureInfo culture, object value, Type destinationType) { if (value == null || destinationType.IsInstanceOfType(value)) { return(value); } // if this is a user-input value but the user didn't type anything, return no value string valueAsString = value as string; if (valueAsString != null && valueAsString.Trim().Length == 0) { return(null); } //modified by Yang Li //TypeConverter converter = TypeDescriptor.GetConverter(destinationType); System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(destinationType); bool canConvertFrom = converter.CanConvertFrom(value.GetType()); if (!canConvertFrom) { converter = TypeDescriptor.GetConverter(value.GetType()); } if (!(canConvertFrom || converter.CanConvertTo(destinationType))) { string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_NoConverterExists, value.GetType().FullName, destinationType.FullName); throw new InvalidOperationException(message); } try { object convertedValue = (canConvertFrom) ? converter.ConvertFrom(null /* context */, culture, value) : converter.ConvertTo(null /* context */, culture, value, destinationType); return(convertedValue); } catch (Exception ex) { string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_ConversionThrew, value.GetType().FullName, destinationType.FullName); throw new InvalidOperationException(message, ex); } }
/// <summary> /// Converts the given object to the type of this converter, using the specified context and culture information. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"></see> that provides a format context.</param> /// <param name="culture">The <see cref="T:System.Globalization.CultureInfo"></see> to use as the current culture.</param> /// <param name="value">The <see cref="T:System.Object"></see> to convert.</param> /// <returns> /// An <see cref="T:System.Object"></see> that represents the converted value. /// </returns> /// <exception cref="T:System.NotSupportedException">The conversion can not be performed. </exception> public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, CultureInfo culture, object value) { if (value != null && value.GetType() == typeof(string)) { if (parseFormats != null) { return(DateTime.ParseExact((string)value, parseFormats, GetCulture(culture).DateTimeFormat, dateTimeStyles)); } else { return(DateTime.Parse((string)value, GetCulture(culture).DateTimeFormat, dateTimeStyles)); } } else { return(baseTypeConverter.ConvertFrom(context, culture, value)); } }
protected override Resources.PDFImageXObject InitImageXObject(PDFContextBase context, Style style) { Document doc = this.Document; if (null == doc) { throw new NullReferenceException(Errors.ParentDocumentCannotBeNull); } if (null != this.Data) { _xobj = null; if (!string.IsNullOrEmpty(this.ImageKey)) { _xobj = this.Document.GetImageResource(this.ImageKey, this, false); } if (null == _xobj) { string name; if (string.IsNullOrEmpty(this.ImageKey)) { name = "DataImage_" + this.Document.GetIncrementID(PDFObjectTypes.ImageXObject); } else { name = this.ImageKey; } System.ComponentModel.TypeConverter BitmapConverter = TypeDescriptor.GetConverter(typeof(Bitmap)); Bitmap img = (Bitmap)BitmapConverter.ConvertFrom(this.Data.Raw); PDFImageData data = PDFImageData.LoadImageFromBitmap(name, img, this.Compress); _xobj = PDFImageXObject.Load(data, name); this.Document.SharedResources.Add(_xobj); } } return(_xobj); }
public static object ConvertToType(string value, Type type) { if (type == null) { return(null); } System.ComponentModel.TypeConverter conv = System.ComponentModel.TypeDescriptor.GetConverter(type); if (conv.CanConvertFrom(typeof(string))) { try { return(conv.ConvertFrom(value)); } catch { return(null); } } return(null); }
public bool LoadDir(string DirPath, List <string> crFiles, Color Transparency) { List <string> filenames = new List <string>(); foreach (var path in this.EditorData.GraphicsPaths) { var fullPath = DirPath + Path.DirectorySeparatorChar + path; if (Directory.Exists(fullPath)) { filenames.AddRange(Directory.GetFiles(fullPath)); } } foreach (var crFile in crFiles) { foreach (var filename in filenames) { string ext = Path.GetExtension(filename).ToLower(); if (!(ext == ".frm" || ext == ".png")) { continue; } byte[] bytes = File.ReadAllBytes(filename); if (ext == ".frm") { var frm = FalloutFRMLoader.LoadFRM(bytes, Transparency); Frms[filename] = frm; } else { System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Bitmap)); Bitmap bitmap = (Bitmap)tc.ConvertFrom(bytes); Frms[filename] = new FalloutFRM(); Frms[filename].Frames = new List <Bitmap>(); Frms[filename].Frames.Add(bitmap); Frms[filename].FileName = filename.Remove(filename.IndexOf(DirPath), DirPath.Length); } } } return(true); }
object ConvertData (TypeConverter c) { if (mime_type == ResXResourceWriter.ByteArraySerializedObjectMimeType) { if (c.CanConvertFrom (typeof (byte []))) return c.ConvertFrom (Convert.FromBase64String (dataString)); } else if (String.IsNullOrEmpty (mime_type)) { if (c.CanConvertFrom (typeof (string))) return c.ConvertFromInvariantString (dataString); } else throw new Exception ("shouldnt get here, invalid mime type"); throw new TypeLoadException ("No converter for this type found"); }
private static object FormatObjectInternal(object value, System.Type targetType, TypeConverter sourceConverter, TypeConverter targetConverter, string formatString, IFormatProvider formatInfo, object formattedNullValue) { if ((value == DBNull.Value) || (value == null)) { if (formattedNullValue != null) { return formattedNullValue; } if (targetType == stringType) { return string.Empty; } if (targetType == checkStateType) { return CheckState.Indeterminate; } return null; } if (((targetType == stringType) && (value is IFormattable)) && !string.IsNullOrEmpty(formatString)) { return (value as IFormattable).ToString(formatString, formatInfo); } System.Type type = value.GetType(); TypeConverter converter = TypeDescriptor.GetConverter(type); if (((sourceConverter != null) && (sourceConverter != converter)) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } TypeConverter converter2 = TypeDescriptor.GetConverter(targetType); if (((targetConverter != null) && (targetConverter != converter2)) && targetConverter.CanConvertFrom(type)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (targetType == checkStateType) { if (type == booleanType) { return (((bool) value) ? CheckState.Checked : CheckState.Unchecked); } if (sourceConverter == null) { sourceConverter = converter; } if ((sourceConverter != null) && sourceConverter.CanConvertTo(booleanType)) { return (((bool) sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType)) ? CheckState.Checked : CheckState.Unchecked); } } if (targetType.IsAssignableFrom(type)) { return value; } if (sourceConverter == null) { sourceConverter = converter; } if (targetConverter == null) { targetConverter = converter2; } if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if ((targetConverter != null) && targetConverter.CanConvertFrom(type)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (!(value is IConvertible)) { throw new FormatException(GetCantConvertMessage(value, targetType)); } return ChangeType(value, targetType, formatInfo); }
private static object ParseObjectInternal(object value, System.Type targetType, System.Type sourceType, TypeConverter targetConverter, TypeConverter sourceConverter, IFormatProvider formatInfo, object formattedNullValue) { if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || (value == DBNull.Value)) { return DBNull.Value; } TypeConverter converter = TypeDescriptor.GetConverter(targetType); if (((targetConverter != null) && (converter != targetConverter)) && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } TypeConverter converter2 = TypeDescriptor.GetConverter(sourceType); if (((sourceConverter != null) && (converter2 != sourceConverter)) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (value is string) { object obj2 = InvokeStringParseMethod(value, targetType, formatInfo); if (obj2 != parseMethodNotFound) { return obj2; } } else if (value is CheckState) { CheckState state = (CheckState) value; if (state == CheckState.Indeterminate) { return DBNull.Value; } if (targetType == booleanType) { return (state == CheckState.Checked); } if (targetConverter == null) { targetConverter = converter; } if ((targetConverter != null) && targetConverter.CanConvertFrom(booleanType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked); } } else if ((value != null) && targetType.IsAssignableFrom(value.GetType())) { return value; } if (targetConverter == null) { targetConverter = converter; } if (sourceConverter == null) { sourceConverter = converter2; } if ((targetConverter != null) && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if ((sourceConverter != null) && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (!(value is IConvertible)) { throw new FormatException(GetCantConvertMessage(value, targetType)); } return ChangeType(value, targetType, formatInfo); }
/// <summary> /// ��ȡ"Value"�ڵ� /// �������ԣ��������ĵ��е�����ֵ�������͵�ת����ת��Ϊ��ǰ���Ե�ֵ���� /// </summary> /// <param name="node">���ڵ�</param> /// <param name="converter">���͵�ת����</param> /// <param name="value">����</param> /// <returns>��ֵ�Ƿ��ܹ���ת������Ҫ������</returns> private bool ReadValue(XmlNode node, TypeConverter converter, ref object value) { try { foreach (XmlNode child in node.ChildNodes) { //XmlNodeTypeö��ָ���ڵ�����͡�.Text:�ڵ���ı����ݡ�Text �ڵ㲻�ܾ����κ��ӽڵ㡣 if (child.NodeType == XmlNodeType.Text) { value = converter.ConvertFromInvariantString(node.InnerText); return true; } else if (child.NodeType == XmlNodeType.Element) {//������Ϣ�ڵ����ô˲��ֶ�ȡ����ӿ���Ϣ20090616 List<string> tempIO = new List<string>(); for (int i = 0; i < node.ChildNodes.Count; i++) { tempIO.Add(node.ChildNodes[i].Attributes["name"].Value); } value = String.Join(",", tempIO.ToArray()); return true; } else if (child.Name.Equals("Binary")) { byte[] data = Convert.FromBase64String(child.InnerText); if (GetConversionSupported(converter, typeof(byte[]))) { value = converter.ConvertFrom(data); return true; } else { BinaryFormatter formatter = new BinaryFormatter(); MemoryStream stream = new MemoryStream(data); value = formatter.Deserialize(stream); return true; } } else { value = null; return false; } } return true; } catch (Exception ex) { value = null; return false; } }
protected virtual object GetFormattedValue (object value, int rowIndex, ref DataGridViewCellStyle cellStyle, TypeConverter valueTypeConverter, TypeConverter formattedValueTypeConverter, DataGridViewDataErrorContexts context) { if (DataGridView == null) return null; if (rowIndex < 0 || rowIndex >= DataGridView.RowCount) throw new ArgumentOutOfRangeException ("rowIndex"); // Give the user a chance to custom format if (!(this is DataGridViewRowHeaderCell)) { DataGridViewCellFormattingEventArgs e = new DataGridViewCellFormattingEventArgs (ColumnIndex, rowIndex, value, FormattedValueType, cellStyle); DataGridView.OnCellFormattingInternal (e); if (e.FormattingApplied) return e.Value; cellStyle = e.CellStyle; value = e.Value; } if (value == null || (cellStyle != null && value == cellStyle.DataSourceNullValue)) { if (FormattedValueType == typeof (string)) return String.Empty; } if (FormattedValueType == typeof(string) && value is IFormattable && !String.IsNullOrEmpty (cellStyle.Format)) return ((IFormattable) value).ToString (cellStyle.Format, cellStyle.FormatProvider); if (value != null && FormattedValueType.IsAssignableFrom (value.GetType())) return value; if (formattedValueTypeConverter == null) formattedValueTypeConverter = FormattedValueTypeConverter; if (valueTypeConverter == null) valueTypeConverter = ValueTypeConverter; if (valueTypeConverter != null && valueTypeConverter.CanConvertTo (FormattedValueType)) return valueTypeConverter.ConvertTo (value, FormattedValueType); if (formattedValueTypeConverter != null && formattedValueTypeConverter.CanConvertFrom (ValueType)) return formattedValueTypeConverter.ConvertFrom (value); return Convert.ChangeType (value, FormattedValueType); }
protected virtual void SetHighlightValue(FrameworkElement ctrl, DependencyProperty dpProp, Highlight h, HighlightConverter converter, TypeConverter finalConverter) { if (converter == null) throw new ArgumentNullException("converter"); if (finalConverter == null) throw new ArgumentNullException("finalConverter"); var value = converter.Convert(h, null, null, null); if (value == Binding.DoNothing) ctrl.SetValue(dpProp, DependencyProperty.UnsetValue); else if (value == null) ctrl.SetValue(dpProp, null); else if (dpProp.PropertyType.IsAssignableFrom(value.GetType())) ctrl.SetValue(dpProp, value); else ctrl.SetValue(dpProp, finalConverter.ConvertFrom(value)); }
/// <devdoc> /// /// Converts a value into a format suitable for display to the end user. /// /// - Converts DBNull or null into a suitable formatted representation of 'null' /// - Performs some special-case conversions (eg. Boolean to CheckState) /// - Uses TypeConverters or IConvertible where appropriate /// - Throws a FormatException is no suitable conversion can be found /// /// </devdoc> private static object FormatObjectInternal(object value, Type targetType, TypeConverter sourceConverter, TypeConverter targetConverter, string formatString, IFormatProvider formatInfo, object formattedNullValue) { if (value == System.DBNull.Value || value == null) { // // Convert DBNull to the formatted representation of 'null' (if possible) // if (formattedNullValue != null) { return formattedNullValue; } // // Convert DBNull or null to a specific 'known' representation of null (otherwise fail) // if (targetType == stringType) { return String.Empty; } if (targetType == checkStateType) { return CheckState.Indeterminate; } // Just pass null through: if this is a value type, it's been unwrapped here, so we return null // and the caller has to wrap if appropriate. return null; } // // Special case conversions // if (targetType == stringType) { if (value is IFormattable && !String.IsNullOrEmpty(formatString)) { return (value as IFormattable).ToString(formatString, formatInfo); } } //The converters for properties should take precedence. Unfortunately, we don't know whether we have one. Check vs. the //type's TypeConverter. We're punting the case where the property-provided converter is the same as the type's converter. Type sourceType = value.GetType(); TypeConverter sourceTypeTypeConverter = TypeDescriptor.GetConverter(sourceType); if (sourceConverter != null && sourceConverter != sourceTypeTypeConverter && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType); if (targetConverter != null && targetConverter != targetTypeTypeConverter && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } if (targetType == checkStateType) { if (sourceType == booleanType) { return ((bool)value) ? CheckState.Checked : CheckState.Unchecked; } else { if (sourceConverter == null) { sourceConverter = sourceTypeTypeConverter; } if (sourceConverter != null && sourceConverter.CanConvertTo(booleanType)) { return (bool)sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, booleanType) ? CheckState.Checked : CheckState.Unchecked; } } } if (targetType.IsAssignableFrom(sourceType)) { return value; } // // If explicit type converters not provided, supply default ones instead // if (sourceConverter == null) { sourceConverter = sourceTypeTypeConverter; } if (targetConverter == null) { targetConverter = targetTypeTypeConverter; } // // Standardized conversions // if (sourceConverter != null && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } else if (targetConverter != null && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } else if (value is IConvertible) { return ChangeType(value, targetType, formatInfo); } // // Fail if no suitable conversion found // throw new FormatException(GetCantConvertMessage(value, targetType)); }
private object ConvertType(FieldMap fm, object val) { Check.VerifyNotNull(fm, Error.NullParameter, "fm"); // convert DBNull to system null if (val != null && val.Equals(DBNull.Value)) { val = null; } // perform null handling (NullValue translation) if (val == null && !fm.IsNullAssignable) { Check.Verify(fm.NullValue != null, Error.NullWithNoNullValue, fm.ColumnName, fm.Type); return(fm.NullValue); } else { if (val != null) { Type type = val.GetType(); // trim strings.. otherwise char columns are as wide as their size if (fm.Type == typeof(string) || fm.Type == typeof(Guid)) { if (fm.Type == typeof(Guid)) { if (fm.Size == 16) // binary compressed version { val = Common.TypeConverter.ToGuid((string)val); } else { val = new Guid(val.ToString()); } } else { string strval = (string)val; // size is 0 for variable width columns // assume we should trim all fixed-width columns val = fm.Size > 0 ? strval.TrimEnd() : strval; } } else if (fm.Type == typeof(bool) && type != typeof(bool)) { // if property is boolean but database uses integers we need to convert // the type before updating it val = Convert.ToBoolean(val); } else if (fm.Type.IsEnum && !type.IsEnum) { // check whether enum should be stored as string or numeric value // TODO we should check if enum requires 64-bit conversion // val = fm.HandleEnumAsString ? Enum.Parse( fm.Type, Convert.ToString( val ), true ) : Enum.ToObject( fm.Type, Convert.ToInt32( val ) ); val = Common.TypeConverter.Get(fm.Type, val); } else if (fm.Type == typeof(decimal) && type != typeof(decimal)) { val = Convert.ToDecimal(val, NumberFormatInfo.InvariantInfo); } else if (fm.Type != type) { TypeConverter typeConv = TypeDescriptor.GetConverter(fm.Type); if (typeConv != null && typeConv.CanConvertFrom(type)) { val = typeConv.ConvertFrom(val); } else { // check for the existence of a TypeConverterAttribute for the field/property object[] attrs = fm.MemberInfo.GetCustomAttributes(typeof(TypeConverterAttribute), false); if (attrs.Length == 1) { TypeConverterAttribute tca = (TypeConverterAttribute)attrs[0]; TypeConverter typeConverter = (TypeConverter) Activator.CreateInstance(Type.GetType(tca.ConverterTypeName)); if (typeConverter != null && typeConverter.CanConvertFrom(val.GetType())) { val = typeConverter.ConvertFrom(val); } else { val = Convert.ChangeType(val, fm.Type); } } else { val = Convert.ChangeType(val, fm.Type); } } } } else { // allow NullValue conversion for null strings if (fm.Type == typeof(string) && fm.NullValue != null) { val = fm.NullValue; } } return(val); } }
protected override object Read (byte token, BinaryReader r, ReaderContext ctx) { Type t = (Type) ObjectFormatter.ReadObject (r, ctx); converter = TypeDescriptor.GetConverter (t); token = r.ReadByte (); string v = (string) base.Read (token, r, ctx); return converter.ConvertFrom (null, Helpers.InvariantCulture, v); }
public static object ChangeType(object value, Type destinationType, CultureInfo culture) { if (value == null || value.IsDbNull()) { return((!destinationType.IsValueType()) ? null : Activator.CreateInstance(destinationType)); } Type type = value.GetType(); if (destinationType == type || destinationType.IsAssignableFrom(type)) { return(value); } if (destinationType.IsGenericType()) { Type genericTypeDefinition = destinationType.GetGenericTypeDefinition(); if (genericTypeDefinition == typeof(Nullable <>)) { Type destinationType2 = destinationType.GetGenericArguments()[0]; object obj = ChangeType(value, destinationType2, culture); return(Activator.CreateInstance(destinationType, obj)); } } if (destinationType.IsEnum()) { string text = value as string; return((text == null) ? value : Enum.Parse(destinationType, text, true)); } if (destinationType == typeof(bool)) { if ("0".Equals(value)) { return(false); } if ("1".Equals(value)) { return(true); } } System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertTo(destinationType)) { return(converter.ConvertTo(null, culture, value, destinationType)); } System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType); if (converter2 != null && converter2.CanConvertFrom(type)) { return(converter2.ConvertFrom(null, culture, value)); } Type[] array = new Type[2] { type, destinationType }; foreach (Type type2 in array) { foreach (MethodInfo publicStaticMethod2 in type2.GetPublicStaticMethods()) { if (publicStaticMethod2.IsSpecialName && (publicStaticMethod2.Name == "op_Implicit" || publicStaticMethod2.Name == "op_Explicit") && destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType)) { ParameterInfo[] parameters = publicStaticMethod2.GetParameters(); if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type)) { try { return(publicStaticMethod2.Invoke(null, new object[1] { value })); } catch (TargetInvocationException ex) { throw ex.Unwrap(); } } } } } if (type == typeof(string)) { try { MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider)); if (publicStaticMethod != null) { return(publicStaticMethod.Invoke(null, new object[2] { value, culture })); } publicStaticMethod = ReflectionExtensions.GetPublicStaticMethod(destinationType, "Parse", typeof(string)); if (publicStaticMethod != null) { return(publicStaticMethod.Invoke(null, new object[1] { value })); } } catch (TargetInvocationException ex2) { throw ex2.Unwrap(); } } if (destinationType == typeof(TimeSpan)) { return(TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture))); } return(Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture)); }
private static bool TryConvertTo( object value, Type targetType, CultureInfo culture, TypeConverter converter, out object result ) { if( converter != null ) { try { result = converter.ConvertTo( null, culture, value, targetType ); return true; } catch { // We'll try to convert the value another way. } if( ( value != null ) && ( converter.CanConvertFrom( value.GetType() ) ) ) { try { var newValue = converter.ConvertFrom( null, culture, value ); result = converter.ConvertTo( null, culture, newValue, targetType ); return true; } catch { } } } result = null; return false; }
/// <summary> /// Convert the object value using a specified TypeConveter, circumventing the Type's TypeConverter /// </summary> /// <param name="value">The original object to convert from</param> /// <param name="tc">The type converter that will be used</param> /// <returns></returns> public static object ConvertValueToTargetType(object value, System.ComponentModel.TypeConverter tc) { //System.ComponentModel.TypeConverter tc = TypeDescriptor.GetConverter(t); return(tc.ConvertFrom(value)); }
/// Generic function to read an object value. Returns true if the read /// succeeded. private bool ReadValue(XmlNode node, TypeConverter converter, ArrayList errors, out object value) { try { foreach (XmlNode child in node.ChildNodes) { if (child.NodeType == XmlNodeType.Text) { value = converter.ConvertFromInvariantString(node.InnerText); return true; } else if (child.Name.Equals("Binary")) { byte[] data = Convert.FromBase64String(child.InnerText); // Binary blob. Now, check to see if the type converter // can convert it. If not, use serialization. // if (GetConversionSupported(converter, typeof(byte[]))) { value = converter.ConvertFrom(null, CultureInfo.InvariantCulture, data); return true; } else { BinaryFormatter formatter = new BinaryFormatter(); MemoryStream stream = new MemoryStream(data); value = formatter.Deserialize(stream); return true; } } else if (child.Name.Equals("InstanceDescriptor")) { value = ReadInstanceDescriptor(child, errors); return (value != null); } else { errors.Add(string.Format("Unexpected element type {0}", child.Name)); value = null; return false; } } // If we get here, it is because there were no nodes. No nodes and no inner // text is how we signify null. // value = null; return true; } catch (Exception ex) { errors.Add(ex.Message); value = null; return false; } }
/// <summary> /// Creates a new instance of the ConfigurationProperty class. /// </summary> /// <param name="name">The name of the xml entity.</param> /// <param name="type">The type of the xml entity.</param> /// <param name="defaultValue">The default value of the xml entity.</param> /// <param name="converter">The type of the converter to apply.</param> /// <param name="validation">The validator to use.</param> /// <param name="flags">One of the APXmlPropertyOptions enumeration values.</param> /// <param name="description">The description of the xml entity.</param> public APXmlProperty(string name, Type type, object defaultValue, TypeConverter converter, APValidatorBase validation, APXmlPropertyOptions flags, string description) { _name = name; _converter = converter != null ? converter : TypeDescriptor.GetConverter(type); if (defaultValue != null) { if (defaultValue == NoDefaultValue) { switch (Type.GetTypeCode(type)) { case TypeCode.Object: defaultValue = null; break; case TypeCode.String: defaultValue = String.Empty; break; default: defaultValue = Activator.CreateInstance(type); break; } } else { if (!type.IsAssignableFrom(defaultValue.GetType())) { if (!_converter.CanConvertFrom(defaultValue.GetType())) throw new APXmlException(APResource.GetString(APResource.APXml_DefaultValueTypeError, name, type, defaultValue.GetType())); defaultValue = _converter.ConvertFrom(defaultValue); } } } _defaultValue = defaultValue; _flags = flags; _type = type; _validation = validation != null ? validation : new DefaultAPValidator(); _description = description; }
/// <devdoc> /// /// Converts a value entered by the end user (through UI) into the corresponding binary value. /// /// - Converts formatted representations of 'null' into DBNull /// - Performs some special-case conversions (eg. CheckState to Boolean) /// - Uses TypeConverters or IConvertible where appropriate /// - Throws a FormatException is no suitable conversion can be found /// /// </devdoc> private static object ParseObjectInternal(object value, Type targetType, Type sourceType, TypeConverter targetConverter, TypeConverter sourceConverter, IFormatProvider formatInfo, object formattedNullValue) { // // Convert the formatted representation of 'null' to DBNull (if possible) // if (EqualsFormattedNullValue(value, formattedNullValue, formatInfo) || value == System.DBNull.Value) { return System.DBNull.Value; } // // Special case conversions // TypeConverter targetTypeTypeConverter = TypeDescriptor.GetConverter(targetType); if (targetConverter != null && targetTypeTypeConverter != targetConverter && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } TypeConverter sourceTypeTypeConverter = TypeDescriptor.GetConverter(sourceType); if (sourceConverter != null && sourceTypeTypeConverter != sourceConverter && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } if (value is string) { // If target type has a suitable Parse method, use that to parse strings object parseResult = InvokeStringParseMethod(value, targetType, formatInfo); if (parseResult != parseMethodNotFound) { return parseResult; } } else if (value is CheckState) { CheckState state = (CheckState)value; if (state == CheckState.Indeterminate) { return DBNull.Value; } // Explicit conversion from CheckState to Boolean if (targetType == booleanType) { return (state == CheckState.Checked); } if (targetConverter == null) { targetConverter = targetTypeTypeConverter; } if (targetConverter != null && targetConverter.CanConvertFrom(booleanType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), state == CheckState.Checked); } } else if (value != null && targetType.IsAssignableFrom(value.GetType())) { // If value is already of a compatible type, just go ahead and use it return value; } // // If explicit type converters not provided, supply default ones instead // if (targetConverter == null) { targetConverter = targetTypeTypeConverter; } if (sourceConverter == null) { sourceConverter = sourceTypeTypeConverter; } // // Standardized conversions // if (targetConverter != null && targetConverter.CanConvertFrom(sourceType)) { return targetConverter.ConvertFrom(null, GetFormatterCulture(formatInfo), value); } else if (sourceConverter != null && sourceConverter.CanConvertTo(targetType)) { return sourceConverter.ConvertTo(null, GetFormatterCulture(formatInfo), value, targetType); } else if (value is IConvertible) { return ChangeType(value, targetType, formatInfo); } // // Fail if no suitable conversion found // throw new FormatException(GetCantConvertMessage(value, targetType)); }
public static bool Convert(object val, Type targetType, out object result) { result = val; // Trivial cases if (val == null) { // Cannot convert null to value type return(!targetType.IsValueType); } if (targetType.IsAssignableFrom(val.GetType())) { return(true); } // Custom type conversions if (_customTypeConverter != null) { if (_customTypeConverter(val, targetType, out result)) { return(true); } } // TODO: typeof(Nullable<T>) // Built-in type conversions if (val.GetType() == typeof(string) && targetType == typeof(Type)) { // string -> Type result = Type.GetType(val.ToString()); return(result != null); } // Enumerations if (val.GetType() == typeof(string) && targetType.IsEnum) { // string -> Enum result = Enum.Parse(targetType, (string)val); return(true); } // String target type must be done before enumerations are tried - else, the string will be treated as enumeration if (targetType.IsAssignableFrom(typeof(string))) { // * -> string result = val.ToString(); return(true); } // Collection types Type enumerableType; Type entryType; ReflectionHelper.FindImplementedEnumerableType(targetType, out enumerableType, out entryType); if (enumerableType != null) // Targets IList, ICollection, IList<>, ICollection<> { ICollection col; if (!ToCollection(val, entryType, out col)) { return(false); } List <object> resultList = col.Cast <object>().ToList(); result = resultList; return(true); } ICollection sourceCol = val as ICollection; if (sourceCol != null && sourceCol.Count == 1) // From collection to non-collection target { // Use the first (single) item of a collection or dictionary IEnumerator enumerator = sourceCol.GetEnumerator(); enumerator.MoveNext(); object item = enumerator.Current; if (Convert(item, targetType, out result)) // Single collection item { return(true); } KeyValuePair <object, object>?kvp = item as KeyValuePair <object, object>?; if (kvp.HasValue && Convert(kvp.Value.Value, targetType, out result)) // Value of single dictionary entry - generic dictionary { IDisposable d = kvp.Value.Key as IDisposable; if (d != null) { d.Dispose(); } return(true); } DictionaryEntry?entry = item as DictionaryEntry?; if (entry.HasValue && Convert(entry.Value.Value, targetType, out result)) // Value of single dictionary entry - legacy dictionary { IDisposable d = entry.Value.Key as IDisposable; if (d != null) { d.Dispose(); } return(true); } } // Simple type conversions System.ComponentModel.TypeConverter tc = TypeDescriptor.GetConverter(targetType); if (tc != null && tc.CanConvertFrom(val.GetType())) { try { result = tc.ConvertFrom(null, CultureInfo.InvariantCulture, val); return(true); } catch { } } tc = TypeDescriptor.GetConverter(val); if (tc != null && tc.CanConvertTo(targetType)) { result = tc.ConvertTo(val, targetType); return(true); } return(false); }
public override object ConvertFrom(cm.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { return(etoConverter.ConvertFrom(null, culture, value)); }
public bool LoadZip(string ZipPath, List <string> crFiles, Color Transparency) { if (!File.Exists(ZipPath)) { MessageBox.Show("Unable to load " + ZipPath + ", doesn't exist.", "Mapper", MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } var zip = ZipStorer.Open(ZipPath, FileAccess.Read); if (zip == null) { MessageBox.Show("Unable to load " + ZipPath + ".", "Mapper", MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } var patternToCheck = new List <string>(); foreach (var cr in crFiles) { patternToCheck.Add(cr); } foreach (var path in this.EditorData.GraphicsPaths) { patternToCheck.Add(path); } var filesToLoad = new List <ZipStorer.ZipFileEntry>(); var entries = zip.ReadCentralDir(); foreach (var entry in entries) { foreach (var path in patternToCheck) { if (!entry.FilenameInZip.Replace('/', '\\').Contains(path)) { continue; } if (entry.CompressedSize == 0) { continue; } string filename = entry.FilenameInZip.ToLower().Replace('/', '\\'); string ext = Path.GetExtension(filename).ToLower(); if (!(ext == ".frm" || ext == ".png")) { continue; } filesToLoad.Add(entry); } } this.BeginInvoke((MethodInvoker) delegate { frmLoading.SetNextFile(Path.GetFileName(ZipPath)); frmLoading.SetResourceNum(filesToLoad.Count); }); foreach (var entry in filesToLoad) { string filename = entry.FilenameInZip.ToLower().Replace('/', '\\'); string ext = Path.GetExtension(filename).ToLower(); this.BeginInvoke((MethodInvoker) delegate { frmLoading.SetNextResource(filename); }); byte[] bytes; using (MemoryStream stream = new MemoryStream()) { zip.ExtractFile(entry, stream); bytes = stream.ToArray(); } if (ext == ".frm") { var frm = FalloutFRMLoader.LoadFRM(bytes, Transparency); Frms[filename] = frm; } else { System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Bitmap)); Bitmap bitmap = (Bitmap)tc.ConvertFrom(bytes); Frms[filename] = new FalloutFRM(); Frms[filename].Frames = new List <Bitmap>(); Frms[filename].Frames.Add(bitmap); Frms[filename].FileName = entry.FilenameInZip; } } return(true); }
public void CheckConversion(object check, object expect, TypeConverter conv, Type type, bool test_from, bool test_to, CultureInfo culture) { object obj; object result; obj = check; if (debug > 0) { Console.WriteLine("{0}: CheckConversion, checking {1}({2}) <-> {3}({4})", conv.ToString(), check.GetType().ToString(), check.ToString(), type.ToString(), expect != null ? expect.ToString() : "null"); } if (test_to) { obj = conv.ConvertTo(null, culture, check, type); if (obj == null) { if (expect != null) { failed++; Console.WriteLine("{0}: ConvertTo failed, type {1}, expected {2}, got null", conv.ToString(), type.ToString(), expect.ToString()); } return; } // Intermediate verification if (expect != null && !obj.Equals(expect)) { failed++; if (verbose > 0) { Console.WriteLine("{0}: ConvertTo failed, type {1}, expected {2}, got {3}", conv.ToString(), type.ToString(), expect.ToString(), obj.ToString()); } } if (debug > 1) { Console.WriteLine("{0}: CheckConversion, ConvertTo result: '{1}')", conv.ToString(), obj); } } if (test_from) { result = conv.ConvertFrom(null, culture, obj); if (test_to) { // Roundtrip check if (!check.Equals(result)) { failed++; if (verbose > 0) { Console.WriteLine("{0}: ConvertTo/ConvertFrom roundtrip failed, type {1}", conv.ToString(), type.ToString()); } } } else { if (!expect.Equals(result)) { failed++; if (verbose > 0) { Console.WriteLine("{0}: ConvertFrom failed, type {1}", conv.ToString(), type.ToString()); } } } if (debug > 1) { Console.WriteLine("{0}: CheckConversion, ConvertFrom result: '{1}')", conv.ToString(), result); } } }
private static bool ConvertObjectToTypeInternal(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject) { IDictionary<string, object> dictionary = o as IDictionary<string, object>; if (dictionary != null) { return ConvertDictionaryToObject(dictionary, type, serializer, throwOnError, out convertedObject); } IList list = o as IList; if (list != null) { IList list2; if (ConvertListToObject(list, type, serializer, throwOnError, out list2)) { convertedObject = list2; return true; } convertedObject = null; return false; } if ((type == null) || (o.GetType() == type)) { convertedObject = o; return true; } //TypeDescriptor.GetConverter(type) !!! TypeConverter converter = new TypeConverter(); if (converter.CanConvertFrom(o.GetType())) { try { convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, o); return true; } catch { if (throwOnError) { throw; } convertedObject = null; return false; } } if (converter.CanConvertFrom(typeof(string))) { try { string str; if (o is DateTime) { DateTime time = (DateTime)o; str = time.ToUniversalTime().ToString("u", CultureInfo.InvariantCulture); } else { //ConvertToInvariantString(o); !!! str = converter.ConvertToString(o); } //ConvertFromInvariantString(str); !!! convertedObject = converter.ConvertToString(str); return true; } catch { if (throwOnError) { throw; } convertedObject = null; return false; } } if (type.IsAssignableFrom(o.GetType())) { convertedObject = o; return true; } if (throwOnError) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotConvertObjectToType, new object[] { o.GetType(), type })); } convertedObject = null; return false; }
public virtual object ParseFormattedValue (object formattedValue, DataGridViewCellStyle cellStyle, TypeConverter formattedValueTypeConverter, TypeConverter valueTypeConverter) { if (cellStyle == null) throw new ArgumentNullException ("cellStyle is null."); if (FormattedValueType == null) throw new FormatException ("The System.Windows.Forms.DataGridViewCell.FormattedValueType property value is null."); if (formattedValue == null) throw new ArgumentException ("formattedValue is null."); if (ValueType == null) throw new FormatException ("valuetype is null"); if (!FormattedValueType.IsAssignableFrom (formattedValue.GetType ())) throw new ArgumentException ("formattedValue is not of formattedValueType."); if (formattedValueTypeConverter == null) formattedValueTypeConverter = FormattedValueTypeConverter; if (valueTypeConverter == null) valueTypeConverter = ValueTypeConverter; if (valueTypeConverter != null && valueTypeConverter.CanConvertFrom (FormattedValueType)) return valueTypeConverter.ConvertFrom (formattedValue); if (formattedValueTypeConverter != null && formattedValueTypeConverter.CanConvertTo (ValueType)) return formattedValueTypeConverter.ConvertTo (formattedValue, ValueType); return Convert.ChangeType (formattedValue, ValueType); }
/// <summary> /// ��ȡ"Value"�ڵ� /// �������ԣ��������ĵ��е�����ֵ�������͵�ת����ת��Ϊ��ǰ���Ե�ֵ���� /// </summary> /// <param name="node">���ڵ�</param> /// <param name="converter">���͵�ת����</param> /// <param name="errors">�����ڼ������Ĵ�������еĻ����ļ���</param> /// <param name="value">����</param> /// <returns>��ֵ�Ƿ��ܹ���ת������Ҫ������</returns> private bool ReadValue(XmlNode node, TypeConverter converter, ArrayList errors, ref object value) { try { foreach (XmlNode child in node.ChildNodes) { //XmlNodeTypeö��ָ���ڵ�����͡�.Text:�ڵ���ı����ݡ�Text �ڵ㲻�ܾ����κ��ӽڵ㡣 if (child.NodeType == XmlNodeType.Text) { value = converter.ConvertFromInvariantString(node.InnerText); return true; } else if (child.Name.Equals("Binary")) { byte[] data = Convert.FromBase64String(child.InnerText); if (GetConversionSupported(converter, typeof(byte[]))) { value = converter.ConvertFrom(data); return true; } else { BinaryFormatter formatter = new BinaryFormatter(); MemoryStream stream = new MemoryStream(data); value = formatter.Deserialize(stream); return true; } } else { errors.Add(string.Format("��������{0}", child.Name)); value = null; return false; } } return true; } catch (Exception ex) { errors.Add(ex.Message); value = null; return false; } }
public static object ChangeType(Type t, object value) { System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(t); return(tc.ConvertFrom(value)); }
public bool LoadDat(string DatPath, List <string> crFiles, Color Transparency) { DatReaderError status; DAT loadedDat = DATReader.ReadDat(DatPath, out status); if (status.Error != DatError.Success) { MessageBox.Show("Error loading " + DatPath + ": " + Environment.NewLine + status.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Error); return(false); } List <DATFile> files = new List <DATFile>(); foreach (string path in this.EditorData.GraphicsPaths) { files.AddRange(loadedDat.GetFilesByPattern(path)); // Critters to load foreach (var crType in critterData.crTypeGraphic.Values) { var file = loadedDat.GetFileByName("art\\critters\\" + crType.ToUpper() + "AA.FRM"); // Idle anim if (file == null) { file = loadedDat.GetFileByName("art\\critters\\" + crType.ToLower() + "aa.frm"); } if (file == null) { continue; } files.Add(file); } } this.BeginInvoke((MethodInvoker) delegate { frmLoading.SetNextFile(Path.GetFileName(DatPath)); frmLoading.SetResourceNum(files.Count); }); foreach (DATFile file in files) { this.BeginInvoke((MethodInvoker) delegate { frmLoading.SetNextResource(file.FileName); }); string ext = Path.GetExtension(file.FileName).ToLower(); if (!(ext == ".frm" || ext == ".png")) { continue; } byte[] data = file.GetData(); if (data == null) { WriteLog("Error opening " + file.FileName + ": " + file.ErrorMsg); continue; } if (ext == ".frm") { var frm = FalloutFRMLoader.LoadFRM(data, Transparency); frm.FileName = file.Path.ToLower(); Frms[frm.FileName] = frm; } else { System.ComponentModel.TypeConverter tc = System.ComponentModel.TypeDescriptor.GetConverter(typeof(Bitmap)); Bitmap bitmap = (Bitmap)tc.ConvertFrom(data); } } loadedDat.Close(); return(true); }
private bool ReadValue(XmlNode node, TypeConverter converter, ArrayList errors, out object value) { try { foreach (XmlNode child in node.ChildNodes) { if (child.NodeType == XmlNodeType.Text) { value = converter.ConvertFromInvariantString(node.InnerText); return true; } if (child.Name.Equals("Binary")) { byte[] data = Convert.FromBase64String(child.InnerText); if (this.GetConversionSupported(converter, typeof(byte[]))) { value = converter.ConvertFrom(null, CultureInfo.InvariantCulture, data); return true; } BinaryFormatter formatter = new BinaryFormatter(); MemoryStream stream = new MemoryStream(data); value = formatter.Deserialize(stream); return true; } if (child.Name.Equals("InstanceDescriptor")) { value = this.ReadInstanceDescriptor(child, errors); return (value != null); } errors.Add(string.Format("Unexpected element type {0}", child.Name)); value = null; return false; } value = null; return true; } catch (Exception ex) { errors.Add(ex.Message); value = null; return false; } }
/// <summary> /// Converts the given object to the type of this converter, using the specified /// context and culture information. /// </summary> /// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param> /// <param name="culture">The System.Globalization.CultureInfo to use as the current culture.</param> /// <param name="value">The System.Object to convert.</param> /// <returns>An System.Object that represents the converted value.</returns> public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { TypeConverter converter = TypeDescriptor.GetConverter(typeof(double)); return(converter.ConvertFrom(context, culture, value)); }