Bir Kaynak Dosyası (Konsol App/Windows Hizmet Projesi) den A Akış Nesne Get Nasıl

Question

Bir Windows hizmeti oluşturma ve ben bir kaynak dosyasına eklenen bazı dosyalara erişmeye çalışıyorum ama takıldım ı don nedeniyle Tek tek dosyalara nasıl erişileceğini bilmiyorum. Sadece bazı arka plan bilgi için, buraya şimdiye kadar yaptığım budur:

• Bu bana koduna adım yardımcı olan bir konsol uygulaması olarak ayıklama modunda çalışan bir C# Windows Hizmet uygulamasıdır.

• ben "Resources.resx" denilen kök dizinine bir kaynak dosyası eklendi. Benim kaynak dosyasında

• , ben görsel tasarımcı/editörü kullanarak birkaç jpg görüntüleri ve html dosyalarını ekledi. Ben kaynak dosyasına görüntüleri ve html dosyalarını ekledi sonra

• , Projemdeki yeni bir klasör ekledim tüm dosyaları "Kaynakları" adlı yazı.

• bu yeni klasörde, ben her dosyanın özelliklerine gitti ve oluşturmak için Embedded kaynak Eylem değiştirdi. (Bunun gerekli olup olmadığını bilmiyorum. Aradığım bazı bloglar denemeliydi.)

