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 (ClientUtils.IsSecurityOrCriticalException(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)
{
string readerTypeName = null;
string writerTypeName = null;
if (resHeaderReaderType != null && resHeaderReaderType.IndexOf(',') != -1)
{
readerTypeName = resHeaderReaderType.Split(',')[0].Trim();
}
if (resHeaderWriterType != null && resHeaderWriterType.IndexOf(',') != -1)
{
writerTypeName = resHeaderWriterType.Split(',')[0].Trim();
}
if (readerTypeName != null &&
writerTypeName != null &&
readerTypeName.Equals(ResXConstants.ResHeaderReaderTypeName, StringComparison.OrdinalIgnoreCase) &&
writerTypeName.Equals(ResXConstants.ResHeaderWriterTypeName, StringComparison.OrdinalIgnoreCase))
{
validFile = true;
}
}
if (!validFile)
{
resData = null;
resMetadata = null;
throw new ArgumentException(SR.InvalidResXFileReaderWriterTypes);
}
}
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;
}
}
}
