asambleas de recursos Construir con AssemblyBuilder

Question

Escenario: Me quieren crear ensamblados satélite que son ensamblados de recursos. Este ensamblado solo tiene recursos compilados (ResourceWriter). El objetivo es crear montajes de recursos fuera de VS y añadirlos a la aplicación y esto en mi C# aplicación

Atm estoy usando AssemblyBuilder para crear la Asamblea. Funciona, pero no hay información sobre el conjunto almacenado. Sin cultureinfo, clave o cualquier otra cosa. El ensamblado no lo toma la aplicación con una excepción de recurso Manfifest faltante. :(

Si es posible me quiero quedar con AssemblyBuilder o el uso de CodeDomProvider

Pregunta:. ¿Qué es necesario para ser capaz de añadir nuevo conjunto del satélite a mi aplicación es suficiente para tener una carpeta con el? la cultura (en-US) y una asamblea con los recursos es-allí

Pregunta2:? ¿es posible dar alguna información meta como la versión, cultura a la asamblea

? Pregunta 3: ¿No es suficiente agregar los recursos al ensamblado?

Código:

AssemblyBuilder builder = AppDomain.CurrentDomain.DefineDynamicAssembly(
         assemblyName, AssemblyBuilderAccess.RunAndSave, resourceFolder); 

builder.AddResourceFile(name, assemblyFileName); 
builder.Save(assemblyName.Name); 

Para cualquier tipo de ayuda le agradecería. Gracias de antemano

Answer 1

encontrado la solución.

Fuente: http://www.dotnet247.com/247reference/msgs/58/290731.aspx

Explicación: En primer lugar parece que el único vínculo AssemblyBuilder el recurso a la asamblea, no es incorporado. En segundo lugar, el recurso debe estar en el Módulo para ser visto por el ensamblaje principal. (me gusta aquí para crear el recurso dentro del módulo, pero no parece haber ninguna forma de recurso ya existente incrustado)

Código:

 string myAsmName = "WriteSatelliteAssembly.resources"; 
     string myAsmFileName = myAsmName + ".dll"; 
     string resourceName = "WriteSatelliteAssembly.MyResource2.fr.resources"; 
     string path; 

     path = AppDomain.CurrentDomain.BaseDirectory + "fr-FR"; 
     AppDomain appDomain = Thread.GetDomain(); 
     AssemblyName asmName = new AssemblyName(); 
     asmName.Name = myAsmName; 
     asmName.CodeBase = path; 
     asmName.CultureInfo = new CultureInfo("fr"); 

     AssemblyBuilder myAsmBuilder = appDomain.DefineDynamicAssembly(
      asmName, 
      AssemblyBuilderAccess.RunAndSave, path); 

     **ModuleBuilder** myModuleBuilder = 
      myAsmBuilder.DefineDynamicModule(myAsmFileName, 
      myAsmFileName); 
     **IResourceWriter** rw = 
      myModuleBuilder.DefineResource(resourceName, 
      "My Description",ResourceAttributes.Public); 

     rw.AddResource("resName","My (dynamic) resource value."); 
     rw.AddResource("resName2","My (dynamic) second resource value."); 

     myAsmBuilder.Save(myAsmFileName); 

shortend Prueba:

recursos Linked in ensamblaje

.file nometadata 'TestProjectResourceManager.Properties.Resources.en-US.resources' 
    .hash = (57 DD 82 37 9E B3 BA 8A 27 D0 69 90 37 67 22 23 // W..7....'.i.7g"# 
      A0 1C F7 47)          // ...G 
.mresource public TestProjectResourceManager.Properties.Resources 
{ 
    .file 'TestProjectResourceManager.Properties.Resources.en-US.resources' at 0x00000000 
} 

recurso incrustado en el ensamblaje

.mresource public 'TestProjectResourceManager.Properties.Resources.en-US.resources' 
{ 
    // Offset: 0x00000000 Length: 0x000000EE 
} 
.module TestProjectResourceManager_2.resources.dll 

Diviértete

Answer 2

Usted necesitará las siguientes herramientas para crear ensamblajes.

1. Resgen.exe
2. al.exe
3. ildasm.exe

al.exe es el programa que incorpora recursos en un ensamblado satélite. Pero al.exe solo aceptará recursos en .resources formato binario. Pero nuestras entradas suelen ser archivos de recursos de texto sin formato o archivos de recursos basados ​​en XML en formato .resx. resgen.exe se utiliza para convertir estas formas alternativas de recursos al formato binario .resources aceptable para al.exe.

ildasm.exe: Si recuerda lo que está haciendo Visual Studio IDE, verá que hay una traducción de nombre entre su estructura de directorio de archivos de recursos y cómo se conoce ese archivo de recursos dentro del ensamblado. Becaue estamos utilizando el IDE de Visual Studio para generar los recursos predeterminados y el proceso extenal para generar los ensamblados satélite, ambos mecanismos deben producir montajes con el mismo tipo de jerarquía de nombres de los archivos de recursos.

por lo que utilizar ildasm para examinar los archivos DLL que genera Visual Studio IDE para averiguar cuál es la estructura, y utilizar el mismo mecanismo para generar los ensamblados satélite. También puede examinar los ensamblajes de satélites utilizando ildasm para asegurarse de obtener los nombres correctos. Esto será útil para depurar errores del administrador de recursos indicándole que no puede encontrar un recurso.

Ahora que las herramientas se describen, ¿cómo convertir un archivo de recursos externo en un ensamblado satélite? Como se indica a continuación, este es un proceso de tres (en realidad, dos) pasos.

Paso 0: Establecer sus caminos para resgen y al.exe:

@set path=%path%; 
    "C:\Program Files\Microsoft Visual Studio .NET\FrameworkSDK\Bin"; 
    c:\winnt\microsoft.NET\framework\v1.0.3705 

Paso 1: Uso resgen para crear un archivo .resources de un archivo .resx.

Resgen MyText.resx 

El comando anterior creará un archivo llamado:

MyText.resources 

Paso 2: Utilice al.exe para crear el ensamblado satélite:

Al.exe 
    /t:lib 
    /embed:MyText.en-gb.Resources,MyApplication.MyText.en-gb.Resources 
    /culture:hi-gb 
    /out:MyApplication.resources.dll 

Hay un par de cosas vale la pena observando aquí:

/t:lib: Says you are interested in a .dll. 

/embed:MyText.en-gb.Resources,MyApplication.MyText.en-gb.Resources : Embeds and renames the resource to a target name to match the Visual Studio IDE naming structure. 

/culture:hi-gb : Identifies the culture in which you are interested. 

/out:MyApplication.resources.dll : Name of the DLL in which you are interested. 

El archivo .dll generado debe tener esa convención de nomenclatura para .NET para encontrarlo. También tenga en cuenta que debe especificar la configuración cultural, aunque la cultura esté disponible en el nombre de los archivos de recursos. Por lo tanto, debe ser mencionado en ambos lugares.

colocar el conjunto de satélite en el directorio apropiado Una vez creado el ensamblado satélite, copiar físicamente el .dll en el directorio siguiente:

\MyApplication\bin\en-gb\MyApplication.Resources.DLL 

En caso de múltiples archivos de recursos:

\MyApplication\resources\files\CommonResources.resx 
\MyApplication\resources\files\Module1Resources.resx 
\MyApplication\resources\files\Module2Resources.resx 

Y puede definir claves para estos recursos en una jerarquía separada, de la siguiente manera:

\MyApplication\resources\keys\CommonKeys.cs 
\MyApplication\resources\keysModule1Keys.cs 
\MyApplication\resources\keys\Module2Keys.cs 

---

Para un script programa por lotes, por favor refiérase a mi blog http://samithenerd.blogspot.com/2011/12/batch-program-for-creating-satellite.html