Comment lire un fichier texte de ressource incorporé

Comment lire une ressource incorporée (fichier texte) en l'utilisant StreamReaderet la renvoyer sous forme de chaîne? Mon script actuel utilise un formulaire et une zone de texte Windows qui permettent à l'utilisateur de rechercher et de remplacer du texte dans un fichier texte qui n'est pas incorporé.

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();
}

Vous pouvez utiliser la Assembly.GetManifestResourceStreamméthode :

1. Ajoutez les utilisations suivantes

   using System.IO;
   using System.Reflection;

2. Définir la propriété du fichier pertinent:
   paramètre Build Actionavec valeurEmbedded Resource

3. Utilisez le code suivant

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();
}

resourceNameest le nom d'une des ressources intégrées assembly. Par exemple, si vous incorporez un fichier texte nommé "MyFile.txt"qui est placé à la racine d'un projet avec un espace de noms par défaut "MyCompany.MyProduct", alors resourceNamec'est le cas "MyCompany.MyProduct.MyFile.txt". Vous pouvez obtenir une liste de toutes les ressources d'un assembly à l'aide de la Assembly.GetManifestResourceNamesméthode .

Un astucieux astucieux pour obtenir le resourceNamenom de fichier uniquement (en passant le truc de l'espace de noms):

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

Un exemple complet:

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();
    }
}

Vous pouvez ajouter un fichier en tant que ressource à l'aide de deux méthodes distinctes.

Le code C # requis pour accéder au fichier est différent , selon la méthode utilisée pour ajouter le fichier en premier lieu.

Méthode 1: ajouter un fichier existant, définir la propriété sur Embedded Resource

Ajoutez le fichier à votre projet, puis définissez le type sur Embedded Resource.

REMARQUE: si vous ajoutez le fichier à l'aide de cette méthode, vous pouvez utiliser GetManifestResourceStreampour y accéder (voir la réponse de @dtb ).

Méthode 2: ajouter un fichier à Resources.resx

Ouvrez le Resources.resxfichier, utilisez la liste déroulante pour ajouter le fichier, définissez Access Modifiersur public.

REMARQUE: si vous ajoutez le fichier à l'aide de cette méthode, vous pouvez l'utiliser Properties.Resourcespour y accéder (voir la réponse de @Night Walker ).

Fondamentalement, vous utilisez System.Reflectionpour obtenir une référence à l'assembly actuel. Ensuite, vous utilisez GetManifestResourceStream().

Exemple, à partir de la page que j'ai publiée:

Remarque : besoin d'ajouter using System.Reflection;pour que cela fonctionne

   Assembly _assembly;
   StreamReader _textStreamReader;

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

Dans Visual Studio, vous pouvez directement intégrer l'accès à une ressource de fichier via l'onglet Ressources des propriétés du projet («Analytics» dans cet exemple).

Le fichier résultant est ensuite accessible sous forme de tableau d'octets par

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

Si vous en avez besoin en tant que flux, (à partir de https://stackoverflow.com/a/4736185/432976 )

Stream stream = new MemoryStream(jsonSecrets)

Lorsque vous avez ajouté le fichier aux ressources, vous devez sélectionner ses modificateurs d'accès en tant que public afin de créer quelque chose comme le suivant.

byte[] clistAsByteArray = Properties.Resources.CLIST01;

CLIST01 est le nom du fichier incorporé.

En fait, vous pouvez aller dans resources.Designer.cs et voir quel est le nom du getter.

ajout par exemple du menu Projet Testfile.sql -> Propriétés -> Ressources -> Ajouter un fichier existant

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

Je sais que c'est un vieux fil, mais c'est ce qui a fonctionné pour moi:

1. ajouter le fichier texte aux ressources du projet
2. définissez le modificateur d'accès sur public, comme indiqué ci-dessus par Andrew Hill

3. lire le texte comme ceci:

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

Le texte que j'ai ajouté aux ressources: «SomeText.txt»

Vous pouvez également utiliser cette version simplifiée de la réponse de @ 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();
    }
}

Quelque chose que j'ai appris tout à l'heure est que votre fichier n'est pas autorisé à avoir un "." (point) dans le nom de fichier.

Templates.plainEmailBodyTemplate-en.txt -> Fonctionne !!!
Templates.plainEmailBodyTemplate.en.txt -> ne fonctionne pas via GetManifestResourceStream ()

Probablement parce que le cadre se confond entre les espaces de noms et le nom de fichier ...

Par tous vos pouvoirs combinés, j'utilise cette classe d'assistance pour lire les ressources de n'importe quel assemblage et de tout espace de noms de manière générique.

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();
            }
        }
    }
}

J'ai lu une utilisation de fichier texte de ressource intégrée:

    /// <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));
    }

Échantillon:

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

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

Je sais que c'est vieux, mais je voulais juste souligner pour NETMF (.Net MicroFramework), vous pouvez facilement le faire:

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

