mensagens de exceção em Inglês?

https://stackoverflow.com/questions/209133

03-07-2019
|

Pergunta

Estamos registrando quaisquer exceções que acontecem em nosso sistema escrevendo o Exception.Message para um arquivo. No entanto, eles são escritos na cultura do cliente. E os erros turcos não significam muito para mim.

Então, como podemos registar quaisquer mensagens de erro em Inglês, sem alterar a cultura usuários?

Solução

Este problema pode ser parcialmente contornado. O código de exceção Framework carrega as mensagens de erro a partir de seus recursos, com base na localidade do thread atual. No caso de algumas exceções, isso acontece no momento em que a propriedade Message é acessado.

Para essas exceções, você pode obter a versão completa US Inglês da mensagem por brevemente mudar o local thread para en-US enquanto registrá-lo (salvando a localidade do usuário original de antemão e restaurá-lo logo em seguida).

Fazer isso em um segmento separado é ainda melhor: Isso garante que não haverá quaisquer efeitos secundários. Por exemplo:

try
{
  System.IO.StreamReader sr=new System.IO.StreamReader(@"c:\does-not-exist");
}
catch(Exception ex)
{
  Console.WriteLine(ex.ToString()); //Will display localized message
  ExceptionLogger el = new ExceptionLogger(ex);
  System.Threading.Thread t = new System.Threading.Thread(el.DoLog);
  t.CurrentUICulture = new System.Globalization.CultureInfo("en-US");
  t.Start();
}

Onde a classe ExceptionLogger é algo como:

class ExceptionLogger
{
  Exception _ex;

  public ExceptionLogger(Exception ex)
  {
    _ex = ex;
  }

  public void DoLog()
  {
    Console.WriteLine(_ex.ToString()); //Will display en-US message
  }
}

No entanto, como Joe corretamente aponta em um comentário sobre uma revisão anterior desta resposta, algumas mensagens já estão ( parcialmente) carregado a partir dos recursos linguísticos no momento a exceção é lançada.

Isto aplica-se ao 'parâmetro não pode ser nulo' parte da mensagem gerada quando um ArgumentNullException ( "foo") exceção é lançada, por exemplo. Nesses casos, a mensagem ainda aparecerá (parcialmente) localizada, mesmo quando se usa o código acima.

Além usando hacks impraticáveis, como a execução de todo o código a sua não-UI em um segmento com locale en-US, para começar, não parece ser muito que você pode fazer sobre isso: a exceção .NET Framework código não tem instalações para substituir o local mensagem de erro.

Outras dicas

Você pode procurar a mensagem de exceção original em unlocalize.com

Um ponto controverso, talvez, mas em vez de definir a cultura para en-US, você pode configurá-lo para Invariant. Na cultura Invariant, as mensagens de erro são em Inglês.

Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

Tem a vantagem de não olhar enviesado, especialmente para locais que falam americano não-inglês. (Evita também chamadas snide observações de colegas)

Windows precisa ter o idioma da interface que deseja usar instalado. Ele não acontecer, ele não tem como saber o que magicamente a mensagem traduzida é.

Em um janelas pt-BR 7 Ultimate, com pt-PT instalado, o código a seguir:

Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("pt-PT");
string msg1 = new DirectoryNotFoundException().Message;

Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US");
string msg2 = new FileNotFoundException().Message;

Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("fr-FR");
string msg3 = new FileNotFoundException().Message;

Produz mensagens na pt-PT, en-US e en-US. Como não há arquivos cultura francesa instalado, o padrão é o padrão do Windows (instalado?) Idioma.

Aqui está a solução que não requer qualquer codificação e funciona mesmo para os textos de exceções que são carregados muito cedo para nós para ser capaz de mudar por código (por exemplo, aqueles em mscorlib).

Pode não ser sempre aplicável em todos os casos (que depende de sua configuração como você precisa ser capaz de criar um arquivo .config de lado o principal arquivo .exe), mas que funciona para mim. Assim, basta criar uma app.config no dev, (ou um [myapp].exe.config ou web.config na produção), que contém as seguintes linhas, por exemplo:

