Métodos System.Resources.ResourceManager.GetObject

  • Artigo

Este artigo fornece observações complementares à documentação de referência para essa API.

O GetObject método é usado para recuperar recursos que não são de cadeia de caracteres. Isso inclui valores que pertencem a tipos de dados primitivos, como ou , bitmaps (como Int32 um System.Drawing.Bitmap objeto) ou Doubleobjetos serializados personalizados. Normalmente, o objeto retornado deve ser convertido (em C#) ou convertido (em Visual Basic) em um objeto do tipo apropriado.

A IgnoreCase propriedade determina se a comparação com os nomes dos recursos não diferencia maiúsculas de minúsculas ou diferencia maiúsculas de name minúsculas (o padrão).

Observação

Esses métodos podem lançar mais exceções do que as listadas. Uma razão pela qual isso pode ocorrer é se um método que esse método chama lança uma exceção. Por exemplo, uma exceção pode ser lançada se um erro foi feito ao implantar ou instalar um assembly satélite, ou uma exceção pode ser lançada se um tipo definido pelo usuário lançar uma FileLoadExceptionSerializationException exceção definida pelo usuário quando o tipo for desserializado.

Método GetObject(String)

O recurso retornado é localizado para a cultura de interface do usuário do thread atual, que é definida pela CultureInfo.CurrentUICulture propriedade. Se o recurso não estiver localizado para essa cultura, o gerenciador de recursos usará regras de fallback para carregar um recurso apropriado. Se nenhum conjunto utilizável de recursos localizados for encontrado, o ResourceManager retorno retornará aos recursos da cultura padrão. Se um conjunto de recursos para a cultura padrão não for encontrado, o método lançará uma exceção ou, se for esperado que o conjunto de recursos resida em um assembly satélite, uma MissingManifestResourceExceptionMissingSatelliteAssemblyException exceção. Se o gerenciador de recursos puder carregar um conjunto de recursos apropriado, mas não conseguir localizar um recurso chamado name, o método retornará null.

Exemplo

O exemplo a seguir usa o método GetObject(String) para desserializar um objeto personalizado. O exemplo inclui um arquivo de código-fonte chamado UIElements.cs (UIElements.vb se você estiver usando o Visual Basic) que define a seguinte estrutura chamada PersonTable. Essa estrutura destina-se a ser usada por uma rotina de exibição geral da tabela que exibe os nomes localizados das colunas da tabela. Observe que a estrutura PersonTable é marcada com o atributo SerializableAttribute.

using System;

[Serializable] public struct PersonTable
{
   public readonly int nColumns;
   public readonly string column1;
   public readonly string column2;
   public readonly string column3;
   public readonly int width1;
   public readonly int width2;
   public readonly int width3;

   public PersonTable(string column1, string column2, string column3,
                  int width1, int width2, int width3)
   {
      this.column1 = column1;
      this.column2 = column2;
      this.column3 = column3;
      this.width1 = width1;
      this.width2 = width2;
      this.width3 = width3;
      this.nColumns = typeof(PersonTable).GetFields().Length / 2;
   }
}

<Serializable> Public Structure PersonTable1
    Public ReadOnly nColumns As Integer
    Public ReadOnly column1 As String
    Public ReadOnly column2 As String
    Public ReadOnly column3 As String
    Public ReadOnly width1 As Integer
    Public ReadOnly width2 As Integer
    Public ReadOnly width3 As Integer

    Public Sub New(column1 As String, column2 As String, column3 As String,
                  width1 As Integer, width2 As Integer, width3 As Integer)
        Me.column1 = column1
        Me.column2 = column2
        Me.column3 = column3
        Me.width1 = width1
        Me.width2 = width2
        Me.width3 = width3
        Me.nColumns = Me.GetType().GetFields().Count \ 2
    End Sub
End Structure

O código a seguir de um arquivo chamado CreateResources.cs (ou CreateResources.vb para Visual Basic) cria um arquivo de recurso XML chamado UIResources.resx que armazena um título de tabela e um objeto que contém informações para um PersonTable aplicativo que está localizado para o idioma inglês.

using System;
using System.Resources;

public class CreateResource
{
   public static void Main()
   {
      PersonTable table = new PersonTable("Name", "Employee Number",
                                          "Age", 30, 18, 5);
      ResXResourceWriter rr = new ResXResourceWriter(@".\UIResources.resx");
      rr.AddResource("TableName", "Employees of Acme Corporation");
      rr.AddResource("Employees", table);
      rr.Generate();
      rr.Close();
   }
}

Imports System.Resources

Module CreateResource1
    Public Sub Main()
        Dim table As New PersonTable("Name", "Employee Number", "Age", 30, 18, 5)
        Dim rr As New ResXResourceWriter(".\UIResources.resx")
        rr.AddResource("TableName", "Employees of Acme Corporation")
        rr.AddResource("Employees", table)
        rr.Generate()
        rr.Close()
    End Sub
End Module

O código a seguir em um arquivo de código-fonte chamado GetObject.cs (ou GetObject.vb) recupera os recursos e os exibe no console.

using System;
using System.Resources;

[assembly: NeutralResourcesLanguageAttribute("en")]

public class Example3
{
   public static void Main()
   {
      string fmtString = String.Empty;
      ResourceManager rm = new ResourceManager("UIResources", typeof(Example).Assembly);
      string title = rm.GetString("TableName");
      PersonTable tableInfo = (PersonTable) rm.GetObject("Employees");

      if (! String.IsNullOrEmpty(title)) {
         fmtString = "{0," + ((Console.WindowWidth + title.Length) / 2).ToString() + "}";
         Console.WriteLine(fmtString, title);
         Console.WriteLine();
      }

      for (int ctr = 1; ctr <= tableInfo.nColumns; ctr++) {
         string columnName = "column"  + ctr.ToString();
         string widthName = "width" + ctr.ToString();
         string value = tableInfo.GetType().GetField(columnName).GetValue(tableInfo).ToString();
         int width = (int) tableInfo.GetType().GetField(widthName).GetValue(tableInfo);
         fmtString = "{0,-" + width.ToString() + "}";
         Console.Write(fmtString, value);
      }
      Console.WriteLine();
   }
}

Imports System.Resources

<Assembly: NeutralResourcesLanguageAttribute("en")>

Module Example
   Public Sub Main()
      Dim fmtString As String = String.Empty
      Dim rm As New ResourceManager("UIResources", GetType(Example).Assembly)       
      Dim title As String = rm.GetString("TableName")
      Dim tableInfo As PersonTable = DirectCast(rm.GetObject("Employees"), PersonTable)

      If Not String.IsNullOrEmpty(title) Then
         fmtString = "{0," + ((Console.WindowWidth + title.Length) \ 2).ToString() + "}" 
         Console.WriteLine(fmtString, title)      
         Console.WriteLine()
      End If

      For ctr As Integer = 1 To tableInfo.nColumns
         Dim columnName As String = "column"  + ctr.ToString()
         Dim widthName As String = "width" + ctr.ToString()
         Dim value As String = CStr(tableInfo.GetType().GetField(columnName).GetValue(tableInfo))
         Dim width As Integer = CInt(tableInfo.GetType().GetField(widthName).GetValue(tableInfo))
         fmtString = "{0,-" + width.ToString() + "}"
         Console.Write(fmtString, value)
      Next      
      Console.WriteLine()
   End Sub
End Module

Você pode criar o arquivo de recurso necessário e os assemblies e executar o aplicativo, executando o seguinte arquivo em lotes. Você deve usar a opção /r para fornecer ao arquivo Resgen.exe uma referência para UIElements.dll para que ele possa acessar informações sobre a estrutura PersonTable. Se você estiver usando C#, substitua o nome do compilador vbc por csc e substitua a extensão .vb por .cs.

vbc /t:library UIElements.vb
vbc CreateResources.vb /r:UIElements.dll
CreateResources

resgen UIResources.resx  /r:UIElements.dll
vbc GetObject.vb /r:UIElements.dll /resource:UIResources.resources

GetObject.exe

Método GetObject(String, CultureInfo)

O recurso retornado é localizado para a cultura especificada por culture, ou para a cultura especificada pela CultureInfo.CurrentUICulture propriedade if culture is null. Se o recurso não estiver localizado para essa cultura, o gerenciador de recursos usará regras de fallback para carregar um recurso apropriado. Se nenhum conjunto utilizável de recursos localizados for encontrado, o gerenciador de recursos recorrerá aos recursos da cultura padrão. Se um conjunto de recursos para a cultura padrão não for encontrado, o método lançará uma exceção ou, se for esperado que o conjunto de recursos resida em um assembly satélite, uma MissingManifestResourceExceptionMissingSatelliteAssemblyException exceção. Se o gerenciador de recursos puder carregar um conjunto de recursos apropriado, mas não conseguir localizar um recurso chamado name, o método retornará null.

Exemplo

O exemplo a seguir usa o método GetObject(String, CultureInfo) para desserializar um objeto personalizado. O exemplo inclui um arquivo de código-fonte chamado NumberInfo.cs (NumberInfo.vb se você estiver usando o Visual Basic) que define a seguinte estrutura chamada Numbers. Essa estrutura deve ser usada por um aplicativo educacional simples que ensina alunos que não falam inglês a contar até dez em inglês. Observe que a Numbers classe é marcada com o atributo SerializableAttribute .

using System;

[Serializable] public class Numbers2
{
   public readonly string One;
   public readonly string Two;
   public readonly string Three;
   public readonly string Four;
   public readonly string Five;
   public readonly string Six;
   public readonly string Seven;
   public readonly string Eight;
   public readonly string Nine;
   public readonly string Ten;

   public Numbers2(string one, string two, string three, string four, 
                  string five, string six, string seven, string eight,
                  string nine, string ten)
   {                     
      this.One = one;
      this.Two = two;
      this.Three = three;
      this.Four = four;
      this.Five = five;
      this.Six = six;
      this.Seven = seven;
      this.Eight = eight;
      this.Nine = nine;
      this.Ten = ten;                                    
   }                  
}

<Serializable> Public Class Numbers2
    Public ReadOnly One As String
    Public ReadOnly Two As String
    Public ReadOnly Three As String
    Public ReadOnly Four As String
    Public ReadOnly Five As String
    Public ReadOnly Six As String
    Public ReadOnly Seven As String
    Public ReadOnly Eight As String
    Public ReadOnly Nine As String
    Public ReadOnly Ten As String

    Public Sub New(one As String, two As String, three As String, four As String,
                   five As String, six As String, seven As String, eight As String,
                   nine As String, ten As String)
        Me.One = one
        Me.Two = two
        Me.Three = three
        Me.Four = four
        Me.Five = five
        Me.Six = six
        Me.Seven = seven
        Me.Eight = eight
        Me.Nine = nine
        Me.Ten = ten
    End Sub
End Class

O código-fonte a seguir de um arquivo chamado CreateResources.cs (CreateResources.vb para Visual Basic) cria arquivos de recurso XML para o idioma inglês padrão, bem como para os idiomas francês, português e russo.

using System;
using System.Resources;

public class CreateResource
{
   public static void Main()
   {
      Numbers en = new Numbers("one", "two", "three", "four", "five",
                               "six", "seven", "eight", "nine", "ten");
      CreateResourceFile(en, "en");
      Numbers fr = new Numbers("un", "deux", "trois", "quatre", "cinq", 
                               "six", "sept", "huit", "neuf", "dix");
      CreateResourceFile(fr, "fr");
      Numbers pt = new Numbers("um", "dois", "três", "quatro", "cinco", 
                               "seis", "sete", "oito", "nove", "dez");
      CreateResourceFile(pt, "pt"); 
      Numbers ru = new Numbers("один", "два", "три", "четыре", "пять", 
                               "шесть", "семь", "восемь", "девять", "десять");                                                       
      CreateResourceFile(ru, "ru");
   }

   public static void CreateResourceFile(Numbers n, string lang)
   {
      string filename = @".\NumberResources" + 
                        (lang != "en" ? "." + lang : "" ) +
                        ".resx";
      ResXResourceWriter rr = new ResXResourceWriter(filename);
      rr.AddResource("Numbers", n);
      rr.Generate();
      rr.Close();    
   }
}

Imports System.Resources

Module CreateResource
   Public Sub Main()
      Dim en As New Numbers("one", "two", "three", "four", "five",
                            "six", "seven", "eight", "nine", "ten")
      CreateResourceFile(en, "en")
      Dim fr As New Numbers("un", "deux", "trois", "quatre", "cinq", 
                            "six", "sept", "huit", "neuf", "dix")
      CreateResourceFile(fr, "fr")
      Dim pt As New Numbers("um", "dois", "três", "quatro", "cinco", 
                            "seis", "sete", "oito", "nove", "dez")
      CreateResourceFile(pt, "pt") 
      Dim ru As New Numbers("один", "два", "три", "четыре", "пять", 
                            "шесть", "семь", "восемь", "девять", "десять")                                                       
      CreateResourceFile(ru, "ru")
   End Sub

   Public Sub CreateResourceFile(n As Numbers, lang As String)
      Dim filename As String = ".\NumberResources" + 
                               If(lang <> "en", "." + lang, "") +
                               ".resx"
      Dim rr As New ResXResourceWriter(filename)
      rr.AddResource("Numbers", n)
      rr.Generate()
      rr.Close()    
   End Sub
End Module

Os recursos são consumidos pelo aplicativo a seguir, que define a cultura atual da interface do usuário como francês (França), português (Brasil) ou russo (Rússia). Ele chama o método para obter um objeto que contém números localizados e o GetObject(String)GetObject(String, CultureInfo) método para obter um NumbersNumbers objeto que contém números de idioma inglês. Em seguida, ele exibe números ímpares usando a cultura atual da interface do usuário e o idioma inglês. O arquivo de código-fonte é chamado ShowNumbers.cs (ShowNumbers.vb).

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

[assembly:NeutralResourcesLanguageAttribute("en-US")]

public class Example
{
   static string[] cultureNames = [ "fr-FR", "pt-BR", "ru-RU" ];

   public static void Main()
   {
      // Make any non-default culture the current culture.
      Random rnd = new Random();
      CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureNames[rnd.Next(0, cultureNames.Length)]);
      Thread.CurrentThread.CurrentUICulture = culture;
      Console.WriteLine("The current culture is {0}\n", CultureInfo.CurrentUICulture.Name);
      CultureInfo enCulture = CultureInfo.CreateSpecificCulture("en-US");

      ResourceManager rm = new ResourceManager(typeof(NumberResources));
      Numbers numbers = (Numbers) rm.GetObject("Numbers");
      Numbers numbersEn = (Numbers) rm.GetObject("Numbers", enCulture);
      Console.WriteLine("{0} --> {1}", numbers.One, numbersEn.One);
      Console.WriteLine("{0} --> {1}", numbers.Three, numbersEn.Three);
      Console.WriteLine("{0} --> {1}", numbers.Five, numbersEn.Five);
      Console.WriteLine("{0} --> {1}", numbers.Seven, numbersEn.Seven);
      Console.WriteLine("{0} --> {1}\n", numbers.Nine, numbersEn.Nine);
   }
}

