英語で読む

次の方法で共有


ModuleBuilder.DefineManifestResource メソッド

定義

動的アセンブリに埋め込まれるマニフェスト リソースを表すバイナリ ラージ オブジェクト (BLOB) を定義します。

C#
public void DefineManifestResource(string name, System.IO.Stream stream, System.Reflection.ResourceAttributes attribute);

パラメーター

name
String

リソースの、大文字と小文字が区別される名前。

stream
Stream

リソースのバイトを格納しているストリーム。

attribute
ResourceAttributes

リソースがパブリックかまたはプライベートかを指定する列挙値。

例外

namenullです。

または

streamnullです。

name は長さゼロの文字列です。

現在のモジュールを格納している動的アセンブリが遷移的です。つまり、DefineDynamicModule(String, String) の呼び出し時にファイル名が指定されていません。

次の例では、 という名前 EmittedManifestResourceAssembly.exeの動的アセンブリを生成して保存します。このアセンブリには、埋め込みアンマネージ リソースが含まれています。 この例では、1 つのモジュールで構成されるアセンブリを作成し、アンマネージ リソースを格納するメモリ ストリームを開きます。 次に、 メソッドを DefineManifestResource 呼び出してリソースを定義します。

注意

リソースには任意の種類のストリームを使用できます。たとえば、アンマネージド バイナリ データをファイルから読み取ることができます。

この例では、 メソッドを使用して動的モジュールの型を Main 定義し、メソッド本体の MSIL を生成します。 メソッドの本文 Main が生成され、型が作成されると、コード例はマニフェスト リソースに関連付けられているストリームに 5 バイトを書き込みます。 アセンブリが保存されると、そのアセンブリにリソースが追加されます。

この例を実行した後、出力されたアセンブリを実行できます。 出力されたアセンブリの メソッドの Main コードは、埋め込みマニフェスト リソースを読み取り、バイト値をコンソールに出力します。 Ildasm.exe (IL 逆アセンブラー) を使用して、アセンブリ マニフェスト内の情報を表示できます。

C#
using System;
using System.Reflection;
using System.Reflection.Emit;
using System.IO;

