Jak czytać osadzony plik tekstowy zasobu

Jak odczytać osadzony zasób (plik tekstowy), używając go StreamReaderi zwracając jako ciąg? Mój obecny skrypt używa formularza Windows i pola tekstowego, które pozwalają użytkownikowi znaleźć i zamienić tekst w pliku tekstowym, który nie jest osadzony.

private void button1_Click(object sender, EventArgs e)
{
    StringCollection strValuesToSearch = new StringCollection();
    strValuesToSearch.Add("Apple");
    string stringToReplace;
    stringToReplace = textBox1.Text;

    StreamReader FileReader = new StreamReader(@"C:\MyFile.txt");
    string FileContents;
    FileContents = FileReader.ReadToEnd();
    FileReader.Close();
    foreach (string s in strValuesToSearch)
    {
        if (FileContents.Contains(s))
            FileContents = FileContents.Replace(s, stringToReplace);
    }
    StreamWriter FileWriter = new StreamWriter(@"MyFile.txt");
    FileWriter.Write(FileContents);
    FileWriter.Close();
}

Możesz użyć Assembly.GetManifestResourceStreammetody :

1. Dodaj następujące zastosowania

   using System.IO;
   using System.Reflection;

2. Ustaw właściwość odpowiedniego pliku:
   parametr Build Actionz wartościąEmbedded Resource

3. Użyj następującego kodu

   var assembly = Assembly.GetExecutingAssembly();
   var resourceName = "MyCompany.MyProduct.MyFile.txt";
   
   using (Stream stream = assembly.GetManifestResourceStream(resourceName))
   using (StreamReader reader = new StreamReader(stream))
   {
       string result = reader.ReadToEnd();
   }

   resourceNameto nazwa jednego z zasobów osadzonych w assembly. Na przykład, jeśli osadzisz plik tekstowy o nazwie "MyFile.txt"umieszczony w katalogu głównym projektu z domyślną przestrzenią nazw "MyCompany.MyProduct", wówczas resourceNamejest "MyCompany.MyProduct.MyFile.txt". Możesz uzyskać listę wszystkich zasobów w zestawie za pomocą Assembly.GetManifestResourceNamesmetody .

Nie ma wątpliwości, że można uzyskać tylko resourceNamez nazwy pliku (pomijając przestrzeń nazw):

string resourceName = assembly.GetManifestResourceNames()
  .Single(str => str.EndsWith("YourFileName.txt"));

Kompletny przykład:

public string ReadResource(string name)
{
    // Determine path
    var assembly = Assembly.GetExecutingAssembly();
    string resourcePath = name;
    // Format: "{Namespace}.{Folder}.{filename}.{Extension}"
    if (!name.StartsWith(nameof(SignificantDrawerCompiler)))
    {
        resourcePath = assembly.GetManifestResourceNames()
            .Single(str => str.EndsWith(name));
    }

    using (Stream stream = assembly.GetManifestResourceStream(resourcePath))
    using (StreamReader reader = new StreamReader(stream))
    {
        return reader.ReadToEnd();
    }
}

Możesz dodać plik jako zasób, używając dwóch osobnych metod.

Kod C # wymagany do uzyskania dostępu do pliku jest inny , w zależności od metody użytej do dodania pliku w pierwszej kolejności.

Metoda 1: Dodaj istniejący plik, ustaw właściwość na Embedded Resource

Dodaj plik do projektu, a następnie ustaw typ na Embedded Resource.

UWAGA: Jeśli dodasz plik za pomocą tej metody, możesz użyć go, GetManifestResourceStreamaby uzyskać do niego dostęp (patrz odpowiedź z @dtb ).

Metoda 2: Dodaj plik do Resources.resx

Otwórz Resources.resxplik, użyj menu rozwijanego, aby dodać plik, ustaw Access Modifierna public.

UWAGA: Jeśli dodasz plik za pomocą tej metody, możesz użyć go, Properties.Resourcesaby uzyskać do niego dostęp (patrz odpowiedź z @Night Walker ).

Zasadniczo służy System.Reflectiondo uzyskania odniesienia do bieżącego zestawu. Następnie używasz GetManifestResourceStream().

Przykład ze strony, którą opublikowałem:

