internal DataNodeInfo GetDataNodeInfo()
{
bool shouldSerialize = true;
if (nodeInfo != null)
{
shouldSerialize = false;
}
else
{
nodeInfo = new DataNodeInfo();
}
nodeInfo.Name = Name;
nodeInfo.Comment = Comment;
// We always serialize if this node represents a FileRef. This is because FileRef is a public property,
// so someone could have modified it.
if (shouldSerialize || FileRefFullPath != null)
{
// if we dont have a datanodeinfo it could be either
// a direct object OR a fileref
if (FileRefFullPath != null)
{
nodeInfo.ValueData = FileRef.ToString();
nodeInfo.MimeType = null;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXFileRef), this.typeNameConverter);
}
else
{
// serialize to string inside the nodeInfo
FillDataNodeInfoFromObject(nodeInfo, value);
}
}
return(nodeInfo);
}
public ResXDataNode(string name, object value, Func <Type, string> typeNameConverter)
{
if (name == null)
{
throw (new ArgumentNullException("name"));
}
if (name.Length == 0)
{
throw (new ArgumentException("name"));
}
this.typeNameConverter = typeNameConverter;
Type valueType = (value == null) ? typeof(object) : value.GetType();
if (value != null && !valueType.IsSerializable)
{
throw new InvalidOperationException(SR.GetString(SR.NotSerializableType, name, valueType.FullName));
}
else if (value != null)
{
this.typeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, this.typeNameConverter);
}
this.name = name;
this.value = value;
}
private string TypeNameWithAssembly(Type type)
{
//
string result = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
return(result);
}
/// <devdoc>
/// Adds a string resource to the resources.
/// </devdoc>
private void AddDataRow(string elementName, string name, string value)
{
if (value == null)
{
// if it's a null string, set it here as a resxnullref
AddDataRow(elementName, name, value, MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter), null, null);
}
else
{
AddDataRow(elementName, name, value, null, null, null);
}
}
//
// Get the multitarget-aware string representation for the give type.
public override void BindToName(Type serializedType, out string assemblyName, out string typeName)
{
// Normally we don't change typeName when changing the target framework,
// only assembly version or assembly name might change, thus we are setting
// typeName only if it changed with the framework version.
// If binder passes in a null, BinaryFormatter will use the original value or
// for un-serializable types will redirect to another type.
// For example:
//
// Encoding = Encoding.GetEncoding("shift_jis");
// public Encoding Encoding { get; set; }
// property type (Encoding) is abstract, but the value is instantiated to a specific class,
// and should be serialized as a specific class in order to be able to instantiate the result.
//
// another example are singleton objects like DBNull.Value which are serialized by System.UnitySerializationHolder
typeName = null;
if (typeNameConverter != null)
{
string assemblyQualifiedTypeName =
MultitargetUtil.GetAssemblyQualifiedName(serializedType, typeNameConverter);
if (!string.IsNullOrEmpty(assemblyQualifiedTypeName))
{
int pos = assemblyQualifiedTypeName.IndexOf(',');
if (pos > 0 && pos < assemblyQualifiedTypeName.Length - 1)
{
assemblyName = assemblyQualifiedTypeName.Substring(pos + 1).TrimStart();
string newTypeName = assemblyQualifiedTypeName.Substring(0, pos);
if (!string.Equals(newTypeName, serializedType.FullName, StringComparison.InvariantCulture))
{
typeName = newTypeName;
}
return;
}
}
}
base.BindToName(serializedType, out assemblyName, out typeName);
}
/// <include file='doc\ResXDataNode.uex' path='docs/doc[@for="ResXDataNode.GetValueTypeName"]/*' />
/// <devdoc>
/// Get the FQ type name for this datanode.
/// We return typeof(object) for ResXNullRef
/// </devdoc>
public string GetValueTypeName(ITypeResolutionService typeResolver)
{
// the type name here is always a FQN
if (typeName != null && typeName.Length > 0)
{
if (typeName.Equals(MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter)))
{
return(MultitargetUtil.GetAssemblyQualifiedName(typeof(object), this.typeNameConverter));
}
else
{
return(typeName);
}
}
string result = FileRefType;
Type objectType = null;
// do we have a fileref?
if (result != null)
{
// try to resolve this type
objectType = ResolveType(FileRefType, typeResolver);
}
else if (nodeInfo != null)
{
// we dont have a fileref, try to resolve the type of the datanode
result = nodeInfo.TypeName;
// if typename is null, the default is just a string
if (result == null || result.Length == 0)
{
// we still dont know... do we have a mimetype? if yes, our only option is to
// deserialize to know what we're dealing with... very inefficient...
if (nodeInfo.MimeType != null && nodeInfo.MimeType.Length > 0)
{
object insideObject = null;
try {
insideObject = GenerateObjectFromDataNodeInfo(nodeInfo, typeResolver);
} catch (Exception ex) { // it'd be better to catch SerializationException but the underlying type resolver
// can throw things like FileNotFoundException which is kinda confusing, so I am catching all here..
if (ClientUtils.IsCriticalException(ex))
{
throw;
}
// something went wrong, type is not specified at all or stream is corrupted
// return system.object
result = MultitargetUtil.GetAssemblyQualifiedName(typeof(object), this.typeNameConverter);
}
if (insideObject != null)
{
result = MultitargetUtil.GetAssemblyQualifiedName(insideObject.GetType(), this.typeNameConverter);
}
}
else
{
// no typename, no mimetype, we have a string...
result = MultitargetUtil.GetAssemblyQualifiedName(typeof(string), this.typeNameConverter);
}
}
else
{
objectType = ResolveType(nodeInfo.TypeName, typeResolver);
}
}
if (objectType != null)
{
if (objectType == typeof(ResXNullRef))
{
result = MultitargetUtil.GetAssemblyQualifiedName(typeof(object), this.typeNameConverter);
}
else
{
result = MultitargetUtil.GetAssemblyQualifiedName(objectType, this.typeNameConverter);
}
}
return(result);
}
private object GenerateObjectFromDataNodeInfo(DataNodeInfo dataNodeInfo, ITypeResolutionService typeResolver)
{
object result = null;
string mimeTypeName = dataNodeInfo.MimeType;
// default behavior: if we dont have a type name, it's a string
string typeName = (dataNodeInfo.TypeName == null || dataNodeInfo.TypeName.Length == 0 ? MultitargetUtil.GetAssemblyQualifiedName(typeof(string), this.typeNameConverter) : dataNodeInfo.TypeName);
if (mimeTypeName != null && mimeTypeName.Length > 0)
{
if (String.Equals(mimeTypeName, ResXResourceWriter.BinSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.Beta2CompatSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.CompatBinSerializedObjectMimeType))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (binaryFormatter == null)
{
binaryFormatter = new BinaryFormatter();
binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
}
IFormatter formatter = binaryFormatter;
if (serializedData != null && serializedData.Length > 0)
{
result = formatter.Deserialize(new MemoryStream(serializedData));
if (result is ResXNullRef)
{
result = null;
}
}
}
#if !SYSTEM_WEB // System.Web does not link with the Soap assembly
else if (String.Equals(mimeTypeName, ResXResourceWriter.SoapSerializedObjectMimeType) ||
String.Equals(mimeTypeName, ResXResourceWriter.CompatSoapSerializedObjectMimeType))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (serializedData != null && serializedData.Length > 0)
{
// Performance : don't inline a new SoapFormatter here. That will always bring in
// the soap assembly, which we don't want. Throw this in another
// function so the class doesn't have to get loaded.
//
IFormatter formatter = CreateSoapFormatter();
result = formatter.Deserialize(new MemoryStream(serializedData));
if (result is ResXNullRef)
{
result = null;
}
}
}
#endif
else if (String.Equals(mimeTypeName, ResXResourceWriter.ByteArraySerializedObjectMimeType))
{
if (typeName != null && typeName.Length > 0)
{
Type type = ResolveType(typeName, typeResolver);
if (type != null)
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(byte[])))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (serializedData != null)
{
result = tc.ConvertFrom(serializedData);
}
}
}
else
{
string newMessage = SR.GetString(SR.TypeLoadException, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
XmlException xml = new XmlException(newMessage, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException newTle = new TypeLoadException(newMessage, xml);
throw newTle;
}
}
}
}
else if (typeName != null && typeName.Length > 0)
{
Type type = ResolveType(typeName, typeResolver);
if (type != null)
{
if (type == typeof(ResXNullRef))
{
result = null;
}
else if (typeName.IndexOf("System.Byte[]") != -1 && typeName.IndexOf("mscorlib") != -1)
{
// Handle byte[]'s, which are stored as base-64 encoded strings.
// We can't hard-code byte[] type name due to version number
// updates & potential whitespace issues with ResX files.
result = FromBase64WrappedString(dataNodeInfo.ValueData);
}
else
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(string)))
{
string text = dataNodeInfo.ValueData;
try {
result = tc.ConvertFromInvariantString(text);
} catch (NotSupportedException nse) {
string newMessage = SR.GetString(SR.NotSupported, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X, nse.Message);
XmlException xml = new XmlException(newMessage, nse, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
NotSupportedException newNse = new NotSupportedException(newMessage, xml);
throw newNse;
}
}
else
{
Debug.WriteLine("Converter for " + type.FullName + " doesn't support string conversion");
}
}
}
else
{
string newMessage = SR.GetString(SR.TypeLoadException, typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
XmlException xml = new XmlException(newMessage, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException newTle = new TypeLoadException(newMessage, xml);
throw newTle;
}
}
else
{
// if mimeTypeName and typeName are not filled in, the value must be a string
Debug.Assert(value is string, "Resource entries with no Type or MimeType must be encoded as strings");
}
return(result);
}
private void FillDataNodeInfoFromObject(DataNodeInfo nodeInfo, object value)
{
CultureInfo ci = value as CultureInfo;
if (ci != null) // special-case CultureInfo, cannot use CultureInfoConverter for serialization (see DevDiv#578701).
{
nodeInfo.ValueData = ci.Name;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(CultureInfo), this.typeNameConverter);
}
else if (value is string)
{
nodeInfo.ValueData = (string)value;
if (value == null)
{
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter);
}
}
else if (value is byte[])
{
nodeInfo.ValueData = ToBase64WrappedString((byte[])value);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(byte[]), this.typeNameConverter);
}
else
{
Type valueType = (value == null) ? typeof(object) : value.GetType();
if (value != null && !valueType.IsSerializable)
{
throw new InvalidOperationException(SR.GetString(SR.NotSerializableType, name, valueType.FullName));
}
TypeConverter tc = TypeDescriptor.GetConverter(valueType);
bool toString = tc.CanConvertTo(typeof(string));
bool fromString = tc.CanConvertFrom(typeof(string));
try {
if (toString && fromString)
{
nodeInfo.ValueData = tc.ConvertToInvariantString(value);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, this.typeNameConverter);
return;
}
}
catch (Exception ex) {
// Some custom type converters will throw in ConvertTo(string)
// to indicate that this object should be serialized through ISeriazable
// instead of as a string. This is semi-wrong, but something we will have to
// live with to allow user created Cursors to be serializable.
if (ClientUtils.IsSecurityOrCriticalException(ex))
{
throw;
}
}
bool toByteArray = tc.CanConvertTo(typeof(byte[]));
bool fromByteArray = tc.CanConvertFrom(typeof(byte[]));
if (toByteArray && fromByteArray)
{
byte[] data = (byte[])tc.ConvertTo(value, typeof(byte[]));
string text = ToBase64WrappedString(data);
nodeInfo.ValueData = text;
nodeInfo.MimeType = ResXResourceWriter.ByteArraySerializedObjectMimeType;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, this.typeNameConverter);
return;
}
if (value == null)
{
nodeInfo.ValueData = string.Empty;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter);
}
else
{
if (binaryFormatter == null)
{
binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
binaryFormatter.Binder = new ResXSerializationBinder(this.typeNameConverter);
}
MemoryStream ms = new MemoryStream();
binaryFormatter.Serialize(ms, value);
string text = ToBase64WrappedString(ms.ToArray());
nodeInfo.ValueData = text;
nodeInfo.MimeType = ResXResourceWriter.DefaultSerializedObjectMimeType;
}
}
}
private void AddDataRow(string elementName, string name, string value, string type, string mimeType, string comment)
{
if (hasBeenSaved)
{
throw new InvalidOperationException(SR.GetString(SR.ResXResourceWriterSaved));
}
string alias = null;
if (!string.IsNullOrEmpty(type) && elementName == DataStr)
{
string assemblyName = GetFullName(type);
if (string.IsNullOrEmpty(assemblyName))
{
try {
Type typeObject = Type.GetType(type);
if (typeObject == typeof(string))
{
type = null;
}
else if (typeObject != null)
{
assemblyName = GetFullName(MultitargetUtil.GetAssemblyQualifiedName(typeObject, this.typeNameConverter));
alias = GetAliasFromName(new AssemblyName(assemblyName));
}
} catch {
}
}
else
{
alias = GetAliasFromName(new AssemblyName(GetFullName(type)));
}
//AddAssemblyRow(AssemblyStr, alias, GetFullName(type));
}
Writer.WriteStartElement(elementName); {
Writer.WriteAttributeString(NameStr, name);
if (!string.IsNullOrEmpty(alias) && !string.IsNullOrEmpty(type) && elementName == DataStr)
{
// CHANGE: we still output version information. This might have
// to change in 3.2
string typeName = GetTypeName(type);
string typeValue = typeName + ", " + alias;
Writer.WriteAttributeString(TypeStr, typeValue);
}
else
{
if (type != null)
{
Writer.WriteAttributeString(TypeStr, type);
}
}
if (mimeType != null)
{
Writer.WriteAttributeString(MimeTypeStr, mimeType);
}
if ((type == null && mimeType == null) || (type != null && type.StartsWith("System.Char", StringComparison.Ordinal)))
{
Writer.WriteAttributeString("xml", "space", null, "preserve");
}
Writer.WriteStartElement(ValueStr); {
if (!string.IsNullOrEmpty(value))
{
Writer.WriteString(value);
}
}
Writer.WriteEndElement();
if (!string.IsNullOrEmpty(comment))
{
Writer.WriteStartElement(CommentStr); {
Writer.WriteString(comment);
}
Writer.WriteEndElement();
}
}
Writer.WriteEndElement();
}
private void InitializeWriter()
{
if (xmlTextWriter == null)
{
//
bool writeHeaderHack = false;
if (textWriter != null)
{
textWriter.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
writeHeaderHack = true;
xmlTextWriter = new XmlTextWriter(textWriter);
}
else if (stream != null)
{
xmlTextWriter = new XmlTextWriter(stream, System.Text.Encoding.UTF8);
}
else
{
Debug.Assert(fileName != null, "Nothing to output to");
xmlTextWriter = new XmlTextWriter(fileName, System.Text.Encoding.UTF8);
}
xmlTextWriter.Formatting = Formatting.Indented;
xmlTextWriter.Indentation = 2;
if (!writeHeaderHack)
{
xmlTextWriter.WriteStartDocument(); // writes <?xml version="1.0" encoding="utf-8"?>
}
}
else
{
xmlTextWriter.WriteStartDocument();
}
xmlTextWriter.WriteStartElement("root");
XmlTextReader reader = new XmlTextReader(new StringReader(ResourceSchema));
reader.WhitespaceHandling = WhitespaceHandling.None;
xmlTextWriter.WriteNode(reader, true);
xmlTextWriter.WriteStartElement(ResHeaderStr); {
xmlTextWriter.WriteAttributeString(NameStr, ResMimeTypeStr);
xmlTextWriter.WriteStartElement(ValueStr); {
xmlTextWriter.WriteString(ResMimeType);
}
xmlTextWriter.WriteEndElement();
}
xmlTextWriter.WriteEndElement();
xmlTextWriter.WriteStartElement(ResHeaderStr); {
xmlTextWriter.WriteAttributeString(NameStr, VersionStr);
xmlTextWriter.WriteStartElement(ValueStr); {
xmlTextWriter.WriteString(Version);
}
xmlTextWriter.WriteEndElement();
}
xmlTextWriter.WriteEndElement();
xmlTextWriter.WriteStartElement(ResHeaderStr); {
xmlTextWriter.WriteAttributeString(NameStr, ReaderStr);
xmlTextWriter.WriteStartElement(ValueStr); {
xmlTextWriter.WriteString(MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXResourceReader), this.typeNameConverter));
}
xmlTextWriter.WriteEndElement();
}
xmlTextWriter.WriteEndElement();
xmlTextWriter.WriteStartElement(ResHeaderStr); {
xmlTextWriter.WriteAttributeString(NameStr, WriterStr);
xmlTextWriter.WriteStartElement(ValueStr); {
xmlTextWriter.WriteString(MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXResourceWriter), this.typeNameConverter));
}
xmlTextWriter.WriteEndElement();
}
xmlTextWriter.WriteEndElement();
initialized = true;
}
private object GenerateObjectFromDataNodeInfo(DataNodeInfo dataNodeInfo, ITypeResolutionService typeResolver)
{
object result = null;
string mimeTypeName = dataNodeInfo.MimeType;
// default behavior: if we dont have a type name, it's a string
string typeName =
string.IsNullOrEmpty(dataNodeInfo.TypeName)
? MultitargetUtil.GetAssemblyQualifiedName(typeof(string), typeNameConverter)
: dataNodeInfo.TypeName;
if (!string.IsNullOrEmpty(mimeTypeName))
{
if (string.Equals(mimeTypeName, ResXResourceWriter.BinSerializedObjectMimeType) ||
string.Equals(mimeTypeName, ResXResourceWriter.Beta2CompatSerializedObjectMimeType) ||
string.Equals(mimeTypeName, ResXResourceWriter.CompatBinSerializedObjectMimeType))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData;
serializedData = FromBase64WrappedString(text);
if (binaryFormatter == null)
{
binaryFormatter = new BinaryFormatter();
binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
}
IFormatter formatter = binaryFormatter;
if (serializedData != null && serializedData.Length > 0)
{
result = formatter.Deserialize(new MemoryStream(serializedData));
if (result is ResXNullRef)
{
result = null;
}
}
}
else if (string.Equals(mimeTypeName, ResXResourceWriter.ByteArraySerializedObjectMimeType))
{
if (!string.IsNullOrEmpty(typeName))
{
Type type = ResolveType(typeName, typeResolver);
if (type != null)
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
string text = dataNodeInfo.ValueData;
byte[] serializedData = FromBase64WrappedString(text);
if (tc.CanConvertFrom(typeof(byte[])))
{
if (serializedData != null)
{
result = tc.ConvertFrom(serializedData);
}
}
else if (serializedData != null)
{
var bitmap = BitmapUtility.CreateFromArray(serializedData);
if (bitmap != null)
{
result = bitmap;
}
}
}
else
{
string newMessage = string.Format(SR.TypeLoadException, typeName,
dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
XmlException xml = new XmlException(newMessage, null, dataNodeInfo.ReaderPosition.Y,
dataNodeInfo.ReaderPosition.X);
TypeLoadException newTle = new TypeLoadException(newMessage, xml);
throw newTle;
}
}
}
}
else if (!string.IsNullOrEmpty(typeName))
{
Type type = ResolveType(typeName, typeResolver);
if (type != null)
{
if (type == typeof(ResXNullRef))
{
result = null;
}
else if (typeName.IndexOf("System.Byte[]") != -1 && typeName.IndexOf("mscorlib") != -1)
{
// Handle byte[]'s, which are stored as base-64 encoded strings.
// We can't hard-code byte[] type name due to version number
// updates & potential whitespace issues with ResX files.
result = FromBase64WrappedString(dataNodeInfo.ValueData);
}
else
{
TypeConverter tc = TypeDescriptor.GetConverter(type);
if (tc.CanConvertFrom(typeof(string)))
{
string text = dataNodeInfo.ValueData;
try
{
result = tc.ConvertFromInvariantString(text);
}
catch (NotSupportedException nse)
{
string newMessage = string.Format(SR.NotSupported, typeName,
dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X, nse.Message);
XmlException xml = new XmlException(newMessage, nse, dataNodeInfo.ReaderPosition.Y,
dataNodeInfo.ReaderPosition.X);
NotSupportedException newNse = new NotSupportedException(newMessage, xml);
throw newNse;
}
}
else
{
Debug.WriteLine("ResxFileRefStringConverter for " + type.FullName +
" doesn't support string conversion");
}
}
}
else
{
string newMessage = string.Format(SR.TypeLoadException, typeName, dataNodeInfo.ReaderPosition.Y,
dataNodeInfo.ReaderPosition.X);
XmlException xml = new XmlException(newMessage, null, dataNodeInfo.ReaderPosition.Y,
dataNodeInfo.ReaderPosition.X);
TypeLoadException newTle = new TypeLoadException(newMessage, xml);
throw newTle;
}
}
else
{
// if mimeTypeName and typeName are not filled in, the value must be a string
Debug.Assert(value is string, "Resource entries with no Type or MimeType must be encoded as strings");
}
return(result);
}