internal class NumberResources
{
}
// The example displays output like the following:
//       The current culture is pt-BR
//
//       um --> one
//       três --> three
//       cinco --> five
//       sete --> seven
//       nove --> nine

Imports System.Globalization
Imports System.Resources
Imports System.Threading

Module Example2
    Dim cultureNames() As String = {"fr-FR", "pt-BR", "ru-RU"}

    Public Sub Main()
        ' Make any non-default culture the current culture.
        Dim rnd As New Random
        Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureNames(rnd.Next(0, cultureNames.Length)))
        Thread.CurrentThread.CurrentUICulture = culture
        Console.WriteLine("The current culture is {0}", CultureInfo.CurrentUICulture.Name)
        Console.WriteLine()
        Dim enCulture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")

        Dim rm As New ResourceManager(GetType(NumberResources))
        Dim numbers As Numbers = CType(rm.GetObject("Numbers"), Numbers)
        Dim numbersEn As Numbers = CType(rm.GetObject("Numbers", enCulture), Numbers)
        Console.WriteLine("{0} --> {1}", numbers.One, numbersEn.One)
        Console.WriteLine("{0} --> {1}", numbers.Three, numbersEn.Three)
        Console.WriteLine("{0} --> {1}", numbers.Five, numbersEn.Five)
        Console.WriteLine("{0} --> {1}", numbers.Seven, numbersEn.Seven)
        Console.WriteLine("{0} --> {1}", numbers.Nine, numbersEn.Nine)
        Console.WriteLine()
    End Sub