Uwaga : należy dodać, using System.Reflection;aby to działało

   Assembly _assembly;
   StreamReader _textStreamReader;

   try
   {
      _assembly = Assembly.GetExecutingAssembly();
      _textStreamReader = new StreamReader(_assembly.GetManifestResourceStream("MyNamespace.MyTextFile.txt"));
   }
   catch
   {
      MessageBox.Show("Error accessing resources!");
   }

W programie Visual Studio możesz bezpośrednio osadzić dostęp do zasobu pliku za pomocą karty Zasoby we właściwościach projektu (w tym przykładzie „Analytics”).

Do pliku wynikowego można następnie uzyskać dostęp jako tablicę bajtów

byte[] jsonSecrets = GoogleAnalyticsExtractor.Properties.Resources.client_secrets_reporter;

Jeśli potrzebujesz go jako strumienia, to (od https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Po dodaniu pliku do zasobów powinieneś wybrać jego modyfikatory dostępu jako publiczne, niż możesz zrobić coś takiego.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 to nazwa osadzonego pliku.

W rzeczywistości możesz przejść do resources.Designer.cs i zobaczyć, jak nazywa się getter.

dodanie np. Testfile.sql Menu projektu -> Właściwości -> Zasoby -> Dodaj istniejący plik

    string queryFromResourceFile = Properties.Resources.Testfile.ToString();

Wiem, że to stary wątek, ale to działało dla mnie:

1. dodaj plik tekstowy do zasobów projektu
2. ustaw modyfikator dostępu na publiczny, jak pokazał powyżej Andrew Hill

3. przeczytaj tekst w ten sposób:

   textBox1 = new TextBox();
   textBox1.Text = Properties.Resources.SomeText;

Tekst, który dodałem do zasobów: „SomeText.txt”

Możesz także użyć tej uproszczonej wersji odpowiedzi @ dtb:

public string GetEmbeddedResource(string ns, string res)
{
    using (var reader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Format("{0}.{1}", ns, res))))
    {
        return reader.ReadToEnd();
    }
}

Nauczyłem się teraz, że w twoim pliku nie może znajdować się „.” (kropka) w nazwie pliku.

Templates.plainEmailBodyTemplate-en.txt -> Działa !!!
Templates.plainEmailBodyTemplate.en.txt -> nie działa za pośrednictwem GetManifestResourceStream ()

Prawdopodobnie dlatego, że ramy są mylone w przestrzeniach nazw i nazwach plików ...

Przez wszystkie twoje połączone moce używam tej klasy pomocniczej do czytania zasobów z dowolnego zestawu i dowolnej przestrzeni nazw w sposób ogólny.

public class ResourceReader
{
    public static IEnumerable<string> FindEmbededResources<TAssembly>(Func<string, bool> predicate)
    {
        if (predicate == null) throw new ArgumentNullException(nameof(predicate));

        return
            GetEmbededResourceNames<TAssembly>()
                .Where(predicate)
                .Select(name => ReadEmbededResource(typeof(TAssembly), name))
                .Where(x => !string.IsNullOrEmpty(x));
    }

    public static IEnumerable<string> GetEmbededResourceNames<TAssembly>()
    {
        var assembly = Assembly.GetAssembly(typeof(TAssembly));
        return assembly.GetManifestResourceNames();
    }

    public static string ReadEmbededResource<TAssembly, TNamespace>(string name)
    {
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));
        return ReadEmbededResource(typeof(TAssembly), typeof(TNamespace), name);
    }

    public static string ReadEmbededResource(Type assemblyType, Type namespaceType, string name)
    {
        if (assemblyType == null) throw new ArgumentNullException(nameof(assemblyType));
        if (namespaceType == null) throw new ArgumentNullException(nameof(namespaceType));
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));

        return ReadEmbededResource(assemblyType, $"{namespaceType.Namespace}.{name}");
    }

    public static string ReadEmbededResource(Type assemblyType, string name)
    {
        if (assemblyType == null) throw new ArgumentNullException(nameof(assemblyType));
        if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name));

        var assembly = Assembly.GetAssembly(assemblyType);
        using (var resourceStream = assembly.GetManifestResourceStream(name))
        {
            if (resourceStream == null) return null;
            using (var streamReader = new StreamReader(resourceStream))
            {
                return streamReader.ReadToEnd();
            }
        }
    }
}

