| public GetResourceData ( String resourceName, String &resourceType, byte &resourceData ) : void | ||
| resourceName | String | |
| resourceType | String | |
| resourceData | byte | |
| return | void | |
private void build_page_1()
{
TextView tv1 = new TextView ();
try
{
string rez = "Adeptus.Resources.resources";
string key = "mystring1";
string resourceType = "";
byte[] resourceData;
ResourceReader r = new ResourceReader(rez);
r.GetResourceData (key, out resourceType, out resourceData);
r.Close();
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
tv1.Buffer.Text = enc.GetString (resourceData);
}
catch (Exception exp)
{
tv1.Buffer.Text = exp.Message;
}
tv1.WrapMode = WrapMode.Word;
tv1.Editable = false;
this.AppendPage (tv1);
this.SetPageTitle (tv1, "Introduction");
this.SetPageType (tv1, AssistantPageType.Intro);
this.SetPageComplete (tv1, true);
}
public static int Main(string[] args)
{
System.Resources.ResourceReader res = new System.Resources.ResourceReader(args[0]);
string type = "";
Byte[] value = null;
res.GetResourceData(args[1], out type, out value);
using (System.IO.Stream stdout = Console.OpenStandardOutput())
{
stdout.Write(value, 4, value.Length - 4);
}
res.Close();
return(0);
}
public void copyFiles() {
using (
var msData =
(UnmanagedMemoryStream)
Assembly.GetExecutingAssembly().GetManifestResourceStream("updateSystemDotNet.Setup.setup.package")) {
using (var resReader = new ResourceReader(msData)) {
//Dateimap einlesen
var xmlMap = new XmlDocument();
byte[] mapData = null;
string tempString;
resReader.GetResourceData("map", out tempString, out mapData);
using (var msMap = new MemoryStream(mapData)) {
using (var srMap = new StreamReader(msMap, Encoding.UTF8)) {
xmlMap.Load(srMap);
}
}
int totalFiles = (xmlMap.SelectNodes("Files/File").Count);
int currentFile = 0;
//Dateien verarbeiten
foreach (XmlNode fileNode in xmlMap.SelectNodes("Files/File")) {
byte[] compressedFileData = null;
resReader.GetResourceData(fileNode.SelectSingleNode("Id").InnerText, out tempString, out compressedFileData);
writeCompressedFile(
compressedFileData,
fileNode.SelectSingleNode("Directory").InnerText,
fileNode.SelectSingleNode("Filename").InnerText);
currentFile++;
if (fileProgressChanged != null)
fileProgressChanged(this, new ProgressChangedEventArgs(Percent(currentFile, totalFiles), null));
}
}
}
}
public void PostRename(ConfuserContext context, INameService service, ProtectionParameters parameters, IDnlibDef def)
{
var module = def as ModuleDefMD;
if (module == null)
return;
var wpfResInfo = context.Annotations.Get<Dictionary<string, Dictionary<string, BamlDocument>>>(module, BAMLKey);
if (wpfResInfo == null)
return;
foreach (EmbeddedResource res in module.Resources.OfType<EmbeddedResource>()) {
Dictionary<string, BamlDocument> resInfo;
if (!wpfResInfo.TryGetValue(res.Name, out resInfo))
continue;
var stream = new MemoryStream();
var writer = new ResourceWriter(stream);
res.Data.Position = 0;
var reader = new ResourceReader(new ImageStream(res.Data));
IDictionaryEnumerator enumerator = reader.GetEnumerator();
while (enumerator.MoveNext()) {
var name = (string)enumerator.Key;
string typeName;
byte[] data;
reader.GetResourceData(name, out typeName, out data);
BamlDocument document;
if (resInfo.TryGetValue(name, out document)) {
var docStream = new MemoryStream();
docStream.Position = 4;
BamlWriter.WriteDocument(document, docStream);
docStream.Position = 0;
docStream.Write(BitConverter.GetBytes((int)docStream.Length - 4), 0, 4);
data = docStream.ToArray();
name = document.DocumentName;
}
writer.AddResourceData(name, typeName, data);
}
writer.Generate();
res.Data = MemoryImageStream.Create(stream.ToArray());
}
}
public static int FillValues2(string fileName, Dictionary <string, System.Tuple <string, byte[]> > values)
{
int result = 0;
using (var reader = new System.Resources.ResourceReader(fileName))
{
var enumer = reader.GetEnumerator();
while (enumer.MoveNext())
{
string name = Convert.ToString(enumer.Key);
string resType = null;
byte[] itemData = null;
reader.GetResourceData(name, out resType, out itemData);
if (resType != null && resType.Length > 0 && itemData != null && itemData.Length > 0)
{
values[name] = new Tuple <string, byte[]>(resType, itemData);
result++;
}
}
}
return(result);
}
/// <summary>
/// Получение иконок для хинтов из ресурсов проекта Controls
/// </summary>
/// <param name="resName">Путь к ресурсу формата GKIcons/RSR2_Bush_Fire.png</param>
/// <returns></returns>
public static Tuple<string, System.Drawing.Size> GetImageResource(string resName)
{
resName = resName.Replace("/Controls;component/", "");
var assembly = Assembly.GetAssembly(typeof(Controls.AlarmButton));
var name =
assembly.GetManifestResourceNames().FirstOrDefault(n => n.EndsWith(".resources", StringComparison.Ordinal));
var resourceStream = assembly.GetManifestResourceStream(name);
if (resourceStream == null)
{
return new Tuple<string, System.Drawing.Size>("", new System.Drawing.Size());
}
byte[] values;
using (var reader = new ResourceReader(resourceStream))
{
string type;
reader.GetResourceData(resName.ToLowerInvariant(), out type, out values);
}
// Получили массив байтов ресурса, теперь преобразуем его в png bitmap, а потом снова в массив битов
// уже корректного формата, после чего преобразуем его в base64string для удобства обратного преобразования
// на клиенте
const int offset = 4;
var size = BitConverter.ToInt32(values, 0);
var value1 = new Bitmap(new MemoryStream(values, offset, size));
byte[] byteArray;
using (var stream = new MemoryStream())
{
value1.Save(stream, ImageFormat.Png);
stream.Close();
byteArray = stream.ToArray();
}
return new Tuple<string, System.Drawing.Size>(Convert.ToBase64String(byteArray), value1.Size);
}
public void GetResourceData2 ()
{
byte [] expected = new byte [] {
0x00, 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
0xFF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x0C, 0x02, 0x00, 0x00, 0x00, 0x51, 0x53,
0x79, 0x73, 0x74, 0x65, 0x6D, 0x2E, 0x44, 0x72,
0x61, 0x77, 0x69, 0x6E, 0x67, 0x2C, 0x20, 0x56,
0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, 0x3D, 0x32,
0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x30, 0x2C, 0x20,
0x43, 0x75, 0x6C, 0x74, 0x75, 0x72, 0x65, 0x3D,
0x6E, 0x65, 0x75, 0x74, 0x72, 0x61, 0x6C, 0x2C,
0x20, 0x50, 0x75, 0x62, 0x6C, 0x69, 0x63, 0x4B,
0x65, 0x79, 0x54, 0x6F, 0x6B, 0x65, 0x6E, 0x3D,
0x62, 0x30, 0x33, 0x66, 0x35, 0x66, 0x37, 0x66,
0x31, 0x31, 0x64, 0x35, 0x30, 0x61, 0x33, 0x61,
0x05, 0x01, 0x00, 0x00, 0x00, 0x13, 0x53, 0x79,
0x73, 0x74, 0x65, 0x6D, 0x2E, 0x44, 0x72, 0x61,
0x77, 0x69, 0x6E, 0x67, 0x2E, 0x53, 0x69, 0x7A,
0x65, 0x02, 0x00, 0x00, 0x00, 0x05, 0x77, 0x69,
0x64, 0x74, 0x68, 0x06, 0x68, 0x65, 0x69, 0x67,
0x68, 0x74, 0x00, 0x00, 0x08, 0x08, 0x02, 0x00,
0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00,
0x00, 0x00, 0x0B};
ResourceReader r = new ResourceReader ("Test/resources/bug81759.resources");
string type;
byte [] bytes;
r.GetResourceData ("imageList.ImageSize", out type, out bytes);
// Note that const should not be used here.
Assert.AreEqual ("System.Drawing.Size, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", type, "#1");
Assert.AreEqual (expected, bytes, "#2");
r.Close ();
}
public void GetResourceData ()
{
byte [] t1 = new byte [] {0x16, 0x00, 0x00, 0x00, 0x76, 0x65, 0x72, 0x69, 0x74, 0x61, 0x73, 0x20, 0x76, 0x6F, 0x73, 0x20, 0x6C, 0x69, 0x62, 0x65, 0x72, 0x61, 0x62, 0x69, 0x74, 0x0A};
byte [] t2 = new byte [] {0x0A, 0x73, 0x6F, 0x6D, 0x65, 0x73, 0x74, 0x72, 0x69, 0x6E, 0x67};
byte [] t3 = new byte [] {0x0E, 0x00, 0x00, 0x00, 0x73, 0x68, 0x61, 0x72, 0x64, 0x65, 0x6E, 0x66, 0x72, 0x65, 0x75, 0x64, 0x65, 0x0A};
ResourceReader r = new ResourceReader ("Test/resources/StreamTest.resources");
Hashtable items = new Hashtable ();
foreach (DictionaryEntry de in r) {
string type;
byte [] bytes;
r.GetResourceData ((string) de.Key, out type, out bytes);
items [de.Key] = new DictionaryEntry (type, bytes);
}
DictionaryEntry p = (DictionaryEntry) items ["test"];
Assert.AreEqual ("ResourceTypeCode.Stream", p.Key as string, "#1-1");
Assert.AreEqual (t1, p.Value as byte [], "#1-2");
p = (DictionaryEntry) items ["test2"];
Assert.AreEqual ("ResourceTypeCode.String", p.Key as string, "#2-1");
Assert.AreEqual (t2, p.Value as byte [], "#2-2");
p = (DictionaryEntry) items ["test3"];
Assert.AreEqual ("ResourceTypeCode.ByteArray", p.Key as string, "#3-1");
Assert.AreEqual (t3, p.Value as byte [], "#3-2");
r.Close ();
}
public void GetResourceDataNullName ()
{
ResourceReader r = new ResourceReader ("Test/resources/StreamTest.resources");
string type;
byte [] bytes;
try {
r.GetResourceData (null, out type, out bytes);
Assert.Fail ("#1");
} catch (ArgumentNullException ex) {
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
Assert.IsNull (ex.InnerException, "#3");
Assert.IsNotNull (ex.Message, "#4");
Assert.IsNotNull (ex.ParamName, "#5");
Assert.AreEqual ("resourceName", ex.ParamName, "#6");
} finally {
r.Close ();
}
}
public prepareEditPackageResult prepareEditUpdatePackage(updatePackage package) {
var result = new prepareEditPackageResult();
//Temporäres Verzeichnis für die Updatedaten erstellen
string tempPackagePath = Path.Combine(Environment.GetEnvironmentVariable("tmp"), package.ID);
result.tempPackagePath = tempPackagePath;
result.updatePackage = package;
if (!Directory.Exists(tempPackagePath))
Directory.CreateDirectory(tempPackagePath);
//Pfad zum Updatepaket ermitteln
string packagePath = Path.Combine(Path.Combine(_session.currentProjectDirectory, "Updates"), package.getFilename());
if (!File.Exists(packagePath))
throw new FileNotFoundException("Das Updatepaket konnte nicht gefunden werden.", packagePath);
//Updatepaket öffnen
using(var fsPackage = File.OpenRead(packagePath)) {
using(var packageReader = new ResourceReader(fsPackage)) {
//Dateien entpacken und im Tempverzeichnis abspeichern
foreach (var copyAction in package.fileCopyActions) {
foreach (var file in copyAction.Files) {
string newFilename = string.Format("{0}.{1}", file.ID, file.Filename);
using(var fsFileOut = new FileStream(Path.Combine(tempPackagePath, newFilename), FileMode.Create)) {
byte[] resourceData;
string tempType; //ungenutzt aber trotzdem notwendig
packageReader.GetResourceData(file.ID, out tempType, out resourceData);
byte[] decompressedData = decompressData(resourceData);
fsFileOut.Write(decompressedData, 0, decompressedData.Length);
}
//Neuen Dateinamen in Updatepaket übernehmen
file.Fullpath = Path.Combine(tempPackagePath, newFilename);
}
}
}
}
//Changelog lesen
string changelogPath = Path.Combine(Path.Combine(_session.currentProjectDirectory, "Updates"),
package.getChangelogFilename());
if(!File.Exists(changelogPath))
throw new FileNotFoundException("Der Changelog konnte nicht gefunden werden", changelogPath);
using(var fsChangelog = new StreamReader(changelogPath, Encoding.UTF8)) {
var xmlChangelog = new XmlDocument();
xmlChangelog.Load(fsChangelog);
XmlNodeList changelogItems = xmlChangelog.SelectNodes("updateSystemDotNet.Changelog/Items/Item");
if(changelogItems == null)
throw new InvalidOperationException("Es konnte im Changelog keine Änderungseinträge gefunden werden.");
if (changelogItems.Count >= 1 && changelogItems[0].SelectSingleNode("Change") != null)
result.changelogGerman = changelogItems[0].SelectSingleNode("Change").InnerText;
if (changelogItems.Count >= 2 && changelogItems[1].SelectSingleNode("Change") != null)
result.changelogEnglish = changelogItems[1].SelectSingleNode("Change").InnerText;
}
return result;
}
void AnalyzeResources(ConfuserContext context, INameService service, ModuleDefMD module)
{
if (analyzer == null) {
analyzer = new BAMLAnalyzer(context, service);
analyzer.AnalyzeElement += AnalyzeBAMLElement;
}
var wpfResInfo = new Dictionary<string, Dictionary<string, BamlDocument>>();
foreach (EmbeddedResource res in module.Resources.OfType<EmbeddedResource>()) {
Match match = ResourceNamePattern.Match(res.Name);
if (!match.Success)
continue;
var resInfo = new Dictionary<string, BamlDocument>();
res.Data.Position = 0;
var reader = new ResourceReader(new ImageStream(res.Data));
IDictionaryEnumerator enumerator = reader.GetEnumerator();
while (enumerator.MoveNext()) {
var name = (string)enumerator.Key;
if (!name.EndsWith(".baml"))
continue;
string typeName;
byte[] data;
reader.GetResourceData(name, out typeName, out data);
BamlDocument document = analyzer.Analyze(module, name, data);
document.DocumentName = name;
resInfo.Add(name, document);
}
if (resInfo.Count > 0)
wpfResInfo.Add(res.Name, resInfo);
}
if (wpfResInfo.Count > 0)
context.Annotations.Set(module, BAMLKey, wpfResInfo);
}
private void CollectTranslatedResource(string bundleName, IDictionaryEnumerator dict, ResourceReader reader, List<ResourceTranslation> translations)
{
Object dictValue = null;
try
{
dictValue = dict.Value;
}
catch (Exception)
{
// wenn eine Assembly wie MeonaKernel gebraucht wird, um dict.Value aufzulösen
return;
}
String key = dict.Key.ToString();
if (key.StartsWith(">>"))
return;
String type;
byte[] data;
reader.GetResourceData(dict.Key.ToString(), out type, out data);
ResourceTranslation translation = new ResourceTranslation();
translation.BinaryValue = data;
translation.StringValue = dict.Value != null ? dict.Value.ToString() : null;
translation.TranslationDateTime = DateTime.UtcNow;
translation.TranslationStatus = COLLECT_STATUS;
translation.TranslationBy = TRANSLATION_IMPORTER;
if (translation.StringValue != null || translation.BinaryValue != null)
{
translation.Locale = assembly.GetName().CultureInfo.Name;
translation.Resource = new Resource();
translation.Resource.Key = key;
translation.Resource.ResourceClass = type;
translations.Add(translation);
}
}
/// <inheritdoc/>
public void Write(
TinyBinaryWriter writer)
{
var orderedResources = new SortedDictionary<Int16, Tuple<ResourceKind, Byte[]>>();
foreach (var item in _resources.OfType<EmbeddedResource>())
{
var count = 0U;
using (var reader = new ResourceReader(item.GetResourceStream()))
{
foreach (DictionaryEntry resource in reader)
{
String resourceType;
Byte[] resourceData;
var resourceName = resource.Key.ToString();
reader.GetResourceData(resourceName, out resourceType, out resourceData);
var kind = GetResourceKind(resourceType, resourceData);
if (kind == ResourceKind.Bitmap)
{
using (var stream = new MemoryStream(resourceData.Length))
{
var bitmapProcessor = new TinyBitmapProcessor((Bitmap)resource.Value);
bitmapProcessor.Process(writer.GetMemoryBasedClone(stream));
resourceData = stream.ToArray();
}
}
orderedResources.Add(GenerateIdFromResourceName(resourceName),
new Tuple<ResourceKind, Byte[]>(kind, resourceData));
++count;
}
}
_context.ResourceFileTable.AddResourceFile(item, count);
}
foreach (var item in orderedResources)
{
var kind = item.Value.Item1;
var bytes = item.Value.Item2;
var padding = 0;
switch (kind)
{
case ResourceKind.String:
var stringLength = (Int32)bytes[0];
if (stringLength < 0x7F)
{
bytes = bytes.Skip(1).Concat(Enumerable.Repeat((Byte)0, 1)).ToArray();
}
else
{
bytes = bytes.Skip(2).Concat(Enumerable.Repeat((Byte)0, 1)).ToArray();
}
break;
case ResourceKind.Bitmap:
padding = _context.ResourceDataTable.AlignToWord();
break;
case ResourceKind.Binary:
bytes = bytes.Skip(4).ToArray();
break;
case ResourceKind.Font:
padding = _context.ResourceDataTable.AlignToWord();
bytes = bytes.Skip(32).ToArray(); // File size + resource header size
break;
}
// Pre-process font data (swap endiannes if needed).
if (kind == ResourceKind.Font)
{
using (var stream = new MemoryStream(bytes.Length))
{
var fontProcessor = new TinyFontProcessor(bytes);
fontProcessor.Process(writer.GetMemoryBasedClone(stream));
bytes = stream.ToArray();
}
}
writer.WriteInt16(item.Key);
writer.WriteByte((Byte)kind);
writer.WriteByte((Byte)padding);
writer.WriteInt32(_context.ResourceDataTable.CurrentOffset);
_context.ResourceDataTable.AddResourceData(bytes);
}
if (orderedResources.Count != 0)
{
writer.WriteInt16(0x7FFF);
writer.WriteByte((Byte)ResourceKind.None);
writer.WriteByte(0x00);
writer.WriteInt32(_context.ResourceDataTable.CurrentOffset);
}
}
/// <summary>
/// Bietet Zugriff auf die Resourcen in einem Updatepaket.
/// </summary>
/// <param name="packagePath">Der Pfad zu dem Updatepaket.</param>
/// <param name="resID">Die ID der Resource die ausgelesen werden soll.</param>
/// <returns>Gibt die Resource in Form eines ByteArrays zurück.</returns>
protected byte[] accessUpdatePackage(string packagePath, string resID) {
var resReader = new ResourceReader(packagePath);
try {
byte[] outData;
string outType;
resReader.GetResourceData(resID, out outType, out outData);
return outData;
}
finally {
resReader.Close();
}
}
private Stream GetResourceAsStream(string name)
{
Stream stream = Assembly.GetEntryAssembly().GetManifestResourceStream("Concierge_Manager.Properties.Resources.resources");
ResourceReader reader = new ResourceReader(stream);
string resourceType = "";
byte[] data = null;
reader.GetResourceData(name, out resourceType , out data );
MemoryStream ms = new MemoryStream(data, 4, data.Length - 4); // it seems that we are getting the file length in the first four bytes
return ms;
}
private void CollectSingleResource(string resourceName, IDictionaryEnumerator dict, ResourceBundle bundle, ResourceReader reader, Object dictValue)
{
var resource = new Resource();
resource.Key = dict.Key.ToString();
resource.CreateDateTime = DateTime.UtcNow;
resource.LastChangeDateTime = DateTime.UtcNow;
resource.DesignerSupportFlag = resource.Key.StartsWith(">>");
String type;
byte[] data;
reader.GetResourceData(dict.Key.ToString(), out type, out data);
resource.ResourceClass = type;
resource.BinaryValue = data;
bundle.Resources.Add(resource);
resource.StringValue = dictValue != null ? dictValue.ToString() : null;
if (dictValue is String)
resource.ResourceType = ResourceType.STRING;
else if (dictValue is Bitmap)
resource.ResourceType = ResourceType.IMAGE;
else
resource.ResourceType = ResourceType.OTHER_BINARY;
}
// ******************************************************************
/// <summary>
/// The path separator is '/'. The path should not start with '/'.
/// </summary>
/// <param name="asm"></param>
/// <param name="path"></param>
/// <returns></returns>
public static Stream GetAssemblyResourceStream(Assembly asm, string path)
{
// Just to be sure
if (path[0] == '/')
{
path = path.Substring(1);
}
// Just to be sure
if (path.IndexOf('\\') == -1)
{
path = path.Replace('\\', '/');
}
Stream resStream = null;
string resName = asm.GetName().Name + ".g.resources"; // Ref: Thomas Levesque Answer at:
// http://stackoverflow.com/questions/2517407/enumerating-net-assembly-resources-at-runtime
using (var stream = asm.GetManifestResourceStream(resName))
{
using (var resReader = new System.Resources.ResourceReader(stream))
{
string dataType = null;
byte[] data = null;
try
{
resReader.GetResourceData(path.ToLower(), out dataType, out data);
}
catch (Exception ex)
{
DebugPrintResources(resReader);
}
if (data != null)
{
switch (dataType) // COde from
{
// Handle internally serialized string data (ResourceTypeCode members).
case "ResourceTypeCode.String":
BinaryReader reader = new BinaryReader(new MemoryStream(data));
string binData = reader.ReadString();
Console.WriteLine(" Recreated Value: {0}", binData);
break;
case "ResourceTypeCode.Int32":
Console.WriteLine(" Recreated Value: {0}", BitConverter.ToInt32(data, 0));
break;
case "ResourceTypeCode.Boolean":
Console.WriteLine(" Recreated Value: {0}", BitConverter.ToBoolean(data, 0));
break;
// .jpeg image stored as a stream.
case "ResourceTypeCode.Stream":
////const int OFFSET = 4;
////int size = BitConverter.ToInt32(data, 0);
////Bitmap value1 = new Bitmap(new MemoryStream(data, OFFSET, size));
////Console.WriteLine(" Recreated Value: {0}", value1);
const int OFFSET = 4;
resStream = new MemoryStream(data, OFFSET, data.Length - OFFSET);
break;
// Our only other type is DateTimeTZI.
default:
////// No point in deserializing data if the type is unavailable.
////if (dataType.Contains("DateTimeTZI") && loaded)
////{
//// BinaryFormatter binFmt = new BinaryFormatter();
//// object value2 = binFmt.Deserialize(new MemoryStream(data));
//// Console.WriteLine(" Recreated Value: {0}", value2);
////}
////break;
break;
}
// resStream = new MemoryStream(resData);
}
}
}
return(resStream);
}
/// <summary>See <see cref="Task.Execute"/>.</summary>
public override bool Execute()
{
TaskLoggingHelper log = base.Log;
ITaskItem targetManifestResource = this._targetManifestResource;
ITaskItem[] mergeResources = this._mergeResources;
this._outputResource = null;
if (mergeResources.Length <= 0)
{
// If we don't have any resources to merge, then we have already succeeded at (not) merging them.
return true;
}
FileInfo targetManifestResourceFileInfo = new FileInfo(targetManifestResource.GetMetadata("FullPath"));
if (!targetManifestResourceFileInfo.Exists)
{
log.LogError("The specified manifest resource file (\"{0}\") does not exist.", targetManifestResource.ItemSpec);
return false;
}
// UNDONE: In all of the IO in this method, we aren't doing any handling of situations where the file changes between when we initially
// look at its size and when we actually read the content.
// Get all of the new resources and their values.
Dictionary<string, byte[]> mergeResourcesValues = new Dictionary<string, byte[]>(mergeResources.Length, StringComparer.Ordinal);
foreach (ITaskItem mergeResource in mergeResources)
{
System.Diagnostics.Debug.Assert(string.Equals(mergeResource.GetMetadata("MergeTarget"), targetManifestResource.ItemSpec, StringComparison.OrdinalIgnoreCase),
"Trying to emit a resource into a different manifest resource than the one specified for MergeTarget.");
FileInfo mergeResourceFileInfo = new FileInfo(mergeResource.GetMetadata("FullPath"));
if (!mergeResourceFileInfo.Exists)
{
log.LogError("The specified resource file to merge (\"{0}\") does not exist.", mergeResource.ItemSpec);
return false;
}
byte[] mergeResourceBytes = new byte[mergeResourceFileInfo.Length];
using (FileStream mergeResourceFileStream = new FileStream(mergeResourceFileInfo.FullName, FileMode.Open,
FileAccess.Read, FileShare.Read, mergeResourceBytes.Length, FileOptions.SequentialScan))
{
mergeResourceFileStream.Read(mergeResourceBytes, 0, mergeResourceBytes.Length);
}
string resourceName = mergeResource.GetMetadata("ResourceName");
if (string.IsNullOrEmpty(resourceName))
{
log.LogError("The specified resource file to merge (\"{0}\") is missing a ResourceName metadata value.", mergeResource.ItemSpec);
return false;
}
if (mergeResourcesValues.ContainsKey(resourceName))
{
log.LogError("The specified resource file to merge (\"{0}\") has a duplicate ResourceName metadata value (\"{2}\").", mergeResource.ItemSpec, resourceName);
return false;
}
mergeResourcesValues.Add(resourceName, mergeResourceBytes);
}
// Read the existing .resources file into a byte array.
byte[] originalResourcesBytes = new byte[targetManifestResourceFileInfo.Length];
using (FileStream originalResourcesFileStream = new FileStream(targetManifestResourceFileInfo.FullName, FileMode.Open,
FileAccess.Read, FileShare.Read, originalResourcesBytes.Length, FileOptions.SequentialScan))
{
originalResourcesFileStream.Read(originalResourcesBytes, 0, originalResourcesBytes.Length);
}
// The FileMode.Truncate on the next line is to make the .resources file zero-length so that we don't have to worry about any excess being left behind.
using (ResourceWriter resourceWriter = new ResourceWriter(new FileStream(targetManifestResourceFileInfo.FullName, FileMode.Truncate,
FileAccess.ReadWrite, FileShare.None, originalResourcesBytes.Length + (mergeResources.Length * 1024), FileOptions.SequentialScan)))
{
// Copy the resources from the original .resources file (now stored in the byte array) into the new .resources file.
using (ResourceReader resourceReader = new ResourceReader(new MemoryStream(originalResourcesBytes, 0, originalResourcesBytes.Length, false, false)))
{
foreach (System.Collections.DictionaryEntry entry in resourceReader)
{
string resourceName = (string)entry.Key;
string resourceType;
byte[] resourceData;
resourceReader.GetResourceData(resourceName, out resourceType, out resourceData);
if (mergeResourcesValues.ContainsKey(resourceName))
{
log.LogMessage(MessageImportance.Normal, "Skipping copying resource \"{0}\" of type \"{1}\" to new manifest resource file \"{2}\". A new resource with this name will be merged.",
resourceName, resourceType, targetManifestResource.ItemSpec);
}
else
{
resourceWriter.AddResourceData(resourceName, resourceType, resourceData);
log.LogMessage(MessageImportance.Low, "Copied resource \"{0}\" of type \"{1}\" to new manifest resource file \"{2}\".", resourceName, resourceType, targetManifestResource.ItemSpec);
}
}
}
// Add each of the new resources into the new .resources file.
foreach (KeyValuePair<string, byte[]> mergeResourceValue in mergeResourcesValues)
{
resourceWriter.AddResource(mergeResourceValue.Key, mergeResourceValue.Value);
log.LogMessage(MessageImportance.Low, "Added new resource \"{0}\" to new manifest resource file \"{1}\".", mergeResourceValue.Key, targetManifestResource.ItemSpec);
}
}
this._outputResource = targetManifestResource;
return true;
}