<configuration>
  ...
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="mscorlib.resources" publicKeyToken="b77a5c561934e089"
                          culture="fr" /> <!-- change this to your language -->

        <bindingRedirect oldVersion="1.0.0.0-999.0.0.0" newVersion="999.0.0.0"/>
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="System.Xml.resources" publicKeyToken="b77a5c561934e089"
                          culture="fr" /> <!-- change this to your language -->

        <bindingRedirect oldVersion="1.0.0.0-999.0.0.0" newVersion="999.0.0.0"/>
      </dependentAssembly>

      <!-- add other assemblies and other languages here -->

    </assemblyBinding>
  </runtime>
  ...
</configuration>

O que isto faz é dizer ao quadro para redirecionar assembly ligações para recursos de mscorlib e recursos de System.Xml, para versões entre 1 e 999, em Francês (cultura é definido como "fr") para um conjunto que ... não existe ( uma versão arbitrária 999).

Assim, quando o CLR irá procurar recursos francês para estes dois conjuntos (mscorlib e System.Xml), não vai encontrá-los e fallback para Inglês graciosamente. Dependendo do seu contexto e testes, você pode querer adicionar outros conjuntos a estes redirecionamentos (assembléias que contém recursos localizados).

É claro que eu não acho que isso é suportado pela Microsoft, por isso o uso em seu próprio risco. Bem, no caso de você detectar um problema, você pode simplesmente remover essa configuração e verificar que é relacionado.

Eu sei que este é um tópico antigo, mas eu acho que a minha solução pode ser bastante relevante para qualquer um que se depara-lo em uma pesquisa na web:

No logger exceção que você poderia registrar ex.GetType.ToString, o que permitiria poupar o nome da classe de exceção. Eu esperaria que o nome de uma classe deve ser independente da linguagem e, portanto, sempre representada em Inglês (por exemplo, "System.FileNotFoundException"), embora no momento eu não tenho acesso a um sistema de língua estrangeira para testar o idéia.

Se você realmente quer o texto da mensagem de erro assim que você poderia criar um dicionário de todos os nomes de classe exceção possíveis e suas mensagens equivalentes em qualquer língua que você prefere, mas para Inglês Eu acho que o nome da classe é perfeitamente adequada.

CultureInfo oldCI = Thread.CurrentThread.CurrentCulture;

Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture ("en-US");
Thread.CurrentThread.CurrentUICulture=new CultureInfo("en-US");
try
{
  System.IO.StreamReader sr=new System.IO.StreamReader(@"c:\does-not-exist");
}
catch(Exception ex)
{
  Console.WriteLine(ex.ToString())
}
Thread.CurrentThread.CurrentCulture = oldCI;
Thread.CurrentThread.CurrentUICulture = oldCI;

Sem soluções alternativas.

Tks:)

O framework .NET vem em duas partes:

O framework .NET si
Os pacotes de idiomas .NET framework

Os textos (ex. Mensagens de exceção, etiquetas de botão em um MessageBox, etc.) estão em Inglês no próprio framework .NET. Os pacotes de idiomas têm os textos localizados.

Dependendo da sua situação exata, uma solução seria para desinstalar os pacotes de idiomas (ou seja, dizer ao cliente a fazê-lo). Nesse caso, os textos de exceção será em Inglês. Nota no entanto, que todos os outros textos framework fornecido será o Inglês, bem como (ex. O botão rótulos em uma MessageBox, atalhos de teclado para ApplicationCommands).

Configuração Thread.CurrentThread.CurrentUICulture será usado para localizar as exceções. Se você precisa de dois tipos de exceções (um para o usuário, uma para você) você pode usar seguinte função de traduzir a exceção-mensagem. Ele está à procura nos recursos .NET-bibliotecas para o texto orignal para obter a chave de recursos e, em seguida, retorna o valor traduzido. Mas há uma fraqueza eu não encontrei uma boa solução ainda: Messages, que contém {0} em recursos não será encontrado. Se alguém tem uma solução boa eu ficaria muito grato.

public static string TranslateExceptionMessage(Exception E, CultureInfo targetCulture)
{
    try
    {
        Assembly a = E.GetType().Assembly;
        ResourceManager rm = new ResourceManager(a.GetName().Name, a);
        ResourceSet rsOriginal = rm.GetResourceSet(Thread.CurrentThread.CurrentUICulture, true, true);
        ResourceSet rsTranslated = rm.GetResourceSet(targetCulture, true, true);
        foreach (DictionaryEntry item in rsOriginal)
            if (item.Value.ToString() == E.Message.ToString())
                return rsTranslated.GetString(item.Key.ToString(), false); // success

    }
    catch { }
    return E.Message; // failed (error or cause it's not intelligent enough to locale '{0}'-patterns
}