Czytam użycie pliku tekstowego zasobu osadzonego:

    /// <summary>
    /// Converts to generic list a byte array
    /// </summary>
    /// <param name="content">byte array (embedded resource)</param>
    /// <returns>generic list of strings</returns>
    private List<string> GetLines(byte[] content)
    {
        string s = Encoding.Default.GetString(content, 0, content.Length - 1);
        return new List<string>(s.Split(new[] { Environment.NewLine }, StringSplitOptions.None));
    }

Próba:

var template = GetLines(Properties.Resources.LasTemplate /* resource name */);

template.ForEach(ln =>
{
    Debug.WriteLine(ln);
});

Wiem, że to stare, ale chciałem tylko zwrócić uwagę na NETMF (.Net MicroFramework), możesz łatwo to zrobić:

string response = Resources.GetString(Resources.StringResources.MyFileName);

Ponieważ NETMF nie maGetManifestResourceStream

Po przeczytaniu wszystkich opublikowanych tutaj rozwiązań. Oto jak to rozwiązałem:

// How to embedded a "Text file" inside of a C# project
//   and read it as a resource from c# code:
//
// (1) Add Text File to Project.  example: 'myfile.txt'
//
// (2) Change Text File Properties:
//      Build-action: EmbeddedResource
//      Logical-name: myfile.txt      
//          (note only 1 dot permitted in filename)
//
// (3) from c# get the string for the entire embedded file as follows:
//
//     string myfile = GetEmbeddedResourceFile("myfile.txt");

public static string GetEmbeddedResourceFile(string filename) {
    var a = System.Reflection.Assembly.GetExecutingAssembly();
    using (var s = a.GetManifestResourceStream(filename))
    using (var r = new System.IO.StreamReader(s))
    {
        string result = r.ReadToEnd();
        return result;
    }
    return "";      
}

Odpowiedź jest dość prosta, po prostu zrób to, jeśli dodałeś plik bezpośrednio z pliku resources.resx.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

Za pomocą tego wiersza kodu tekst z pliku jest bezpośrednio odczytywany z pliku i umieszczany w zmiennej string.

Byłem zirytowany, że musisz zawsze dołączać przestrzeń nazw i folder do ciągu. Chciałem uprościć dostęp do zasobów osadzonych. Właśnie dlatego napisałem tę małą klasę. Zachęcamy do korzystania i ulepszania!

Stosowanie:

using(Stream stream = EmbeddedResources.ExecutingResources.GetStream("filename.txt"))
{
 //...
}

Klasa:

public class EmbeddedResources
{
    private static readonly Lazy<EmbeddedResources> _callingResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetCallingAssembly()));

    private static readonly Lazy<EmbeddedResources> _entryResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetEntryAssembly()));

    private static readonly Lazy<EmbeddedResources> _executingResources = new Lazy<EmbeddedResources>(() => new EmbeddedResources(Assembly.GetExecutingAssembly()));

    private readonly Assembly _assembly;

    private readonly string[] _resources;

    public EmbeddedResources(Assembly assembly)
    {
        _assembly = assembly;
        _resources = assembly.GetManifestResourceNames();
    }

    public static EmbeddedResources CallingResources => _callingResources.Value;

    public static EmbeddedResources EntryResources => _entryResources.Value;

    public static EmbeddedResources ExecutingResources => _executingResources.Value;

    public Stream GetStream(string resName) => _assembly.GetManifestResourceStream(_resources.Single(s => s.Contains(resName)));

}

Niektóre typy projektów VS .NET nie generują automatycznie pliku .NET (.resx). Poniższe kroki dodają plik zasobów do projektu:

1. Kliknij prawym przyciskiem myszy węzeł projektu i wybierz Dodaj / Nowy element, przewiń do Plik zasobów. W polu Nazwa wybierz odpowiednią nazwę, na przykład Zasoby i kliknij przycisk Dodaj.
2. Plik zasobów Resources.resx jest dodawany do projektu i może być postrzegany jako węzeł w eksploratorze rozwiązań.
3. W rzeczywistości tworzone są dwa pliki, istnieje również automatycznie wygenerowana klasa C # Resources.Designer.cs. Nie edytuj go, jest obsługiwany przez VS. Plik zawiera klasę o nazwie Resources.

