Text Resourcen aus Assembly auslesen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.IO;

namespace Softwareküche.Common
{
    /// <summary>
    /// Klasse zum Zugriff auf Resourcen innerhalb der DLL.
    /// </summary>
    internal static class ResourceReader
    {
        #region Konsturktor

        private static List<String> _resources;
        private static Assembly _assembly;

        /// <summary>
        /// Initialisieren der Liste mit den Resourcen
        /// </summary>
        static ResourceReader()
        {
            // Lesen und sortieren der Resourcen
            _resources = new List<String>();
            _assembly = Assembly.GetCallingAssembly();
            _resources.AddRange(_assembly.GetManifestResourceNames());
            _resources.Sort();
        }

        #endregion

        #region Eingebettete Resourcen auflisten

        /// <summary>
        /// Listet alle Resourcen mit dem angegebenen Filter zurück
        /// </summary>
        /// <param name="pattern">Muster, für das die Resourcen gefilter werden</param>
        /// <remarks>
        /// Unterstützte Filter:
        /// Exakte: foo
        /// EndsWith: *foo
        /// Starts With: foo*
        ///</remarks>
        public static string[] GetResourceList(string pattern)
        {
            if (String.IsNullOrEmpty(pattern)) return _resources.ToArray();

            string[] parts = pattern.Split(''*'');

            // Exakten String suchen
            if (parts.Length == 1)
            {
                foreach (string s in _resources)
                {
                    if (string.Compare(s, parts[0], false) == 0) return new string[] { s };
                }

                return (new List<String>()).ToArray();
            }
            // Anfang oder Ende ist gegeben *xxx oder yyy*
            else if (parts.Length == 2)
            {
                List<String> res = new List<string>();

                foreach (string s in _resources)
                {
                    if (s.StartsWith(parts[0]) && s.EndsWith(parts[1])) res.Add(s);
                }

                return res.ToArray();
            }
            else
            {
                throw new NotImplementedException("Mehr als ein ''*'' ist derzeit nicht implementiert");
            }
        }

        #endregion

        #region String Reader

        /// <summary>
        /// Liest einen Stream bis ans Ende aus und gibt die enthaltenen Daten zurück.
        /// </summary>
        /// <param name="stream">Der Stream, der bis zum Ende gelesen werden soll</param>
        /// <returns>Inhalt des Streams</returns>
        private static string ReadStreamToEnd(Stream stream)
        {
            try
            {
                byte[] data = new byte[(int)stream.Length];
                int size = stream.Read(data, 0, data.Length);

                return Encoding.Default.GetString(data, 0, size);
            }
            catch (Exception ex)
            {
                // Fehler mit einer eigenen Fehlerklasse kapseln
                throw new Exception("Fehler beim Auslesen der Resource in eine Zeichenkette", ex);
            }
        }

        /// <summary>
        /// Liste eine String Resource aus der Assembly aus
        /// </summary>
        /// <param name="resourceName">Name der Resource</param>
        public static string GetStringResource(string resourceName)
        {
            try
            {
                Stream stream = _assembly.GetManifestResourceStream(resourceName);
                return ReadStreamToEnd(stream);
            }
            catch (Exception ex)
            {
                // Vermeiden verschachtelter "Exceptions"
                throw new PException(ex.Message + Environment.NewLine + "Die Resource ''" + resourceName + "'' konnte nicht gelesen werden.", ex.InnerException);
            }
            catch (Exception ex)
            {
                // Exception geschachtelt neu werfen
                throw new Exception("Die Resource ''" + resourceName + "'' konnte nicht gelesen werden.", ex);
            }
        }

        #endregion
    }
}