Partilhar via

AssemblyBuilder.DefineUnmanagedResource Método

  • Referência

Definição

Namespace:
System.Reflection.Emit
Assembly:
mscorlib.dll

Define um recurso não gerenciado para este assembly.

Sobrecargas

DefineUnmanagedResource(String)

Define um arquivo de recurso não gerenciado para este assembly, considerando o nome do arquivo de recurso.
DefineUnmanagedResource(Byte[])

Define um recurso não gerenciado para este assembly como um blob de bytes opaco.

DefineUnmanagedResource(String)

Define um arquivo de recurso não gerenciado para este assembly, considerando o nome do arquivo de recurso.

public:
 void DefineUnmanagedResource(System::String ^ resourceFileName);
public void DefineUnmanagedResource (string resourceFileName);
member this.DefineUnmanagedResource : string -> unit
Public Sub DefineUnmanagedResource (resourceFileName As String)

Parâmetros

resourceFileName
String

O nome do arquivo de recurso.

Exceções

ArgumentException

Um recurso não gerenciado foi definido anteriormente.

- ou -

O arquivo resourceFileName não é legível.

- ou -

resourceFileName é a cadeia de caracteres vazia ("").

ArgumentNullException

resourceFileName é null.

FileNotFoundException

resourceFileName não foi encontrado.

- ou -

resourceFileName é um diretório.

SecurityException

O chamador não tem a permissão necessária.

Exemplos

O exemplo a seguir demonstra uma chamada para DefineUnmanagedResource, passando um arquivo de recurso externo.

void main()
{
   AssemblyBuilder^ myAssembly = CreateAssembly("MyEmitTestAssembly");
   
   // Defines a standalone managed resource for this assembly.
   IResourceWriter^ myResourceWriter = 
      myAssembly->DefineResource( "myResourceFile", "A sample Resource File", 
         "MyAssemblyResource.resources", ResourceAttributes::Private );

   myResourceWriter->AddResource( "AddResource Test", "Testing for the added resource" );

   myAssembly->Save(myAssembly->GetName()->Name + ".dll" );
   
   // Defines an unmanaged resource file for this assembly.
   myAssembly->DefineUnmanagedResource(  "MyAssemblyResource.resources" );
};

   internal static void Main()
   {
      AssemblyBuilder myAssembly = CreateAssembly("MyEmitTestAssembly");

      // Defines a standalone managed resource for this assembly.
      IResourceWriter myResourceWriter = myAssembly.DefineResource("myResourceFile",
         "A sample Resource File", "MyAssemblyResource.resources",
         ResourceAttributes.Private);

      myResourceWriter.AddResource("AddResource Test", "Testing for the added resource");

      myAssembly.Save(myAssembly.GetName().Name + ".dll");

      // Defines an unmanaged resource file for this assembly.
      myAssembly.DefineUnmanagedResource("MyAssemblyResource.resources");
   }

   private static AssemblyBuilder CreateAssembly(string name)
   {
      AssemblyName aName = new AssemblyName(name);
      AssemblyBuilder myAssembly =
         AppDomain.CurrentDomain.DefineDynamicAssembly(aName,
            AssemblyBuilderAccess.Save);

      // Define a dynamic module.
      ModuleBuilder myModule =
         myAssembly.DefineDynamicModule(aName.Name, aName.Name + ".dll");

      // Define a public class named "EmitClass" in the assembly.
      TypeBuilder myEmitClass = myModule.DefineType("EmitClass", TypeAttributes.Public);

      // Define the Display method.
      MethodBuilder myMethod = myEmitClass.DefineMethod("Display",
         MethodAttributes.Public, typeof(String), null);

      // Generate IL for Display method.
      ILGenerator methodIL = myMethod.GetILGenerator();
      methodIL.Emit(OpCodes.Ldstr, "Display method gets called.");
      methodIL.Emit(OpCodes.Ret);

      myEmitClass.CreateType();

      return(myAssembly);
   }
}

Friend Shared Sub Main()
   Dim myAssembly As AssemblyBuilder = _
       CreateAssembly("MyEmitTestAssembly")
   
   ' Defines a standalone managed resource for this assembly.
   Dim myResourceWriter As IResourceWriter = _
      myAssembly.DefineResource("myResourceFile", _
         "A sample Resource File", "MyAssemblyResource.resources", _
         ResourceAttributes.Private)

   myResourceWriter.AddResource("AddResource Test", "Testing for the added resource")

   myAssembly.Save(myAssembly.GetName().Name & ".dll")
   
   ' Defines an unmanaged resource file for this assembly.
   myAssembly.DefineUnmanagedResource("MyAssemblyResource.resources")

