/// <summary>
/// 将resources文件转换为resx文件,如果转换成功,返回True
/// </summary>
/// <param name="strResources">resources文件的路径,注意请保证路径正确无误</param>
/// <param name="strResx">res文件的路径,注意请保证路径正确无误</param>
public static bool ConvertRes(string strResources, string strResx)
{
if (string.IsNullOrEmpty(strResources) || string.IsNullOrEmpty(strResx))
{
return(false);
}
if (File.Exists(strResources) && File.Exists(strResx) == false)
{
return(false);
}
//开始转换.
try
{
ResourceReader reader = new ResourceReader(strResources);
ResXResourceWriter writer = new ResXResourceWriter(strResx);
foreach (DictionaryEntry en in reader)
{
writer.AddMetadata(en.Key.ToString(), en.Value);
}
reader.Close();
writer.Close();
}
catch
{
return(false);
}
return(true);
}
// ********************************************************************************************************************************
/// <summary>
/// Save changes done to the resource content to disk.
/// </summary>
/// <param name="writer">The <see cref="IResourceWriter" /> to be used to save the resource content.</param>
protected override void SaveContent(IResourceWriter writer)
{
base.SaveContent(writer);
ResXResourceWriter w = (ResXResourceWriter)writer;
foreach (KeyValuePair <string, object> entry in this.metadata)
{
w.AddMetadata(entry.Key, entry.Value);
}
}
public void WriteToFile(string fileName)
{
using (var resxWriter = new ResXResourceWriter(fileName)) {
Resources.ForEach(resxWriter.AddResource);
if (Resources.Count == 0)
{
resxWriter.AddMetadata("", "");
}
}
}
public void Save()
{
if (!IsDirty)
{
return;
}
if (File.Exists(TargetResXFileName))
{
File.Delete(TargetResXFileName);
}
bool containsTranslation = false;
foreach (var str in StringsWithTranslations)
{
containsTranslation = true;
break;
}
if (containsTranslation)
{
if (!FileSystemWalker.TranslationsDirExists)
{
Directory.CreateDirectory(FileSystemWalker.TranslationsDirectory);
}
using (ResXResourceWriter writer = new ResXResourceWriter(TargetResXFileName))
{
foreach (var str in StringsWithTranslations)
{
writer.AddResource(str.Key, str.Target);
writer.AddMetadata(OrgSourceMetadataKeyPrefix + str.Key, str.TranslatedSource);
}
}
}
else
{
if (File.Exists(TargetResXFileName))
{
File.Delete(TargetResXFileName);
}
}
// Clear dirty flag
foreach (var str in translatableStrings)
{
str.ClearDirty();
}
}
public void WriteToFile(IEnumerable <ResXNode> nodes)
{
using (var writer = new ResXResourceWriter(Path)) {
foreach (var item in nodes)
{
writer.AddResource(item);
}
foreach (var item in Metadata)
{
writer.AddMetadata(item.Name, GetValue(item));
}
writer.Generate();
}
}
public void WriteToFile()
{
using (var writer = new ResXResourceWriter(path))
{
foreach (var item in Nodes)
{
writer.AddResource(item);
}
foreach (var item in Metadata)
{
writer.AddMetadata(item.Name, item.Value);
}
writer.Generate();
}
FileService.NotifyFileChanged(path);
}
private void OnSerializationComplete(object sender, EventArgs e)
{
if (this.writer != null)
{
this.writer.Close();
this.writer = null;
}
if (this.invariantCultureResourcesDirty || this.metadataResourcesDirty)
{
IResourceService service = (IResourceService)this.manager.GetService(typeof(IResourceService));
if (service != null)
{
IResourceWriter resourceWriter = service.GetResourceWriter(CultureInfo.InvariantCulture);
try
{
object obj2 = this.ResourceTable[CultureInfo.InvariantCulture];
IDictionaryEnumerator enumerator = ((Hashtable)obj2).GetEnumerator();
while (enumerator.MoveNext())
{
string key = (string)enumerator.Key;
object obj3 = enumerator.Value;
resourceWriter.AddResource(key, obj3);
}
this.invariantCultureResourcesDirty = false;
ResXResourceWriter writer2 = resourceWriter as ResXResourceWriter;
if (writer2 != null)
{
foreach (DictionaryEntry entry in this.metadata)
{
writer2.AddMetadata((string)entry.Key, entry.Value);
}
}
this.metadataResourcesDirty = false;
return;
}
finally
{
resourceWriter.Close();
}
}
this.invariantCultureResourcesDirty = false;
this.metadataResourcesDirty = false;
}
}
public void SaveFile(string filename, Stream stream)
{
switch (Path.GetExtension(filename).ToLowerInvariant())
{
// write XML resource
case ".resx":
ResXResourceWriter rxw = new ResXResourceWriter(stream, t => ResXConverter.ConvertTypeName(t, filename));
foreach (KeyValuePair <string, ResourceItem> entry in resources)
{
if (entry.Value != null)
{
ResourceItem item = entry.Value;
rxw.AddResource(item.Name, item.ResourceValue);
}
}
foreach (KeyValuePair <string, ResourceItem> entry in metadata)
{
if (entry.Value != null)
{
ResourceItem item = entry.Value;
rxw.AddMetadata(item.Name, item.ResourceValue);
}
}
rxw.Generate();
rxw.Close();
break;
// write default resource
default:
ResourceWriter rw = new ResourceWriter(stream);
foreach (KeyValuePair <string, ResourceItem> entry in resources)
{
ResourceItem item = (ResourceItem)entry.Value;
rw.AddResource(item.Name, item.ResourceValue);
}
rw.Generate();
rw.Close();
break;
}
}
public void SaveFile(FileName filename, Stream stream)
{
switch (Path.GetExtension(filename).ToLowerInvariant())
{
case ".resx":
// write XML resource
ResXResourceWriter rxw = new ResXResourceWriter(stream, t => ResXConverter.ConvertTypeName(t, filename));
foreach (ResourceItem entry in resourceItems)
{
if (entry != null)
{
rxw.AddResource(entry.ToResXDataNode(t => ResXConverter.ConvertTypeName(t, filename)));
}
}
foreach (ResourceItem entry in metadataItems)
{
if (entry != null)
{
rxw.AddMetadata(entry.Name, entry.ResourceValue);
}
}
rxw.Generate();
rxw.Close();
break;
default:
// write default resource
ResourceWriter rw = new ResourceWriter(stream);
foreach (ResourceItem entry in resourceItems)
{
rw.AddResource(entry.Name, entry.ResourceValue);
}
rw.Generate();
rw.Close();
break;
}
}
/// <summary>
/// Save one resource file
/// </summary>
private void UpdateFile(string filename, string valueColumnId, bool skipNontranslatableData, bool saveComments)
{
// Read the entire resource file to a buffer
var originalMetadatas = new Dictionary <string, object>();
var originalResources = new Dictionary <string, ResXDataNode>();
var fileExists = filename != null && File.Exists(filename);
if (fileExists)
{
using (var reader = new ResXResourceReader(filename,
AppDomain.CurrentDomain.GetAssemblies().Select(x => x.GetName()).ToArray()))
{
// Set base path so that relative paths work
reader.BasePath = Path.GetDirectoryName(filename);
// If UseResXDataNodes == true before you call GetMetadataEnumerator, no resource nodes are retrieved
var metadataEnumerator = reader.GetMetadataEnumerator();
while (metadataEnumerator.MoveNext())
{
originalMetadatas.Add((string)metadataEnumerator.Key, metadataEnumerator.Value);
}
}
using (var reader = new ResXResourceReader(filename))
{
// If GetMetadataEnumerator was already called setting the UseResXDataNodes to true will have no effect
// Because of this creating a new reader is necessary
reader.UseResXDataNodes = true;
var dataEnumerator = reader.GetEnumerator();
while (dataEnumerator.MoveNext())
{
var key = (string)dataEnumerator.Key;
// GetEnumerator will also get metadata items, filter them out
if (!originalMetadatas.ContainsKey(key))
{
originalResources.Add(key, (ResXDataNode)dataEnumerator.Value);
}
}
}
// Get rid of keys marked as deleted. If they have been restored they will be re-added later
// Only support localizable strings to avoid removing other resources by mistake
// BUG Clear the _deletedKeys?
foreach (var originalResource in originalResources
.Where(originalResource => _deletedKeys.Contains(originalResource.Key))
.Where(originalResource => IsLocalizableString(originalResource.Key, originalResource.Value))
.ToList())
{
originalResources.Remove(originalResource.Key);
}
}
// Precache the valid keys
var localizableResourceKeys = originalResources
.Where(originalResource => IsLocalizableString(originalResource.Key, originalResource.Value))
.Select(x => x.Key).ToList();
// Update originalResources with information stored in _stringsTable.
// Adds keys if they are missing in originalResources
foreach (DataRow dataRow in _stringsTable.Rows)
{
var key = (string)dataRow[Properties.Resources.ColNameKey];
var valueData = dataRow[valueColumnId] == DBNull.Value ? null : dataRow[valueColumnId];
var stringValueData = valueData?.ToString() ?? string.Empty;
var stringCommentData = saveComments ? TryGetCommentFromRow(dataRow) : string.Empty;
if (localizableResourceKeys.Contains(key))
{
// Skip if the original value and comment is the same as the new one
if (stringCommentData.Equals(originalResources[key].Comment, StringComparison.InvariantCulture) &&
stringValueData.Equals(originalResources[key].GetValueAsString(), StringComparison.InvariantCulture))
{
continue;
}
originalResources[key] = new ResXDataNode(originalResources[key].Name, stringValueData)
{
Comment = stringCommentData
};
}
else
{
originalResources.Add(key, new ResXDataNode(key, stringValueData)
{
Comment = stringCommentData
});
localizableResourceKeys.Add(key);
}
}
// Write the cached resources to the drive
using (var writer = new ResXResourceWriter(filename))
{
foreach (var originalResource in originalResources)
{
// Write localizable resource only if it is not empty, unless we are saving the default file
if (valueColumnId.Equals(Properties.Resources.ColNameNoLang) ||
!localizableResourceKeys.Contains(originalResource.Key) ||
!string.IsNullOrWhiteSpace(originalResource.Value.GetValueAsString()))
{
if (!skipNontranslatableData || IsLocalizableString(originalResource.Key, originalResource.Value))
{
writer.AddResource(originalResource.Value);
}
}
}
foreach (var originalMetadata in originalMetadatas)
{
writer.AddMetadata(originalMetadata.Key, originalMetadata.Value);
}
writer.Generate();
}
}
public void SetMetadata(IDesignerSerializationManager manager, string resourceName, object value, bool shouldSerializeValue, bool applyingCachedResources)
{
if ((value == null) || value.GetType().IsSerializable)
{
if (this.ReadCulture.Equals(CultureInfo.InvariantCulture))
{
ResXResourceWriter writer = this.Writer as ResXResourceWriter;
if (shouldSerializeValue)
{
if (writer != null)
{
writer.AddMetadata(resourceName, value);
}
else
{
this.Writer.AddResource(resourceName, value);
}
}
}
else
{
Hashtable metadata = null;
IResourceWriter resourceWriter = null;
IResourceService service = (IResourceService)manager.GetService(typeof(IResourceService));
if (service != null)
{
resourceWriter = service.GetResourceWriter(CultureInfo.InvariantCulture);
}
Hashtable resourceSet = this.GetResourceSet(CultureInfo.InvariantCulture);
if ((resourceWriter == null) || (resourceWriter is ResXResourceWriter))
{
metadata = this.GetMetadata();
if (metadata == null)
{
this.metadata = new Hashtable();
metadata = this.metadata;
}
if (resourceSet.ContainsKey(resourceName))
{
resourceSet.Remove(resourceName);
}
this.metadataResourcesDirty = true;
}
else
{
metadata = resourceSet;
this.invariantCultureResourcesDirty = true;
}
if (metadata != null)
{
if (shouldSerializeValue)
{
metadata[resourceName] = value;
}
else
{
metadata.Remove(resourceName);
}
}
this.mergedMetadata = null;
}
if (!applyingCachedResources)
{
this.AddCacheEntry(manager, resourceName, value, true, false, shouldSerializeValue, false);
}
}
}
