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); } } } }
/// <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); } }
/// <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"); }
public void WriteToStream(Stream stream) { IResourceWriter writer = null; if (_file.FilePath.Extension == ".resx") { writer = new ResXResourceWriter(stream); } else if (_file.FilePath.Extension == ".resources") { writer = new ResourceWriter(stream); } else { throw new NotSupportedException(); } foreach (var item in resourcesListView.Items.Cast <EditorListViewItem>()) { item.ResourceEntry.AddToWriter(writer); } writer.Generate(); // no closing/disposing needed. caller will close stream. }
private static void WriteResourceFile(IResourceWriter resources, Dictionary <string, Image> images) { foreach (var kvp in images) { resources.AddResource(kvp.Key, kvp.Value); } }
public static int Pack(List <string> files) { IResourceWriter output = null; try { if (files [0].EndsWith(".resx")) { output = new ResXResourceWriter(files [0]); } else { output = new ResourceWriter(files [0]); } } catch { Console.WriteLine("Error creating {0} file", files [0]); } int i = 1; while (i < files.Count) { string f = files [i++]; string key; string file = f; if (f.StartsWith("@")) { files.AddRange(System.IO.File.ReadAllLines(f.Substring(1))); continue; } int comma = file.IndexOf(','); if (comma != -1) { key = file.Substring(comma + 1); file = file.Substring(0, comma); } else { key = Path.GetFileName(file); } using (FileStream source = File.OpenRead(file)){ byte [] buffer = new byte [source.Length]; source.Read(buffer, 0, (int)source.Length); // Sadly, we cant just pass byte arrays to resourcewriter, we need // to wrap this on a MemoryStream MemoryStream value = new MemoryStream(buffer); output.AddResource(Uri.EscapeUriString(key).ToLowerInvariant(), value); } } output.Generate(); return(0); }
// ******************************************************************************************************************************** /// <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 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(); }
/// <summary> /// Save changes done to the resource content to disk. /// </summary> protected virtual void SaveContent() { using (IResourceWriter writer = this.GetResourceWriter()) { if (writer != null) { this.SaveContent(writer); writer.Close(); } } }
// ******************************************************************************************************************************** /// <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 AddTo(IResourceWriter writer) { if (writer is PreserializedResourceWriter preserializedResourceWriter) { preserializedResourceWriter.AddTypeConverterResource(Name, Bytes, TypeName); } else { ErrorUtilities.ThrowInternalError($"{nameof(TypeConverterByteArrayResource)} was asked to serialize to a {writer.GetType().ToString()}"); } }
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); }
public void Dispose() { if (this.stream != null) { this.writer.Dispose(); this.stream.Dispose(); this.writer = null; this.stream = null; } this.buffer = null; }
public void AddTo(IResourceWriter writer) { if (writer is PreserializedResourceWriter preserializedResourceWriter) { preserializedResourceWriter.AddTypeConverterResource(Name, Bytes, TypeAssemblyQualifiedName); } else { throw new PreserializedResourceWriterRequiredException(); } }
public void AddTo(IResourceWriter writer) { if (writer is PreserializedResourceWriter preserializedResourceWriter) { preserializedResourceWriter.AddBinaryFormattedResource(Name, Bytes); } else { throw new PreserializedResourceWriterRequiredException(); } }
public void AddTo(IResourceWriter writer) { if (writer is PreserializedResourceWriter preserializedResourceWriter) { preserializedResourceWriter.AddResource(Name, StringRepresentation, TypeAssemblyQualifiedName); } else { throw new PreserializedResourceWriterRequiredException(); } }
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)); } }
static void ProcessDirectory(DirectoryInfo dir, IResourceWriter writer, String localeName, String prefix) { foreach (FileInfo name in dir.GetFiles("*_" + localeName + ".properties")) { ProcessFile(name, writer, prefix + name.Name.Split(new char[] { '_' })[0] + "."); } foreach (DirectoryInfo name in dir.GetDirectories()) { ProcessDirectory(name, writer, localeName, prefix + name + "."); } }
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); } } }
public override void SaveResources(IResourceWriter writer) { _resources = new Localizer() { Culture = CultureInfo.CurrentUICulture }; foreach (var step in _steps) { step.SaveResources(); } _resources.Save(writer); }
/// <summary> /// Writes the byte array containing the most recent version of the resource /// represented by this instance into the private field "buffer", if a /// resource writer has previously been requested for this resource. /// </summary> public void WriteResourcesToBuffer() { if (this.stream != null) { this.writer.Close(); this.writer.Dispose(); this.buffer = this.stream.ToArray(); this.writer = null; this.stream.Dispose(); this.stream = null; } }
// 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 AddTo(IResourceWriter writer) { if (writer is PreserializedResourceWriter preserializedResourceWriter) { FileStream fileStream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read); preserializedResourceWriter.AddActivatorResource(Name, fileStream, TypeName, closeAfterWrite: true); } else { throw new PreserializedResourceWriterRequiredException(); } }
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 AddTo(IResourceWriter writer) { if (writer is PreserializedResourceWriter preserializedResourceWriter) { FileStream fileStream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read); preserializedResourceWriter.AddActivatorResource(Name, fileStream, TypeName, closeAfterWrite: true); } else { ErrorUtilities.ThrowInternalError($"{nameof(FileStreamResource)} was asked to serialize to a {writer.GetType().ToString()}"); } }
public Resource(string name, IResourceReader reader, IResourceWriter writer) { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("Resource name is not set", nameof(name)); } _name = name; _reader = reader ?? throw new ArgumentNullException(nameof(reader)); _writer = writer ?? throw new ArgumentNullException(nameof(writer)); _formatter = new CompositeResourceFormatter( new JsonResourceFormatter(), new XmlResourceFormatter()); }
public void WriteResource(string aUriTail, uint aIpAddress, List<string> aLanguageList, IResourceWriter aWriter) { if (iUiDir == null) { // UI is disabled. return; } if (IsNodeJsPath(aUriTail)) { WriteNodeJs(aWriter); return; } string tail = (aUriTail.Length == 0 ? "index.html" : aUriTail); string fullPath = Path.Combine(iUiDir, tail); if (Path.GetDirectoryName(fullPath).EndsWith(kResourcesDir)) { string resDir = Path.Combine(iUiDir, kResourcesDir); string fileName = Path.GetFileName(aUriTail); foreach (string lang in aLanguageList) { string language = lang.ToLower(); if (language.Contains('-')) { if (TryWriteFile(resDir, language, fileName, aWriter)) { return; } } else { string[] paths = Directory.GetDirectories(resDir); foreach (string path in paths) { int index = path.LastIndexOf(Path.DirectorySeparatorChar); string dir = path.Substring(index + 1); if (dir.StartsWith(language)) { if (TryWriteFile(resDir, dir, fileName, aWriter)) { return; } } } } } } TryWriteFile(fullPath, aWriter); }
/// <summary> /// Constructeur. /// </summary> /// <param name="dataSourceName">Nom de la source de données.</param> /// <param name="resourceLoader">Service de chargement des ressources.</param> /// <param name="resourceWriter">Service d'écriture des ressources.</param> public ReferenceBroker(string dataSourceName, IResourceLoader resourceLoader, IResourceWriter resourceWriter) : base(dataSourceName) { if (resourceLoader == null) { throw new ArgumentNullException("resourceLoader"); } if (resourceWriter == null) { throw new ArgumentNullException("resourceWriter"); } _resourceLoader = resourceLoader; _resourceWriter = resourceWriter; }
/// <summary> /// Embeds a single resource into the assembly. /// </summary> void AddResource(ModuleBuilder moduleBuilder, ResourceFile resourceFile) { string fileName = resourceFile.FileName; string extension = Path.GetExtension(fileName).ToLowerInvariant(); if (extension == ".resources") { string fullFileName = Path.GetFileName(fileName); IResourceWriter resourceWriter = moduleBuilder.DefineResource(fullFileName, resourceFile.Name, ResourceAttributes.Public); AddResources(resourceWriter, fileName); } else { moduleBuilder.DefineManifestResource(resourceFile.Name, new FileStream(fileName, FileMode.Open), ResourceAttributes.Public); } }
// <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(); } }
void WriteNodeJs(IResourceWriter aWriter) { MemoryStream memStream = new MemoryStream(); StreamWriter writer = new StreamWriter(memStream); writer.Write("var nodeUdn = \"" + iUdn + "\";\n"); writer.Write("var webSocketPort = " + iWebSocketPort + ";\n"); writer.Write("var isRemote = false;\n"); writer.Flush(); aWriter.WriteResourceBegin((int)memStream.Length, "application/javascript"); aWriter.WriteResource(memStream.GetBuffer(), (int)memStream.Length); aWriter.WriteResourceEnd(); 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; } }
public ResourceBuilder(IResourceWriter resourceWriter) { _resourceWriter = resourceWriter; }
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); } } }
/// <summary> /// Returns a new resource writer for this resource. /// According to the SDK documentation of IResourceService.GetResourceWriter, /// a new writer needs to be returned every time one is requested, discarding any /// data written by previously returned writers. /// </summary> public IResourceWriter GetWriter() { this.stream = new MemoryStream(); this.writer = CreateResourceWriter(this.stream, GetResourceType(OpenedFile.FileName)); return this.writer; }
public void WriteResource(string aUriTail, uint aIpAddress, List<string> aLanguageList, IResourceWriter aWriter) { iResourceManager.WriteResource(aUriTail, aIpAddress, aLanguageList, aWriter); }
/// <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(); } }
/// <summary> /// Initializes a new instance of the <see cref="ResourceOutput" /> class. /// </summary> /// <param name="name">The output file name.</param> /// <param name="type">The resource type.</param> public ResourceOutput(string name, ResourceOutputType type) { OutputFileName = ChangeExtension(name, type); resourceWriter = GetResourceWriter(OutputFileName, type); }
/// <summary> /// Returns a new resource writer for this resource. /// According to the SDK documentation of IResourceService.GetResourceWriter, /// a new writer needs to be returned every time one is requested, discarding any /// data written by previously returned writers. /// </summary> public IResourceWriter GetWriter() { this.stream = new MemoryStream(); this.writer = CreateResourceWriter(this.stream); return this.writer; }
/// <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 ResourceRegistryRenderer(RegisteredResources resources, IResourceWriter resourceWriter, Func<string,string> urlResolver) { _resources = resources; _resourceWriter = resourceWriter; _urlResolver = urlResolver; }
public void AddToWriter(IResourceWriter writer) { writer.AddResource(Name, Value); }
/// <summary> /// Writes the byte array containing the most recent version of the resource /// represented by this instance into the private field "buffer" and returns it. /// Returns null, if this resource has not been written to yet. /// </summary> byte[] GetBuffer() { if (this.stream != null) { byte[] buffer = this.stream.ToArray(); if (buffer.Length > 0) { this.writer.Close(); this.writer.Dispose(); this.buffer = this.stream.ToArray(); this.writer = null; this.stream.Dispose(); this.stream = null; } } return this.buffer; }
public void SetResourceWriter(IResourceWriter writer) { resourceWriter = writer; }
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)); } }
/// <summary> /// ChessResourseWriterconstructor /// </summary> public ChessResourseWriter() { writer = new ResourceWriter("Chess.resources"); // Chess Pieces }
private static bool TryWriteFile(string aResDir, string aLangDir, string aFileName, IResourceWriter aWriter) { string fullPath = Path.Combine(Path.Combine(aResDir, aLangDir), aFileName); return TryWriteFile(fullPath, aWriter); }
private static bool TryWriteFile(string aFullName, IResourceWriter aWriter) { if (!File.Exists(aFullName)) return false; string mime = MimeFromFileName(aFullName); byte[] data = File.ReadAllBytes(aFullName); aWriter.WriteResourceBegin(data.Length, mime); aWriter.WriteResource(data, data.Length); aWriter.WriteResourceEnd(); return true; }
/// <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. } } }
public void SetResourceWriter(IResourceWriter writer) { this.writer = writer; }