private static void WriteResourceFile(string resxFilePath)
{
using (var fs = File.OpenRead(resxFilePath))
{
var document = XDocument.Load(fs);
var binDirPath = Path.Combine(Path.GetDirectoryName(resxFilePath), "bin");
if (!Directory.Exists(binDirPath))
{
Directory.CreateDirectory(Path.Combine(Path.GetDirectoryName(resxFilePath), "bin"));
}
// Put in "bin" sub-folder of resx file
var targetPath = Path.Combine(binDirPath, Path.ChangeExtension(Path.GetFileName(resxFilePath), ".resources"));
using (var targetStream = File.Create(targetPath))
{
var rw = new ResourceWriter(targetStream);
foreach (var e in document.Root.Elements("data"))
{
var name = e.Attribute("name").Value;
var value = e.Element("value").Value;
rw.AddResource(name, value);
}
rw.Generate();
}
}
}
public void SystemResourceTests_Should_WriteUpdateValueToResx()
{
var filename = Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid().ToString() + ".resx");
var inputData = "TheInputData";
using (ResourceWriter w = new ResourceWriter(filename))
{
w.AddResource("InvariantName", inputData);
w.Generate();
}
inputData = "TheUpdatedInputData";
using (ResourceWriter w = new ResourceWriter(filename))
{
w.AddResource("InvariantName", inputData);
w.Generate();
}
var data = string.Empty;
using( var r = new ResourceReader(filename))
{
var rr = r.GetEnumerator();
rr.MoveNext();
data = rr.Value as string;
}
Assert.IsTrue(inputData == data);
}
public void Run()
{
Catalog catalog = new Catalog();
foreach(string fileName in Options.InputFiles)
{
Catalog temp = new Catalog();
temp.Load(fileName);
catalog.Append(temp);
}
using (ResourceWriter writer = new ResourceWriter(Options.OutFile))
{
foreach (CatalogEntry entry in catalog)
{
try
{
writer.AddResource(entry.Key, entry.IsTranslated ? entry.GetTranslation(0) : entry.String);
}
catch (Exception e)
{
string message = String.Format("Error adding item {0}", entry.String);
if (!String.IsNullOrEmpty(entry.Context))
message = String.Format("Error adding item {0} in context '{1}'",
entry.String, entry.Context);
throw new Exception(message, e);
}
}
writer.Generate();
}
}
private static Stream MakeResourceStream()
{
var stream = new MemoryStream();
var resourceWriter = new ResourceWriter(stream);
resourceWriter.AddResource("TestName", "value");
resourceWriter.Generate();
stream.Position = 0;
return stream;
}
static void Main(string[] args)
{
var getopt = new Getopt(Assembly.GetExecutingAssembly().GetName().Name, args, "i:o:") { Opterr = false };
string input = null;
string output = null;
int option;
while (-1 != (option = getopt.getopt()))
{
switch (option)
{
case 'i': input = getopt.Optarg; break;
case 'o': output = getopt.Optarg; break;
default: PrintUsage(); return;
}
}
if (input == null || output == null)
{
PrintUsage();
return;
}
try
{
if (!File.Exists(input))
{
Console.WriteLine("File {0} not found", input);
return;
}
Dictionary<string, string> entries;
var parser = new PoParser();
using (var reader = new StreamReader(input))
{
entries = parser.ParseIntoDictionary(reader);
}
using (var writer = new ResourceWriter(output))
{
foreach (var kv in entries)
{
try { writer.AddResource(kv.Key, kv.Value); }
catch (Exception e) { Console.WriteLine("Error adding item {0}: {1}", kv.Key, e.Message); }
}
writer.Generate();
}
}
catch (Exception ex)
{
Console.WriteLine("Error during execution: {0}", ex.Message);
return;
}
}
public void AddItem(string entity, string key, string value, string culture)
{
var filename = GetResourceFilename(entity, culture);
using (var writer = new ResourceWriter(filename))
{
writer.AddResource(key, value);
writer.Generate();
}
}
internal void EnsureRepositoryFileExists()
{
if (!File.Exists(this.RepositoryFilename))
{
using (IResourceWriter writer = new ResourceWriter(this.RepositoryFilename))
{
writer.Generate();
}
}
}
/// <summary>
/// Adds a given resourcename and data to the app resources in the target assembly
/// </summary>
/// <param name="ResourceName"></param>
/// <param name="ResourceData"></param>
/// <remarks></remarks>
public void Add(string ResourceName, byte[] ResourceData)
{
// make sure the writer is initialized
InitAssembly();
// have to enumerate this way
for (var x = 0; x <= _Resources.Count - 1; x++)
{
var res = _Resources[x];
if (res.Name.Contains(".Resources.resources"))
{
// Have to assume this is the root application's .net resources.
// That might not be the case though.
// cast as embeded resource to get at the data
var EmbededResource = (Mono.Cecil.EmbeddedResource)res;
// a Resource reader is required to read the resource data
var ResReader = new ResourceReader(new MemoryStream(EmbededResource.GetResourceData()));
// Use this output stream to capture all the resource data from the
// existing resource block, so we can add the new resource into it
var MemStreamOut = new MemoryStream();
var ResWriter = new System.Resources.ResourceWriter(MemStreamOut);
var ResEnumerator = ResReader.GetEnumerator();
byte[] resdata = null;
while (ResEnumerator.MoveNext())
{
var resname = (string)ResEnumerator.Key;
string restype = "";
// if we come across a resource named the same as the one
// we're about to add, skip it
if (Strings.StrComp(resname, ResourceName, CompareMethod.Text) != 0)
{
ResReader.GetResourceData(resname, out restype, out resdata);
ResWriter.AddResourceData(resname, restype, resdata);
}
}
// add the new resource data here
ResWriter.AddResourceData(ResourceName, "ResourceTypeCode.ByteArray", ResourceData);
// gotta call this to render the memory stream
ResWriter.Generate();
// update the resource
var buf = MemStreamOut.ToArray();
var NewEmbedRes = new EmbeddedResource(res.Name, res.Attributes, buf);
_Resources.Remove(res);
_Resources.Add(NewEmbedRes);
// gotta bail out, there can't be 2 embedded resource chunks, right?
break; // TODO: might not be correct. Was : Exit For
}
}
}
public void SystemResourceTests_Should_CreateResxFile()
{
var filename = Path.Combine(TestContext.TestRunDirectory, Guid.NewGuid().ToString() + ".resx");
using (ResourceWriter w = new ResourceWriter(filename))
{
w.Generate();
}
Assert.IsTrue(File.Exists(filename));
}
// Read all msgid/msgstr pairs, register them in the ResourceWriter,
// and write the binary contents to the output stream.
private void ReadAllInput (ResourceWriter rw) {
for (;;) {
String msgid = ReadString();
if (msgid == null)
break;
String msgstr = ReadString();
if (msgstr == null)
break;
rw.AddResource(msgid, msgstr);
}
rw.Generate();
}
private static void CreateResource()
{
FileStream stream = File.OpenWrite(ResourceFile);
using (var writer = new ResourceWriter(stream))
{
writer.AddResource("Title", "Professional C#");
writer.AddResource("Author", "Christian Nagel");
writer.AddResource("Publisher", "Wrox Press");
writer.Generate();
}
}
public static ResourceWriter GenerateResourceStream(Dictionary<string, string> inp_dict, MemoryStream ms)
{
ResourceWriter rw = new ResourceWriter(ms);
foreach (KeyValuePair<string, string> e in inp_dict)
{
string name = e.Key;
string values = e.Value;
rw.AddResource(name, values);
}
rw.Generate();
ms.Seek(0L, SeekOrigin.Begin);
return rw;
}
private static void WriteResourcesFile(Stream outfs, IEnumerable<XElement> data)
{
var rw = new ResourceWriter(outfs);
foreach (var e in data)
{
var name = e.Attribute("name").Value;
var value = e.Element("value").Value;
rw.AddResource(name, value);
}
rw.Generate();
}
/// <summary>
/// TODO - Refactor into just creating the resource 'MyResource'. AddItem will handle the key/value pairs.
/// </summary>
/// <param name="entity"></param>
/// <param name="key"></param>
/// <param name="data"></param>
/// <param name="culture"></param>
/// <returns></returns>
public string New(string entity, string culture)
{
var filename = GetResourceFilename(entity, culture);
if (File.Exists(filename))
{
// TODO - Replace this with an EntityAlreadyExistsException or something similar - IOException is too generic
//
throw new IOException("File already exists: " + filename);
}
using (var writer = new ResourceWriter(filename))
{
writer.Generate();
}
return filename;
}
private static void WriteResourcesFile(string resxFilePath, string outputFile)
{
using (var fs = File.OpenRead(resxFilePath))
using (var outfs = File.Create(outputFile))
{
var document = XDocument.Load(fs);
var rw = new ResourceWriter(outfs);
foreach (var e in document.Root.Elements("data"))
{
string name = e.Attribute("name").Value;
string value = e.Element("value").Value;
rw.AddResource(name, value);
}
rw.Generate();
}
}
public static void Generate(ResourceFile sourceFile, Stream outputStream)
{
if (outputStream == null) throw new ArgumentNullException(nameof(outputStream));
using (var input = sourceFile.File.OpenRead())
{
var document = XDocument.Load(input);
var data = document.Root.Elements("data");
if (data.Any())
{
var rw = new ResourceWriter(outputStream);
foreach (var e in data)
{
var name = e.Attribute("name").Value;
var value = e.Element("value").Value;
rw.AddResource(name, value);
}
rw.Generate();
}
}
}
private static Stream GetResourceStream(string resxFilePath)
{
using (var fs = File.OpenRead(resxFilePath))
{
var document = XDocument.Load(fs);
var ms = new MemoryStream();
var rw = new ResourceWriter(ms);
foreach (var e in document.Root.Elements("data"))
{
string name = e.Attribute("name").Value;
string value = e.Element("value").Value;
rw.AddResource(name, value);
}
rw.Generate();
ms.Seek(0, SeekOrigin.Begin);
return ms;
}
}
static void Main(string[] args) {
string dataDirectory = args[0];
string targetFile = args[1];
XmlDocument map = new XmlDocument();
XmlNode xFilesNode = map.CreateElement("Files");
ResourceWriter writer = new ResourceWriter(targetFile);
foreach (string file in Directory.GetFiles(dataDirectory, "*", SearchOption.AllDirectories)) {
XmlNode xFile = map.CreateElement("File");
string id = Guid.NewGuid().ToString();
string targetDirectory = Path.GetDirectoryName(file).Replace(dataDirectory, "");
if (targetDirectory.StartsWith("\\"))
targetDirectory = targetDirectory.Substring(1);
xFile.AppendChild(createNode(map, "Id", id));
xFile.AppendChild(createNode(map, "Directory", targetDirectory)); ;
xFile.AppendChild(createNode(map, "Filename", Path.GetFileName(file)));
xFilesNode.AppendChild(xFile);
writer.AddResourceData(id, "setupData", Compress(File.ReadAllBytes(file)));
}
map.AppendChild(xFilesNode);
using (MemoryStream msData = new MemoryStream()) {
using (StreamWriter sw = new StreamWriter(msData, Encoding.UTF8)) {
map.Save(sw);
writer.AddResourceData("map", "setupData", msData.ToArray());
}
}
writer.Generate();
writer.Dispose();
}
public void Generate_Closed ()
{
MemoryStream ms = new MemoryStream ();
ResourceWriter writer = new ResourceWriter (ms);
writer.AddResource ("Name", "Miguel");
writer.Close ();
try {
writer.Generate ();
Assert.Fail ("#B1");
} catch (InvalidOperationException ex) {
// The resource writer has already been closed
// and cannot be edited
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#B2");
Assert.IsNull (ex.InnerException, "#B3");
Assert.IsNotNull (ex.Message, "#B4");
}
}
[Test] // AddResource (string, string)
public void AddResource2_Value_Null ()
{
MemoryStream ms = new MemoryStream ();
ResourceWriter writer = new ResourceWriter (ms);
writer.AddResource ("Name", (string) null);
writer.Generate ();
ms.Position = 0;
ResourceReader rr = new ResourceReader (ms);
IDictionaryEnumerator enumerator = rr.GetEnumerator ();
Assert.IsTrue (enumerator.MoveNext (), "#1");
Assert.AreEqual ("Name", enumerator.Key, "#2");
Assert.IsNull (enumerator.Value, "#3");
Assert.IsFalse (enumerator.MoveNext (), "#4");
writer.Close ();
}
[Test] // AddResource (string, byte [])
public void AddResource0 ()
{
byte [] value = new byte [] { 5, 7 };
MemoryStream ms = new MemoryStream ();
ResourceWriter writer = new ResourceWriter (ms);
writer.AddResource ("Name", value);
writer.Generate ();
try {
writer.AddResource ("Address", new byte [] { 8, 12 });
Assert.Fail ("#A1");
} catch (InvalidOperationException ex) {
// The resource writer has already been closed
// and cannot be edited
Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
Assert.IsNull (ex.InnerException, "#A3");
Assert.IsNotNull (ex.Message, "#A4");
}
ms.Position = 0;
ResourceReader rr = new ResourceReader (ms);
IDictionaryEnumerator enumerator = rr.GetEnumerator ();
Assert.IsTrue (enumerator.MoveNext (), "#B1");
Assert.AreEqual ("Name", enumerator.Key, "#B3");
Assert.AreEqual (value, enumerator.Value, "#B4");
Assert.IsFalse (enumerator.MoveNext (), "#B5");
writer.Close ();
}
[Test] // bug #79976
public void ByteArray ()
{
byte [] content = new byte [] { 1, 2, 3, 4, 5, 6 };
Stream stream = null;
#if NET_2_0
// we currently do not support writing v2 resource files
stream = new MemoryStream ();
stream.Write (byte_resource_v2, 0, byte_resource_v2.Length);
stream.Position = 0;
#else
using (IResourceWriter rw = new ResourceWriter (_tempResourceFile)) {
rw.AddResource ("byteArrayTest", content);
rw.Generate ();
}
stream = File.OpenRead (_tempResourceFile);
#endif
using (stream) {
int entryCount = 0;
using (IResourceReader rr = new ResourceReader (stream)) {
foreach (DictionaryEntry de in rr) {
Assert.AreEqual ("byteArrayTest", de.Key, "#1");
Assert.AreEqual (content, de.Value, "#2");
entryCount++;
}
}
Assert.AreEqual (1, entryCount, "#3");
}
}
[Test] // bug #81757
public void ReadNullResource ()
{
MemoryStream stream = new MemoryStream ();
object value = null;
ResourceWriter rw = new ResourceWriter (stream);
rw.AddResource ("NullTest", value);
rw.Generate ();
stream.Position = 0;
using (ResourceReader rr = new ResourceReader (stream)) {
int entryCount = 0;
foreach (DictionaryEntry de in rr) {
Assert.AreEqual ("NullTest", de.Key, "#1");
Assert.IsNull (de.Value, "#2");
Assert.AreEqual (0, entryCount, "#3");
entryCount++;
}
Assert.AreEqual (1, entryCount, "#4");
}
}
private void CompileResourceFile()
{
ResXResourceReader resxReader = new ResXResourceReader(ResourcesFilePath);
IDictionaryEnumerator resxEnumerator = resxReader.GetEnumerator();
using (IResourceWriter writer = new ResourceWriter(CompiledResourcesFilePath))
{
while (resxEnumerator.MoveNext())
{
try
{
writer.AddResource(resxEnumerator.Key.ToString(), resxEnumerator.Value);
}
catch (Exception ex)
{
throw new FrameworkException(string.Format("Error while compiling resource file \"{0}\" on key \"{1}\".", ResourcesFileName, resxEnumerator.Key.ToString()), ex);
}
}
writer.Generate();
writer.Close();
}
resxReader.Close();
}
private static void CompileEmbeddedRes(PlgxPluginInfo plgx)
{
foreach(string strResSrc in plgx.EmbeddedResourceSources)
{
string strResFileName = plgx.BaseFileName + "." + UrlUtil.ConvertSeparators(
UrlUtil.MakeRelativePath(plgx.CsprojFilePath, strResSrc), '.');
string strResFile = UrlUtil.GetFileDirectory(plgx.CsprojFilePath, true,
true) + strResFileName;
if(strResSrc.EndsWith(".resx", StrUtil.CaseIgnoreCmp))
{
PrepareResXFile(strResSrc);
string strRsrc = UrlUtil.StripExtension(strResFile) + ".resources";
ResXResourceReader r = new ResXResourceReader(strResSrc);
ResourceWriter w = new ResourceWriter(strRsrc);
r.BasePath = UrlUtil.GetFileDirectory(strResSrc, false, true);
foreach(DictionaryEntry de in r)
w.AddResource((string)de.Key, de.Value);
w.Generate();
w.Close();
r.Close();
if(File.Exists(strRsrc))
{
plgx.CompilerParameters.EmbeddedResources.Add(strRsrc);
Program.TempFilesPool.Add(strRsrc);
}
}
else
{
File.Copy(strResSrc, strResFile, true);
plgx.CompilerParameters.EmbeddedResources.Add(strResFile);
}
}
}
[Test] // bug #82566
public void WriteEnum ()
{
MemoryStream ms = new MemoryStream ();
ResourceWriter writer = new ResourceWriter (ms);
writer.AddResource ("Targets", AttributeTargets.Assembly);
writer.Generate ();
ms.Position = 0;
bool found = false;
ResourceReader reader = new ResourceReader (ms);
foreach (DictionaryEntry de in reader) {
string name = de.Key as string;
Assert.IsNotNull (name, "#1");
Assert.AreEqual ("Targets", name, "#2");
Assert.IsNotNull (de.Value, "#3");
Assert.AreEqual (AttributeTargets.Assembly, de.Value, "#4");
found = true;
}
Assert.IsTrue (found, "#5");
writer.Dispose ();
}
public void UpdateReference(Identifier old, Identifier @new)
{
EmbeddedResource res = mod.Resources[resId] as EmbeddedResource;
foreach (KeyValuePair<string, BamlDocument> pair in (res as IAnnotationProvider).Annotations["Gbamls"] as Dictionary<string, BamlDocument>)
{
Stream dst = new MemoryStream();
BamlWriter.WriteDocument(pair.Value, dst);
((res as IAnnotationProvider).Annotations["Gresources"] as Dictionary<string, object>)[pair.Key] = dst;
}
MemoryStream newRes = new MemoryStream();
ResourceWriter wtr = new ResourceWriter(newRes);
foreach (KeyValuePair<string, object> pair in (res as IAnnotationProvider).Annotations["Gresources"] as Dictionary<string, object>)
wtr.AddResource(pair.Key, pair.Value);
wtr.Generate();
mod.Resources[resId] = new EmbeddedResource(res.Name, res.Attributes, newRes.ToArray());
}
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
public override bool Execute()
{
TaskHelper.DisplayLogo(Log, SR.Get(SRID.ResourcesGeneratorTask));
//
// Validate the property settings
//
if (ValidResourceFiles(ResourceFiles) == false)
{
// ValidResourceFiles has already showed up error message.
// Just stop here.
return false;
}
if (OutputResourcesFile != null && OutputResourcesFile.Length > 1)
{
// Every task should generate only one .resources.
Log.LogErrorWithCodeFromResources(SRID.MoreResourcesFiles);
return false;
}
try
{
// create output directory
if (!Directory.Exists(OutputPath))
{
Directory.CreateDirectory(OutputPath);
}
string resourcesFile = OutputResourcesFile[0].ItemSpec;
Log.LogMessageFromResources(MessageImportance.Low, SRID.ResourcesGenerating, resourcesFile);
// Go through all the files and create a resources file.
using (var resWriter = new ResourceWriter(resourcesFile))
{
foreach (var resourceFile in ResourceFiles)
{
string resFileName = resourceFile.ItemSpec;
string resourceId = GetResourceIdForResourceFile(resourceFile);
// We're handing off lifetime management for the stream.
// True for the third argument tells resWriter to dispose of the stream when it's done.
resWriter.AddResource(resourceId, new LazyFileStream(resFileName), true);
Log.LogMessageFromResources(MessageImportance.Low, SRID.ReadResourceFile, resFileName);
Log.LogMessageFromResources(MessageImportance.Low, SRID.ResourceId, resourceId);
}
// Generate the .resources file.
resWriter.Generate();
}
Log.LogMessageFromResources(MessageImportance.Low, SRID.ResourcesGenerated, resourcesFile);
}
catch (Exception e)
{
// PreSharp Complaint 6500 - do not handle null-ref or SEH exceptions.
if (e is NullReferenceException || e is SEHException)
{
throw;
}
else
{
string message;
string errorId = Log.ExtractMessageCode(e.Message, out message);
if (string.IsNullOrEmpty(errorId))
{
errorId = UnknownErrorID;
message = SR.Get(SRID.UnknownBuildError, message);
}
Log.LogError(null, errorId, null, null, 0, 0, 0, 0, message, null);
return false;
}
}
#pragma warning disable 6500
catch // Non-cls compliant errors
{
Log.LogErrorWithCodeFromResources(SRID.NonClsError);
return false;
}
#pragma warning restore 6500
return true;
}
public static void ExceptionforResWriter06()
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
byte[] buffer = new byte[_RefBuffer.Length];
using (var ms2 = new MemoryStream(buffer, true))
{
var rw1 = new ResourceWriter(ms2);
try
{
rw1.Generate();
}
finally
{
Assert.Throws<NotSupportedException>(() =>
{
rw1.Dispose();
});
}
}
});
}
public void SaveFile(string filename, Stream stream)
{
switch (Path.GetExtension(filename).ToLowerInvariant()) {
// write XML resource
case ".resx":
ResXResourceWriter rxw = new ResXResourceWriter(stream);
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 static void GenerateResources()
{
byte[] buffer = new byte[_RefBuffer.Length];
using (var ms2 = new MemoryStream(buffer, true))
{
using (var rw = new ResourceWriter(ms2))
{
foreach (var e in s_dict)
{
string name = e.Key;
string values = e.Value;
rw.AddResource(name, values);
}
rw.Generate();
}
}
bool hError = buffer.SequenceEqual(_RefBuffer);
Assert.True(hError, "The generated Resource does not match the reference");
}
