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);
}
}
private void ParseDataNode(bool meta)
{
Hashtable hashtable = ((meta && !useResXDataNodes) ? hashtm : hasht);
Point_ pos = new Point_(((IXmlLineInfo)xmlReader).LineNumber, ((IXmlLineInfo)xmlReader).LinePosition);
string name = GetAttribute("name");
string type_name = GetAttribute("type");
string mime_type = GetAttribute("mimetype");
string comment = null;
string value = GetDataValue(meta, out comment);
ResXDataNode node = new ResXDataNode(name, mime_type, type_name, value, comment, pos, BasePath);
if (useResXDataNodes)
{
hashtable [name] = node;
return;
}
if (name == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"Could not find a name for a resource. The resource value was '{0}'.",
node.GetValue((AssemblyName [])null).ToString()));
}
// useResXDataNodes is false, add to dictionary of values
if (assemblyNames != null)
{
try {
hashtable [name] = node.GetValue(assemblyNames);
} catch (TypeLoadException ex) {
// different error messages depending on type of resource, hacky solution
if (node.handler is TypeConverterFromResXHandler)
{
hashtable [name] = null;
}
else
{
throw ex;
}
}
}
else // there is a typeresolver or its null
{
try {
hashtable [name] = node.GetValue(typeresolver);
} catch (TypeLoadException ex) {
if (node.handler is TypeConverterFromResXHandler)
{
hashtable [name] = null;
}
else
{
throw ex;
}
}
}
}
/// <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;
}
}
}
/// <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);
}
}
/// <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);
}
public void AddResource(ResXDataNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (writer == null)
{
InitWriter();
}
if (node.IsWritable)
{
WriteWritableNode(node);
}
else if (node.FileRef != null)
{
AddResource(node.Name, node.FileRef, node.Comment);
}
else
{
AddResource(node.Name, node.GetValue((AssemblyName [])null), node.Comment);
}
}
public void Update(ResxTranslatorTableRow row, ResXDataNode entry, bool isSource = true)
{
try
{
if (null == row) return;
if (isSource)
{
// ソース
row.SourceValue = entry.GetValue((ITypeResolutionService)null).ToString();
}
else
{
// ターゲット
row.TargetValue = entry.GetValue((ITypeResolutionService)null).ToString();
}
// コメント
if (string.IsNullOrWhiteSpace(row.Comment))
{
row.Comment = entry.Comment;
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
public void Add(ResXDataNode entry, bool isSource = true)
{
try
{
if (isSource)
{
// ソース
this.ResxTranslatorTable.AddResxTranslatorTableRow(
entry.Name,
entry.GetValue((ITypeResolutionService)null).ToString(),
string.Empty,
entry.Comment
);
}
else
{
// ターゲット
this.ResxTranslatorTable.AddResxTranslatorTableRow(
entry.Name,
string.Empty,
entry.GetValue((ITypeResolutionService)null).ToString(),
entry.Comment
);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
public void ITRSNotUsedWhenNodeCreatedNew ()
{
ResXDataNode node;
node = new ResXDataNode ("along", 34L);
string returnedType = node.GetValueTypeName (new ReturnIntITRS ());
Assert.AreEqual ((typeof (long)).AssemblyQualifiedName, returnedType, "#A1");
}
public void ITRSNotUsedWhenCreatedNew ()
{
ResXDataNode node;
node = new ResXDataNode ("along", 34L);
object obj = node.GetValue (new ReturnIntITRS ());
Assert.IsInstanceOfType (typeof (long), obj, "#A1");
}
public void ITRSUsedWithNodeFromReader ()
{
ResXDataNode returnedNode, originalNode;
originalNode = new ResXDataNode ("aNumber", 23L);
returnedNode = GetNodeFromResXReader (originalNode);
Assert.IsNotNull (returnedNode, "#A1");
string returnedType = returnedNode.GetValueTypeName (new ReturnIntITRS ());
Assert.AreEqual ((typeof (Int32)).AssemblyQualifiedName, returnedType, "#A2");
}
/// <summary>
/// May return null.
/// </summary>
public virtual ResXDataNode ToResXDataNode()
{
ResXDataNode result = null;
if (!String.IsNullOrEmpty(_name)) {
result = new ResXDataNode(_name, _value);
if (!String.IsNullOrEmpty(Metadata_Comment)) result.Comment = Metadata_Comment;
}
return result;
}
public void ITRSUsedEachTimeWhenNodeFromReader ()
{
ResXDataNode returnedNode, originalNode;
originalNode = new ResXDataNode ("aNumber", 23L);
returnedNode = GetNodeFromResXReader (originalNode);
Assert.IsNotNull (returnedNode, "#A1");
string newType = returnedNode.GetValueTypeName (new ReturnIntITRS ());
Assert.AreEqual (typeof (int).AssemblyQualifiedName, newType, "#A2");
string origType = returnedNode.GetValueTypeName ((ITypeResolutionService) null);
Assert.AreEqual (typeof (long).AssemblyQualifiedName, origType, "#A3");
}
public void BuildResX(string outputPath)
{
using (ResXResourceWriter w2 = new ResXResourceWriter(outputPath))
{
foreach (Item item in _items)
{
ResXDataNode node = new ResXDataNode(item.Name, item.Value);
node.Comment = item.Comment;
w2.AddResource(item.Name, node);
}
}
}
public void ResXNullRef_WriteBack ()
{
ResXDataNode node = new ResXDataNode ("NullRef", (object) null);
node.Comment = "acomment";
ResXDataNode returnedNode = GetNodeFromResXReader (node);
Assert.IsNotNull (returnedNode, "#A1");
Assert.IsNull (returnedNode.GetValue ((AssemblyName []) null), "#A2");
Assert.AreEqual ("acomment", returnedNode.Comment,"#A3");
ResXDataNode finalNode = GetNodeFromResXReader (returnedNode);
Assert.IsNotNull (finalNode, "#A4");
Assert.IsNull (finalNode.GetValue ((AssemblyName []) null), "#A5");
Assert.AreEqual ("acomment", finalNode.Comment,"#A6");
}
public StringEntry(ResourceCatalog _owner, ResXDataNode _node, bool isMeta)
{
if (_node == null)
throw new ArgumentNullException ("node");
if (!_node.GetValueTypeName ((AssemblyName []) null).StartsWith ("System.String, mscorlib"))
throw new ArgumentException ("node","Should be string resource");
if (_node.FileRef != null)
throw new ArgumentException ("node", "FileRef should not be set");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = _node;
SetRelativePos ();
}
public IconEntry(ResourceCatalog _owner, ResXDataNode _node, bool isMeta)
{
if (_node == null)
throw new ArgumentNullException ("node");
string nodeTypeName = _node.GetValueTypeName ((AssemblyName []) null);
if (!nodeTypeName.StartsWith ("System.Drawing.Icon, System.Drawing"))
throw new ArgumentException ("node","Invalid resource type");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = _node;
SetRelativePos ();
}
// <devdoc>
// this is a deep clone
//</devdoc>
internal ResXDataNode DeepClone()
{
ResXDataNode result = new ResXDataNode();
result.nodeInfo = (this.nodeInfo != null) ? this.nodeInfo.Clone() : null; // nodeinfo is just made up of immutable objects, we don't need to clone it
result.name = this.name;
result.comment = this.comment;
result.typeName = this.typeName;
result.fileRefFullPath = this.fileRefFullPath;
result.fileRefType = this.fileRefType;
result.fileRefTextEncoding = this.fileRefTextEncoding;
result.value = this.value; // we don't clone the value, because we don't know how
result.fileRef = (this.fileRef != null) ? this.fileRef.Clone() : null;
result.typeNameConverter = this.typeNameConverter;
return(result);
}
public OtherEmbeddedEntry(ResourceCatalog _owner, string _name, object _value, bool isMeta)
{
if (_name == null)
throw new ArgumentNullException ("name");
if (_name == String.Empty)
throw new ArgumentException ("name", "Name should not be empty");
if (_value == null)
throw new ArgumentNullException ("value");
if (_value is string || _value is Icon || _value is Bitmap || _value is MemoryStream)
throw new ArgumentException ("value", "Invalid type");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = new ResXDataNode (_name,_value);
SetRelativePos ();
}
protected ResXDataNode GetNodeFromResXReader (ResXDataNode node)
{
StringWriter sw = new StringWriter ();
using (ResXResourceWriter writer = new ResXResourceWriter (sw)) {
writer.AddResource (node);
}
StringReader sr = new StringReader (sw.GetStringBuilder ().ToString ());
using (ResXResourceReader reader = new ResXResourceReader (sr)) {
reader.UseResXDataNodes = true;
IDictionaryEnumerator enumerator = reader.GetEnumerator ();
enumerator.MoveNext ();
return ((DictionaryEntry) enumerator.Current).Value as ResXDataNode;
}
}
public StringEntry(ResourceCatalog _owner, string _name, string _value, string _comment, bool isMeta)
{
if (_name == null)
throw new ArgumentNullException ("name");
if (_name == String.Empty)
throw new ArgumentException ("name","Should not be empty");
if (_value == null)
throw new ArgumentNullException ("value");
if (!(_value is String))
throw new ArgumentException ("value", "Should be string resource");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = new ResXDataNode (_name, _value); //FIXME: perhaps shouldn't create node yet
node.Comment = _comment;
SetRelativePos ();
}
public BinaryOrStringEntry(ResourceCatalog _owner, ResXDataNode _node, bool isMeta)
{
if (_node == null)
throw new ArgumentNullException ("node");
if (_node.FileRef == null)
throw new ArgumentNullException ("node","FileRef should be set");
string nodeTypeName = _node.GetValueTypeName ((AssemblyName []) null);
if (!nodeTypeName.StartsWith ("System.String, mscorlib") &&
!nodeTypeName.StartsWith ("System.Byte[], mscorlib"))
throw new ArgumentException ("node","Only string or byte[] TypeName allowed");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = _node;
SetRelativePos ();
}
public IconEntry(ResourceCatalog _owner, string _name,
string _fileName, bool isMeta)
{
if (_name == null)
throw new ArgumentNullException ("name");
if (_name == String.Empty)
throw new ArgumentException ("name", "should not be empty");
if (_fileName == null)
throw new ArgumentNullException ("fileName");
if (!(_fileName.EndsWith (".ico")))
throw new ArgumentException ("fileName", "must point to a .ico file");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = new ResXDataNode (_name, new ResXFileRef (_fileName, typeof (Icon).AssemblyQualifiedName)); // same ver as MD
SetRelativePos ();
}
public OtherFileEntry(ResourceCatalog _owner, ResXDataNode _node, bool isMeta)
{
if (_node == null)
throw new ArgumentNullException ("node");
if (_node.FileRef == null)
throw new ArgumentNullException ("node","FileRef should be set");
string nodeTypeName = _node.GetValueTypeName ((AssemblyName []) null);
if (nodeTypeName.StartsWith ("System.String, mscorlib") ||
nodeTypeName.StartsWith ("System.Drawing.Bitmap, System.Drawing") ||
nodeTypeName.StartsWith ("System.Drawing.Icon, System.Drawing") ||
nodeTypeName.StartsWith ("System.IO.MemoryStream, mscorlib"))
throw new ArgumentException ("node","Invalid resource type");
if (_owner == null)
throw new ArgumentNullException ("owner");
IsMeta = isMeta;
Owner = _owner;
node = _node;
SetRelativePos ();
}
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);
}
/*
* //adapted from MonoDevelop.Core
* unsafe static string AbsoluteToRelativePath (string baseDirectoryPath, string absPath)
* {
* if (string.IsNullOrEmpty (baseDirectoryPath))
* return absPath;
*
* baseDirectoryPath = baseDirectoryPath.TrimEnd (Path.DirectorySeparatorChar);
*
* fixed (char* bPtr = baseDirectoryPath, aPtr = absPath) {
* var bEnd = bPtr + baseDirectoryPath.Length;
* var aEnd = aPtr + absPath.Length;
* char* lastStartA = aEnd;
* char* lastStartB = bEnd;
*
* int indx = 0;
* // search common base path
* var a = aPtr;
* var b = bPtr;
* while (a < aEnd) {
* if (*a != *b)
* break;
* if (IsSeparator (*a)) {
* indx++;
* lastStartA = a + 1;
* lastStartB = b;
* }
* a++;
* b++;
* if (b >= bEnd) {
* if (a >= aEnd || IsSeparator (*a)) {
* indx++;
* lastStartA = a + 1;
* lastStartB = b;
* }
* break;
* }
* }
* if (indx == 0)
* return absPath;
*
* if (lastStartA >= aEnd)
* return ".";
*
* // handle case a: some/path b: some/path/deeper...
* if (a >= aEnd) {
* if (IsSeparator (*b)) {
* lastStartA = a + 1;
* lastStartB = b;
* }
* }
*
* // look how many levels to go up into the base path
* int goUpCount = 0;
* while (lastStartB < bEnd) {
* if (IsSeparator (*lastStartB))
* goUpCount++;
* lastStartB++;
* }
* var size = goUpCount * 2 + goUpCount + aEnd - lastStartA;
* var result = new char [size];
* fixed (char* rPtr = result) {
* // go paths up
* var r = rPtr;
* for (int i = 0; i < goUpCount; i++) {
*(r++) = '.';
*(r++) = '.';
*(r++) = Path.DirectorySeparatorChar;
* }
* // copy the remaining absulute path
* while (lastStartA < aEnd)
*(r++) = *(lastStartA++);
* }
* return new string (result);
* }
* }
*/
// avoids instantiating objects
void WriteWritableNode(ResXDataNode node)
{
writer.WriteStartElement("data");
writer.WriteAttributeString("name", node.Name);
if (!(node.Type == null || node.Type.Equals(String.Empty)))
{
writer.WriteAttributeString("type", node.Type);
}
if (!(node.MimeType == null || node.MimeType.Equals(String.Empty)))
{
writer.WriteAttributeString("mimetype", node.MimeType);
}
writer.WriteStartElement("value");
writer.WriteString(node.DataString);
writer.WriteEndElement();
if (!(node.Comment == null || node.Comment.Equals(String.Empty)))
{
writer.WriteStartElement("comment");
writer.WriteString(node.Comment);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteWhitespace("\n ");
}
public void ConstructorEx3 ()
{
ResXDataNode d = new ResXDataNode ("", (object) null);
}
public void ConstructorEx2B ()
{
ResXDataNode d = new ResXDataNode ("aname", (ResXFileRef) null);
}
string GetResXFileWithNode (ResXDataNode node, string filename)
{
string fullfileName;
_tempDirectory = Path.Combine (Path.GetTempPath (), "ResXDataNodeTest");
_otherTempDirectory = Path.Combine (_tempDirectory, "in");
if (!Directory.Exists (_otherTempDirectory)) {
Directory.CreateDirectory (_otherTempDirectory);
}
fullfileName = Path.Combine (_tempDirectory, filename);
using (ResXResourceWriter writer = new ResXResourceWriter (fullfileName)) {
writer.AddResource (node);
}
return fullfileName;
}
public void BasePathSetOnResXResourceReaderDoesAffectResXDataNode ()
{
ResXFileRef fileRef = new ResXFileRef ("file.name", "type.name");
ResXDataNode node = new ResXDataNode("anode", fileRef);
string resXFile = GetResXFileWithNode (node, "afilename.xxx");
using (ResXResourceReader rr = new ResXResourceReader (resXFile)) {
rr.BasePath = "basePath";
rr.UseResXDataNodes = true;
IDictionaryEnumerator en = rr.GetEnumerator ();
en.MoveNext ();
ResXDataNode returnedNode = ((DictionaryEntry) en.Current).Value as ResXDataNode;
Assert.IsNotNull (node, "#A1");
Assert.AreEqual (Path.Combine ("basePath", "file.name"), returnedNode.FileRef.FileName, "#A2");
}
}
public void ITRSPassedToResourceReaderDoesNotAffectResXDataNode_Serializable ()
{
serializable ser = new serializable ("aaaaa", "bbbbb");
ResXDataNode dn = new ResXDataNode ("test", ser);
string resXFile = GetResXFileWithNode (dn,"resx.resx");
ResXResourceReader rr = new ResXResourceReader (resXFile, new ReturnSerializableSubClassITRS ());
rr.UseResXDataNodes = true;
IDictionaryEnumerator en = rr.GetEnumerator ();
en.MoveNext ();
ResXDataNode node = ((DictionaryEntry) en.Current).Value as ResXDataNode;
Assert.IsNotNull (node, "#A1");
object o = node.GetValue ((AssemblyName []) null);
Assert.IsNotInstanceOfType (typeof (serializableSubClass), o, "#A2");
Assert.IsInstanceOfType (typeof (serializable), o, "#A3");
rr.Close ();
}
public void ITRSPassedToResourceReaderDoesNotAffectResXDataNode_TypeConverter ()
{
ResXDataNode dn = new ResXDataNode ("test", 34L);
string resXFile = GetResXFileWithNode (dn,"resx.resx");
ResXResourceReader rr = new ResXResourceReader (resXFile, new ReturnIntITRS ());
rr.UseResXDataNodes = true;
IDictionaryEnumerator en = rr.GetEnumerator ();
en.MoveNext ();
ResXDataNode node = ((DictionaryEntry) en.Current).Value as ResXDataNode;
Assert.IsNotNull (node, "#A1");
object o = node.GetValue ((AssemblyName []) null);
Assert.IsInstanceOfType (typeof (long), o, "#A2");
Assert.AreEqual (34L, o, "#A3");
rr.Close ();
}
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);
}
}
}
public void ConstructorEx6 ()
{
ResXDataNode d = new ResXDataNode ("name", new notserializable ());
}
public void ConstructorEx4 ()
{
ResXDataNode d = new ResXDataNode ("", (ResXFileRef) null);
}
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);
}
}
}
public void AddResource(ResXDataNode node)
{
throw null;
}
private void ParseDataNode(bool meta)
{
Hashtable hashtable = ((meta && !useResXDataNodes) ? hashtm : hasht);
Point pos = new Point(xmlReader.LineNumber, xmlReader.LinePosition);
string name = GetAttribute("name");
string type_name = GetAttribute("type");
string mime_type = GetAttribute("mimetype");
Type type = type_name == null ? null : ResolveType(type_name);
if (type_name != null && type == null)
{
throw new ArgumentException(String.Format(
"The type '{0}' of the element '{1}' could not be resolved.", type_name, name));
}
if (type == typeof(ResXNullRef))
{
if (useResXDataNodes)
{
hashtable [name] = new ResXDataNode(name, null, pos);
}
else
{
hashtable [name] = null;
}
return;
}
string comment = null;
string value = GetDataValue(meta, out comment);
object obj = null;
if (mime_type != null && mime_type.Length > 0)
{
if (mime_type == ResXResourceWriter.BinSerializedObjectMimeType)
{
byte [] data = Convert.FromBase64String(value);
BinaryFormatter f = new BinaryFormatter();
using (MemoryStream s = new MemoryStream(data)) {
obj = f.Deserialize(s);
}
}
else if (mime_type == ResXResourceWriter.ByteArraySerializedObjectMimeType)
{
if (type != null)
{
TypeConverter c = TypeDescriptor.GetConverter(type);
if (c.CanConvertFrom(typeof(byte [])))
{
obj = c.ConvertFrom(Convert.FromBase64String(value));
}
}
}
}
else if (type != null)
{
if (type == typeof(byte []))
{
obj = Convert.FromBase64String(value);
}
else
{
TypeConverter c = TypeDescriptor.GetConverter(type);
if (c.CanConvertFrom(typeof(string)))
{
if (BasePath != null && type == typeof(ResXFileRef))
{
string [] parts = ResXFileRef.Parse(value);
parts [0] = Path.Combine(BasePath, parts [0]);
obj = c.ConvertFromInvariantString(string.Join(";", parts));
}
else
{
obj = c.ConvertFromInvariantString(value);
}
}
}
}
else
{
obj = value;
}
if (name == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"Could not find a name for a resource. The resource value "
+ "was '{0}'.", obj));
}
if (useResXDataNodes)
{
ResXDataNode dataNode = new ResXDataNode(name, obj, pos);
dataNode.Comment = comment;
hashtable [name] = dataNode;
}
else
{
hashtable [name] = obj;
}
}
public void ConstructorEx5 ()
{
ResXDataNode d = new ResXDataNode ("", new ResXFileRef ("filename", "typename"));
}
public void AddResource(ResXDataNode node)
{
AddResource(node.Name, node.Value, node.Comment);
}
public void Name ()
{
ResXDataNode node = new ResXDataNode ("startname", (object) null);
Assert.AreEqual ("startname", node.Name, "#A1");
node.Name = "newname";
Assert.AreEqual ("newname", node.Name, "#A2");
}
public void NullObjectReturnedFromResXGetValueTypeNameReturnsObject ()
{
ResXDataNode node = new ResXDataNode ("aname", (object) null);
ResXDataNode returnedNode = GetNodeFromResXReader (node);
Assert.IsNotNull (returnedNode, "#A1");
Assert.IsNull (returnedNode.GetValue ((AssemblyName []) null), "#A2");
string type = returnedNode.GetValueTypeName ((AssemblyName []) null);
Assert.AreEqual (typeof (object).AssemblyQualifiedName, type, "#A3");
}
public void AddResource (ResXDataNode node)
{
AddResource (node.Name, node.Value, node.Comment);
}
public void DoesNotRequireResXFileToBeOpen_Serializable ()
{
serializable ser = new serializable ("aaaaa", "bbbbb");
ResXDataNode dn = new ResXDataNode ("test", ser);
string resXFile = GetResXFileWithNode (dn,"resx.resx");
ResXResourceReader rr = new ResXResourceReader (resXFile);
rr.UseResXDataNodes = true;
IDictionaryEnumerator en = rr.GetEnumerator ();
en.MoveNext ();
ResXDataNode node = ((DictionaryEntry) en.Current).Value as ResXDataNode;
rr.Close ();
File.Delete ("resx.resx");
Assert.IsNotNull (node,"#A1");
serializable o = node.GetValue ((AssemblyName []) null) as serializable;
Assert.IsNotNull (o, "#A2");
}