Eu imagino uma dessas abordagens:

1) As excepções são sempre apenas lido por você, ou seja, eles não são uma característica do cliente, assim você pode usar hardwired cordas não localizadas que não vai mudar quando você executa no modo turco.

2) Incluir um código de erro, por exemplo. 0x00000001 com cada erro de modo que você pode facilmente procurá-lo em até em uma tabela Inglês.

Eu tive a mesma situação, e todas as respostas que eu encontrei aqui e em outros lugares não ajuda ou não foram satisfazendo:
Força linguagem exceções em Inglês
C # - Obter mensagens de exceção em Inglês quando o aplicativo está em outro idioma?
Como mudar Visual Studio idioma mensagem de exceção para Inglês durante a depuração
Como lidar com tradução de mensagem de exceção?
Como evitar completamente as mensagens de exceção NET localizada

O Thread.CurrentUICulture altera o idioma das exceções .net, mas não faz para Win32Exception, que utiliza recursos do Windows na linguagem da própria interface do usuário do Windows. Então, eu nunca conseguiu imprimir as mensagens de Win32Exception em Inglês em vez de alemão, nem mesmo usando FormatMessage() como descrito na
Como chegar Win32Exception em Inglês?

Por isso eu criei a minha própria solução, que armazena a maioria das mensagens de exceção existente para diferentes idiomas em arquivos externos. Você não receberá a mensagem muito exata no idioma desejado, mas você receberá uma mensagem nesse idioma, que é muito mais do que você recebe atualmente (que é uma mensagem em um idioma que você provavelmente não entendem).

As funções estáticas desta classe podem ser executados em instalações do Windows com diferentes línguas: CreateMessages() cria os textos específicos da cultura
SaveMessagesToXML() salva-los como muitos arquivos XML como línguas são criados ou carregado
cargas LoadMessagesFromXML() todos os arquivos XML com mensagens específicas do idioma

Ao criar os arquivos XML em diferentes instalações do Windows com idiomas diferentes, você terá em breve todas as línguas que você precisa.
Talvez você possa criar os textos para diferentes línguas no 1 do Windows quando você tem vários pacotes de idiomas MUI instalado, mas eu não testei isso ainda.

Testado com VS2008, pronto para uso. Comentários e sugestões são bem-vindos!

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Reflection;
using System.Threading;
using System.Xml;

public struct CException
{
  //----------------------------------------------------------------------------
  public CException(Exception i_oException)
  {
    m_oException = i_oException;
    m_oCultureInfo = null;
    m_sMessage = null;
  }

  //----------------------------------------------------------------------------
  public CException(Exception i_oException, string i_sCulture)
  {
    m_oException = i_oException;
    try
    { m_oCultureInfo = new CultureInfo(i_sCulture); }
    catch
    { m_oCultureInfo = CultureInfo.InvariantCulture; }
    m_sMessage = null;
  }

  //----------------------------------------------------------------------------
  public CException(Exception i_oException, CultureInfo i_oCultureInfo)
  {
    m_oException = i_oException;
    m_oCultureInfo = i_oCultureInfo == null ? CultureInfo.InvariantCulture : i_oCultureInfo;
    m_sMessage = null;
  }

  //----------------------------------------------------------------------------
  // GetMessage
  //----------------------------------------------------------------------------
  public string GetMessage() { return GetMessage(m_oException, m_oCultureInfo); }

  public string GetMessage(String i_sCulture) { return GetMessage(m_oException, i_sCulture); }

  public string GetMessage(CultureInfo i_oCultureInfo) { return GetMessage(m_oException, i_oCultureInfo); }

  public static string GetMessage(Exception i_oException) { return GetMessage(i_oException, CultureInfo.InvariantCulture); }

  public static string GetMessage(Exception i_oException, string i_sCulture)
  {
    CultureInfo oCultureInfo = null;
    try
    { oCultureInfo = new CultureInfo(i_sCulture); }
    catch
    { oCultureInfo = CultureInfo.InvariantCulture; }
    return GetMessage(i_oException, oCultureInfo);
  }

