¿Cómo puedo descubrir la "ruta" de un recurso integrado?

Estoy almacenando un PNG como recurso incrustado en un ensamblado. Desde dentro del mismo ensamblado, tengo un código como este:

Bitmap image = new Bitmap(typeof(MyClass), "Resources.file.png");

El archivo, llamado "file.png" se almacena en la carpeta "Recursos" (dentro de Visual Studio) y está marcado como un recurso incrustado.

El código falla con una excepción que dice:

El recurso MyNamespace.Resources.file.png no se puede encontrar en la clase MyNamespace.MyClass

Tengo un código idéntico (en un ensamblado diferente, cargando un recurso diferente) que funciona. Entonces sé que la técnica es sólida. Mi problema es que termino pasando mucho tiempo tratando de averiguar cuál es el camino correcto. Si pudiera simplemente consultar (por ejemplo, en el depurador) el ensamblado para encontrar la ruta correcta, eso me ahorraría un montón de dolores de cabeza.

Esto le dará una matriz de cadenas de todos los recursos:

System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceNames();

Me encuentro olvidando cómo hacer esto cada vez, así que simplemente envuelvo las dos frases breves que necesito en una pequeña clase:

public class Utility
{
    /// <summary>
    /// Takes the full name of a resource and loads it in to a stream.
    /// </summary>
    /// <param name="resourceName">Assuming an embedded resource is a file
    /// called info.png and is located in a folder called Resources, it
    /// will be compiled in to the assembly with this fully qualified
    /// name: Full.Assembly.Name.Resources.info.png. That is the string
    /// that you should pass to this method.</param>
    /// <returns></returns>
    public static Stream GetEmbeddedResourceStream(string resourceName)
    {
        return Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName);
    }

    /// <summary>
    /// Get the list of all emdedded resources in the assembly.
    /// </summary>
    /// <returns>An array of fully qualified resource names</returns>
    public static string[] GetEmbeddedResourceNames()
    {
        return Assembly.GetExecutingAssembly().GetManifestResourceNames();
    }
}

Supongo que tu clase está en un espacio de nombres diferente. La forma canónica de resolver esto sería usar la clase de recursos y un recurso fuertemente tipado:

ProjectNamespace.Properties.Resources.file

Utilice el administrador de recursos del IDE para agregar recursos.

Utilizo el siguiente método para obtener recursos integrados:

    protected static Stream GetResourceStream(string resourcePath)
    {
        Assembly assembly = Assembly.GetExecutingAssembly();
        List<string> resourceNames = new List<string>(assembly.GetManifestResourceNames());

        resourcePath = resourcePath.Replace(@"/", ".");
        resourcePath = resourceNames.FirstOrDefault(r => r.Contains(resourcePath));

        if (resourcePath == null)
            throw new FileNotFoundException("Resource not found");

        return assembly.GetManifestResourceStream(resourcePath);
    }

Luego llamo a esto con la ruta en el proyecto:

GetResourceStream(@"DirectoryPathInLibrary/Filename")

El nombre del recurso es el espacio de nombre más el "pseudo" espacio de nombre de la ruta al archivo. El "pseudo" espacio de nombres lo crea la estructura de subcarpetas usando \ (barras invertidas) en lugar de. (puntos).

public static Stream GetResourceFileStream(String nameSpace, String filePath)
{
    String pseduoName = filePath.Replace('\\', '.');
    Assembly assembly = Assembly.GetExecutingAssembly();
    return assembly.GetManifestResourceStream(nameSpace + "." + pseduoName);
}

La siguiente convocatoria:

GetResourceFileStream("my.namespace", "resources\\xml\\my.xml")

devolverá el flujo de my.xml ubicado en la estructura de carpetas resources \ xml en el espacio de nombres: my.namespace.