Hilfsklasse zu eingebetteten Ressourcen

    • VB.NET

    Es gibt 6 Antworten in diesem Thema. Der letzte Beitrag () ist von nafets3646.

      Hilfsklasse zu eingebetteten Ressourcen

      Hallo alle zusammen,
      ich habe für euch eine Klasse, welche den Umgang mit eingebetteten Ressourcen vereinfachen soll. Als Inspiration diente dieser Thread: [Allgemein] Video im Programm einfügen. Hier ist mir aufgefallen, dass es keinen einheitlichen Weg gibt, Ressourcen abzuspeichern (zum Beispiel muss man für Bilder den Umweg über einen ImageConverter gehen). Über die eingebetteten Ressourcen geht das zwar, allerdings ist die Vorgehensweise nicht so simpel und daher für Anfänger und Leute, welche auf dem Gebiet noch nicht so erfahren sind nicht wirklich geeignet.
      Die Klasse löst das Problem, indem sie einen einfachen Weg bietet, Ressourcen zu durchsuchen, den dazugehörigen Stream zu erhalten und abzuspeichern und das mit der eigenen oder sogar mit einer fremden Assembly. Sie ist übersichtlich aufgebaut und alle Methoden sind mit XML-Kommentaren versehen. Das System sollte mit allen Dateitypen zurechtkommen (getestet wurden docx, doc, mp4, flv, png, jpg, pdf, zip, ico und noch ein paar mehr).

      Code:
      VB (Original)

      VB.NET-Quellcode

      1. Imports System.IO
      2. Imports System.Reflection
      4. Public Class EmbeddedResourceHelper
      6. Private _SourceAssembly As Assembly = Nothing
      7. ''' <summary>
      8. ''' Die Assembly, welche durchsucht werden soll
      9. ''' </summary>
      10. Public Property SourceAssembly As Assembly
      11. Get
      12. Return _SourceAssembly
      13. End Get
      14. Private Set(value As Assembly)
      15. _SourceAssembly = value
      16. End Set
      17. End Property
      19. ''' <summary>
      20. ''' Erstellt einen neuen EmbeddedResourceHelper
      21. ''' </summary>
      22. Public Sub New()
      23. Me.SourceAssembly = Assembly.GetCallingAssembly()
      24. End Sub
      26. ''' <summary>
      27. ''' Erstellt einen neuen EmbeddedResourceHelper
      28. ''' </summary>
      29. ''' <param name="assembly">Die Assembly, welche durchsucht werden soll</param>
      30. Public Sub New(assembly As Assembly)
      31. Me.SourceAssembly = assembly
      32. End Sub
      34. ''' <summary>
      35. ''' Gibt den zu einer Ressource gehörenden Stream aus
      36. ''' </summary>
      37. ''' <param name="fileName">Der Name der Ressource, nach der gesucht werden soll</param>
      38. ''' <returns>Den zu der Ressource gehörenden Stream</returns>
      39. Public Function GetStream(fileName As String) As Stream
      40. Dim AvailableResources = GetResourceNames()
      41. If AvailableResources.Contains(fileName) Then
      42. Return SourceAssembly.GetManifestResourceStream(fileName)
      43. Else
      44. Dim MatchingResource = AvailableResources.FirstOrDefault(Function(resourcePath) resourcePath.EndsWith(fileName))
      45. If MatchingResource IsNot Nothing Then
      46. Return SourceAssembly.GetManifestResourceStream(MatchingResource)
      47. Else
      48. Throw New ArgumentException("Ressource wurde nicht gefunden", "fileName")
      49. End If
      50. End If
      51. End Function
      53. ''' <summary>
      54. ''' Schreibt eine Ressource in eine Datei
      55. ''' </summary>
      56. ''' <param name="fileName">Der Name der Originaldatei</param>
      57. ''' <param name="outputPath">Der Pfad, in den sie geschrieben werden soll</param>
      58. Public Function WriteResourceToFile(fileName As String, outputPath As String) As FileInfo
      59. Using ResourceStream = GetStream(fileName)
      60. Dim OutputFile As New FileInfo(Path.Combine(outputPath, fileName))
      61. Using OutputStream = OutputFile.Open(FileMode.Create)
      62. ResourceStream.CopyTo(OutputStream)
      63. 'OutputStream.Close()
      64. End Using
      65. Return OutputFile
      66. End Using
      67. End Function
      69. ''' <summary>
      70. ''' Gibt die Namen aller in die Assembly eingebetteten Ressourcen aus
      71. ''' </summary>
      72. ''' <returns>Die Namen aller in die Assembly eingebetteten Ressourcen</returns>
      73. Public Function GetResourceNames() As IEnumerable(Of String)
      74. Return SourceAssembly.GetManifestResourceNames()
      75. End Function
      77. End Class
      C#

      C-Quellcode

      1. using System.IO;
      2. using System.Reflection;
      4. public class EmbeddedResourceHelper
      5. {
      6. private Assembly _SourceAssembly = null;
      7. /// <summary>
      8. /// Die Assembly, welche durchsucht werden soll
      9. /// </summary>
      10. public Assembly SourceAssembly {
      11. get { return _SourceAssembly; }
      12. private set { _SourceAssembly = value; }
      13. }
      15. /// <summary>
      16. /// Erstellt einen neuen EmbeddedResourceHelper
      17. /// </summary>
      18. public EmbeddedResourceHelper()
      19. {
      20. this.SourceAssembly = Assembly.GetCallingAssembly();
      21. }
      23. /// <summary>
      24. /// Erstellt einen neuen EmbeddedResourceHelper
      25. /// </summary>
      26. /// <param name="assembly">Die Assembly, welche durchsucht werden soll</param>
      27. public EmbeddedResourceHelper(Assembly assembly)
      28. {
      29. this.SourceAssembly = assembly;
      30. }
      32. /// <summary>
      33. /// Gibt den zu einer Ressource gehörenden Stream aus
      34. /// </summary>
      35. /// <param name="fileName">Der Name der Ressource, nach der gesucht werden soll</param>
      36. /// <returns>Den zu der Ressource gehörenden Stream</returns>
      37. public Stream GetStream(string fileName)
      38. {
      39. var AvailableResources = GetResourceNames();
      40. if (AvailableResources.Contains(fileName)) {
      41. return SourceAssembly.GetManifestResourceStream(fileName);
      42. } else {
      43. var MatchingResource = AvailableResources.FirstOrDefault(resourcePath => resourcePath.EndsWith(fileName));
      44. if (MatchingResource != null) {
      45. return SourceAssembly.GetManifestResourceStream(MatchingResource);
      46. } else {
      47. throw new ArgumentException("Ressource wurde nicht gefunden", "fileName");
      48. }
      49. }
      50. }
      52. /// <summary>
      53. /// Schreibt eine Ressource in eine Datei
      54. /// </summary>
      55. /// <param name="fileName">Der Name der Originaldatei</param>
      56. /// <param name="outputPath">Der Pfad, in den sie geschrieben werden soll</param>
      57. public FileInfo WriteResourceToFile(string fileName, string outputPath)
      58. {
      59. using (ResourceStream == GetStream(fileName)) {
      60. FileInfo OutputFile = new FileInfo(Path.Combine(outputPath, fileName));
      61. using (OutputStream == OutputFile.Open(FileMode.Create)) {
      62. ResourceStream.CopyTo(OutputStream);
      63. //OutputStream.Close()
      64. }
      65. return OutputFile;
      66. }
      67. }
      69. /// <summary>
      70. /// Gibt die Namen aller in die Assembly eingebetteten Ressourcen aus
      71. /// </summary>
      72. /// <returns>Die Namen aller in die Assembly eingebetteten Ressourcen</returns>
      73. public IEnumerable<string> GetResourceNames()
      74. {
      75. return SourceAssembly.GetManifestResourceNames();
      76. }
      77. }

      Klassendiagramm:


      Benutzung
      Schritt 1, Klasse zum Projekt hinzufügen:
      • Projekt > Klasse hinzufügen > Namen geben > Code einfügen
      Schritt 2, Ressourcen hinzufügen:
      1. Projekt > Vorhandenes Element hinzufügen > Datei auswählen
      2. Datei im Projektmappenexplorer auswählen und in den Eigenschaften den Buildvorgang auf "Eingebettete Ressource" stellen
      Schritt 3, Ressource im Programm abrufen:
      • Methode 1, Datei abspeichern:
        Dafür verwenden wir die Methode WriteResourceToFile. Die Benutzung ist einfach, wir geben den Namen der Originaldatei und den Ausgabeordner ein und kriegen eine FileInfo auf die erstellte Datei zurück. Das könnte beispielsweise so aussehen:

        VB.NET-Quellcode

        1. 'Neuen EmbeddedResourceHelper auf die eigene Assembly erstellen
        2. Dim Helper As New EmbeddedResourceHelper()
        3. 'Die Datei TestPNG.png aus den Ressourcen in den Temp-Ordner schreiben
        4. Dim OutputFile As FileInfo = Helper.WriteResourceToFile("TestPNG.png", Path.GetTempPath)

        Mit der FileInfo, welche wir bekommen haben, können wir jetzt vieles machen, beispielsweise uns den Pfad der Datei daraus holen und sie öffnen:

        VB.NET-Quellcode

        1. 'Pfad holen
        2. Dim OutputFilePath As String = OutputFile.FullName
        3. 'Datei öffnen
        4. Process.Start(OutputFilePath)

      • Methode 2, Stream holen:
        Wir können uns auch den Stream auf die Datei holen, indem wir die Funktion GetStream verwenden. Das kann zum Beispiel hilfreich sein, wenn man nur den Inhalt der Datei in Textform bekommen möchte:

        VB.NET-Quellcode

        1. 'Neuen EmbeddedResourceHelper auf die eigene Assembly erstellen
        2. Dim Helper As New EmbeddedResourceHelper()
        3. 'Stream auf die Datei TestTXT.txt holen
        4. Dim OutputStream As Stream = Helper.GetStream("TestTXT.txt")

        Aus dem Stream könnte man jetzt beispielsweise den Text auslesen (wenn es eine Textdatei ist) und diesen ausgeben:

        VB.NET-Quellcode

        1. 'Streamreader auf den Stream erstellen
        2. Dim OutputStreamReader As New StreamReader(OutputStream)
        3. 'Den Stream in einen String lesen
        4. Dim OutputText As String = OutputStreamReader.ReadToEnd()
        5. 'Den String ausgeben
        6. MessageBox.Show(OutputText)

      Changelog

      Version 0.1
      Erste funktionsfähige Version
      Version 0.2
      Kleine Verbesserungen (Danke an ~blaze~ für den Hinweis)

      Ich hoffe, dass einigen dieser Code weiterhelfen wird :).
      MfG Stefan

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „nafets3646“ ()

      Weil der Wert bereits im Konstruktor auf einen entsprechenden Wert festgelegt wurde. Das ist auch sinnvoller, als eine Property zu definieren, über die das ganze abläuft.
      Was mir noch aufgefallen ist: Statt .Count() > 0 solltest du .Any() verwenden. Count muss erst alle Elemente des Enumerable durchlaufen und dabei eine Zählvariable inkrementieren. Du kannst theoretisch aber auch FirstOrDefault verwenden und auf Nothing überprüfen. Es ist nicht notwendig, bei IO.File.Delete zu überprüfen, ob die Datei existiert. Außerdem ist es eleganter, einfach direkt System.IO.FileStream im Create-Modus zu erzeugen. Dateien können zwischen zwei Aufrufen noch geändert werden, wenn ein zweites Programm Änderungen daran vornimmt, daher sollten die Operationen atomar sein. Zwischen einer Exists-Abfrage und einem Delete-Aufruf kann z.B. die Datei bereits gelöscht werden.

      Gruß
      ~blaze~

    Facebook
    Telefonspende