End Module


Friend Class NumberResources
End Class

' The example displays output like the following:
'       The current culture is pt-BR
'       
'       um --> one
'       três --> three
'       cinco --> five
'       sete --> seven
'       nove --> nine

Você pode usar o seguinte arquivo em lotes para criar e executar a versão do Visual Basic do exemplo. Se você estiver usando C#, substitua por csc, e substitua vbc a .vb extensão por .cs.

vbc /t:library NumberInfo.vb

vbc CreateResources.vb /r:NumberInfo.dll
CreateResources

resgen NumberResources.resx /r:NumberInfo.dll

resgen NumberResources.fr.resx /r:Numberinfo.dll
Md fr
al /embed:NumberResources.fr.resources /culture:fr /t:lib /out:fr\ShowNumbers.resources.dll

resgen NumberResources.pt.resx  /r:Numberinfo.dll
Md pt
al /embed:NumberResources.pt.resources /culture:pt /t:lib /out:pt\ShowNumbers.resources.dll

resgen NumberResources.ru.resx /r:Numberinfo.dll
Md ru
al /embed:NumberResources.ru.resources /culture:ru /t:lib /out:ru\ShowNumbers.resources.dll

vbc ShowNumbers.vb /r:NumberInfo.dll /resource:NumberResources.resources
ShowNumbers.exe

Considerações sobre o desempenho

Se você chamar o método várias vezes com o GetObject mesmo parâmetro, não dependa do método que retorna uma referência ao mesmo name objeto com cada chamada. Isso ocorre porque o método pode retornar uma referência a um objeto de recurso existente em um cache ou pode recarregar o GetObject recurso e retornar uma referência a um novo objeto de recurso.