Depuis NETMF n'a pasGetManifestResourceStream

Après avoir lu toutes les solutions publiées ici. Voici comment je l'ai résolu:

// 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 "";      
}

La réponse est assez simple, faites-le simplement si vous avez ajouté le fichier directement à partir du fichier resources.resx.

string textInResourceFile = fileNameSpace.Properties.Resources.fileName;

Avec cette ligne de code, le texte du fichier est directement lu dans le fichier et placé dans la variable de chaîne.

J'étais ennuyé que vous deviez toujours inclure l'espace de noms et le dossier dans la chaîne. Je voulais simplifier l'accès aux ressources embarquées. C'est pourquoi j'ai écrit ce petit cours. N'hésitez pas à utiliser et à améliorer!

Usage:

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

Classe:

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)));

}

Certains types de projets VS .NET ne génèrent pas automatiquement un fichier .NET (.resx). Les étapes suivantes ajoutent un fichier de ressources à votre projet:

1. Cliquez avec le bouton droit sur le nœud du projet et sélectionnez Ajouter / Nouvel élément, faites défiler jusqu'à Fichier de ressources. Dans la zone Nom, choisissez un nom approprié, par exemple Ressources et cliquez sur le bouton Ajouter.
2. Le fichier de ressources Resources.resx est ajouté au projet et peut être vu comme un nœud dans l'explorateur de solutions.
3. En fait, deux fichiers sont créés, il existe également une classe C # générée automatiquement Resources.Designer.cs. Ne le modifiez pas, il est maintenu par VS. Le fichier contient une classe nommée Resources.

Vous pouvez maintenant ajouter un fichier texte en tant que ressource, par exemple un fichier xml:

1. Double-cliquez sur Resources.resx. Sélectionnez Ajouter une ressource> Ajouter un fichier existant et faites défiler jusqu'au fichier que vous souhaitez inclure. Laissez la valeur par défaut Internal pour Access Modify.
2. Une icône représente le nouvel élément de ressource. S'il est sélectionné, le volet des propriétés affiche ses propriétés. Pour les fichiers xml, sous la propriété Encoding, sélectionnez Unicode (UTF-8) - Page de code 65001 au lieu de la page de code locale par défaut. Pour les autres fichiers texte, sélectionnez l'encodage correct de ce fichier, par exemple la page de codes 1252.
3. Pour les fichiers texte comme les fichiers xml, la classe Resourcesa une propriété de type stringqui porte le nom du fichier inclus. Si le nom du fichier est par exemple RibbonManifest.xml, la propriété doit avoir le nom RibbonManifest. Vous trouvez le nom exact dans le fichier de code Resources.Designer.cs.
4. Utilisez la propriété de chaîne comme une autre propriété de chaîne, par exemple: string xml = Resources.RibbonManifest. La forme générale est ResourceFileName.IncludedTextFileName. Ne l'utilisez pas ResourceManager.GetStringcar la fonction get de la propriété string l'a déjà fait.

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;
    }
}

Il s'agit d'une classe que vous pourriez trouver très pratique pour lire les fichiers de ressources intégrés à partir de la version actuelle 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());
    }
}

Pour toutes les personnes qui veulent rapidement le texte d'un fichier codé en dur dans Winforms;

1. Cliquez avec le bouton droit sur votre application dans l'explorateur de solutions> Ressources> Ajouter votre fichier.
2. Cliquez dessus et dans l'onglet Propriétés, définissez le "FileType" sur "Text".
3. Dans votre programme, il suffit Resources.<name of resource>.toString();de lire le fichier.

Je ne recommanderais pas cela comme meilleure pratique ou quoi que ce soit, mais cela fonctionne rapidement et fait ce qu'il doit faire.

Pour les utilisateurs qui utilisent 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()

où MyApplicationName est l'espace de noms de mon application. Ce n'est pas le nom de l'assembly. Ce nom est défini dans les propriétés du projet (onglet Application).

Si vous ne trouvez pas le nom de ressource correct, vous pouvez utiliser la GetManifestResourceNames()fonction

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

ou

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

ou

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

Lisez le fichier TXT intégré lors de l'événement de chargement de formulaire.

Définissez les variables dynamiquement.

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

Appelez un 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.
}

Créer un vide pour IncludeText (), Visual Studio fait cela pour vous. Cliquez sur l'ampoule pour générer automatiquement le CodeBlock.

Mettez ce qui suit à l'intérieur du bloc de code généré

Ressource 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 );
}

Ressource 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 );
}

Ressource 3

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

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

Si vous souhaitez envoyer la variable renvoyée ailleurs, appelez simplement une autre fonction et ...

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);
  }

}

Ce que cela a réalisé, c'est une méthode pour combiner plusieurs fichiers txt et lire leurs données incorporées, dans une seule zone de texte riche. ce qui était mon effet souhaité avec cet échantillon de code.