public class Example
{
    public static void Main()
    {
        // Define a dynamic assembly with one module. The module
        // name and the assembly name are the same.
        AssemblyName asmName =
            new AssemblyName("EmittedManifestResourceAssembly");
        AssemblyBuilder asmBuilder =
            AppDomain.CurrentDomain.DefineDynamicAssembly(
                asmName,
                AssemblyBuilderAccess.RunAndSave
            );
        ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule(
            asmName.Name,
            asmName.Name + ".exe"
        );

        // Create a memory stream for the unmanaged resource data.
        // You can use any stream; for example, you might read the
        // unmanaged resource data from a binary file. It is not
        // necessary to put any data into the stream right now.
        MemoryStream ms = new MemoryStream(1024);

        // Define a public manifest resource with the name
        // "MyBinaryData, and associate it with the memory stream.
        modBuilder.DefineManifestResource(
            "MyBinaryData",
            ms,
            ResourceAttributes.Public
        );

        // Create a type with a public static Main method that will
        // be the entry point for the emitted assembly.
        //
        // The purpose of the Main method in this example is to read
        // the manifest resource and display it, byte by byte.
        //
        TypeBuilder tb = modBuilder.DefineType("Example");
        MethodBuilder main = tb.DefineMethod("Main",
            MethodAttributes.Public | MethodAttributes.Static
        );

        // The Main method uses the Assembly type and the Stream
        // type.
        Type asm = typeof(Assembly);
        Type str = typeof(Stream);

        // Get MethodInfo objects for the methods called by
        // Main.
        MethodInfo getEx = asm.GetMethod("GetExecutingAssembly");
        // Use the overload of GetManifestResourceStream that
        // takes one argument, a string.
        MethodInfo getMRS = asm.GetMethod(
            "GetManifestResourceStream",
            new Type[] {typeof(string)}
        );
        MethodInfo rByte = str.GetMethod("ReadByte");
        // Use the overload of WriteLine that writes an Int32.
        MethodInfo write = typeof(Console).GetMethod(
            "WriteLine",
            new Type[] {typeof(int)}
        );

        ILGenerator ilg = main.GetILGenerator();

        // Main uses two local variables: the instance of the
        // stream returned by GetManifestResourceStream, and
        // the value returned by ReadByte. The load and store
        // instructions refer to these locals by position
        // (0 and 1).
        LocalBuilder s = ilg.DeclareLocal(str);
        LocalBuilder b = ilg.DeclareLocal(typeof(int));

        // Call the static Assembly.GetExecutingAssembly() method,
        // which leaves the assembly instance on the stack. Push the
        // string name of the resource on the stack, and call the
        // GetManifestResourceStream(string) method of the assembly
        // instance.
        ilg.EmitCall(OpCodes.Call, getEx, null);
        ilg.Emit(OpCodes.Ldstr, "MyBinaryData");
        ilg.EmitCall(OpCodes.Callvirt, getMRS, null);

        // Store the Stream instance.
        ilg.Emit(OpCodes.Stloc_0);

        // Create a label, and associate it with this point
        // in the emitted code.
        Label loop = ilg.DefineLabel();
        ilg.MarkLabel(loop);

        // Load the Stream instance onto the stack, and call
        // its ReadByte method. The return value is on the
        // stack now; store it in location 1 (variable b).
        ilg.Emit(OpCodes.Ldloc_0);
        ilg.EmitCall(OpCodes.Callvirt, rByte, null);
        ilg.Emit(OpCodes.Stloc_1);

        // Load the value on the stack again, and call the
        // WriteLine method to print it.
        ilg.Emit(OpCodes.Ldloc_1);
        ilg.EmitCall(OpCodes.Call, write, null);

        // Load the value one more time; load -1 (minus one)
        // and compare the two values. If return value from
        // ReadByte was not -1, branch to the label 'loop'.
        ilg.Emit(OpCodes.Ldloc_1);
        ilg.Emit(OpCodes.Ldc_I4_M1);
        ilg.Emit(OpCodes.Ceq);
        ilg.Emit(OpCodes.Brfalse_S, loop);

        // When all the bytes in the stream have been read,
        // return. This is the end of Main.
        ilg.Emit(OpCodes.Ret);

        // Create the type "Example" in the dynamic assembly.
        tb.CreateType();

        // Because the manifest resource was added as an open
        // stream, the data can be written at any time, right up
        // until the assembly is saved. In this case, the data
        // consists of five bytes.
        ms.Write(new byte[] { 105, 36, 74, 97, 109 }, 0, 5);
        ms.SetLength(5);

        // Set the Main method as the entry point for the
        // assembly, and save the assembly. The manifest resource
        // is read from the memory stream, and appended to the
        // end of the assembly. You can open the assembly with
        // Ildasm and view the resource header for "MyBinaryData".
        asmBuilder.SetEntryPoint(main);
    asmBuilder.Save(asmName.Name + ".exe");

        Console.WriteLine("Now run EmittedManifestResourceAssembly.exe");
    }
}

/* This code example doesn't produce any output. The assembly it
   emits, EmittedManifestResourceAssembly.exe, produces the following
   output:

105
36
74
97
109
-1

 */

注釈

アセンブリ マニフェストに記録されるリソースは、マネージド リソースまたはマニフェスト リソース BLOB にすることができます。これらの各リソースは、リンクまたは埋め込みによってアセンブリに含めることができます。 動的アセンブリでは、4 つのシナリオすべてがサポートされています。

  • このメソッドを使用すると、マニフェスト リソース BLOB を動的アセンブリに埋め込むことができます。

  • 動的アセンブリのマニフェスト モジュールまたはサテライト モジュールにマネージド リソースを埋め込むには、 メソッドを ModuleBuilder.DefineResource 使用してリソース ライターを取得し、 メソッドを ResourceWriter.AddResource 使用してリソースを追加します。

  • マネージド リソースを動的アセンブリにリンクするには、 メソッドを AssemblyBuilder.DefineResource 使用してリソース ライターを取得し、 メソッドを ResourceWriter.AddResource 使用してリンクされたリソースを追加します。

  • マニフェスト リソース BLOB を動的アセンブリにリンクするには、 メソッドを AssemblyBuilder.AddResourceFile 使用してリンクされたリソースを追加します。

さらに、 メソッドまたは メソッドを使用して、1 つの Win32 リソースをアセンブリにAssemblyBuilder.DefineUnmanagedResourceModuleBuilder.DefineUnmanagedResourceアタッチできます。 このリソースはアセンブリ マニフェストには表示されません。

適用対象

製品 バージョン
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1

こちらもご覧ください