  public static string GetMessage(Exception i_oException, CultureInfo i_oCultureInfo)
  {
    if (i_oException == null) return null;
    if (i_oCultureInfo == null) i_oCultureInfo = CultureInfo.InvariantCulture;

    if (ms_dictCultureExceptionMessages == null) return null;
    if (!ms_dictCultureExceptionMessages.ContainsKey(i_oCultureInfo))
      return CreateMessage(i_oException, i_oCultureInfo);

    Dictionary<string, string> dictExceptionMessage = ms_dictCultureExceptionMessages[i_oCultureInfo];
    string sExceptionName = i_oException.GetType().FullName;
    sExceptionName = MakeXMLCompliant(sExceptionName);
    Win32Exception oWin32Exception = (Win32Exception)i_oException;
    if (oWin32Exception != null)
      sExceptionName += "_" + oWin32Exception.NativeErrorCode;
    if (dictExceptionMessage.ContainsKey(sExceptionName))
      return dictExceptionMessage[sExceptionName];
    else
      return CreateMessage(i_oException, i_oCultureInfo);
  }

  //----------------------------------------------------------------------------
  // CreateMessages
  //----------------------------------------------------------------------------
  public static void CreateMessages(CultureInfo i_oCultureInfo)
  {
    Thread oTH = new Thread(new ThreadStart(CreateMessagesInThread));
    if (i_oCultureInfo != null)
    {
      oTH.CurrentCulture = i_oCultureInfo;
      oTH.CurrentUICulture = i_oCultureInfo;
    }
    oTH.Start();
    while (oTH.IsAlive)
    { Thread.Sleep(10); }
  }

  //----------------------------------------------------------------------------
  // LoadMessagesFromXML
  //----------------------------------------------------------------------------
  public static void LoadMessagesFromXML(string i_sPath, string i_sBaseFilename)
  {
    if (i_sBaseFilename == null) i_sBaseFilename = msc_sBaseFilename;

    string[] asFiles = null;
    try
    {
      asFiles = System.IO.Directory.GetFiles(i_sPath, i_sBaseFilename + "_*.xml");
    }
    catch { return; }

    ms_dictCultureExceptionMessages.Clear();
    for (int ixFile = 0; ixFile < asFiles.Length; ixFile++)
    {
      string sXmlPathFilename = asFiles[ixFile];

      XmlDocument xmldoc = new XmlDocument();
      try
      {
        xmldoc.Load(sXmlPathFilename);
        XmlNode xmlnodeRoot = xmldoc.SelectSingleNode("/" + msc_sXmlGroup_Root);

        string sCulture = xmlnodeRoot.SelectSingleNode(msc_sXmlGroup_Info + "/" + msc_sXmlData_Culture).Value;
        CultureInfo oCultureInfo = new CultureInfo(sCulture);

        XmlNode xmlnodeMessages = xmlnodeRoot.SelectSingleNode(msc_sXmlGroup_Messages);
        XmlNodeList xmlnodelistMessage = xmlnodeMessages.ChildNodes;
        Dictionary<string, string> dictExceptionMessage = new Dictionary<string, string>(xmlnodelistMessage.Count + 10);
        for (int ixNode = 0; ixNode < xmlnodelistMessage.Count; ixNode++)
          dictExceptionMessage.Add(xmlnodelistMessage[ixNode].Name, xmlnodelistMessage[ixNode].InnerText);
        ms_dictCultureExceptionMessages.Add(oCultureInfo, dictExceptionMessage);
      }
      catch
      { return; }
    }
  }