Teraz możesz dodać plik tekstowy jako zasób, na przykład plik xml:

1. Kliknij dwukrotnie Resources.resx. Wybierz Dodaj zasób> Dodaj istniejący plik i przewiń do pliku, który chcesz dołączyć. Pozostaw wartość domyślną Wewnętrzna dla modyfikacji dostępu.
2. Ikona reprezentuje nowy element zasobu. Jeśli wybrano, panel właściwości pokazuje swoje właściwości. Dla plików XML, we właściwości Kodowanie wybierz Unicode (UTF-8) - Strona kodowa 65001 zamiast domyślnej lokalnej strony kodowej. W przypadku innych plików tekstowych wybierz prawidłowe kodowanie tego pliku, na przykład stronę kodową 1252.
3. W przypadku plików tekstowych, takich jak pliki xml, klasa Resourcesma właściwość typu stringnazwaną na podstawie dołączonego pliku. Jeśli nazwa pliku to np. RibbonManifest.xml, właściwość powinna mieć nazwę RibbonManifest. Dokładną nazwę znajdziesz w pliku kodu Resources.Designer.cs.
4. Użyj właściwości String jak inne właściwości String, np string xml = Resources.RibbonManifest. Ogólna forma to ResourceFileName.IncludedTextFileName. Nie używaj, ResourceManager.GetStringponieważ funkcja get właściwości string już to zrobiła.

public class AssemblyTextFileReader
{
    private readonly Assembly _assembly;

    public AssemblyTextFileReader(Assembly assembly)
    {
        _assembly = assembly ?? throw new ArgumentNullException(nameof(assembly));
    }

    public async Task<string> ReadFileAsync(string fileName)
    {
        var resourceName = _assembly.GetManifestResourceName(fileName);

        using (var stream = _assembly.GetManifestResourceStream(resourceName))
        {
            using (var reader = new StreamReader(stream))
            {
                return await reader.ReadToEndAsync();
            }
        }
    }
}

public static class AssemblyExtensions
{
    public static string GetManifestResourceName(this Assembly assembly, string fileName)
    {
        string name = assembly.GetManifestResourceNames().SingleOrDefault(n => n.EndsWith(fileName, StringComparison.InvariantCultureIgnoreCase));

        if (string.IsNullOrEmpty(name))
        {
            throw new FileNotFoundException($"Embedded file '{fileName}' could not be found in assembly '{assembly.FullName}'.", fileName);
        }

        return name;
    }
}

Jest to klasa, która może być bardzo przydatna do odczytu osadzonych plików zasobów z bieżącego Assembly:

using System.IO;
using System.Linq;
using System.Text;
using static System.IO.Path;
using static System.Reflection.Assembly;

public static class EmbeddedResourceUtils
{
    public static string ReadFromResourceFile(string endingFileName)
    {
        var assembly = GetExecutingAssembly();
        var manifestResourceNames = assembly.GetManifestResourceNames();

        foreach (var resourceName in manifestResourceNames)
        {
            var fileNameFromResourceName = _GetFileNameFromResourceName(resourceName);
            if (!fileNameFromResourceName.EndsWith(endingFileName))
            {
                continue;
            }

            using (var manifestResourceStream = assembly.GetManifestResourceStream(resourceName))
            {
                if (manifestResourceStream == null)
                {
                    continue;
                }

                using (var streamReader = new StreamReader(manifestResourceStream))
                {
                    return streamReader.ReadToEnd();
                }
            }
        }

        return null;
    }

    // https://stackoverflow.com/a/32176198/3764804
    private static string _GetFileNameFromResourceName(string resourceName)
    {
        var stringBuilder = new StringBuilder();
        var escapeDot = false;
        var haveExtension = false;

        for (var resourceNameIndex = resourceName.Length - 1;
            resourceNameIndex >= 0;
            resourceNameIndex--)
        {
            if (resourceName[resourceNameIndex] == '_')
            {
                escapeDot = true;
                continue;
            }

            if (resourceName[resourceNameIndex] == '.')
            {
                if (!escapeDot)
                {
                    if (haveExtension)
                    {
                        stringBuilder.Append('\\');
                        continue;
                    }

                    haveExtension = true;
                }
            }
            else
            {
                escapeDot = false;
            }

            stringBuilder.Append(resourceName[resourceNameIndex]);
        }

        var fileName = GetDirectoryName(stringBuilder.ToString());
        return fileName == null ? null : new string(fileName.Reverse().ToArray());
    }
}

