英文异常消息? - 开卷题库

小开

我可以想象其中一种方法:

异常只会被你读取，也就是说，它们不是客户端特性，所以你可以使用硬连线的非本地化字符串，当你在土耳其模式下运行时不会改变。

每个错误都包含一个错误代码，例如0x00000001，这样你就可以很容易地在英文表中查找它。

小开

最佳答案

这个问题可以部分解决。框架异常代码根据当前线程区域设置从其资源加载错误消息。在某些异常的情况下，这将在访问Message属性时发生。

对于这些例外情况，您可以通过在记录消息的同时将线程语言环境简单地切换为en-US来获得消息的完整的美国英语版本(预先保存原始用户语言环境，然后立即恢复它)。

在一个单独的线程上执行这个操作会更好:这样可以确保不会有任何副作用。例如:

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();
}

其中ExceptionLogger类看起来像这样:

class ExceptionLogger
{
Exception _ex;


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


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

然而，正如乔在此回复的早期修订的注释中正确指出的那样，在抛出异常时，一些消息已经(部分)从语言资源加载。

例如，这适用于抛出ArgumentNullException("foo")异常时生成的消息中的'parameter cannot be null'部分。在这些情况下，即使在使用上述代码时，消息仍将出现(部分)本地化。

除了使用一些不切实际的技巧，比如在一个带有en-US语言环境的线程上运行所有的非ui代码之外，似乎没有什么可以做的:. net Framework异常代码没有覆盖错误消息语言环境的工具。

小开

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;

没有解决方法。

谢谢大家:)

小开

您应该记录调用堆栈，而不仅仅是错误消息(IIRC，简单的异常。tostring()应该为您做这件事)。从那里，您可以确定异常的确切来源，并且通常可以推断出它是哪个异常。

小开

Windows需要安装你想要使用的UI语言。如果没有，它没有办法神奇地知道翻译后的信息是什么。

在安装了pt-PT的en-US windows 7 ultimate中，以下代码:

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;

生成pt-PT, en-US和en-US格式的消息。由于没有安装法语文化文件，它默认为windows默认(已安装?)语言。

小开

我知道这是一个古老的话题，但我认为我的解决方案可能与任何在网络搜索中偶然发现它的人非常相关:

在异常记录器中，您可以记录ex.GetType。ToString，它将保存异常类的名称。我希望类的名称应该是独立于语言的，因此总是用英语表示(例如。“system . filenotfoundexception”)，尽管目前我还没有一个外语系统来测试这个想法。

如果您真的想要错误消息文本，您可以创建一个字典，其中包含所有可能的异常类名称及其等效消息，无论您喜欢哪种语言，但对于英语，我认为类名已经足够了。

小开

设置Thread.CurrentThread.CurrentUICulture将用于本地化异常。如果您需要两种类型的异常(一种用于用户，一种用于您自己)，您可以使用以下函数来转换异常消息。它在. net libraries资源中搜索原始文本以获得资源键，然后返回翻译后的值。但有一个弱点，我还没有找到一个好的解决方案:消息，包含{0}的资源将不会被找到。如果有人有好的解决方案，我会很感激。

public static string TranslateExceptionMessage(Exception ex, CultureInfo targetCulture)
{
try
{
Assembly assembly = ex.GetType().Assembly;
ResourceManager resourceManager = new ResourceManager(assembly.GetName().Name, assembly);
ResourceSet originalResources = resourceManager.GetResourceSet(Thread.CurrentThread.CurrentUICulture, createIfNotExists: true, tryParents: true);
ResourceSet targetResources = resourceManager.GetResourceSet(targetCulture, createIfNotExists: true, tryParents: true);
foreach (DictionaryEntry originalResource in originalResources)
if (originalResource.Value.ToString().Equals(ex.Message.ToString(), StringComparison.Ordinal))
return targetResources.GetString(originalResource.Key.ToString(), ignoreCase: false); // success


}
catch { }
return ex.Message; // failed (error or cause it's not smart enough to find texts with '{0}'-patterns)
}

小开

这可能是一个有争议的观点，但与其将区域性设置为en-US，不如将其设置为Invariant。在Invariant区域性中，错误消息是英文的。

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

它的优点是看起来没有偏见，特别是对于非美式英语地区。(也就是避免同事的冷嘲热讽)

小开

使用扩展方法覆盖捕获块中的异常消息，检查抛出的消息是否来自代码，如下所述。

    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();
}

小开

.NET框架分为两部分:

.NET框架本身
.NET框架语言包

在. net框架中，所有文本(例如异常消息、MessageBox上的按钮标签等)都是英文的。语言包具有本地化文本。

