public void Write(TzdbDatabase database, WindowsZones cldrWindowsZones) { var timeZoneMap = new Dictionary <string, string>(); foreach (var zone in database.GenerateDateTimeZones()) { timeZoneMap.Add(zone.Id, zone.Id); WriteTimeZone(zone); } // Normalize the aliases foreach (var key in database.Aliases.Keys) { var value = database.Aliases[key]; while (database.Aliases.ContainsKey(value)) { value = database.Aliases[value]; } timeZoneMap.Add(key, value); } resourceWriter.AddResource(TzdbResourceData.VersionKey, database.Version); WriteDictionary(TzdbResourceData.IdMapKey, timeZoneMap); WriteDictionary(TzdbResourceData.WindowsToPosixMapKey, cldrWindowsZones.PrimaryMapping); resourceWriter.AddResource(TzdbResourceData.WindowsToPosixMapVersionKey, cldrWindowsZones.Version); resourceWriter.Close(); }
/// <summary> /// Embeds a single resource into the assembly. /// </summary> void AddResource(ModuleBuilder moduleBuilder, ResourceFile resourceFile) { string fileName = resourceFile.FileName; IResourceWriter resourceWriter = moduleBuilder.DefineResource(Path.GetFileName(fileName), resourceFile.Name, ResourceAttributes.Public); string extension = Path.GetExtension(fileName).ToLowerInvariant(); if (extension == ".resources") { ResourceReader resourceReader = new ResourceReader(fileName); using (resourceReader) { IDictionaryEnumerator enumerator = resourceReader.GetEnumerator(); while (enumerator.MoveNext()) { string key = enumerator.Key as string; Stream resourceStream = enumerator.Value as Stream; if (resourceStream != null) { BinaryReader reader = new BinaryReader(resourceStream); MemoryStream stream = new MemoryStream(); byte[] bytes = reader.ReadBytes((int)resourceStream.Length); stream.Write(bytes, 0, bytes.Length); resourceWriter.AddResource(key, stream); } else { resourceWriter.AddResource(key, enumerator.Value); } } } } else { resourceWriter.AddResource(resourceFile.Name, File.ReadAllBytes(fileName)); } }
public CodeGenerator() { // Get the current application domain for the current thread. AppDomain currentDomain = AppDomain.CurrentDomain; AssemblyName myAssemblyName = new AssemblyName(); myAssemblyName.Name = "TempAssembly"; // Define 'TempAssembly' assembly in the current application domain. AssemblyBuilder myAssemblyBuilder = currentDomain.DefineDynamicAssembly (myAssemblyName, AssemblyBuilderAccess.RunAndSave); // Define 'TempModule' module in 'TempAssembly' assembly. ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("TempModule", "TempModule.netmodule", true); // Define the managed embedded resource, 'MyResource' in 'TempModule'. IResourceWriter myResourceWriter = myModuleBuilder.DefineResource("MyResource.resource", "Description"); // Add resources to the resource writer. myResourceWriter.AddResource("String 1", "First String"); myResourceWriter.AddResource("String 2", "Second String"); myResourceWriter.AddResource("String 3", "Third String"); myAssemblyBuilder.Save("MyAssembly.dll"); }
void AddResources(IResourceWriter resourceWriter, string fileName) { ResourceReader resourceReader = new ResourceReader(fileName); using (resourceReader) { IDictionaryEnumerator enumerator = resourceReader.GetEnumerator(); while (enumerator.MoveNext()) { string key = enumerator.Key as string; Stream resourceStream = enumerator.Value as Stream; if (resourceStream != null) { BinaryReader reader = new BinaryReader(resourceStream); MemoryStream stream = new MemoryStream(); byte[] bytes = reader.ReadBytes((int)resourceStream.Length); stream.Write(bytes, 0, bytes.Length); resourceWriter.AddResource(key, stream); } else { resourceWriter.AddResource(key, enumerator.Value); } } } }
private static void WriteResourceFile(IResourceWriter resources, Dictionary <string, Image> images) { foreach (var kvp in images) { resources.AddResource(kvp.Key, kvp.Value); } }
/// <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 virtual void SaveContent(IResourceWriter writer) { foreach (KeyValuePair <string, object> entry in this.data) { writer.AddResource(entry.Key, entry.Value); } }
public static void AddResource(this IResourceWriter writer, IResource resource) { var value = resource.Value; if (value is string text) { writer.AddResource(resource.Name, text); } else if (value is byte [] data) { writer.AddResource(resource.Name, data); } else { writer.AddResource(resource.Name, value); } }
public void Save(IResourceWriter writer) { writer.AddResource("CULTURE" + SEPARATOR, Culture.Name); foreach (var entry in _translations) { writer.AddResource("VALUE" + SEPARATOR + entry.Key, entry.Value); } foreach (var entry in _arrayTranslations) { writer.AddResource("LIST" + SEPARATOR + entry.Key, MakeList(entry.Value)); } // Switch from field;usage -> patterns // to usage;pattern* -> [fields] var byPattern = new Dictionary <string, List <string> >(); foreach (var entry in _templateTranslations) { var names = entry.Key.SplitList().ToArray(); var field = names[0]; var usage = names[1]; var key = MakeList(AddPrefix(usage, entry.Value)); List <string> fields; if (byPattern.TryGetValue(key, out fields)) { fields.Add(field); } else { byPattern.Add(key, new List <string> { field }); } } // Write out TEMPLATE;usage;field* -> pattern* foreach (var entry in byPattern) { var elements = entry.Key.SplitList().ToArray(); var usage = elements[0]; var patterns = elements.Skip(1); var key = "TEMPLATE" + SEPARATOR + usage + SEPARATOR + MakeList(entry.Value); writer.AddResource(key, MakeList(patterns)); } }
// Creates a default resource file for the current // CultureInfo and adds 3 strings to it. private void CreateResources(object sender, EventArgs e) { IResourceService rs = (IResourceService)this.Component.Site.GetService(typeof(IResourceService)); if (rs == null) { throw new Exception("Could not obtain IResourceService."); } IResourceWriter rw = rs.GetResourceWriter(CultureInfo.CurrentUICulture); rw.AddResource("string1", "Persisted resource string #1"); rw.AddResource("string2", "Persisted resource string #2"); rw.AddResource("string3", "Persisted resource string #3"); rw.Generate(); rw.Close(); }
public void Save(IResourceWriter resources) { foreach (var info in _images.Values) resources.AddResource(info.FullName, info.Image); foreach (var folder in _folders) folder.Save(resources); IsChanged = false; }
public override void VisitEmbeddedResource(EmbeddedResource res) { // TODO: Description? IResourceWriter resourceWriter = module.Builder.DefineResource(res.Name, "", (System.Reflection.ResourceAttributes)res.Flags); resourceWriter.AddResource(res.Name, res.Data); resourceWriter.Generate(); }
public void Build() { foreach (var i in _resourceEntries) { _resourceWriter.AddResource(i.Key, i.Value); } _resourceWriter.Generate(); _resourceWriter.Close(); }
static void ProcessFile(FileInfo name, IResourceWriter writer, String prefix) { Properties properties = new Properties(); properties.load(name.OpenRead()); foreach (String key in properties.Keys) { writer.AddResource(prefix + key, properties.getProperty(key)); } }
protected override void OnGenerate(IResourceWriter resourceWrite, XElement element) { string id = element.AttibuteStringValue("Id"); string value = element.AttibuteStringValue("Value"); if (string.IsNullOrEmpty(id)) { return; } resourceWrite.AddResource(id, value); }
// closes writer automatically private static void WriteResources(IResourceWriter writer) { foreach (Entry entry in resources) { string key = entry.name; object value = entry.value; writer.AddResource(key, value); } Console.Write(SR.GetString(SR.BeginWriting)); writer.Close(); Console.WriteLine(SR.GetString(SR.DoneDot)); }
public void WriteResource(IResourceService service) { using (ResourceReader reader = new ResourceReader(this.FileName)) { IResourceWriter writer = service.DefineResource(this.Name, this.Description); IDictionaryEnumerator e = reader.GetEnumerator(); while (e.MoveNext()) { writer.AddResource((string)e.Key, e.Value); } } }
/// <summary>Enbdeds resource into assembly</summary> /// <param name="builder"><see cref="ModuleBuilder"/> to embede resource in</param> /// <param name="name">Name of the resource</param> /// <param name="path">File to obtain resource from</param> /// <param name="attributes">Defines resource visibility</param> //DefineResource // Exceptions: // System.ArgumentException: // name has been previously defined or if there is another file in the assembly // named fileName.-or- The length of name is zero.-or- The length of fileName // is zero.-or- fileName includes a path. // // System.ArgumentNullException: // name or fileName is null. // // System.Security.SecurityException: // The caller does not have the required permission. //ResourceReader // Exceptions: // System.ArgumentException: // The stream is not readable. // // System.ArgumentNullException: // The stream parameter is null. // // System.IO.IOException: // An I/O error has occurred while accessing stream. //AddResource // Exceptions: // System.ArgumentNullException: // The name parameter is null. //ReadAllBytes // Exceptions: // System.ArgumentException: // path is a zero-length string, contains only white space, or contains one // or more invalid characters as defined by System.IO.Path.InvalidPathChars. // // System.ArgumentNullException: // path is null. // // System.IO.PathTooLongException: // The specified path, file name, or both exceed the system-defined maximum // length. For example, on Windows-based platforms, paths must be less than // 248 characters, and file names must be less than 260 characters. // // System.IO.DirectoryNotFoundException: // The specified path is invalid (for example, it is on an unmapped drive). // // System.IO.IOException: // An I/O error occurred while opening the file. // // System.UnauthorizedAccessException: // path specified a file that is read-only.-or- This operation is not supported // on the current platform.-or- path specified a directory.-or- The caller does // not have the required permission. // // System.IO.FileNotFoundException: // The file specified in path was not found. // // System.NotSupportedException: // path is in an invalid format. // // System.Security.SecurityException: // The caller does not have the required permission. private void AddResourceFile(ModuleBuilder builder, string name, FullPath path, ResourceAttributes attributes) { IResourceWriter rw = builder.DefineResource(path.FileName, name, attributes); string ext = path.Extension.ToLower(); if (ext == ".resources") { ResourceReader rr = new ResourceReader(path); using (rr) { System.Collections.IDictionaryEnumerator de = rr.GetEnumerator(); while (de.MoveNext()) { string key = de.Key as string; rw.AddResource(key, de.Value); } } } else { rw.AddResource(name, File.ReadAllBytes(path)); } }
public void Save(IResourceWriter resources) { foreach (var info in _images.Values) { resources.AddResource(info.FullName, info.Image); } foreach (var folder in _folders) { folder.Save(resources); } IsChanged = false; }
public void AddResourceFile(string name, string file, ResourceAttributes attribute) { IResourceWriter rw = _myModule.DefineResource(Path.GetFileName(file), name, attribute); string ext = Path.GetExtension(file); if (String.Equals(ext, ".resources", StringComparison.OrdinalIgnoreCase)) { ResourceReader rr = new ResourceReader(file); using (rr) { System.Collections.IDictionaryEnumerator de = rr.GetEnumerator(); while (de.MoveNext()) { string key = de.Key as string; rw.AddResource(key, de.Value); } } } else { rw.AddResource(name, File.ReadAllBytes(file)); } }
// <Snippet2> // <Snippet3> internal static void Main() { AssemblyBuilder myAssembly = CreateAssembly("MyEmitTestAssembly"); // Defines a standalone managed resource for this assembly. IResourceWriter myResourceWriter = myAssembly.DefineResource("myResourceFile", "A sample Resource File", "MyAssemblyResource.resources", ResourceAttributes.Private); myResourceWriter.AddResource("AddResource Test", "Testing for the added resource"); myAssembly.Save(myAssembly.GetName().Name + ".dll"); // Defines an unmanaged resource file for this assembly. myAssembly.DefineUnmanagedResource("MyAssemblyResource.resources"); }
private void WriteResources(IResourceWriter writer) { try { foreach (Entry entry in this.resources) { string name = entry.name; object obj2 = entry.value; writer.AddResource(name, obj2); } } finally { writer.Close(); } }
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; } }
static int CompileResourceFile(string sname, string dname, bool useSourcePath) { FileStream source = null; FileStream dest = null; IResourceReader reader = null; IResourceWriter writer = null; try { source = new FileStream(sname, FileMode.Open, FileAccess.Read); reader = GetReader(source, sname, useSourcePath); dest = new FileStream(dname, FileMode.Create, FileAccess.Write); writer = GetWriter(dest, dname); int rescount = 0; foreach (DictionaryEntry e in reader) { rescount++; object val = e.Value; if (val is string) { writer.AddResource((string)e.Key, (string)e.Value); } else { writer.AddResource((string)e.Key, e.Value); } } Console.WriteLine("Read in {0} resources from '{1}'", rescount, sname); reader.Close(); writer.Close(); Console.WriteLine("Writing resource file... Done."); } catch (Exception e) { Console.WriteLine("Error: {0}", e.Message); Exception inner = e.InnerException; // under 2.0 ResXResourceReader can wrap an exception into an XmlException // and this hides some helpful message from the original exception XmlException xex = (inner as XmlException); if (xex != null) { // message is identical to the inner exception (from MWF ResXResourceReader) Console.WriteLine("Position: Line {0}, Column {1}.", xex.LineNumber, xex.LinePosition); inner = inner.InnerException; } if (inner is System.Reflection.TargetInvocationException && inner.InnerException != null) { inner = inner.InnerException; } if (inner != null) { Console.WriteLine("Inner exception: {0}", inner.Message); } if (reader != null) { reader.Dispose(); } if (source != null) { source.Close(); } if (writer != null) { writer.Dispose(); } if (dest != null) { dest.Close(); } // since we're not first reading all entries in source, we may get a // read failure after we're started writing to the destination file // and leave behind a broken resources file, so remove it here try { File.Delete(dname); } catch { } return(1); } return(0); }
public void AddToWriter(IResourceWriter writer) { writer.AddResource(Name, Value); }
public void AddTo(IResourceWriter writer) { writer.AddResource(Name, Value); }
static int CompileResourceFile(string sname, string dname, bool useSourcePath, Options options) { FileStream source = null; FileStream dest = null; IResourceReader reader = null; IResourceWriter writer = null; try { source = new FileStream(sname, FileMode.Open, FileAccess.Read); reader = GetReader(source, sname, useSourcePath, options); dest = new FileStream(dname, FileMode.Create, FileAccess.Write); writer = GetWriter(dest, dname, options, sname); int rescount = 0; foreach (DictionaryEntry e in reader) { rescount++; object val = e.Value; if (val is string) { writer.AddResource((string)e.Key, (string)e.Value); } else { // refactoring to do: We should probably wrap the ResXResourceWriter, and replace our use of IResourceWriter with a ResourceItem based interface ResourceItem item = val as ResourceItem; try { if (writer is ResXResourceWriter && item != null) { // only write if the ResourceItem can be cast to ResXDataNode ResXDataNode dataNode = ((ResourceItem)val).ToResXDataNode(); if (dataNode != null) { writer.AddResource((string)e.Key, dataNode); } } else { writer.AddResource((string)e.Key, e.Value); } } catch { if (item != null && item.Metadata_OriginalSourceLine > 0) { Console.WriteLine("Line: {0}", item.Metadata_OriginalSourceLine); } throw; } } } Console.WriteLine("Read in {0} resources from '{1}'", rescount, sname); reader.Close(); writer.Close(); Console.WriteLine("Writing resource file... Done."); } catch (Exception e) { Console.WriteLine("Error: {0}", e.Message); Exception inner = e.InnerException; // under 2.0 ResXResourceReader can wrap an exception into an XmlException // and this hides some helpful message from the original exception XmlException xex = (inner as XmlException); if (xex != null) { // message is identical to the inner exception (from MWF ResXResourceReader) Console.WriteLine("Position: Line {0}, Column {1}.", xex.LineNumber, xex.LinePosition); inner = inner.InnerException; } if (inner is TargetInvocationException && inner.InnerException != null) { inner = inner.InnerException; } if (inner != null) { Console.WriteLine("Inner exception: {0}", inner.Message); } if (reader != null) { reader.Dispose(); } if (source != null) { source.Close(); } if (writer != null) { writer.Dispose(); } if (dest != null) { dest.Close(); } // since we're not first reading all entries in source, we may get a // read failure after we're started writing to the destination file // and leave behind a broken resources file, so remove it here try { File.Delete(dname); } catch { } return(1); } return(0); }
public new void AddTo(IResourceWriter writer) { writer.AddResource(Name, (string)Value); }
/// <summary> /// Write resources to an XML or binary format resources file. /// </summary> /// <remarks>Closes writer automatically</remarks> /// <param name="writer">Appropriate IResourceWriter</param> private void WriteResources(IResourceWriter writer) { try { foreach (Entry entry in resources) { string key = entry.RawName; object value = entry.Value; if(writer is TinyResourceWriter) { ((TinyResourceWriter)writer).AddResource( entry ); } else { writer.AddResource(key, value); } } writer.Generate(); } finally { writer.Close(); } }
private static void GenerateResourceStream( ResourceGenerationOptions options, // options from the command line string resourceName, // the name of the .resources file IResourceReader reader, // the reader for the .resources IResourceWriter writer, // the writer for the output .resources TranslationDictionariesReader dictionaries // the translations ) { //options.WriteLine(StringLoader.Get("GenerateResource", resourceName)); // enumerate through each resource and generate it foreach (DictionaryEntry entry in reader) { string name = entry.Key as string; object resourceValue = null; // See if it looks like a Baml resource if (BamlStream.IsResourceEntryBamlStream(name, entry.Value)) { Stream targetStream = null; // options.Write(" "); //options.Write(StringLoader.Get("GenerateBaml", name)); // grab the localizations available for this Baml string bamlName = BamlStream.CombineBamlStreamName(resourceName, name); BamlLocalizationDictionary localizations = dictionaries[bamlName]; if (localizations != null) { targetStream = new MemoryStream(); // generate into a new Baml stream GenerateBamlStream( (Stream)entry.Value, targetStream, localizations, options ); } options.WriteLine(StringLoader.Get("Done")); // sets the generated object to be the generated baml stream resourceValue = targetStream; } if (resourceValue == null) { // // The stream is not localized as Baml yet, so we will make a copy of this item into // the localized resources // // We will add the value as is if it is serializable. Otherwise, make a copy resourceValue = entry.Value; object[] serializableAttributes = resourceValue.GetType().GetCustomAttributes(typeof(SerializableAttribute), true); if (serializableAttributes.Length == 0) { // The item returned from resource reader is not serializable // If it is Stream, we can wrap all the values in a MemoryStream and // add to the resource. Otherwise, we had to skip this resource. Stream resourceStream = resourceValue as Stream; if (resourceStream != null) { Stream targetStream = new MemoryStream(); byte[] buffer = new byte[resourceStream.Length]; resourceStream.Read(buffer, 0, buffer.Length); targetStream = new MemoryStream(buffer); resourceValue = targetStream; } } } if (resourceValue != null) { writer.AddResource(name, resourceValue); } } }
/// <summary> /// Write resources to an XML or binary format resources file. /// </summary> /// <remarks>Closes writer automatically</remarks> /// <param name="writer">Appropriate IResourceWriter</param> private void WriteResources(ReaderInfo reader, IResourceWriter writer) { Exception capturedException = null; try { foreach (Entry entry in reader.resources) { string key = entry.name; object value = entry.value; writer.AddResource(key, value); } } catch (Exception e) { capturedException = e; // Rethrow this after catching exceptions thrown by Close(). } finally { if (capturedException == null) { writer.Close(); // If this throws, exceptions will be caught upstream. } else { // It doesn't hurt to call Close() twice. In the event of a full disk, we *need* to call Close() twice. // In that case, the first time we catch an exception indicating that the XML written to disk is malformed, // specifically an InvalidOperationException: "Token EndElement in state Error would result in an invalid XML document." try { writer.Close(); } catch (Exception) { } // We agressively catch all exception types since we already have one we will throw. // The second time we catch the out of disk space exception. try { writer.Close(); } catch (Exception) { } // We agressively catch all exception types since we already have one we will throw. throw capturedException; // In the event of a full disk, this is an out of disk space IOException. } } }
private static void GenerateResourceStream( LocBamlOptions options, // options from the command line string resourceName, // the name of the .resources file IResourceReader reader, // the reader for the .resources IResourceWriter writer, // the writer for the output .resources TranslationDictionariesReader dictionaries // the translations ) { options.WriteLine(StringLoader.Get("GenerateResource", resourceName)); // enumerate through each resource and generate it foreach(DictionaryEntry entry in reader) { string name = entry.Key as string; object resourceValue = null; // See if it looks like a Baml resource if (BamlStream.IsResourceEntryBamlStream(name, entry.Value)) { Stream targetStream = null; options.Write(" "); options.Write(StringLoader.Get("GenerateBaml", name)); // grab the localizations available for this Baml string bamlName = BamlStream.CombineBamlStreamName(resourceName, name); BamlLocalizationDictionary localizations = dictionaries[bamlName]; if (localizations != null) { targetStream = new MemoryStream(); // generate into a new Baml stream GenerateBamlStream( (Stream) entry.Value, targetStream, localizations, options ); } options.WriteLine(StringLoader.Get("Done")); // sets the generated object to be the generated baml stream resourceValue = targetStream; } if (resourceValue == null) { // // The stream is not localized as Baml yet, so we will make a copy of this item into // the localized resources // // We will add the value as is if it is serializable. Otherwise, make a copy resourceValue = entry.Value; object[] serializableAttributes = resourceValue.GetType().GetCustomAttributes(typeof(SerializableAttribute), true); if (serializableAttributes.Length == 0) { // The item returned from resource reader is not serializable // If it is Stream, we can wrap all the values in a MemoryStream and // add to the resource. Otherwise, we had to skip this resource. Stream resourceStream = resourceValue as Stream; if (resourceStream != null) { Stream targetStream = new MemoryStream(); byte[] buffer = new byte[resourceStream.Length]; resourceStream.Read(buffer, 0, buffer.Length); targetStream = new MemoryStream(buffer); resourceValue = targetStream; } } } if (resourceValue != null) { writer.AddResource(name, resourceValue); } } }
static void Main(string[] args) { if (args.Length < 1) { Usage(); } string path = null; string locale = null; string assemblyPath = null; string methodPath = null; for (var i = 0; i < args.Length; ++i) { var arg = args[i]; if (arg.StartsWith("-")) { switch (arg) { case "-c": if (++i < args.Length) { locale = args[i]; } break; case "-g": if (++i < args.Length) { assemblyPath = Path.GetFullPath(args[i]); } if (++i < args.Length) { methodPath = args[i]; } break; default: Usage(); break; } } else { path = arg; } } if (assemblyPath != null) { var assembly = Assembly.LoadFrom(assemblyPath); var methodParts = methodPath.Split('.'); var methodName = methodParts.Last(); var className = string.Join(".", methodParts.Take(methodParts.Count() - 1)); var classType = assembly.GetType(className); var method = classType.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy); var methodArgs = new object[method.GetParameters().Length]; var form = method.Invoke(null, methodArgs); var formPath = className + ".resx"; using (var stream = new FileStream(formPath, FileMode.Create)) using (var writer = new ResXResourceWriter(stream)) { form.GetType().InvokeMember("SaveResources", BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy, null, form, new object[] { writer }); } Console.WriteLine($"Generated {formPath} by calling {methodPath} in {assemblyPath}."); } else { var isResX = Path.GetExtension(path) == ".resx"; IResourceWriter writer = null; FileStream outStream = null; if (locale != null) { var outPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path) + "-" + locale + Path.GetExtension(path)); Console.Write($"Copying to {outPath}"); Console.WriteLine(); outStream = new FileStream(outPath, FileMode.Create); writer = isResX ? (IResourceWriter) new ResXResourceWriter(outStream) : (IResourceWriter) new ResourceWriter(outStream); } using (var stream = new FileStream(path, FileMode.Open)) using (var reader = isResX ? (IResourceReader) new ResXResourceReader(stream) : (IResourceReader) new ResourceReader(stream)) using (outStream) using (writer) { int values = 0; int lists = 0; int templates = 0; foreach (DictionaryEntry entry in reader) { var fullKey = (string)entry.Key; var value = (string)entry.Value; var typeAndKey = fullKey.Split(SEPERATOR); var type = typeAndKey.Last(); if (writer == null) { Console.WriteLine($"{fullKey}: {value}"); } else { if (type == "LIST" || type == "TEMPLATE") { writer.AddResource(fullKey, MakeList(from elt in SplitList(value) select "<" + elt + ">")); } else { writer.AddResource(fullKey, "<" + value + ">"); } } switch (type) { case "VALUE": ++values; break; case "LIST": ++lists; break; case "TEMPLATE": ++templates; break; } } Console.WriteLine($"Found {values} values, {lists} lists and {templates} templates"); } } }
public void WriteImage(string aName, Image aImage) { writer.AddResource(aName, aImage); }
/// <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 virtual void SaveContent(IResourceWriter writer) { foreach (KeyValuePair<string, object> entry in this.data) { writer.AddResource(entry.Key, entry.Value); } }
public void Save(IResourceWriter writer) { foreach (var entry in _translations) { writer.AddResource(entry.Key + SEPARATOR + "VALUE", entry.Value); } foreach (var entry in _arrayTranslations) { writer.AddResource(entry.Key + SEPARATOR + "LIST", MakeList(entry.Value)); } // Switch from field;usage -> patterns // to usage;pattern* -> [fields] var byPattern = new Dictionary<string, List<string>>(); foreach (var entry in _templateTranslations) { var names = entry.Key.SplitList().ToArray(); var field = names[0]; var usage = names[1]; var key = MakeList(AddPrefix(usage, entry.Value)); List<string> fields; if (byPattern.TryGetValue(key, out fields)) { fields.Add(field); } else { byPattern.Add(key, new List<string> { field }); } } // Write out TEMPLATE;usage;field* -> pattern* foreach (var entry in byPattern) { var elements = entry.Key.SplitList().ToArray(); var usage = elements[0]; var patterns = elements.Skip(1); var key = usage + SEPARATOR + MakeList(entry.Value) + SEPARATOR + "TEMPLATE"; writer.AddResource(key, MakeList(patterns)); } }
static void Main(string[] args) { if (args.Length < 1) { Usage(); } var path = args[0]; var isResX = Path.GetExtension(path) == ".resx"; string locale = null; string prefix = null; for (var i = 1; i < args.Length; ++i) { var arg = args[i]; switch (arg) { case "-c": if (++i < args.Length) { locale = args[i]; } break; case "-p": if (++i < args.Length) { prefix = args[i]; } break; default: Usage(); break; } } IResourceWriter writer = null; FileStream outStream = null; if (locale != null) { var outPath = Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path) + "-" + locale + Path.GetExtension(path)); Console.Write($"Copying to {outPath}"); if (prefix != null) { Console.Write($" with prefix {prefix}"); } Console.WriteLine(); outStream = new FileStream(outPath, FileMode.Create); writer = isResX ? (IResourceWriter) new ResXResourceWriter(outStream) : (IResourceWriter) new ResourceWriter(outStream); } using (var stream = new FileStream(path, FileMode.Open)) using (var reader = isResX ? (IResourceReader) new ResXResourceReader(stream) : (IResourceReader) new ResourceReader(stream)) using (outStream) using (writer) { int values = 0; int lists = 0; int templates = 0; foreach (DictionaryEntry entry in reader) { var fullKey = (string)entry.Key; var value = (string)entry.Value; var typeAndKey = fullKey.Split(SEPERATOR); var type = typeAndKey[0]; if (writer == null) { Console.WriteLine($"{fullKey}: {value}"); } else { if (type == "LIST" || type == "TEMPLATE") { writer.AddResource(fullKey, MakeList(from elt in SplitList(value) select prefix + elt)); } else if (type == "CULTURE") { writer.AddResource("CULTURE" + SSEPERATOR, locale); } else { writer.AddResource(fullKey, prefix + value); } } switch (type) { case "VALUE": ++values; break; case "LIST": ++lists; break; case "TEMPLATE": ++templates; break; } } Console.WriteLine($"Found {values} values, {lists} lists and {templates} templates"); } }