  //----------------------------------------------------------------------------
  // SaveMessagesToXML
  //----------------------------------------------------------------------------
  public static void SaveMessagesToXML(string i_sPath, string i_sBaseFilename)
  {
    if (i_sBaseFilename == null) i_sBaseFilename = msc_sBaseFilename;

    foreach (KeyValuePair<CultureInfo, Dictionary<string, string>> kvpCultureExceptionMessages in ms_dictCultureExceptionMessages)
    {
      string sXmlPathFilename = i_sPath + i_sBaseFilename + "_" + kvpCultureExceptionMessages.Key.TwoLetterISOLanguageName + ".xml";
      Dictionary<string, string> dictExceptionMessage = kvpCultureExceptionMessages.Value;

      XmlDocument xmldoc = new XmlDocument();
      XmlWriter xmlwriter = null;
      XmlWriterSettings writerSettings = new XmlWriterSettings();
      writerSettings.Indent = true;

      try
      {
        XmlNode xmlnodeRoot = xmldoc.CreateElement(msc_sXmlGroup_Root);
        xmldoc.AppendChild(xmlnodeRoot);
        XmlNode xmlnodeInfo = xmldoc.CreateElement(msc_sXmlGroup_Info);
        XmlNode xmlnodeMessages = xmldoc.CreateElement(msc_sXmlGroup_Messages);
        xmlnodeRoot.AppendChild(xmlnodeInfo);
        xmlnodeRoot.AppendChild(xmlnodeMessages);

        XmlNode xmlnodeCulture = xmldoc.CreateElement(msc_sXmlData_Culture);
        xmlnodeCulture.InnerText = kvpCultureExceptionMessages.Key.Name;
        xmlnodeInfo.AppendChild(xmlnodeCulture);

        foreach (KeyValuePair<string, string> kvpExceptionMessage in dictExceptionMessage)
        {
          XmlNode xmlnodeMsg = xmldoc.CreateElement(kvpExceptionMessage.Key);
          xmlnodeMsg.InnerText = kvpExceptionMessage.Value;
          xmlnodeMessages.AppendChild(xmlnodeMsg);
        }

        xmlwriter = XmlWriter.Create(sXmlPathFilename, writerSettings);
        xmldoc.WriteTo(xmlwriter);
      }
      catch (Exception e)
      { return; }
      finally
      { if (xmlwriter != null) xmlwriter.Close(); }
    }
  }

  //----------------------------------------------------------------------------
  // CreateMessagesInThread
  //----------------------------------------------------------------------------
  private static void CreateMessagesInThread()
  {
    Thread.CurrentThread.Name = "CException.CreateMessagesInThread";

    Dictionary<string, string> dictExceptionMessage = new Dictionary<string, string>(0x1000);

    GetExceptionMessages(dictExceptionMessage);
    GetExceptionMessagesWin32(dictExceptionMessage);

    ms_dictCultureExceptionMessages.Add(Thread.CurrentThread.CurrentUICulture, dictExceptionMessage);
  }

  //----------------------------------------------------------------------------
  // GetExceptionTypes
  //----------------------------------------------------------------------------
  private static List<Type> GetExceptionTypes()
  {
    Assembly[] aoAssembly = AppDomain.CurrentDomain.GetAssemblies();

    List<Type> listoExceptionType = new List<Type>();

    Type oExceptionType = typeof(Exception);
    for (int ixAssm = 0; ixAssm < aoAssembly.Length; ixAssm++)
    {
      if (!aoAssembly[ixAssm].GlobalAssemblyCache) continue;
      Type[] aoType = aoAssembly[ixAssm].GetTypes();
      for (int ixType = 0; ixType < aoType.Length; ixType++)
      {
        if (aoType[ixType].IsSubclassOf(oExceptionType))
          listoExceptionType.Add(aoType[ixType]);
      }
    }

    return listoExceptionType;
  }

  //----------------------------------------------------------------------------
  // GetExceptionMessages
  //----------------------------------------------------------------------------
  private static void GetExceptionMessages(Dictionary<string, string> i_dictExceptionMessage)
  {
    List<Type> listoExceptionType = GetExceptionTypes();
    for (int ixException = 0; ixException < listoExceptionType.Count; ixException++)
    {
      Type oExceptionType = listoExceptionType[ixException];
      string sExceptionName = MakeXMLCompliant(oExceptionType.FullName);
      try
      {
        if (i_dictExceptionMessage.ContainsKey(sExceptionName))
          continue;
        Exception e = (Exception)(Activator.CreateInstance(oExceptionType));
        i_dictExceptionMessage.Add(sExceptionName, e.Message);
      }
      catch (Exception)
      { i_dictExceptionMessage.Add(sExceptionName, null); }
    }
  }

  //----------------------------------------------------------------------------
  // GetExceptionMessagesWin32
  //----------------------------------------------------------------------------
  private static void GetExceptionMessagesWin32(Dictionary<string, string> i_dictExceptionMessage)
  {
    string sTypeName = MakeXMLCompliant(typeof(Win32Exception).FullName) + "_";
    for (int iError = 0; iError < 0x4000; iError++)  // Win32 errors may range from 0 to 0xFFFF
    {
      Exception e = new Win32Exception(iError);
      if (!e.Message.StartsWith("Unknown error (", StringComparison.OrdinalIgnoreCase))
        i_dictExceptionMessage.Add(sTypeName + iError, e.Message);
    }
  }

