public ResXDataNode(string name, object value, Func <Type, string> typeNameConverter)
{
if (name == null)
{
throw (new ArgumentNullException(nameof(name)));
}
if (name.Length == 0)
{
throw (new ArgumentException(nameof(name)));
}
this.typeNameConverter = typeNameConverter;
Type valueType = (value == null) ? typeof(object) : value.GetType();
if (value != null && !valueType.IsSerializable)
{
throw new InvalidOperationException(string.Format(SR.NotSerializableType, name, valueType.FullName));
}
if (value != null)
{
typeName = MultitargetUtil.GetAssemblyQualifiedName(valueType, this.typeNameConverter);
}
this.name = name;
this.value = value;
}
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);
}
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 string resource to the resources.
/// </devdoc>
private void AddDataRow(string elementName, string name, string value)
{
// if it's a null string, set it here as a resxnullref
string typeName =
value == null
? MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter)
: null;
AddDataRow(elementName, name, value, typeName, null, null);
}
private string TypeNameWithAssembly(Type type)
{
//
string result = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
return(result);
}
private void AddDataRow(string elementName, string name, string value)
{
if (value == null)
{
this.AddDataRow(elementName, name, value, MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter), null, null);
}
else
{
this.AddDataRow(elementName, name, value, null, null, null);
}
}
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 is not 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);
}
public ResXDataNode(string name, object value, Func <System.Type, string> typeNameConverter)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (name.Length == 0)
{
throw new ArgumentException("name");
}
this.typeNameConverter = typeNameConverter;
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[] { name, type.FullName }));
}
if (value != null)
{
this.typeName = MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter);
}
this.name = name;
this.value = value;
}
private void AddDataRow(string elementName, string name, string value, string type, string mimeType, string comment)
{
if (hasBeenSaved)
{
throw new InvalidOperationException(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 writeHeaderRequired = false;
if (textWriter != null)
{
textWriter.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
writeHeaderRequired = 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 (!writeHeaderRequired)
{
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 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 AddDataRow(string elementName, string name, string value, string type, string mimeType, string comment)
{
if (this.hasBeenSaved)
{
throw new InvalidOperationException(System.Windows.Forms.SR.GetString("ResXResourceWriterSaved"));
}
string aliasFromName = null;
if (!string.IsNullOrEmpty(type) && (elementName == "data"))
{
if (string.IsNullOrEmpty(this.GetFullName(type)))
{
try
{
System.Type type2 = System.Type.GetType(type);
if (type2 == typeof(string))
{
type = null;
}
else if (type2 != null)
{
string fullName = this.GetFullName(MultitargetUtil.GetAssemblyQualifiedName(type2, this.typeNameConverter));
aliasFromName = this.GetAliasFromName(new AssemblyName(fullName));
}
}
catch
{
}
}
else
{
aliasFromName = this.GetAliasFromName(new AssemblyName(this.GetFullName(type)));
}
}
this.Writer.WriteStartElement(elementName);
this.Writer.WriteAttributeString("name", name);
if ((!string.IsNullOrEmpty(aliasFromName) && !string.IsNullOrEmpty(type)) && (elementName == "data"))
{
string str4 = this.GetTypeName(type) + ", " + aliasFromName;
this.Writer.WriteAttributeString("type", str4);
}
else if (type != null)
{
this.Writer.WriteAttributeString("type", type);
}
if (mimeType != null)
{
this.Writer.WriteAttributeString("mimetype", mimeType);
}
if (((type == null) && (mimeType == null)) || ((type != null) && type.StartsWith("System.Char", StringComparison.Ordinal)))
{
this.Writer.WriteAttributeString("xml", "space", null, "preserve");
}
this.Writer.WriteStartElement("value");
if (!string.IsNullOrEmpty(value))
{
this.Writer.WriteString(value);
}
this.Writer.WriteEndElement();
if (!string.IsNullOrEmpty(comment))
{
this.Writer.WriteStartElement("comment");
this.Writer.WriteString(comment);
this.Writer.WriteEndElement();
}
this.Writer.WriteEndElement();
}
private void ParseXml(XmlTextReader reader)
{
bool success = false;
try
{
try
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
string s = reader.LocalName;
if (reader.LocalName.Equals(ResXResourceWriter.AssemblyStr))
{
ParseAssemblyNode(reader);
}
else if (reader.LocalName.Equals(ResXResourceWriter.DataStr))
{
ParseDataNode(reader, false);
}
else if (reader.LocalName.Equals(ResXResourceWriter.ResHeaderStr))
{
ParseResHeaderNode(reader);
}
else if (reader.LocalName.Equals(ResXResourceWriter.MetadataStr))
{
ParseDataNode(reader, true);
}
}
}
success = true;
}
catch (SerializationException se)
{
Point pt = GetPosition(reader);
string newMessage = string.Format(SR.SerializationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, se.Message);
XmlException xml = new XmlException(newMessage, se, pt.Y, pt.X);
SerializationException newSe = new SerializationException(newMessage, xml);
throw newSe;
}
catch (TargetInvocationException tie)
{
Point pt = GetPosition(reader);
string newMessage = string.Format(SR.InvocationException, reader[ResXResourceWriter.TypeStr], pt.Y, pt.X, tie.InnerException.Message);
XmlException xml = new XmlException(newMessage, tie.InnerException, pt.Y, pt.X);
TargetInvocationException newTie = new TargetInvocationException(newMessage, xml);
throw newTie;
}
catch (XmlException e)
{
throw new ArgumentException(string.Format(SR.InvalidResXFile, e.Message), e);
}
catch (Exception e)
{
if (MultitargetUtil.IsCriticalException(e))
{
throw;
}
else
{
Point pt = GetPosition(reader);
XmlException xmlEx = new XmlException(e.Message, e, pt.Y, pt.X);
throw new ArgumentException(string.Format(SR.InvalidResXFile, xmlEx.Message), xmlEx);
}
}
}
finally
{
if (!success)
{
_resData = null;
_resMetadata = null;
}
}
bool validFile = false;
if (_resHeaderMimeType == ResXResourceWriter.ResMimeType)
{
Type readerType = typeof(ResXResourceReader);
Type writerType = typeof(ResXResourceWriter);
string readerTypeName = _resHeaderReaderType;
string writerTypeName = _resHeaderWriterType;
if (readerTypeName != null && readerTypeName.IndexOf(',') != -1)
{
readerTypeName = readerTypeName.Split(',')[0].Trim();
}
if (writerTypeName != null && writerTypeName.IndexOf(',') != -1)
{
writerTypeName = writerTypeName.Split(',')[0].Trim();
}
if (readerTypeName != null &&
writerTypeName != null &&
readerTypeName.Equals(readerType.FullName) &&
writerTypeName.Equals(writerType.FullName))
{
validFile = true;
}
}
if (!validFile)
{
_resData = null;
_resMetadata = null;
throw new ArgumentException(SR.InvalidResXFileReaderWriterTypes);
}
}
public string GetValueTypeName(ITypeResolutionService typeResolver)
{
if ((this.typeName != null) && (this.typeName.Length > 0))
{
if (this.typeName.Equals(MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), this.typeNameConverter)))
{
return(MultitargetUtil.GetAssemblyQualifiedName(typeof(object), this.typeNameConverter));
}
return(this.typeName);
}
string fileRefType = this.FileRefType;
System.Type type = null;
if (fileRefType != null)
{
type = this.ResolveType(this.FileRefType, typeResolver);
}
else if (this.nodeInfo != null)
{
fileRefType = this.nodeInfo.TypeName;
if ((fileRefType == null) || (fileRefType.Length == 0))
{
if ((this.nodeInfo.MimeType != null) && (this.nodeInfo.MimeType.Length > 0))
{
object obj2 = null;
try
{
obj2 = this.GenerateObjectFromDataNodeInfo(this.nodeInfo, typeResolver);
}
catch (Exception exception)
{
if (System.Windows.Forms.ClientUtils.IsCriticalException(exception))
{
throw;
}
fileRefType = MultitargetUtil.GetAssemblyQualifiedName(typeof(object), this.typeNameConverter);
}
if (obj2 != null)
{
fileRefType = MultitargetUtil.GetAssemblyQualifiedName(obj2.GetType(), this.typeNameConverter);
}
}
else
{
fileRefType = MultitargetUtil.GetAssemblyQualifiedName(typeof(string), this.typeNameConverter);
}
}
else
{
type = this.ResolveType(this.nodeInfo.TypeName, typeResolver);
}
}
if (type == null)
{
return(fileRefType);
}
if (type == typeof(ResXNullRef))
{
return(MultitargetUtil.GetAssemblyQualifiedName(typeof(object), this.typeNameConverter));
}
return(MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter));
}
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 InitializeWriter()
{
if (this.xmlTextWriter == null)
{
bool flag = false;
if (this.textWriter != null)
{
this.textWriter.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
flag = true;
this.xmlTextWriter = new XmlTextWriter(this.textWriter);
}
else if (this.stream != null)
{
this.xmlTextWriter = new XmlTextWriter(this.stream, Encoding.UTF8);
}
else
{
this.xmlTextWriter = new XmlTextWriter(this.fileName, Encoding.UTF8);
}
this.xmlTextWriter.Formatting = Formatting.Indented;
this.xmlTextWriter.Indentation = 2;
if (!flag)
{
this.xmlTextWriter.WriteStartDocument();
}
}
else
{
this.xmlTextWriter.WriteStartDocument();
}
this.xmlTextWriter.WriteStartElement("root");
XmlTextReader reader = new XmlTextReader(new StringReader(ResourceSchema))
{
WhitespaceHandling = WhitespaceHandling.None
};
this.xmlTextWriter.WriteNode(reader, true);
this.xmlTextWriter.WriteStartElement("resheader");
this.xmlTextWriter.WriteAttributeString("name", "resmimetype");
this.xmlTextWriter.WriteStartElement("value");
this.xmlTextWriter.WriteString(ResMimeType);
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteStartElement("resheader");
this.xmlTextWriter.WriteAttributeString("name", "version");
this.xmlTextWriter.WriteStartElement("value");
this.xmlTextWriter.WriteString(Version);
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteStartElement("resheader");
this.xmlTextWriter.WriteAttributeString("name", "reader");
this.xmlTextWriter.WriteStartElement("value");
this.xmlTextWriter.WriteString(MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXResourceReader), this.typeNameConverter));
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteStartElement("resheader");
this.xmlTextWriter.WriteAttributeString("name", "writer");
this.xmlTextWriter.WriteStartElement("value");
this.xmlTextWriter.WriteString(MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXResourceWriter), this.typeNameConverter));
this.xmlTextWriter.WriteEndElement();
this.xmlTextWriter.WriteEndElement();
this.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 = 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 string TypeNameWithAssembly(System.Type type)
{
return(MultitargetUtil.GetAssemblyQualifiedName(type, this.typeNameConverter));
}
/// <summary>
/// Get the FQ type name for this datanode.
/// We return typeof(object) for ResXNullRef
/// </summary>
public string GetValueTypeName(ITypeResolutionService typeResolver)
{
// the type name here is always a FQN
if (!string.IsNullOrEmpty(typeName))
{
return
(typeName == MultitargetUtil.GetAssemblyQualifiedName(typeof(ResXNullRef), typeNameConverter)
? MultitargetUtil.GetAssemblyQualifiedName(typeof(object), typeNameConverter)
: 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 (string.IsNullOrEmpty(result))
{
// 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 (!string.IsNullOrEmpty(nodeInfo.MimeType))
{
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), typeNameConverter);
}
if (insideObject != null)
{
result = MultitargetUtil.GetAssemblyQualifiedName(insideObject.GetType(), typeNameConverter);
}
}
else
{
// no typename, no mimetype, we have a string...
result = MultitargetUtil.GetAssemblyQualifiedName(typeof(string), typeNameConverter);
}
}
else
{
objectType = ResolveType(nodeInfo.TypeName, typeResolver);
}
}
if (objectType != null)
{
if (objectType == typeof(ResXNullRef))
{
result = MultitargetUtil.GetAssemblyQualifiedName(typeof(object), typeNameConverter);
}
else
{
result = MultitargetUtil.GetAssemblyQualifiedName(objectType, typeNameConverter);
}
}
return(result);
}
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);
}
}
}