• Projenin ad alanı "MicroSecurity.EmailService" olarak adlandırılıyor.) (

• kaynak dosyasının adını almak için, ben

  GetType(). Assembly.GetManifestResourceNames()

kullanılan ve aşağıdaki

GetType olsun .Assembly.GetManifestResourceNames() {string [2]} string [] [0] "MicroSecurity.EmailService.Services.EmailService.resources" dize [1] "MicroSecurity.EmailService.Resources.resources" dize Buradan ben "MicroSecurity.EmailService.Resources.resources" Ben (indeksi 1) Kullanmak istediğiniz dizesi olduğunu belirledi.

• Akış kodu almak için bu kodu kullandım.

  var stream = Assembly.GetExecutingAssembly() GetManifestResourceStream ("MicroSecurity.EmailService.Resources.resources"); Sıkıştım nerede hata ayıklama sırasında bu değişkene bir saat eklediğinizde, ben vb Resimlerim için meta veriler ve burada

  gibi şeyleri görebilirsiniz

olduğunu. "Logo.jpg" adlı resme erişmek istiyorum. Görüntüye ulaşmak için yaptığım şey bu, ama işe yaramıyor.

var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("MicroSecurity.EmailService.Resources.resources.logo.jpg"); 

nasıl logo.jpg dosyasından bir akışı alabilirsiniz ?

GÜNCELLEME: Andrew

sayesinde bunu anlamaya başardı. Aşağıda, kaynak dosyanın çalışma biçimini doğrudan dosyalara yerleştirmek için nasıl çalıştığını incelemek üzere bir demo projesi için yazdığım bazı kodlar yer almaktadır.Umarım bu, başkalarının farklılıklara açıklık kazandırmasına yardımcı olur.

using System; 
using System.Drawing; 
using System.IO; 
using System.Reflection; 

namespace UsingResourceFiles 
{ 
    public class Program 
    { 
     /// <summary> 
     /// Enum to indicate what type of file a resource is. 
     /// </summary> 
     public enum FileType 
     { 
      /// <summary> 
      /// The resource is an image. 
      /// </summary> 
      Image, 

      /// <summary> 
      /// The resource is something other than an image or text file. 
      /// </summary> 
      Other, 

      /// <summary> 
      /// The resource is a text file. 
      /// </summary> 
      Text,   
     } 

     public static void Main(string[] args) 
     { 
      // There are two ways to reference resource files: 
      // 1. Use embedded objects. 
      // 2. Use a resource file. 

      // Get the embedded resource files in the Images and Text folders. 
      UseEmbeddedObjects(); 

      // Get the embedded resource files in the Images and Text folders. This allows for dynamic typing 
      // so the resource file can be returned either as a stream or an object in its native format. 
      UseEmbeddedObjectsViaGetResource(); 

      // Use the zombie.gif and TextFile.txt in the Resources.resx file. 
      UseResourceFile(); 
     } 

     public static void UseEmbeddedObjects() 
     { 
      // ============================================================================================================================= 
      // 
      //              -=[ Embedded Objects ]=- 
      // 
      // This way is the easiest to accomplish. You simply add a file to your project in the directory of your choice and then 
      // right-click the file and change the "Build Action" to "Embedded Resource". When you reference the file, it will be as an 
      // unmanaged stream. In order to access the stream, you'll need to use the GetManifestResourceStream() method. This method needs 
      // the name of the file in order to open it. The name is in the following format: 
      // 
      // Namespace + Folder Path + File Name 
      // 
      // For example, in this project the namespace is "UsingResourceFiles", the folder path is "Images" and the file name is 
      // "zombie.gif". The string is "UsingResourceFiles.Images.zombie.gif". 
      // 
      // For images, once the image is in a stream, you'll have to convert it into a Bitmap object in order to use it as an Image 
      // object. For text, you'll need to use a StreamReader to get the text file's text. 
      // ============================================================================================================================= 
      var imageStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("UsingResourceFiles.Images.zombie.gif"); 
      var image = new Bitmap(imageStream); 

      var textStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("UsingResourceFiles.Text.TextFile.txt"); 
      var text = new StreamReader(textStream).ReadToEnd(); 
     } 

     public static void UseEmbeddedObjectsViaGetResource() 
     { 
      // ============================================================================================================================= 
      // 
      //            -=[ Embedded Objects Using GetResource() ]=- 
      // 
      // Using the overloaded GetResource() method, you can easily obtain an embedded resource file by specifying the dot file path 
      // and type. If you need the stream version of the file, pass in false to the useNativeFormat argument. If you use the 
      // GetResource() method outside of this file and are getting a null value back, make sure you set the resource's "Build Action" 
      // to "Embedded Resource". 
      // ============================================================================================================================= 

      // Use the GetResource() methods to obtain the Images\zombie.gif file and the text from the Text\TextFile.txt file. 
      Bitmap image = GetResource("Images.zombie.gif", FileType.Image); 
      Stream imageStream = GetResource("Images.zombie.gif", FileType.Image, false); 

      string text = GetResource("Text.TextFile.txt", FileType.Text); 
      Stream textStream = GetResource("Text.TextFile.txt", FileType.Text, false); 
     } 

     public static void UseResourceFile() 
     { 
      // ============================================================================================================================= 
      // 
      //              -=[ Resource File ]=- 
      // 
      // This way takes more upfront work, but referencing the files is easier in the code-behind. One drawback to this approach is 
      // that there is no way to organize your files in a folder structure; everything is stuffed into a single resource blob. 
      // Another drawback is that once you create the resource file and add any files to it, a folder with the same name as your 
      // resource file is created, creating clutter in your project. A final drawback is that the properties of the Resources object 
      // may not follow proper C# naming conventions (e.g. "Resources.funny_man" instead of "Resources.FunnyMan"). A plus for using 
      // resource files is that they allow for localization. However, if you're only going to use the resource file for storing files, 
      // using the files as embedded objects is a better approach in my opinion. 
      // ============================================================================================================================= 

      // The Resources object references the resource file called "Resources.resx". 
      // Images come back as Bitmap objects and text files come back as string objects. 
      var image = Resources.zombie; 
      var text = Resources.TextFile; 
     } 

     /// <summary> 
     /// This method allows you to specify the dot file path and type of the resource file and return it in its native format. 
     /// </summary> 
     /// <param name="dotFilePath">The file path with dots instead of backslashes. e.g. Images.zombie.gif instead of Images\zombie.gif</param> 
     /// <param name="fileType">The type of file the resource is.</param> 
     /// <returns>Returns the resource in its native format.</returns> 
     public static dynamic GetResource(string dotFilePath, FileType fileType) 
     { 
      try 
      { 
       var assembly = Assembly.GetExecutingAssembly(); 
       var assemblyName = assembly.GetName().Name; 
       var stream = assembly.GetManifestResourceStream(assemblyName + "." + dotFilePath); 
       switch (fileType) 
       { 
        case FileType.Image:      
         return new Bitmap(stream); 
        case FileType.Text: 
         return new StreamReader(stream).ReadToEnd(); 
        default: 
         return stream; 
       } 
      } 
      catch (Exception e) 
      { 
       Console.WriteLine(e); 
       return null; 
      } 
     } 

     /// <summary> 
     /// This method allows you to specify the dot file path and type of the resource file and return it in its native format. 
     /// </summary> 
     /// <param name="dotFilePath">The file path with dots instead of backslashes. e.g. Images.zombie.gif instead of Images\zombie.gif</param> 
     /// <param name="fileType">The type of file the resource is.</param> 
     /// <param name="useNativeFormat">Indicates that the resource is to be returned as resource's native format or as a stream.</param> 
     /// <returns>When "useNativeFormat" is true, returns the resource in its native format. Otherwise it returns the resource as a stream.</returns> 
     public static dynamic GetResource(string dotFilePath, FileType fileType, bool useNativeFormat) 
     { 
      try 
      { 
       if (useNativeFormat) 
       { 
        return GetResource(dotFilePath, fileType); 
       } 

       var assembly = Assembly.GetExecutingAssembly(); 
       var assemblyName = assembly.GetName().Name; 
       return assembly.GetManifestResourceStream(assemblyName + "." + dotFilePath); 
      } 
      catch (Exception e) 
      { 
       Console.WriteLine(e); 
       return null; 
      } 
     } 
    } 
} 

Answer 1

sen Katıştırılmış kaynak için Kaynaklar klasöründeki dosyaları ayarlarsanız o zaman() çağrısı GetManifestResourceNames listelenen görmeliydiniz. Bunu Kaynakları klasöründe ise

var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("MicroSecurity.EmailService.Resources.logo.jpg"); 

adı "MicroSecurity.EmailService.Resources.logo.jpg" olmalıdır deneyebilirsiniz. Ancak, dosyanın kendisini bir Gömülü Kaynak olarak işaretlemek, Kaynaklar dosyasının amacını bozar (görüntünün kendisi iki kez gömülür).

Kaynak dosyasını tamamen kaldırabilir ve her dosyayı Gömülü Kaynak olarak ayarlayabilirsiniz. Bu noktada, her dosya için ayrı manifesto kaynakları olmalıdır. Bir C# projesinde, her dosya adı proje ad alanı + alt klasör tarafından öneklenir. Örneğin. Bir Kaynaklar/Gömülü klasörde bir "logo.jpg" dosyası eklerseniz, kaynak adı "MicroSecurity.EmailService.Resources.Embedded.logo.jpg" olacaktır.

Alternatif olarak, Bitmap'i Kaynaklar dosyasından alın ve bir akışa dönüştürün. Bir Bitmap'u How do I convert a Bitmap to byte[]?

Answer 2

sen kullanabilir miyim:

System.Drawing.Bitmap myLogo = MicroSecurity.Properties.Resources.logo;