  //----------------------------------------------------------------------------
  // CreateMessage
  //----------------------------------------------------------------------------
  private static string CreateMessage(Exception i_oException, CultureInfo i_oCultureInfo)
  {
    CException oEx = new CException(i_oException, i_oCultureInfo);
    Thread oTH = new Thread(new ParameterizedThreadStart(CreateMessageInThread));
    oTH.Start(oEx);
    while (oTH.IsAlive)
    { Thread.Sleep(10); }
    return oEx.m_sMessage;
  }

  //----------------------------------------------------------------------------
  // CreateMessageInThread
  //----------------------------------------------------------------------------
  private static void CreateMessageInThread(Object i_oData)
  {
    if (i_oData == null) return;
    CException oEx = (CException)i_oData;
    if (oEx.m_oException == null) return;

    Thread.CurrentThread.CurrentUICulture = oEx.m_oCultureInfo == null ? CultureInfo.InvariantCulture : oEx.m_oCultureInfo;
    // create new exception in desired culture
    Exception e = null;
    Win32Exception oWin32Exception = (Win32Exception)(oEx.m_oException);
    if (oWin32Exception != null)
      e = new Win32Exception(oWin32Exception.NativeErrorCode);
    else
    {
      try
      {
        e = (Exception)(Activator.CreateInstance(oEx.m_oException.GetType()));
      }
      catch { }
    }
    if (e != null)
      oEx.m_sMessage = e.Message;
  }

  //----------------------------------------------------------------------------
  // MakeXMLCompliant
  // from https://www.w3.org/TR/xml/
  //----------------------------------------------------------------------------
  private static string MakeXMLCompliant(string i_sName)
  {
    if (string.IsNullOrEmpty(i_sName))
      return "_";

    System.Text.StringBuilder oSB = new System.Text.StringBuilder();
    for (int ixChar = 0; ixChar < (i_sName == null ? 0 : i_sName.Length); ixChar++)
    {
      char character = i_sName[ixChar];
      if (IsXmlNodeNameCharacterValid(ixChar, character))
        oSB.Append(character);
    }
    if (oSB.Length <= 0)
      oSB.Append("_");
    return oSB.ToString();
  }

  //----------------------------------------------------------------------------
  private static bool IsXmlNodeNameCharacterValid(int i_ixPos, char i_character)
  {
    if (i_character == ':') return true;
    if (i_character == '_') return true;
    if (i_character >= 'A' && i_character <= 'Z') return true;
    if (i_character >= 'a' && i_character <= 'z') return true;
    if (i_character >= 0x00C0 && i_character <= 0x00D6) return true;
    if (i_character >= 0x00D8 && i_character <= 0x00F6) return true;
    if (i_character >= 0x00F8 && i_character <= 0x02FF) return true;
    if (i_character >= 0x0370 && i_character <= 0x037D) return true;
    if (i_character >= 0x037F && i_character <= 0x1FFF) return true;
    if (i_character >= 0x200C && i_character <= 0x200D) return true;
    if (i_character >= 0x2070 && i_character <= 0x218F) return true;
    if (i_character >= 0x2C00 && i_character <= 0x2FEF) return true;
    if (i_character >= 0x3001 && i_character <= 0xD7FF) return true;
    if (i_character >= 0xF900 && i_character <= 0xFDCF) return true;
    if (i_character >= 0xFDF0 && i_character <= 0xFFFD) return true;
    // if (i_character >= 0x10000 && i_character <= 0xEFFFF) return true;

    if (i_ixPos > 0)
    {
      if (i_character == '-') return true;
      if (i_character == '.') return true;
      if (i_character >= '0' && i_character <= '9') return true;
      if (i_character == 0xB7) return true;
      if (i_character >= 0x0300 && i_character <= 0x036F) return true;
      if (i_character >= 0x203F && i_character <= 0x2040) return true;
    }
    return false;
  }

  private static string msc_sBaseFilename = "exception_messages";
  private static string msc_sXmlGroup_Root = "exception_messages";
  private static string msc_sXmlGroup_Info = "info";
  private static string msc_sXmlGroup_Messages = "messages";
  private static string msc_sXmlData_Culture = "culture";