End Sub 

Private Shared Function CreateAssembly(ByVal name As String) As AssemblyBuilder

   Dim aName As New AssemblyName(name)

   Dim myAssembly As AssemblyBuilder = _
      AppDomain.CurrentDomain.DefineDynamicAssembly(aName, _
         AssemblyBuilderAccess.Save)
   
   ' Define a dynamic module.
   Dim myModule As ModuleBuilder = _
      myAssembly.DefineDynamicModule(aName.Name, aName.Name & ".dll")

   ' Define a public class named "EmitClass" in the assembly.
   Dim myEmitClass As TypeBuilder = _
      myModule.DefineType("EmitClass", TypeAttributes.Public)
   
   ' Define the Display method.
   Dim myMethod As MethodBuilder = _
      myEmitClass.DefineMethod("Display", MethodAttributes.Public, _
                                             GetType(String), Nothing)
   
   ' Generate IL for Display method.
   Dim methodIL As ILGenerator = myMethod.GetILGenerator()
   methodIL.Emit(OpCodes.Ldstr, "Display method get called.")
   methodIL.Emit(OpCodes.Ret)
   
   myEmitClass.CreateType()

   Return myAssembly

End Function

Comentários

Um assembly pode ser associado a apenas um recurso não gerenciado. Isso significa que chamar DefineVersionInfoResource ou DefineUnmanagedResource depois que um dos métodos foi chamado anteriormente gerará System.ArgumentException. Vários recursos não gerenciados precisam ser mesclados com uma ferramenta como o utilitário Microsoft ResMerge (não fornecido com o Common Language Runtime).

Observação

A partir do .NET Framework 2.0 Service Pack 1, esse membro não requer ReflectionPermission mais com o ReflectionPermissionFlag.ReflectionEmit sinalizador. (Consulte Problemas de segurança em Emissão de Reflexão.) Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3.5 ou posterior.

Aplica-se a

DefineUnmanagedResource(Byte[])

Define um recurso não gerenciado para este assembly como um blob de bytes opaco.

public:
 void DefineUnmanagedResource(cli::array <System::Byte> ^ resource);
public void DefineUnmanagedResource (byte[] resource);
member this.DefineUnmanagedResource : byte[] -> unit
Public Sub DefineUnmanagedResource (resource As Byte())

Parâmetros

resource
Byte[]

O blob de bytes opaco que representa o recurso não gerenciado.

Exceções

ArgumentException

Um recurso não gerenciado foi definido anteriormente.

ArgumentNullException

resource é null.

SecurityException

O chamador não tem a permissão necessária.

Exemplos

O exemplo de código a seguir cria e anexa uma matriz de bytes que representam um recurso não gerenciado a um assembly dinâmico, usando DefineUnmanagedResource.

/*
   The following program demonstrates the 'DefineResource' and 'DefineUnmanagedResource'
   methods of 'AssemblyBuilder' class. It builds an assembly and a resource file at runtime.
   An unmanaged resource file is also defined for the same resource file. The EmittedTest2.cpp file
   calls the methods of "MyEmitAssembly.dll" assembly and the message is displayed to console.
*/
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
using namespace System::Resources;

   static AssemblyBuilder^ CreateAssembly( String^ name )
   {
      AssemblyName^ aName = gcnew AssemblyName(name);
      AssemblyBuilder^ myAssembly = 
         AppDomain::CurrentDomain->DefineDynamicAssembly( aName, 
            AssemblyBuilderAccess::Save );
      
      // Define a dynamic module.
      ModuleBuilder^ myModule = 
         myAssembly->DefineDynamicModule( aName->Name, aName->Name + ".dll" );
      
      // Define a public class named "EmitClass" in the assembly.
      TypeBuilder^ myEmitClass = 
         myModule->DefineType( "EmitClass", TypeAttributes::Public );
      
      // Define the Display method.
      MethodBuilder^ myMethod = 
         myEmitClass->DefineMethod( "Display", MethodAttributes::Public, 
            String::typeid, nullptr );
      
      // Generate IL for Display method.
      ILGenerator^ methodIL = myMethod->GetILGenerator();
      methodIL->Emit( OpCodes::Ldstr, "Display method gets called." );
      methodIL->Emit( OpCodes::Ret );
      
      myEmitClass->CreateType();

      return (myAssembly);
   };

   void main()
   {
      AssemblyBuilder^ myAssembly = CreateAssembly("MyEmitTestAssembly");
      
      // Defines a standalone managed resource for this assembly.
      IResourceWriter^ myResourceWriter = 
         myAssembly->DefineResource( "myResourceFile", "A sample Resource File", 
            "MyAssemblyResource.resources", ResourceAttributes::Private );

      myResourceWriter->AddResource( "AddResource Test", "Testing for the added resource" );

      myAssembly->Save(myAssembly->GetName()->Name + ".dll" );
      
      // Defines an unmanaged resource file for this assembly.
      myAssembly->DefineUnmanagedResource( gcnew array<Byte>{01, 00, 01} );
   };

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;

