StronglyTypedResourceBuilder Clase

Definición

Proporciona compatibilidad para los recursos fuertemente tipados. Esta clase no puede heredarse.

public ref class StronglyTypedResourceBuilder abstract sealed
public static class StronglyTypedResourceBuilder
type StronglyTypedResourceBuilder = class
Public Class StronglyTypedResourceBuilder
Herencia
StronglyTypedResourceBuilder

Ejemplos

En el ejemplo siguiente se genera una clase denominada DemoResources que se escribe en C# o Visual Basic (según el código fuente del ejemplo). Esta clase está en el DemoApp espacio de nombres y tiene propiedades que devuelven el mapa de bits de un logotipo y el nombre de una aplicación. El ejemplo llama a un CreateResourceFile método para crear el archivo .resw necesario y requiere que se encuentre un archivo de mapa de bits denominado Logo.bmp en el directorio actual del ejemplo. En el ejemplo de código se usa el siguiente archivo de recursos, denominado demo.resx:

using Microsoft.CSharp;
using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Drawing;
using System.IO;
using System.Resources;
using System.Resources.Tools;

public class Example
{
   public static void Main()
   {
      CreateResXFile();
      
      StreamWriter sw = new StreamWriter(@".\DemoResources.cs");
      string[] errors = null;
      CSharpCodeProvider provider = new CSharpCodeProvider();
      CodeCompileUnit code = StronglyTypedResourceBuilder.Create("Demo.resx", "DemoResources", 
                                                                 "DemoApp", provider, 
                                                                 false, out errors);    
      if (errors.Length > 0)
         foreach (var error in errors)
            Console.WriteLine(error); 

      provider.GenerateCodeFromCompileUnit(code, sw, new CodeGeneratorOptions());                                         
      sw.Close();
   }

   private static void CreateResXFile()
   {
      Bitmap logo = new Bitmap(@".\Logo.bmp");

      ResXResourceWriter rw = new ResXResourceWriter(@".\Demo.resx");
      rw.AddResource("Logo", logo); 
      rw.AddResource("AppTitle", "Demo Application");
      rw.Generate();
      rw.Close();
   }
}
Imports System.CodeDom
Imports System.CodeDom.Compiler
Imports System.Drawing
Imports System.IO
Imports System.Resources
Imports System.Resources.Tools

Module Example
   Public Sub Main()
      CreateResXFile()
      
      Dim sw As New StreamWriter(".\DemoResources.vb")
      Dim errors() As String = Nothing
      Dim provider As New VBCodeProvider()
      Dim code As CodeCompileUnit = StronglyTypedResourceBuilder.Create("Demo.resx", "DemoResources", 
                                                                        "DemoApp", provider, 
                                                                        false, errors)    
      If errors.Length > 0 Then
         For Each [error] In errors
            Console.WriteLine([error]) 
         Next
      End If
      provider.GenerateCodeFromCompileUnit(code, sw, New CodeGeneratorOptions())                                         
      sw.Close()
   End Sub
   
   Private Sub CreateResXFile()
      Dim logo As New Bitmap(".\Logo.bmp")

      Dim rw As New ResXResourceWriter(".\Demo.resx")
      rw.AddResource("Logo", logo) 
      rw.AddResource("AppTitle", "Demo Application")
      rw.Generate()
      rw.Close()
   End Sub
End Module

Después, el código de la aplicación puede usar la clase como se indica a continuación:

this.Text = DemoApp.DemoResources.AppTitle;
System.Drawing.Bitmap bmp = DemoApp.DemoResources.Logo;
Me.Text = DemoApp.DemoResources.AppTitle
Dim bmp As System.Drawing.Bitmap = DemoApp.DemoResources.Logo

Comentarios

Normalmente, los recursos separan el código del contenido dentro de una aplicación. Crear y consumir estos recursos facilita el desarrollo de aplicaciones localizables. En .NET Framework, los recursos se consumen normalmente mediante la ResourceManager clase , que contiene métodos que proporcionan acceso a recursos específicos de la referencia cultural en tiempo de ejecución. Para obtener más información sobre cómo crear y consumir recursos, consulte Recursos en aplicaciones de escritorio.

La compatibilidad con recursos fuertemente tipados es una característica en tiempo de compilación que encapsula el acceso a los recursos mediante la creación de clases que contienen un conjunto de propiedades estáticas de solo lectura (get). Esto proporciona una manera alternativa de consumir recursos en lugar de llamar a los ResourceManager.GetString métodos y ResourceManager.GetObject .

La clase proporciona StronglyTypedResourceBuilder la funcionalidad básica para la compatibilidad con recursos fuertemente tipados (así como la opción de /str línea de comandos de la Resgen.exe (Generador de archivos de recursos)). La salida del Create método es una clase que contiene propiedades fuertemente tipadas que coinciden con los recursos a los que se hace referencia en el parámetro de entrada. Esta clase proporciona acceso de solo lectura a los recursos que están disponibles en el archivo procesado.

Métodos

Create(IDictionary, String, String, CodeDomProvider, Boolean, String[])

Genera un archivo de clase que contiene propiedades fuertemente tipadas que coinciden con los recursos a los que se hace referencia en la colección especificada.

Create(IDictionary, String, String, String, CodeDomProvider, Boolean, String[])

Genera un archivo de clase que contiene propiedades fuertemente tipadas que coinciden con los recursos a los que se hace referencia en la colección especificada.

Create(String, String, String, CodeDomProvider, Boolean, String[])

Genera un archivo de clase que contiene propiedades fuertemente tipadas que coinciden con los recursos del archivo .resx especificado.

Create(String, String, String, String, CodeDomProvider, Boolean, String[])

Genera un archivo de clase que contiene propiedades fuertemente tipadas que coinciden con los recursos del archivo .resx especificado.

VerifyResourceName(String, CodeDomProvider)

Genera una cadena de recurso válida tomando como base la cadena de entrada y el proveedor de código especificados.

Se aplica a