Dla wszystkich osób, które po prostu chcą szybko tekstu zakodowanego pliku w winforms;

1. Kliknij aplikację prawym przyciskiem myszy w eksploratorze rozwiązań> Zasoby> Dodaj plik.
2. Kliknij go, a na karcie właściwości ustaw „FileType” na „Text”.
3. W swoim programie po prostu zrób to, Resources.<name of resource>.toString();aby odczytać plik.

Nie poleciłbym tego jako najlepszej praktyki ani niczego, ale działa szybko i robi to, co musi zrobić.

Dla użytkowników korzystających z VB.Net

Imports System.IO
Imports System.Reflection

Dim reader As StreamReader
Dim ass As Assembly = Assembly.GetExecutingAssembly()
Dim sFileName = "MyApplicationName.JavaScript.js" 
Dim reader = New StreamReader(ass.GetManifestResourceStream(sFileName))
Dim sScriptText = reader.ReadToEnd()
reader.Close()

gdzie MyApplicationNamejest przestrzeń nazw mojej aplikacji. To nie jest nazwa zestawu. Ta nazwa jest zdefiniowana we właściwościach projektu (zakładka Aplikacja).

Jeśli nie znajdziesz poprawnej nazwy zasobu, możesz użyć GetManifestResourceNames()funkcji

Dim resourceName() As String = ass.GetManifestResourceNames()

lub

Dim sName As String 
    = ass.GetManifestResourceNames()
        .Single(Function(x) x.EndsWith("JavaScript.js"))

lub

Dim sNameList 
    = ass.GetManifestResourceNames()
        .Where(Function(x As String) x.EndsWith(".js"))

Czytaj osadzony plik TXT na zdarzeniu ładowania formularza.

Ustaw zmienne dynamicznie.

string f1 = "AppName.File1.Ext";
string f2 = "AppName.File2.Ext";
string f3 = "AppName.File3.Ext";

Zadzwoń do Try Catch.

try 
{
     IncludeText(f1,f2,f3); 
     /// Pass the Resources Dynamically 
     /// through the call stack.
}

catch (Exception Ex)
{
     MessageBox.Show(Ex.Message);  
     /// Error for if the Stream is Null.
}

Utwórz Void dla IncludeText (), Visual Studio Robi to za Ciebie. Kliknij żarówkę, aby automatycznie wygenerować kod.

Umieść następujące elementy w generowanym bloku kodu

Zasób 1

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file1))
using (StreamReader reader = new StreamReader(stream))
{
string result1 = reader.ReadToEnd();
richTextBox1.AppendText(result1 + Environment.NewLine + Environment.NewLine );
}

Zasób 2

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file2))
using (StreamReader reader = new StreamReader(stream))
{
string result2 = reader.ReadToEnd();
richTextBox1.AppendText(
result2 + Environment.NewLine + 
Environment.NewLine );
}

Zasób 3

var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(file3))

using (StreamReader reader = new StreamReader(stream))
{
    string result3 = reader.ReadToEnd();
    richTextBox1.AppendText(result3);
}

Jeśli chcesz wysłać zwróconą zmienną gdzie indziej, po prostu wywołaj inną funkcję i ...

using (StreamReader reader = new StreamReader(stream))
{
    string result3 = reader.ReadToEnd();
    ///richTextBox1.AppendText(result3);
    string extVar = result3;

    /// another try catch here.

   try {

   SendVariableToLocation(extVar)
   {
         //// Put Code Here.
   }

       }

  catch (Exception ex)
  {
    Messagebox.Show(ex.Message);
  }

}

Osiągnięto to dzięki metodzie łączenia wielu plików txt i odczytywania ich osadzonych danych w jednym bogatym polu tekstowym. co było moim pożądanym efektem w tej próbce kodu.