根据您的具体情况，解决方案是卸载语言包(即告诉客户端这样做)。在这种情况下，异常文本将是英文的。但是请注意，所有其他框架提供的文本也将是英文的(例如MessageBox上的按钮标签，ApplicationCommands的键盘快捷键)。

小开

这里有一个解决方案，不需要任何编码，甚至适用于异常的文本加载过早，我们能够通过代码更改(例如，那些在mscorlib)。

它可能并不总是适用于每一种情况(这取决于你的设置，因为你需要能够创建一个。config文件之外的主。exe文件)，但这对我来说是可行的。因此，只需在dev中创建app.config(或在生产中创建[myapp].exe.config或web.config)，其中包含以下行，例如:

<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>

它的作用是告诉框架将法语版本中mscorlib的资源和System.Xml的资源的程序集绑定重定向到一个…不存在(任意版本999)。

因此，当CLR为这两个程序集(mscorlib和System.xml)寻找法语资源时，它不会找到它们，而是优雅地回退到英语。根据上下文和测试，您可能希望将其他程序集添加到这些重定向(包含本地化资源的程序集)。

当然，我认为微软不支持这个功能，所以请自行承担使用风险。好吧，如果您发现了问题，您可以删除这个配置并检查它是否无关。

小开

出于日志记录的目的，某些应用程序可能需要获取英文异常消息(除了在通常客户机的UICulture中显示它之外)。

为此，使用以下代码

改变当前的用户界面文化
使用"GetType()"重新创建抛出的Exception对象,“Activator.CreateInstance (t)”
在新的UICuture中显示新的异常对象的消息

，然后最后将当前UICulture更改回较早的UICulture。

    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();


}

小开

我也遇到过同样的情况，我在这里和其他地方找到的所有答案都没有帮助或不令人满意:

Thread.CurrentUICulture改变了。net异常的语言，但它不会改变Win32Exception，因为它使用Windows UI本身语言中的Windows资源。所以我从来没有设法用英语而不是德语打印Win32Exception的消息，甚至没有使用
中所描述的FormatMessage() 如何获得Win32Exception的英文? < / p >

因此，我创建了自己的解决方案，它将不同语言的大多数现有异常消息存储在外部文件中。您将不会用您想要的语言得到非常精确的消息，但是您将得到该语言的消息，这比您目前得到的消息(可能是用一种您不理解的语言得到的消息)要好得多。

该类的静态函数可以在使用不同语言的Windows安装上执行: CreateMessages()创建特定于区域性的文本
SaveMessagesToXML()将它们保存到创建或加载语言的尽可能多的XML文件中
LoadMessagesFromXML()加载所有带有特定语言消息的XML文件

在使用不同语言的不同Windows安装上创建XML文件时，您很快就会拥有所需的所有语言当你安装了多个MUI语言包时，也许你可以在1个Windows上为不同的语言创建文本，但我还没有测试过

使用VS2008测试，可以使用了。欢迎评论和建议!

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");
}
}

小开

基于Undercover1989答案，但考虑参数以及当消息由多个资源字符串组成时(如参数异常)。

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;
}

小开

英文异常消息

try
{
......
}
catch (Exception ex)
{
throw new UserFriendlyException(L("ExceptionmessagesinEnglish"));
}

然后进入本地化文件夹，把它放在projectName.xml中，然后添加

<text name="ExceptionmessagesinEnglish">Exception Message in English</text>

小开

这招对我很管用:

 //Exception Class Extensions
public static class ExceptionExtensions
{
public static string EnMessage(this Exception ex)
{
CultureInfo oldCI = Thread.CurrentThread.CurrentCulture;
string englishExceptionMessage = ex.Message;
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
try
{
var objectType = Type.GetType(ex.GetType().FullName);
var instantiatedObject = Activator.CreateInstance(objectType);
throw (Exception)instantiatedObject;
}
catch (Exception e)
{
englishExceptionMessage = e.Message;
}
Thread.CurrentThread.CurrentCulture = oldCI;
Thread.CurrentThread.CurrentUICulture = oldCI;
return englishExceptionMessage;
}
}

然后你可以通过调用新方法ex.EnMessage()来使用它;

小开

必须在IIS上进行更改。转到IIS管理器>选择场地>.NET全球化>在那里将UI文化设置为英文。

在这是另一个SO帖子上可以看到更详细的答案。

小开

关于。net Core和以上，Thread.CurrentUICulture的文档建议使用CultureInfo.CurrentUICulture属性来检索和设置当前区域性。

CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;

在一个相关的GitHub问题，Tarek Mahmoud Sayed建议上使用CultureInfo.DefaultThreadCurrentUICulture，以确保稍后其他创建的线程也将获得相同的区域性:

CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;

后者只在。net Framework 4.5(和。net Core 1.0)之后才可用。