  private Exception m_oException;
  private CultureInfo m_oCultureInfo;
  private string m_sMessage;

  static Dictionary<CultureInfo, Dictionary<string, string>> ms_dictCultureExceptionMessages = new Dictionary<CultureInfo, Dictionary<string, string>>();
}

internal class Program
{
  public static void Main()
  {
    CException.CreateMessages(null);
    CException.SaveMessagesToXML(@"d:\temp\", "emsg");
    CException.LoadMessagesFromXML(@"d:\temp\", "emsg");
  }
}

Com base na resposta Undercover1989, mas leva em conta parâmetros e quando as mensagens são compostas de várias seqüências de recursos (como exceções argumento).

public static string TranslateExceptionMessage(Exception exception, CultureInfo targetCulture)
{
    Assembly a = exception.GetType().Assembly;
    ResourceManager rm = new ResourceManager(a.GetName().Name, a);
    ResourceSet rsOriginal = rm.GetResourceSet(Thread.CurrentThread.CurrentUICulture, true, true);
    ResourceSet rsTranslated = rm.GetResourceSet(targetCulture, true, true);

    var result = exception.Message;

    foreach (DictionaryEntry item in rsOriginal)
    {
        if (!(item.Value is string message))
            continue;

        string translated = rsTranslated.GetString(item.Key.ToString(), false);

        if (!message.Contains("{"))
        {
            result = result.Replace(message, translated);
        }
        else
        {
            var pattern = $"{Regex.Escape(message)}";
            pattern = Regex.Replace(pattern, @"\\{([0-9]+)\}", "(?<group$1>.*)");

            var regex = new Regex(pattern);

            var replacePattern = translated;
            replacePattern = Regex.Replace(replacePattern, @"{([0-9]+)}", @"${group$1}");
            replacePattern = replacePattern.Replace("\\$", "$");

            result = regex.Replace(result, replacePattern);
        }
    }

    return result;
}

Você deve registrar a pilha de chamadas em vez de mensagem apenas erro (IIRC, simples exception.ToString () deve fazer isso para você). De lá, você pode determinar exatamente onde a exceção originaram, e, geralmente, deduzir qual exceção é.

mensagem de exceção Override no bloco catch usando método de extensão, Cheque mensagem lançada é a partir do código ou não conforme mencionado abaixo.

    public static string GetEnglishMessageAndStackTrace(this Exception ex)
    {
        CultureInfo currentCulture = Thread.CurrentThread.CurrentUICulture;
        try
        {

            dynamic exceptionInstanceLocal = System.Activator.CreateInstance(ex.GetType());
            string str;
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");

            if (ex.Message == exceptionInstanceLocal.Message)
            {
                dynamic exceptionInstanceENG = System.Activator.CreateInstance(ex.GetType());

                str = exceptionInstanceENG.ToString() + ex.StackTrace;

            }
            else
            {
                str = ex.ToString();
            }
            Thread.CurrentThread.CurrentUICulture = currentCulture;

            return str;

        }
        catch (Exception)
        {
            Thread.CurrentThread.CurrentUICulture = currentCulture;

            return ex.ToString();
        }

Para fins de registro, determinadas aplicações podem precisar buscar a mensagem Inglês exceção (além de exibi-lo em UICulture do cliente usual).

Para o efeito, o seguinte código

muda a UICulture atual
recria o objeto de exceção jogado usando "GetType ()" e "Activator.CreateInstance (t)"
exibe a mensagem do novo objeto de exceção no novo UICuture

e, finalmente, muda a volta UICulture atual para UICulture anteriormente.

    try
    {
        int[] a = { 3, 6 };
        Console.WriteLine(a[3]); //Throws index out of bounds exception

        System.IO.StreamReader sr = new System.IO.StreamReader(@"c:\does-not-exist"); // throws file not found exception
        throw new System.IO.IOException();

    }
    catch (Exception ex)
    {

        Console.WriteLine(ex.Message);
        Type t = ex.GetType();

        CultureInfo CurrentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture;

        System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("en-US");

        object o = Activator.CreateInstance(t);

        System.Threading.Thread.CurrentThread.CurrentUICulture = CurrentUICulture; // Changing the UICulture back to earlier culture


        Console.WriteLine(((Exception)o).Message.ToString());
        Console.ReadLine();

     }

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow