GetManifestResourceStream devuelve NULL

Esta es una aplicación C # .NET 4.0:

Estoy incrustando un archivo de texto como recurso y luego intento mostrarlo en un cuadro de diálogo:

    var assembly = Assembly.GetExecutingAssembly();
    var resourceName = "MyProj.Help.txt";

        using (Stream stream = assembly.GetManifestResourceStream(resourceName))
        {
            using (StreamReader reader = new StreamReader(stream))
            {
                string result = reader.ReadToEnd();
                System.Windows.Forms.MessageBox.Show(result, "MyProj", MessageBoxButtons.OK);
            }
        }

La solución es MyProjSolution y el ejecutable es MyProj.exe. Help.txt es un recurso integrado. Sin embargo, la secuencia es nula. Probé MyProjSolution.Help.txt y MyProjSolution.MyProj.Help.txt pero nada parece funcionar.

Puede comprobar que los recursos están incrustados correctamente utilizando

//From the assembly where this code lives!
this.GetType().Assembly.GetManifestResourceNames()

//or from the entry point to the application - there is a difference!
Assembly.GetExecutingAssembly().GetManifestResourceNames()

al depurar. Esto enumerará todos los (nombres completos) de todos los recursos incrustados en el ensamblado en el que está escrito su código.

Vea Assembly.GetManifestResourceNames () en MSDN.

Simplemente copie el nombre relevante y utilícelo en lugar de lo que haya definido en la variable 'resourceName'.

Notas: el nombre del recurso distingue entre mayúsculas y minúsculas, y si ha incrustado incorrectamente el archivo de recursos, no aparecerá en la lista devuelta por la llamada a GetManifestResourceNames (). Además, asegúrese de leer el recurso del ensamblado correcto (si se utilizan varios ensamblados); es muy fácil obtener los recursos del ensamblado que se está ejecutando actualmente en lugar de un ensamblado referenciado.

EDITAR: .NET Core
Consulte esta publicación de SO para obtener detalles sobre cómo incrustar usando .NET Core.

Recuperar la información del manifiesto parece ser similar; solo utilícelo this.GetType().GetTypeInfo().Assembly.GetManifestResourceNames()para obtener el manifiesto del ensamblado donde se está ejecutando el código.

¡Todavía no he descubierto cómo hacer el equivalente Assembly.GetExecutingAssembly()en .NET Core! si alguien lo sabe, hágamelo saber y actualizaré esta respuesta.

Tuve un problema similar, verifique primero que el archivo esté incluido en su proyecto, luego vaya a propiedades y establezca la acción de compilación de ese archivo en Recurso incrustado. esto funcionó para mí.

La propiedad "Acción de compilación" del archivo incrustado debe establecerse como "Recurso incrustado" para ejecutar la línea, que se muestra a continuación, correctamente:

Stream stream = assembly.GetManifestResourceStream(resourceName)

Haga clic derecho en el archivo, haga clic en la propiedad y luego establezca la propiedad "Acción de compilación" como "Recurso incrustado":

Aquí está la causa de mi valor nulo.

http://adrianmejia.com/blog/2011/07/18/cs-getmanifestresourcestream-gotcha/

El GetManifestResourceStreammétodo siempre devolverá NULLsi la propiedad 'acción construida' del recurso no está establecida en 'recurso incrustado'

Después de establecer esta propiedad con todos los archivos necesarios, assembly.GetManifestResourceStreamcomienza a devolver la secuencia correcta en lugar de NULL.

Sólo una advertencia.

No pude acceder a mi archivo como recurso incrustado aunque especifiqué que lo era y aunque tenía esa propiedad Build Action. Perdí mucho tiempo golpeándome la cabeza. Inserté un archivo de código csharp con .txt adjunto a su nombre (xxx.cs.txt). Por alguna razón, los métodos GetManifestResourceNames () y GetManifestResourceStream () no verán un archivo con .cs en su nombre.

Lo renombré simplemente xxx.txt y todo estuvo bien.

Extraño.

Tuve el mismo problema, gracias a Jay descubrí que había guiones en el nombre del directorio.

ProjectName.ResourceFolder.Sub-Directoryse convierte en ProjectName.ResourceFolder.Sub_Directorycuando hace referencia al flujo de recursos.

En mi caso, el problema fue que el código que buscaba el recurso estaba en un proyecto diferente al del propio recurso.

Solo puede acceder a los recursos que están en el mismo proyecto que el código. Pensé que podría poner todos mis recursos en el proyecto de la página web, pero también necesito imágenes en el proyecto de correo.

Espero que esto ayude a alguien en la misma situación que yo.

Encuentro llamadas realmente útiles Assembly.GetExecutingAssembly().GetManifestResourceNames();.

En caso de que ayude a alguien más, asegúrese Assembly.GetExecutingAssembly()de que se llame a la línea desde el mismo ensamblado que tiene recursos integrados.

Una solución simple y optimizada es tener esta clase base :

public class EmbededResourceReader
{
    protected string LoadString(string fileName)
    {
        return LoadString(fileName, Encoding.UTF8);
    }

    protected string LoadString(string fileName, Encoding encoding)
    {
        var assembly = this.GetType().Assembly;
        var resourceStream = assembly.GetManifestResourceStream($"{this.GetType().Namespace}.{fileName}");
        using (var reader = new StreamReader(resourceStream, encoding))
        {
            return reader.ReadToEnd();
        }
    }
}

Luego, cuando agrega un recurso, crea una clase de lector C # en la misma carpeta:

donde la clase de lector MyResource.cs es muy simple:

public class MyResource : EmbededResourceReader
{
    public string LoadString() => LoadString($"{nameof(MyResource)}.txt");
}

Entonces, cada recurso tendrá una clase "sombra" que sepa leerlo correctamente.

Así es como lee el recurso en su código:

var text = new MyResource().LoadString();

Y como sugirieron otras respuestas, no olvide establecer "Recurso incrustado" en la propiedad Acción de compilación del archivo de recursos.

La ventaja de esta solución uniforme es

1. menos problemas para encontrar el nombre completo correcto del recurso, especialmente cuando se coloca en carpetas anidadas
2. en caso de que se cambie el nombre de la carpeta O se cambie el espacio de nombres predeterminado en la configuración del proyecto, el código NO se romperá

    First Unload the project and click on edit the project file. 

    Inside the project file make sure that the item you are fetching from the assembly is included inside <EmbeddedResource> tag.

    Eg: 

         <ItemGroup>
          <EmbeddedResource Include="Template\ForExampleFile.html" />
         </ItemGroup>


    The files I added into the project were just in Content tag but not in the EmbeddedResource as shown below by default. Hence the stream was returning null.
    <ItemGroup>
        <Content Include="Template\ForExampleFile.html" />
  </ItemGroup>

Necesitas descargar tu solución, luego edita el proyecto, luego encuentra tu carpeta y cambia así:

<EmbeddedResource Include="yourpath" />

Aunque OP obtuvo GetManifestResourceStream devolviendo NULL de los recursos en el mismo ensamblado, algunas respuestas sugirieron que cuando los recursos están en otro proyecto o ensamblado no se pueden recuperar y son una causa justa de que GetManifestResourceStream devuelva NULL.

Esto no es cierto, al menos desde 2011; como señalé en algunos comentarios en otro lugar, Assembly.LoadFrom () o typeof hacen el truco y, como resultado, puede acceder a los recursos que están en otro proyecto.

Tengo aquí un ejemplo moderadamente complejo para ilustrar; esta es mi configuración de prueba:

Camino a otro proyecto:

Capturado aquí:

 var sharedXMLResource =
                "D:\\My Documents\\Consultório Impressos\\DB Pacientes\\Teste\\TestesVariados\\WinFormFramework\\Read_Embedded_XML_File_CS\\bin\\Debug\\Read_Embedded_XML_File_CS.exe";

Y en Form1.cs de WinFormFramework especifico con

Namespace.Folder.Resource

como eso:

StreamReader reader = 
                new StreamReader(Assembly.LoadFrom(sharedXMLResource).GetManifestResourceStream("Read_Embedded_XML_File_CS.SharedResources.ContactList.xml") ?? throw new InvalidOperationException());

Y el resultado se muestra en el cuadro de texto:

Pasé varias horas para hacerlo bien; para eso, tuve que usar mucho estos en Immediate Window:

Environment.CurrentDirectory
AppDomain.CurrentDomain.BaseDirectory
System.Reflection.Assembly.GetExecutingAssembly().Location
System.Reflection.Assembly.GetAssembly(typeof(WinFormFramework.Program)).Location

Espero que ayude a alguien

Probablemente necesite especificar la ruta a su archivo txt en el GetManifestResourceStreamparámetro, o podría intentar pegar el archivo txt en el mismo directorio que su ejecutable. ¡Espero que ayude!