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"); }