public class MyAssemblyResource
{
   internal static void Main()
   {
      AssemblyBuilder myAssembly = CreateAssembly("MyEmitTestAssembly");

      // Defines a standalone managed resource for this assembly.
      IResourceWriter myResourceWriter = myAssembly.DefineResource("myResourceFile",
         "A sample Resource File", "MyAssemblyResource.resources",
         ResourceAttributes.Private);

      myResourceWriter.AddResource("AddResource Test", "Testing for the added resource");

      myAssembly.Save(myAssembly.GetName().Name + ".dll");

      // Defines an unmanaged resource file for this assembly.
      myAssembly.DefineUnmanagedResource(new byte[]{01, 00, 01});
   }

   private static AssemblyBuilder CreateAssembly(string name)
   {
      AssemblyName aName = new AssemblyName(name);
      AssemblyBuilder myAssembly =
         AppDomain.CurrentDomain.DefineDynamicAssembly(aName,
            AssemblyBuilderAccess.Save);

      // Define a dynamic module.
      ModuleBuilder myModule =
         myAssembly.DefineDynamicModule(aName.Name, aName.Name + ".dll");

      // Define a public class named "EmitClass" in the assembly.
      TypeBuilder myEmitClass = myModule.DefineType("EmitClass", TypeAttributes.Public);

      // Define the Display method.
      MethodBuilder myMethod = myEmitClass.DefineMethod("Display",
         MethodAttributes.Public, typeof(String), null);

      // Generate IL for Display method.
      ILGenerator methodIL = myMethod.GetILGenerator();
      methodIL.Emit(OpCodes.Ldstr, "Display method gets called.");
      methodIL.Emit(OpCodes.Ret);

      myEmitClass.CreateType();

      return(myAssembly);
   }
}

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Resources

Public Class MyAssemblyResource
   
   Friend Shared Sub Main()
      Dim myAssembly As AssemblyBuilder = _
          CreateAssembly("MyEmitTestAssembly")
      
      ' Defines a standalone managed resource for this assembly.
      Dim myResourceWriter As IResourceWriter = _
         myAssembly.DefineResource("myResourceFile", _
            "A sample Resource File", "MyAssemblyResource.resources", _
            ResourceAttributes.Private)

      myResourceWriter.AddResource("AddResource Test", "Testing for the added resource")

      myAssembly.Save(myAssembly.GetName().Name & ".dll")
      
      ' Defines an unmanaged resource file for this assembly.
      myAssembly.DefineUnmanagedResource(New Byte() {1, 0, 1})

   End Sub 
   
   Private Shared Function CreateAssembly(ByVal name As String) As AssemblyBuilder

      Dim aName As New AssemblyName(name)

      Dim myAssembly As AssemblyBuilder = _
         AppDomain.CurrentDomain.DefineDynamicAssembly(aName, _
            AssemblyBuilderAccess.Save)
      
      ' Define a dynamic module.
      Dim myModule As ModuleBuilder = _
         myAssembly.DefineDynamicModule(aName.Name, aName.Name & ".dll")

      ' Define a public class named "EmitClass" in the assembly.
      Dim myEmitClass As TypeBuilder = _
         myModule.DefineType("EmitClass", TypeAttributes.Public)
      
      ' Define the Display method.
      Dim myMethod As MethodBuilder = _
         myEmitClass.DefineMethod("Display", MethodAttributes.Public, _
                                                GetType(String), Nothing)
      
      ' Generate IL for Display method.
      Dim methodIL As ILGenerator = myMethod.GetILGenerator()
      methodIL.Emit(OpCodes.Ldstr, "Display method get called.")
      methodIL.Emit(OpCodes.Ret)
      
      myEmitClass.CreateType()

      Return myAssembly

   End Function 
End Class

Comentários

Um assembly pode ser associado a apenas um recurso não gerenciado. Isso significa que chamar DefineVersionInfoResource ou DefineUnmanagedResource depois que um dos métodos foi chamado anteriormente gerará o System.ArgumentException sendo lançado. Vários recursos não gerenciados precisam ser mesclados com uma ferramenta como o utilitário Microsoft ResMerge (não fornecido com o Common Language Runtime).

Aplica-se a