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), typeNameConverter);
}
else
{
// serialize to string inside the nodeInfo
FillDataNodeInfoFromObject(nodeInfo, value);
}
}
return(nodeInfo);
}
/// <devdoc>
/// Adds a resource to the resources. If the resource is a string,
/// it will be saved that way, otherwise it will be serialized
/// and stored as in binary.
/// </devdoc>
private void AddDataRow(string elementName, string name, object value)
{
Debug.WriteLineIf(ResValueProviderSwitch.TraceVerbose, " resx: adding resource " + name);
if (value is string)
{
AddDataRow(elementName, name, (string)value);
}
else if (value is byte[])
{
AddDataRow(elementName, name, (byte[])value);
}
else if (value is ResXFileRef)
{
ResXFileRef fileRef = (ResXFileRef)value;
ResXDataNode node = new ResXDataNode(name, fileRef, this.typeNameConverter);
if (fileRef != null)
{
fileRef.MakeFilePathRelative(BasePath);
}
DataNodeInfo info = node.GetDataNodeInfo();
AddDataRow(elementName, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
}
else
{
ResXDataNode node = new ResXDataNode(name, value, this.typeNameConverter);
DataNodeInfo info = node.GetDataNodeInfo();
AddDataRow(elementName, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
}
}
private void AddDataRow(string elementName, string name, object value)
{
if (value is string)
{
this.AddDataRow(elementName, name, (string)value);
}
else if (value is byte[])
{
this.AddDataRow(elementName, name, (byte[])value);
}
else if (value is ResXFileRef)
{
ResXFileRef fileRef = (ResXFileRef)value;
ResXDataNode node = new ResXDataNode(name, fileRef, this.typeNameConverter);
if (fileRef != null)
{
fileRef.MakeFilePathRelative(this.BasePath);
}
DataNodeInfo dataNodeInfo = node.GetDataNodeInfo();
this.AddDataRow(elementName, dataNodeInfo.Name, dataNodeInfo.ValueData, dataNodeInfo.TypeName, dataNodeInfo.MimeType, dataNodeInfo.Comment);
}
else
{
DataNodeInfo info2 = new ResXDataNode(name, value, this.typeNameConverter).GetDataNodeInfo();
this.AddDataRow(elementName, info2.Name, info2.ValueData, info2.TypeName, info2.MimeType, info2.Comment);
}
}
/// <include file='doc\ResXResourceWriter.uex' path='docs/doc[@for="ResXResourceWriter.AddResource3"]/*' />
/// <devdoc>
/// Adds a string resource to the resources.
/// </devdoc>
public void AddResource(ResXDataNode node)
{
// we're modifying the node as we're adding it to the resxwriter
// this is BAD, so we clone it. adding it to a writer doesnt change it
// we're messing with a copy
ResXDataNode nodeClone = node.DeepClone();
ResXFileRef fileRef = nodeClone.FileRef;
string modifiedBasePath = BasePath;
if (!string.IsNullOrEmpty(modifiedBasePath))
{
if (!(modifiedBasePath.EndsWith("\\")))
{
modifiedBasePath += "\\";
}
if (fileRef != null)
{
fileRef.MakeFilePathRelative(modifiedBasePath);
}
}
DataNodeInfo info = nodeClone.GetDataNodeInfo();
AddDataRow(DataStr, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
}
internal DataNodeInfo GetDataNodeInfo()
{
bool flag = true;
if (this.nodeInfo != null)
{
flag = false;
}
else
{
this.nodeInfo = new DataNodeInfo();
}
this.nodeInfo.Name = this.Name;
this.nodeInfo.Comment = this.Comment;
if (flag || (this.FileRefFullPath != null))
{
if (this.FileRefFullPath != null)
{
this.nodeInfo.ValueData = this.FileRef.ToString();
this.nodeInfo.MimeType = null;
this.nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXFileRef), this.typeNameConverter);
}
else
{
this.FillDataNodeInfoFromObject(this.nodeInfo, this.value);
}
}
return(this.nodeInfo);
}
/// <devdoc>
/// Adds a resource to the resources. If the resource is a string,
/// it will be saved that way, otherwise it will be serialized
/// and stored as in binary.
/// </devdoc>
private void AddDataRow(string elementName, string name, object value)
{
Debug.WriteLineIf(ResValueProviderSwitch.TraceVerbose, " resx: adding resource " + name);
switch (value)
{
case string str:
AddDataRow(elementName, name, str);
break;
case byte[] bytes:
AddDataRow(elementName, name, bytes);
break;
case ResXFileRef fileRef:
{
ResXDataNode node = new ResXDataNode(name, fileRef, this.typeNameConverter);
DataNodeInfo info = node.GetDataNodeInfo();
AddDataRow(elementName, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
break;
}
default:
{
ResXDataNode node = new ResXDataNode(name, value, this.typeNameConverter);
DataNodeInfo info = node.GetDataNodeInfo();
AddDataRow(elementName, info.Name, info.ValueData, info.TypeName, info.MimeType, info.Comment);
break;
}
}
}
/// <summary>
/// Get the value contained in this datanode
/// </summary>
void ISerializable.GetObjectData(SerializationInfo si, StreamingContext context)
{
DataNodeInfo nodeInfo = GetDataNodeInfo();
si.AddValue("Name", nodeInfo.Name, typeof(string));
si.AddValue("Comment", nodeInfo.Comment, typeof(string));
si.AddValue("TypeName", nodeInfo.TypeName, typeof(string));
si.AddValue("MimeType", nodeInfo.MimeType, typeof(string));
si.AddValue("ValueData", nodeInfo.ValueData, typeof(string));
}
internal Point ReaderPosition; //only used to track position in the reader
internal DataNodeInfo Clone()
{
DataNodeInfo result = new DataNodeInfo();
result.Name = this.Name;
result.Comment = this.Comment;
result.TypeName = this.TypeName;
result.MimeType = this.MimeType;
result.ValueData = this.ValueData;
result.ReaderPosition = new Point(this.ReaderPosition.X, this.ReaderPosition.Y);
return(result);
}
private ResXDataNode(SerializationInfo info, StreamingContext context)
{
nodeInfo = new DataNodeInfo
{
Name = (string)info.GetValue("Name", typeof(string)),
Comment = (string)info.GetValue("Comment", typeof(string)),
TypeName = (string)info.GetValue("TypeName", typeof(string)),
MimeType = (string)info.GetValue("MimeType", typeof(string)),
ValueData = (string)info.GetValue("ValueData", typeof(string))
};
InitializeDataNode(null);
}
private ResXDataNode(SerializationInfo info, StreamingContext context)
{
DataNodeInfo info2 = new DataNodeInfo {
Name = (string) info.GetValue("Name", typeof(string)),
Comment = (string) info.GetValue("Comment", typeof(string)),
TypeName = (string) info.GetValue("TypeName", typeof(string)),
MimeType = (string) info.GetValue("MimeType", typeof(string)),
ValueData = (string) info.GetValue("ValueData", typeof(string))
};
this.nodeInfo = info2;
this.InitializeDataNode(null);
}
private ResXDataNode(SerializationInfo info, StreamingContext context)
{
DataNodeInfo nodeInfo = new DataNodeInfo();
nodeInfo.Name = (string)info.GetValue("Name", typeof(string));
nodeInfo.Comment = (string)info.GetValue("Comment", typeof(string));
nodeInfo.TypeName = (string)info.GetValue("TypeName", typeof(string));
nodeInfo.MimeType = (string)info.GetValue("MimeType", typeof(string));
nodeInfo.ValueData = (string)info.GetValue("ValueData", typeof(string));
this.nodeInfo = nodeInfo;
InitializeDataNode(null);
}
public void AddResource(ResXDataNode node)
{
ResXDataNode node2 = node.DeepClone();
ResXFileRef fileRef = node2.FileRef;
string basePath = this.BasePath;
if (!string.IsNullOrEmpty(basePath))
{
if (!basePath.EndsWith(@"\"))
{
basePath = basePath + @"\";
}
if (fileRef != null)
{
fileRef.MakeFilePathRelative(basePath);
}
}
DataNodeInfo dataNodeInfo = node2.GetDataNodeInfo();
this.AddDataRow("data", dataNodeInfo.Name, dataNodeInfo.ValueData, dataNodeInfo.TypeName, dataNodeInfo.MimeType, dataNodeInfo.Comment);
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData)
{
DataNodeInfo nodeInfo = new DataNodeInfo
{
Name = reader[ResXResourceWriter.NameStr]
};
string typeName = reader[ResXResourceWriter.TypeStr];
string alias = null;
AssemblyName assemblyName = null;
if (!string.IsNullOrEmpty(typeName))
{
alias = GetAliasFromTypeName(typeName);
}
if (!string.IsNullOrEmpty(alias))
{
assemblyName = _aliasResolver.ResolveAlias(alias);
}
if (assemblyName != null)
{
nodeInfo.TypeName = GetTypeFromTypeName(typeName) + ", " + assemblyName.FullName;
}
else
{
nodeInfo.TypeName = reader[ResXResourceWriter.TypeStr];
}
nodeInfo.MimeType = reader[ResXResourceWriter.MimeTypeStr];
bool finishedReadingDataNode = false;
nodeInfo.ReaderPosition = GetPosition(reader);
while (!finishedReadingDataNode && reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement && (reader.LocalName.Equals(ResXResourceWriter.DataStr) || reader.LocalName.Equals(ResXResourceWriter.MetadataStr)))
{
// we just found </data>, quit or </metadata>
finishedReadingDataNode = true;
}
else
{
// could be a <value> or a <comment>
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals(ResXResourceWriter.ValueStr))
{
WhitespaceHandling oldValue = reader.WhitespaceHandling;
try
{
// based on the documentation at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemxmlxmltextreaderclasswhitespacehandlingtopic.asp
// this is ok because:
// "Because the XmlTextReader does not have DTD information available to it,
// SignificantWhitepsace nodes are only returned within the an xml:space='preserve' scope."
// the xml:space would not be present for anything else than string and char (see ResXResourceWriter)
// so this would not cause any breaking change while reading data from Everett (we never outputed
// xml:space then) or from whidbey that is not specifically either a string or a char.
// However please note that manually editing a resx file in Everett and in Whidbey because of the addition
// of xml:space=preserve might have different consequences...
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
}
finally
{
reader.WhitespaceHandling = oldValue;
}
}
else if (reader.Name.Equals(ResXResourceWriter.CommentStr))
{
nodeInfo.Comment = reader.ReadString();
}
}
else
{
// weird, no <xxxx> tag, just the inside of <data> as text
nodeInfo.ValueData = reader.Value.Trim();
}
}
}
if (nodeInfo.Name == null)
{
throw new ArgumentException(string.Format(SR.InvalidResXResourceNoName, nodeInfo.ValueData));
}
ResXDataNode dataNode = new ResXDataNode(nodeInfo, BasePath);
if (UseResXDataNodes)
{
_resData[nodeInfo.Name] = dataNode;
}
else
{
IDictionary data = (isMetaData ? _resMetadata : _resData);
if (_assemblyNames == null)
{
data[nodeInfo.Name] = dataNode.GetValue(_typeResolver);
}
else
{
data[nodeInfo.Name] = dataNode.GetValue(_assemblyNames);
}
}
}
internal ResXDataNode(DataNodeInfo nodeInfo, string basePath)
{
this.nodeInfo = nodeInfo;
this.InitializeDataNode(basePath);
}
internal DataNodeInfo GetDataNodeInfo()
{
bool flag = true;
if (this.nodeInfo != null)
{
flag = false;
}
else
{
this.nodeInfo = new DataNodeInfo();
}
this.nodeInfo.Name = this.Name;
this.nodeInfo.Comment = this.Comment;
if (flag || (this.FileRefFullPath != null))
{
if (this.FileRefFullPath != null)
{
this.nodeInfo.ValueData = this.FileRef.ToString();
this.nodeInfo.MimeType = null;
this.nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXFileRef), this.typeNameConverter);
}
else
{
this.FillDataNodeInfoFromObject(this.nodeInfo, this.value);
}
}
return this.nodeInfo;
}
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;
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData)
{
DataNodeInfo nodeInfo = new DataNodeInfo {
Name = reader["name"]
};
string str = reader["type"];
string aliasFromTypeName = null;
AssemblyName name = null;
if (!string.IsNullOrEmpty(str))
{
aliasFromTypeName = this.GetAliasFromTypeName(str);
}
if (!string.IsNullOrEmpty(aliasFromTypeName))
{
name = this.aliasResolver.ResolveAlias(aliasFromTypeName);
}
if (name != null)
{
nodeInfo.TypeName = this.GetTypeFromTypeName(str) + ", " + name.FullName;
}
else
{
nodeInfo.TypeName = reader["type"];
}
nodeInfo.MimeType = reader["mimetype"];
bool flag = false;
nodeInfo.ReaderPosition = this.GetPosition(reader);
while (!flag && reader.Read())
{
if ((reader.NodeType == XmlNodeType.EndElement) && (reader.LocalName.Equals("data") || reader.LocalName.Equals("metadata")))
{
flag = true;
}
else
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals("value"))
{
WhitespaceHandling whitespaceHandling = reader.WhitespaceHandling;
try
{
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
continue;
}
finally
{
reader.WhitespaceHandling = whitespaceHandling;
}
}
if (reader.Name.Equals("comment"))
{
nodeInfo.Comment = reader.ReadString();
}
continue;
}
nodeInfo.ValueData = reader.Value.Trim();
}
}
if (nodeInfo.Name == null)
{
throw new ArgumentException(System.Windows.Forms.SR.GetString("InvalidResXResourceNoName", new object[] { nodeInfo.ValueData }));
}
ResXDataNode node = new ResXDataNode(nodeInfo, this.BasePath);
if (this.UseResXDataNodes)
{
this.resData[nodeInfo.Name] = node;
}
else
{
IDictionary dictionary = isMetaData ? this.resMetadata : this.resData;
if (this.assemblyNames == null)
{
dictionary[nodeInfo.Name] = node.GetValue(this.typeResolver);
}
else
{
dictionary[nodeInfo.Name] = node.GetValue(this.assemblyNames);
}
}
}
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 = FromBase64WrappedString(text);
if (binaryFormatter == null)
{
binaryFormatter = new 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);
if (tc.CanConvertFrom(typeof(byte[])))
{
string text = dataNodeInfo.ValueData;
byte[] serializedData = FromBase64WrappedString(text);
if (serializedData != null)
{
result = tc.ConvertFrom(serializedData);
}
}
}
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("Converter 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);
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData) {
DataNodeInfo nodeInfo = new DataNodeInfo();
nodeInfo.Name = reader[ResXResourceWriter.NameStr];
string typeName = reader[ResXResourceWriter.TypeStr];
string alias = null;
AssemblyName assemblyName = null;
if (!string.IsNullOrEmpty(typeName)) {
alias = GetAliasFromTypeName(typeName);
}
if (!string.IsNullOrEmpty(alias)) {
assemblyName = aliasResolver.ResolveAlias(alias);
}
if (assemblyName != null )
{
nodeInfo.TypeName = GetTypeFromTypeName(typeName) + ", " + assemblyName.FullName;
}
else {
nodeInfo.TypeName = reader[ResXResourceWriter.TypeStr];
}
nodeInfo.MimeType = reader[ResXResourceWriter.MimeTypeStr];
bool finishedReadingDataNode = false;
nodeInfo.ReaderPosition = GetPosition(reader);
while(!finishedReadingDataNode && reader.Read()) {
if(reader.NodeType == XmlNodeType.EndElement && ( reader.LocalName.Equals(ResXResourceWriter.DataStr) || reader.LocalName.Equals(ResXResourceWriter.MetadataStr) )) {
// we just found </data>, quit or </metadata>
finishedReadingDataNode = true;
} else {
// could be a <value> or a <comment>
if (reader.NodeType == XmlNodeType.Element) {
if (reader.Name.Equals(ResXResourceWriter.ValueStr)) {
WhitespaceHandling oldValue = reader.WhitespaceHandling;
try {
// based on the documentation at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemxmlxmltextreaderclasswhitespacehandlingtopic.asp
// this is ok because:
// "Because the XmlTextReader does not have DTD information available to it,
// SignificantWhitepsace nodes are only returned within the an xml:space='preserve' scope."
// the xml:space would not be present for anything else than string and char (see ResXResourceWriter)
// so this would not cause any breaking change while reading data from Everett (we never outputed
// xml:space then) or from whidbey that is not specifically either a string or a char.
// However please note that manually editing a resx file in Everett and in Whidbey because of the addition
// of xml:space=preserve might have different consequences...
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
} finally {
reader.WhitespaceHandling = oldValue;
}
} else if (reader.Name.Equals(ResXResourceWriter.CommentStr)) {
nodeInfo.Comment = reader.ReadString();
}
} else {
// weird, no <xxxx> tag, just the inside of <data> as text
nodeInfo.ValueData = reader.Value.Trim();
}
}
}
if (nodeInfo.Name==null) {
throw new ArgumentException(SR.GetString(SR.InvalidResXResourceNoName, nodeInfo.ValueData));
}
ResXDataNode dataNode = new ResXDataNode(nodeInfo, BasePath);
if(UseResXDataNodes) {
resData[nodeInfo.Name] = dataNode;
} else {
IDictionary data = (isMetaData ? resMetadata : resData);
if(assemblyNames == null) {
data[nodeInfo.Name] = dataNode.GetValue(typeResolver);
} else {
data[nodeInfo.Name] = dataNode.GetValue(assemblyNames);
}
}
}
private object GenerateObjectFromDataNodeInfo(DataNodeInfo dataNodeInfo, ITypeResolutionService typeResolver)
{
object obj2 = null;
string mimeType = dataNodeInfo.MimeType;
string typeName = ((dataNodeInfo.TypeName == null) || (dataNodeInfo.TypeName.Length == 0)) ? MultitargetUtil.GetAssemblyQualifiedName(typeof(string), this.typeNameConverter) : dataNodeInfo.TypeName;
if ((mimeType != null) && (mimeType.Length > 0))
{
if ((string.Equals(mimeType, ResXResourceWriter.BinSerializedObjectMimeType) || string.Equals(mimeType, ResXResourceWriter.Beta2CompatSerializedObjectMimeType)) || string.Equals(mimeType, ResXResourceWriter.CompatBinSerializedObjectMimeType))
{
byte[] buffer = FromBase64WrappedString(dataNodeInfo.ValueData);
if (this.binaryFormatter == null)
{
this.binaryFormatter = new BinaryFormatter();
this.binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
}
IFormatter binaryFormatter = this.binaryFormatter;
if ((buffer != null) && (buffer.Length > 0))
{
obj2 = binaryFormatter.Deserialize(new MemoryStream(buffer));
if (obj2 is ResXNullRef)
{
obj2 = null;
}
}
return(obj2);
}
if (string.Equals(mimeType, ResXResourceWriter.SoapSerializedObjectMimeType) || string.Equals(mimeType, ResXResourceWriter.CompatSoapSerializedObjectMimeType))
{
byte[] buffer2 = FromBase64WrappedString(dataNodeInfo.ValueData);
if ((buffer2 != null) && (buffer2.Length > 0))
{
obj2 = this.CreateSoapFormatter().Deserialize(new MemoryStream(buffer2));
if (obj2 is ResXNullRef)
{
obj2 = null;
}
}
return(obj2);
}
if ((!string.Equals(mimeType, ResXResourceWriter.ByteArraySerializedObjectMimeType) || (typeName == null)) || (typeName.Length <= 0))
{
return(obj2);
}
System.Type type = this.ResolveType(typeName, typeResolver);
if (type != null)
{
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter.CanConvertFrom(typeof(byte[])))
{
byte[] buffer3 = FromBase64WrappedString(dataNodeInfo.ValueData);
if (buffer3 != null)
{
obj2 = converter.ConvertFrom(buffer3);
}
}
return(obj2);
}
string str6 = System.Windows.Forms.SR.GetString("TypeLoadException", new object[] { typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X });
XmlException exception = new XmlException(str6, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException exception2 = new TypeLoadException(str6, exception);
throw exception2;
}
if ((typeName == null) || (typeName.Length <= 0))
{
return(obj2);
}
System.Type type2 = this.ResolveType(typeName, typeResolver);
if (type2 != null)
{
if (type2 == typeof(ResXNullRef))
{
return(null);
}
if ((typeName.IndexOf("System.Byte[]") != -1) && (typeName.IndexOf("mscorlib") != -1))
{
return(FromBase64WrappedString(dataNodeInfo.ValueData));
}
TypeConverter converter2 = TypeDescriptor.GetConverter(type2);
if (!converter2.CanConvertFrom(typeof(string)))
{
return(obj2);
}
string valueData = dataNodeInfo.ValueData;
try
{
return(converter2.ConvertFromInvariantString(valueData));
}
catch (NotSupportedException exception3)
{
string str8 = System.Windows.Forms.SR.GetString("NotSupported", new object[] { typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X, exception3.Message });
XmlException innerException = new XmlException(str8, exception3, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
NotSupportedException exception5 = new NotSupportedException(str8, innerException);
throw exception5;
}
}
string message = System.Windows.Forms.SR.GetString("TypeLoadException", new object[] { typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X });
XmlException inner = new XmlException(message, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException exception7 = new TypeLoadException(message, inner);
throw exception7;
}
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;
}
}
}
internal Point ReaderPosition; //only used to track position in the reader
internal DataNodeInfo Clone() {
DataNodeInfo result = new DataNodeInfo();
result.Name = this.Name;
result.Comment = this.Comment;
result.TypeName = this.TypeName;
result.MimeType = this.MimeType;
result.ValueData = this.ValueData;
result.ReaderPosition = new Point(this.ReaderPosition.X, this.ReaderPosition.Y);
return result;
}
private ResXDataNode(SerializationInfo info, StreamingContext context) {
DataNodeInfo nodeInfo = new DataNodeInfo();
nodeInfo.Name = (string)info.GetValue("Name", typeof(string));
nodeInfo.Comment = (string)info.GetValue("Comment", typeof(string));
nodeInfo.TypeName = (string)info.GetValue("TypeName", typeof(string));
nodeInfo.MimeType = (string)info.GetValue("MimeType", typeof(string));
nodeInfo.ValueData = (string)info.GetValue("ValueData", typeof(string));
this.nodeInfo = nodeInfo;
InitializeDataNode(null);
}
internal ResXDataNode(DataNodeInfo nodeInfo, string basePath)
{
this.nodeInfo = nodeInfo;
InitializeDataNode(basePath);
}
private void FillDataNodeInfoFromObject(DataNodeInfo nodeInfo, object value)
{
if (value is CultureInfo ci)
{ // special-case CultureInfo, cannot use CultureInfoConverter for serialization
nodeInfo.ValueData = ci.Name;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(CultureInfo), typeNameConverter);
}
else if (value is string str)
{
nodeInfo.ValueData = str;
}
else if (value is byte[] bytes)
{
nodeInfo.ValueData = ToBase64WrappedString(bytes);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(byte[]), typeNameConverter);
}
else
{
Type valueType = (value == null) ? typeof(object) : value.GetType();
if (value != null && !valueType.IsSerializable)
{
throw new InvalidOperationException(string.Format(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, 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[]));
nodeInfo.ValueData = ToBase64WrappedString(data);
nodeInfo.MimeType = ResXResourceWriter.ByteArraySerializedObjectMimeType;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, typeNameConverter);
return;
}
if (value == null)
{
nodeInfo.ValueData = string.Empty;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), typeNameConverter);
}
else
{
if (binaryFormatter == null)
{
binaryFormatter = new BinaryFormatter
{
Binder = new ResXSerializationBinder(typeNameConverter)
};
}
using (MemoryStream ms = new MemoryStream())
{
binaryFormatter.Serialize(ms, value);
nodeInfo.ValueData = ToBase64WrappedString(ms.ToArray());
}
nodeInfo.MimeType = ResXResourceWriter.DefaultSerializedObjectMimeType;
}
}
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData)
{
DataNodeInfo nodeInfo = new DataNodeInfo {
Name = reader["name"]
};
string str = reader["type"];
string aliasFromTypeName = null;
AssemblyName name = null;
if (!string.IsNullOrEmpty(str))
{
aliasFromTypeName = this.GetAliasFromTypeName(str);
}
if (!string.IsNullOrEmpty(aliasFromTypeName))
{
name = this.aliasResolver.ResolveAlias(aliasFromTypeName);
}
if (name != null)
{
nodeInfo.TypeName = this.GetTypeFromTypeName(str) + ", " + name.FullName;
}
else
{
nodeInfo.TypeName = reader["type"];
}
nodeInfo.MimeType = reader["mimetype"];
bool flag = false;
nodeInfo.ReaderPosition = this.GetPosition(reader);
while (!flag && reader.Read())
{
if ((reader.NodeType == XmlNodeType.EndElement) && (reader.LocalName.Equals("data") || reader.LocalName.Equals("metadata")))
{
flag = true;
}
else
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals("value"))
{
WhitespaceHandling whitespaceHandling = reader.WhitespaceHandling;
try
{
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
continue;
}
finally
{
reader.WhitespaceHandling = whitespaceHandling;
}
}
if (reader.Name.Equals("comment"))
{
nodeInfo.Comment = reader.ReadString();
}
continue;
}
nodeInfo.ValueData = reader.Value.Trim();
}
}
if (nodeInfo.Name == null)
{
throw new ArgumentException(System.Windows.Forms.SR.GetString("InvalidResXResourceNoName", new object[] { nodeInfo.ValueData }));
}
ResXDataNode node = new ResXDataNode(nodeInfo, this.BasePath);
if (this.UseResXDataNodes)
{
this.resData[nodeInfo.Name] = node;
}
else
{
IDictionary dictionary = isMetaData ? this.resMetadata : this.resData;
if (this.assemblyNames == null)
{
dictionary[nodeInfo.Name] = node.GetValue(this.typeResolver);
}
else
{
dictionary[nodeInfo.Name] = node.GetValue(this.assemblyNames);
}
}
}
private void FillDataNodeInfoFromObject(DataNodeInfo nodeInfo, object value)
{
CultureInfo info = value as CultureInfo;
if (info != null)
{
nodeInfo.ValueData = info.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
{
System.Type type = (value == null) ? typeof(object) : value.GetType();
if ((value != null) && !type.IsSerializable)
{
throw new InvalidOperationException(System.Windows.Forms.SR.GetString("NotSerializableType", new object[] { this.name, type.FullName }));
}
TypeConverter converter = TypeDescriptor.GetConverter(type);
bool flag = converter.CanConvertTo(typeof(string));
bool flag2 = converter.CanConvertFrom(typeof(string));
try
{
if (flag && flag2)
{
nodeInfo.ValueData = converter.ConvertToInvariantString(value);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
return;
}
}
catch (Exception exception)
{
if (System.Windows.Forms.ClientUtils.IsSecurityOrCriticalException(exception))
{
throw;
}
}
bool flag3 = converter.CanConvertTo(typeof(byte[]));
bool flag4 = converter.CanConvertFrom(typeof(byte[]));
if (!flag3 || !flag4)
{
if (value == null)
{
nodeInfo.ValueData = string.Empty;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter);
}
else
{
if (this.binaryFormatter == null)
{
this.binaryFormatter = new BinaryFormatter();
}
MemoryStream serializationStream = new MemoryStream();
if (this.binaryFormatter == null)
{
this.binaryFormatter = new BinaryFormatter();
}
this.binaryFormatter.Serialize(serializationStream, value);
string str2 = ToBase64WrappedString(serializationStream.ToArray());
nodeInfo.ValueData = str2;
nodeInfo.MimeType = ResXResourceWriter.DefaultSerializedObjectMimeType;
}
}
else
{
byte[] data = (byte[]) converter.ConvertTo(value, typeof(byte[]));
string str = ToBase64WrappedString(data);
nodeInfo.ValueData = str;
nodeInfo.MimeType = ResXResourceWriter.ByteArraySerializedObjectMimeType;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
}
}
}
private object GenerateObjectFromDataNodeInfo(DataNodeInfo dataNodeInfo, ITypeResolutionService typeResolver)
{
object obj2 = null;
string mimeType = dataNodeInfo.MimeType;
string typeName = ((dataNodeInfo.TypeName == null) || (dataNodeInfo.TypeName.Length == 0)) ? MultitargetUtil.GetAssemblyQualifiedName(typeof(string), this.typeNameConverter) : dataNodeInfo.TypeName;
if ((mimeType != null) && (mimeType.Length > 0))
{
if ((string.Equals(mimeType, ResXResourceWriter.BinSerializedObjectMimeType) || string.Equals(mimeType, ResXResourceWriter.Beta2CompatSerializedObjectMimeType)) || string.Equals(mimeType, ResXResourceWriter.CompatBinSerializedObjectMimeType))
{
byte[] buffer = FromBase64WrappedString(dataNodeInfo.ValueData);
if (this.binaryFormatter == null)
{
this.binaryFormatter = new BinaryFormatter();
this.binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
}
IFormatter binaryFormatter = this.binaryFormatter;
if ((buffer != null) && (buffer.Length > 0))
{
obj2 = binaryFormatter.Deserialize(new MemoryStream(buffer));
if (obj2 is ResXNullRef)
{
obj2 = null;
}
}
return obj2;
}
if (string.Equals(mimeType, ResXResourceWriter.SoapSerializedObjectMimeType) || string.Equals(mimeType, ResXResourceWriter.CompatSoapSerializedObjectMimeType))
{
byte[] buffer2 = FromBase64WrappedString(dataNodeInfo.ValueData);
if ((buffer2 != null) && (buffer2.Length > 0))
{
obj2 = this.CreateSoapFormatter().Deserialize(new MemoryStream(buffer2));
if (obj2 is ResXNullRef)
{
obj2 = null;
}
}
return obj2;
}
if ((!string.Equals(mimeType, ResXResourceWriter.ByteArraySerializedObjectMimeType) || (typeName == null)) || (typeName.Length <= 0))
{
return obj2;
}
System.Type type = this.ResolveType(typeName, typeResolver);
if (type != null)
{
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter.CanConvertFrom(typeof(byte[])))
{
byte[] buffer3 = FromBase64WrappedString(dataNodeInfo.ValueData);
if (buffer3 != null)
{
obj2 = converter.ConvertFrom(buffer3);
}
}
return obj2;
}
string str6 = System.Windows.Forms.SR.GetString("TypeLoadException", new object[] { typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X });
XmlException exception = new XmlException(str6, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException exception2 = new TypeLoadException(str6, exception);
throw exception2;
}
if ((typeName == null) || (typeName.Length <= 0))
{
return obj2;
}
System.Type type2 = this.ResolveType(typeName, typeResolver);
if (type2 != null)
{
if (type2 == typeof(ResXNullRef))
{
return null;
}
if ((typeName.IndexOf("System.Byte[]") != -1) && (typeName.IndexOf("mscorlib") != -1))
{
return FromBase64WrappedString(dataNodeInfo.ValueData);
}
TypeConverter converter2 = TypeDescriptor.GetConverter(type2);
if (!converter2.CanConvertFrom(typeof(string)))
{
return obj2;
}
string valueData = dataNodeInfo.ValueData;
try
{
return converter2.ConvertFromInvariantString(valueData);
}
catch (NotSupportedException exception3)
{
string str8 = System.Windows.Forms.SR.GetString("NotSupported", new object[] { typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X, exception3.Message });
XmlException innerException = new XmlException(str8, exception3, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
NotSupportedException exception5 = new NotSupportedException(str8, innerException);
throw exception5;
}
}
string message = System.Windows.Forms.SR.GetString("TypeLoadException", new object[] { typeName, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X });
XmlException inner = new XmlException(message, null, dataNodeInfo.ReaderPosition.Y, dataNodeInfo.ReaderPosition.X);
TypeLoadException exception7 = new TypeLoadException(message, inner);
throw exception7;
}
private void FillDataNodeInfoFromObject(DataNodeInfo nodeInfo, object value)
{
CultureInfo info = value as CultureInfo;
if (info != null)
{
nodeInfo.ValueData = info.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
{
System.Type type = (value == null) ? typeof(object) : value.GetType();
if ((value != null) && !type.IsSerializable)
{
throw new InvalidOperationException(System.Windows.Forms.SR.GetString("NotSerializableType", new object[] { this.name, type.FullName }));
}
TypeConverter converter = TypeDescriptor.GetConverter(type);
bool flag = converter.CanConvertTo(typeof(string));
bool flag2 = converter.CanConvertFrom(typeof(string));
try
{
if (flag && flag2)
{
nodeInfo.ValueData = converter.ConvertToInvariantString(value);
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
return;
}
}
catch (Exception exception)
{
if (System.Windows.Forms.ClientUtils.IsSecurityOrCriticalException(exception))
{
throw;
}
}
bool flag3 = converter.CanConvertTo(typeof(byte[]));
bool flag4 = converter.CanConvertFrom(typeof(byte[]));
if (!flag3 || !flag4)
{
if (value == null)
{
nodeInfo.ValueData = string.Empty;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter);
}
else
{
if (this.binaryFormatter == null)
{
this.binaryFormatter = new BinaryFormatter();
}
MemoryStream serializationStream = new MemoryStream();
if (this.binaryFormatter == null)
{
this.binaryFormatter = new BinaryFormatter();
}
this.binaryFormatter.Serialize(serializationStream, value);
string str2 = ToBase64WrappedString(serializationStream.ToArray());
nodeInfo.ValueData = str2;
nodeInfo.MimeType = ResXResourceWriter.DefaultSerializedObjectMimeType;
}
}
else
{
byte[] data = (byte[])converter.ConvertTo(value, typeof(byte[]));
string str = ToBase64WrappedString(data);
nodeInfo.ValueData = str;
nodeInfo.MimeType = ResXResourceWriter.ByteArraySerializedObjectMimeType;
nodeInfo.TypeName = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
}
}
}
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;
}
