public string FormatString(uint id, params string[] args)
{
CheckDisposed();
IntPtr buffer = IntPtr.Zero;
string source = LoadString(id);
// For some reason FORMAT_MESSAGE_FROM_HMODULE doesn't work so we use this way.
FormatMessageFlags flags = FormatMessageFlags.FormatMessageAllocateBuffer | FormatMessageFlags.FormatMessageArgumentArray | FormatMessageFlags.FormatMessageFromString;
IntPtr sourcePtr = System.Runtime.InteropServices.Marshal.StringToHGlobalAuto(source);
try
{
if (Kernel32.FormatMessage(flags, sourcePtr, id, 0, ref buffer, 0, args) == 0)
{
throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
}
}
finally
{
System.Runtime.InteropServices.Marshal.FreeHGlobal(sourcePtr);
}
string result = System.Runtime.InteropServices.Marshal.PtrToStringAuto(buffer);
// FreeHGlobal calls LocalFree
System.Runtime.InteropServices.Marshal.FreeHGlobal(buffer);
return(result);
}
/// <summary>
/// Tries to get the error message text using the supplied buffer.
/// </summary>
/// <param name="flags">
/// The formatting options, and how to interpret the lpSource parameter. The low-order byte of dwFlags specifies how the function handles line breaks in the output buffer. The low-order byte can also specify the maximum width of a formatted output line.
/// </param>
/// <param name="source">
/// The location of the message definition. The type of this parameter depends upon the settings in the <paramref name="flags"/> parameter.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_HMODULE"/>: A handle to the module that contains the message table to search.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>: Pointer to a string that consists of unformatted message text. It will be scanned for inserts and formatted accordingly.
/// If neither of these flags is set in dwFlags, then lpSource is ignored.
/// </param>
/// <param name="messageId">
/// The message identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING" />.
/// </param>
/// <param name="languageId">
/// The language identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>.
/// If you pass a specific LANGID in this parameter, FormatMessage will return a message for that LANGID only.If the function cannot find a message for that LANGID, it sets Last-Error to ERROR_RESOURCE_LANG_NOT_FOUND.If you pass in zero, FormatMessage looks for a message for LANGIDs in the following order:
/// Language neutral
/// Thread LANGID, based on the thread's locale value
/// User default LANGID, based on the user's default locale value
/// System default LANGID, based on the system default locale value
/// US English
/// If FormatMessage does not locate a message for any of the preceding LANGIDs, it returns any language message string that is present.If that fails, it returns ERROR_RESOURCE_LANG_NOT_FOUND.
/// </param>
/// <param name="sb">The buffer to use for acquiring the message.</param>
/// <param name="arguments">
/// An array of values that are used as insert values in the formatted message. A %1 in the format string indicates the first value in the Arguments array; a %2 indicates the second argument; and so on.
/// The interpretation of each value depends on the formatting information associated with the insert in the message definition.The default is to treat each value as a pointer to a null-terminated string.
/// By default, the Arguments parameter is of type va_list*, which is a language- and implementation-specific data type for describing a variable number of arguments.The state of the va_list argument is undefined upon return from the function.To use the va_list again, destroy the variable argument list pointer using va_end and reinitialize it with va_start.
/// If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values.Each insert must have a corresponding element in the array.
/// </param>
/// <param name="errorMsg">Receives the resulting error message.</param>
/// <returns><c>true</c> if the attempt is successful; <c>false</c> otherwise.</returns>
private static unsafe bool TryGetErrorMessage(FormatMessageFlags flags, void *source, int messageId, int languageId, StringBuilder sb, IntPtr[] arguments, out string errorMsg)
{
errorMsg = string.Empty;
int result = FormatMessage(
flags | FormatMessageFlags.FORMAT_MESSAGE_ARGUMENT_ARRAY & ~FormatMessageFlags.FORMAT_MESSAGE_ALLOCATE_BUFFER,
source,
messageId,
languageId,
sb,
sb.Capacity + 1,
arguments);
if (result > 0)
{
int i = sb.Length;
while (i > 0)
{
char ch = sb[i - 1];
if (ch > 32 && ch != '.')
{
break;
}
i--;
}
errorMsg = sb.ToString(0, i);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Formats a message string. The function requires a message definition as input. The message definition can come from a buffer passed into the function. It can come from a message table resource in an already-loaded module. Or the caller can ask the function to search the system's message table resource(s) for the message definition. The function finds the message definition in a message table resource based on a message identifier and a language identifier. The function copies the formatted message text to an output buffer, processing any embedded insert sequences if requested.
/// </summary>
/// <param name="dwFlags">
/// The formatting options, and how to interpret the lpSource parameter. The low-order byte of dwFlags specifies how the function handles line breaks in the output buffer. The low-order byte can also specify the maximum width of a formatted output line.
/// The <see cref="FormatMessageFlags.FORMAT_MESSAGE_ARGUMENT_ARRAY"/> flag is always added
/// and the <see cref="FormatMessageFlags.FORMAT_MESSAGE_ALLOCATE_BUFFER"/> flag is always suppressed by this helper method
/// </param>
/// <param name="lpSource">
/// The location of the message definition. The type of this parameter depends upon the settings in the <paramref name="dwFlags"/> parameter.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_HMODULE"/>: A handle to the module that contains the message table to search.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>: Pointer to a string that consists of unformatted message text. It will be scanned for inserts and formatted accordingly.
/// If neither of these flags is set in dwFlags, then lpSource is ignored.
/// </param>
/// <param name="dwMessageId">
/// The message identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING" />.
/// </param>
/// <param name="dwLanguageId">
/// The language identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>.
/// If you pass a specific LANGID in this parameter, FormatMessage will return a message for that LANGID only.If the function cannot find a message for that LANGID, it sets Last-Error to ERROR_RESOURCE_LANG_NOT_FOUND.If you pass in zero, FormatMessage looks for a message for LANGIDs in the following order:
/// Language neutral
/// Thread LANGID, based on the thread's locale value
/// User default LANGID, based on the user's default locale value
/// System default LANGID, based on the system default locale value
/// US English
/// If FormatMessage does not locate a message for any of the preceding LANGIDs, it returns any language message string that is present.If that fails, it returns ERROR_RESOURCE_LANG_NOT_FOUND.
/// </param>
/// <param name="Arguments">
/// An array of values that are used as insert values in the formatted message. A %1 in the format string indicates the first value in the Arguments array; a %2 indicates the second argument; and so on.
/// The interpretation of each value depends on the formatting information associated with the insert in the message definition.The default is to treat each value as a pointer to a null-terminated string.
/// By default, the Arguments parameter is of type va_list*, which is a language- and implementation-specific data type for describing a variable number of arguments.The state of the va_list argument is undefined upon return from the function.To use the va_list again, destroy the variable argument list pointer using va_end and reinitialize it with va_start.
/// If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values.Each insert must have a corresponding element in the array.
/// </param>
/// <param name="maxAllowedBufferSize">The maximum size of the returned string. If exceeded, <c>null</c> is returned.</param>
/// <returns>
/// If the function succeeds, the return value is the number of TCHARs stored in the output buffer, excluding the terminating null character.
/// If the function fails, the return value is zero. To get extended error information, call <see cref="GetLastError"/>.
/// </returns>
public static unsafe string FormatMessage(FormatMessageFlags dwFlags, void *lpSource, int dwMessageId, int dwLanguageId, IntPtr[] Arguments, int maxAllowedBufferSize)
{
string errorMsg;
StringBuilder sb = new StringBuilder(256);
do
{
if (TryGetErrorMessage(dwFlags, lpSource, dwMessageId, dwLanguageId, sb, Arguments, out errorMsg))
{
return(errorMsg);
}
else
{
if (GetLastError() == Win32ErrorCode.ERROR_INSUFFICIENT_BUFFER)
{
// increase the capacity of the StringBuilder by 4 times.
sb.Capacity *= 4;
}
else
{
// No message with the given ID was found, or some other error occurred.
return(null);
}
}
}while (sb.Capacity < maxAllowedBufferSize);
// If you come here then a size as large as 65K is also not sufficient.
return(null);
}
private static extern uint FormatMessage(FormatMessageFlags flags,
IntPtr source,
uint messageId,
uint languageId,
ref IntPtr buffer,
uint size,
IntPtr arguments);
/// <summary>
/// Formats a message string. The function requires a message definition as input. The message definition can come from a buffer passed into the function. It can come from a message table resource in an already-loaded module. Or the caller can ask the function to search the system's message table resource(s) for the message definition. The function finds the message definition in a message table resource based on a message identifier and a language identifier. The function copies the formatted message text to an output buffer, processing any embedded insert sequences if requested.
/// </summary>
/// <param name="dwFlags">
/// The formatting options, and how to interpret the lpSource parameter. The low-order byte of dwFlags specifies how the function handles line breaks in the output buffer. The low-order byte can also specify the maximum width of a formatted output line.
/// The <see cref="FormatMessageFlags.FORMAT_MESSAGE_ARGUMENT_ARRAY"/> flag is always added
/// and the <see cref="FormatMessageFlags.FORMAT_MESSAGE_ALLOCATE_BUFFER"/> flag is always suppressed by this helper method
/// </param>
/// <param name="lpSource">
/// The location of the message definition. The type of this parameter depends upon the settings in the <paramref name="dwFlags"/> parameter.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_HMODULE"/>: A handle to the module that contains the message table to search.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>: Pointer to a string that consists of unformatted message text. It will be scanned for inserts and formatted accordingly.
/// If neither of these flags is set in dwFlags, then lpSource is ignored.
/// </param>
/// <param name="dwMessageId">
/// The message identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING" />.
/// </param>
/// <param name="dwLanguageId">
/// The language identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>.
/// If you pass a specific LANGID in this parameter, FormatMessage will return a message for that LANGID only.If the function cannot find a message for that LANGID, it sets Last-Error to ERROR_RESOURCE_LANG_NOT_FOUND.If you pass in zero, FormatMessage looks for a message for LANGIDs in the following order:
/// Language neutral
/// Thread LANGID, based on the thread's locale value
/// User default LANGID, based on the user's default locale value
/// System default LANGID, based on the system default locale value
/// US English
/// If FormatMessage does not locate a message for any of the preceding LANGIDs, it returns any language message string that is present.If that fails, it returns ERROR_RESOURCE_LANG_NOT_FOUND.
/// </param>
/// <param name="Arguments">
/// An array of values that are used as insert values in the formatted message. A %1 in the format string indicates the first value in the Arguments array; a %2 indicates the second argument; and so on.
/// The interpretation of each value depends on the formatting information associated with the insert in the message definition.The default is to treat each value as a pointer to a null-terminated string.
/// By default, the Arguments parameter is of type va_list*, which is a language- and implementation-specific data type for describing a variable number of arguments.The state of the va_list argument is undefined upon return from the function.To use the va_list again, destroy the variable argument list pointer using va_end and reinitialize it with va_start.
/// If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values.Each insert must have a corresponding element in the array.
/// </param>
/// <param name="maxAllowedBufferSize">The maximum size of the returned string. If exceeded, <c>null</c> is returned.</param>
/// <returns>
/// If the function succeeds, the return value is the number of TCHARs stored in the output buffer, excluding the terminating null character.
/// If the function fails, the return value is zero. To get extended error information, call <see cref="GetLastError"/>.
/// </returns>
public static unsafe string FormatMessage(FormatMessageFlags dwFlags, void* lpSource, int dwMessageId, int dwLanguageId, IntPtr[] Arguments, int maxAllowedBufferSize)
{
string errorMsg;
StringBuilder sb = new StringBuilder(256);
do
{
if (TryGetErrorMessage(dwFlags, lpSource, dwMessageId, dwLanguageId, sb, Arguments, out errorMsg))
{
return errorMsg;
}
else
{
if (GetLastError() == Win32ErrorCode.ERROR_INSUFFICIENT_BUFFER)
{
// increase the capacity of the StringBuilder by 4 times.
sb.Capacity *= 4;
}
else
{
// No message with the given ID was found, or some other error occurred.
return null;
}
}
}
while (sb.Capacity < maxAllowedBufferSize);
// If you come here then a size as large as 65K is also not sufficient.
return null;
}
internal static extern int FormatMessage(FormatMessageFlags dwFlags,
SafeLibraryHandle lpSource,
int dwMessageId,
int dwLanguageId,
[In, Out] ref IntPtr lpBuffer,
int nSize,
IntPtr pArguments);
private static String GetErrorString(Int32 errorCode)
{
String failed = "Unable to FormatMessage({0}), cause: {1}";
String message;
Int16 languageId = MakeLangId(LanguageId.Neutral, SubLanguageId.Neutral);
FormatMessageFlags flags = FormatMessageFlags.AllocateBuffer | FormatMessageFlags.FromSystem;
IntPtr zero = IntPtr.Zero;
Int32 length = FormatMessage(flags, zero, errorCode, languageId, out message, 0, zero);
if (
length == 0 ||
message == null ||
message.Length != length)
{
return(String.Format(Cult.InvariantCulture, failed, errorCode, GetLastErrorString()));
}
message = message.Trim('\r', '\n');
return(message);
}
public static extern int FormatMessage(FormatMessageFlags flags,
IntPtr source,
int messageId,
int languageId,
out string buffer,
int size,
IntPtr arguments);
/// <summary>
///
/// </summary>
/// <param name="errorCode"></param>
/// <param name="moduleHandle"></param>
/// <param name="args"></param>
/// <returns></returns>
public static string TranslateError(int errorCode, IntPtr moduleHandle = default(IntPtr), params string[] args)
{
FormatMessageFlags flags = moduleHandle.IsZero() ? FormatMessageFlags.FromSystem : FormatMessageFlags.FromModule;
if (args != null && !args.Length.IsZero())
{
flags |= FormatMessageFlags.ArgumentArray;
}
else
{
flags |= FormatMessageFlags.IgnoreInserts;
}
StringBuilder sbDescription = new StringBuilder(0x400);
int result = Kernel32.FormatMessage(
flags,
moduleHandle,
errorCode,
0x400 /* NEUTRAL LANGUAGE */,
sbDescription,
0x400 /* Size */,
args);
// if PInvoke fails, use Win32Exception to get error message
if (result.IsZero())
{
Win32Exception exception = new Win32Exception(Marshal.GetLastWin32Error());
return(exception.Message);
}
return(sbDescription.ToString());
}
public static extern uint FormatMessage(FormatMessageFlags dwFlags,
IntPtr lpSource,
uint dwMessageId,
uint dwLanguageId,
out IntPtr lpBuffer,
uint nSize,
IntPtr Arguments);
public static extern int FormatMessage(
FormatMessageFlags dwFlags,
IntPtr lpSource,
int dwMessageId,
int dwLanguageId,
IntPtr buffer,
int nSize,
IntPtr arguments);
public static extern uint FormatMessageW(
[MarshalAs(UnmanagedType.U4)] FormatMessageFlags dwFlags,
IntPtr lpSource,
uint dwMessageId,
uint dwLanguageId,
[Out] StringBuilder lpBuffer,
uint nSize,
IntPtr Arguments);
internal extern static uint FormatMessage(
FormatMessageFlags dwFlags,
IntPtr lpSource,
UInt32 dwMessageId,
UInt32 dwLanguageId,
ref IntPtr lpBuffer,
UInt32 nSize,
IntPtr vaArguments
);
internal extern static uint FormatMessage(
FormatMessageFlags dwFlags,
IntPtr lpSource,
UInt32 dwMessageId,
UInt32 dwLanguageId,
ref IntPtr lpBuffer,
UInt32 nSize,
IntPtr vaArguments
);
public static extern uint FormatMessageW(
[MarshalAs(UnmanagedType.U4)] FormatMessageFlags dwFlags,
UnmanagedString lpSource,
uint dwMessageId,
uint dwLanguageId,
IntPtr lpBuffer,
uint nSize,
[MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr)]
string[] Arguments);
public static extern uint FormatMessageW(
FormatMessageFlags dwFlags,
IntPtr lpSource,
uint dwMessageId,
// LANGID or 0 for auto lookup
uint dwLanguageId,
IntPtr lpBuffer,
// Size is in chars
uint nSize,
string[] Arguments);
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms679351.aspx
public static uint FormatMessageW(
FormatMessageFlags dwFlags,
IntPtr lpSource,
uint dwMessageId,
// LANGID or 0 for auto lookup
uint dwLanguageId,
IntPtr lpBuffer,
// Size is in chars
uint nSize,
string[] Arguments) => Internal.Imports.FormatMessageW(dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments);
public static string FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource, int dwMessageId, int dwLanguageId, IntPtr argumentsLong)
{
var ret = new String('\0', MAX_BUFFER_SIZE);
var Length = FormatMessage((int)dwFlags, lpSource, dwMessageId, dwLanguageId, ret, (uint)ret.Length, argumentsLong);
ret = ret.Substring(0, Length);
return(ret);
}
// .NET's Win32Exception impements the error code lookup on FormatMessage using FORMAT_MESSAGE_FROM_SYSTEM.
// It won't handle Network Errors (NERR_BASE..MAX_NERR), which come from NETMSG.DLL.
public static string FormatMessage(
uint messageId,
IntPtr source,
FormatMessageFlags flags,
params string[] args)
{
using (StringBuffer buffer = new StringBuffer())
{
// Don't use line breaks
flags |= FormatMessageFlags.FORMAT_MESSAGE_MAX_WIDTH_MASK;
if (args == null || args.Length == 0)
{
flags |= FormatMessageFlags.FORMAT_MESSAGE_IGNORE_INSERTS;
}
WindowsError lastError = WindowsError.ERROR_INSUFFICIENT_BUFFER;
uint capacity = byte.MaxValue;
uint result = 0;
while (lastError == WindowsError.ERROR_INSUFFICIENT_BUFFER && capacity <= short.MaxValue)
{
buffer.EnsureCharCapacity(capacity);
result = Imports.FormatMessageW(
dwFlags: flags,
lpSource: source,
dwMessageId: messageId,
// Do the default language lookup
dwLanguageId: 0,
lpBuffer: buffer.DangerousGetHandle(),
nSize: buffer.CharCapacity,
Arguments: args);
if (result == 0)
{
lastError = Errors.GetLastError();
capacity = (uint)Math.Min(capacity * 2, short.MaxValue);
}
else
{
buffer.Length = result;
return(buffer.ToString());
}
}
throw new IOException("Failed to get error string.", (int)ErrorMacros.HRESULT_FROM_WIN32(lastError));
}
}
private static string GetSysErrMsg(uint errCode)
{
var lpMsgBuf = IntPtr.Zero;
const FormatMessageFlags flags = FormatMessageFlags.FormatMessageAllocateBuffer
| FormatMessageFlags.FormatMessageIgnoreInserts
| FormatMessageFlags.FormatMessageFromSystem;
var chars = FormatMessage(flags /*0x1300*/, IntPtr.Zero, errCode, 0, ref lpMsgBuf, 255, IntPtr.Zero);
if (chars == 0)
{
return(null);
}
var msg = Marshal.PtrToStringAnsi(lpMsgBuf);
LocalFree(lpMsgBuf);
return(msg);
}
public static String GetErrorString(Int32 errorCode)
{
String message;
Int16 languageId = MakeLangId(LanguageId.Neutral, SubLanguageId.Neutral);
FormatMessageFlags flags = FormatMessageFlags.AllocateBuffer | FormatMessageFlags.FromSystem;
IntPtr zero = IntPtr.Zero;
Int32 length = FormatMessage(flags, zero, errorCode, languageId, out message, 0, zero);
if (message.Length != length)
{
return(null); // TODO: Throw exception
}
message = message.Trim('\r', '\n');
return(message);
}
/// <summary>
/// Returns the last error code in a formatted message.
/// </summary>
public static string GetLastErrorMsg()
{
try
{
IntPtr lpMsgBuf = IntPtr.Zero;
uint errorCode = GetLastError();
FormatMessageFlags dwFlags = FormatMessageFlags.AllocateBuffer | FormatMessageFlags.FromSystem | FormatMessageFlags.IgnoreInserts;
if (FormatMessage(dwFlags, IntPtr.Zero, errorCode, 0, out lpMsgBuf, 0, IntPtr.Zero) == 0)
{
return(string.Format("Failed to get error message from system ({0})", GetLastError()));
}
string result = Marshal.PtrToStringAnsi(lpMsgBuf);
lpMsgBuf = LocalFree(lpMsgBuf);
return(result);
}
catch (Exception e)
{
return(string.Format("Failed to get error message from system, ex ({0})", e.Message));
}
}
public static extern int FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource, int dwMessageId, int dwLanguageId, StringBuilder lpBuffer, int nSize, string[] Arguments);
public static extern int FormatMessage (FormatMessageFlags dwFlags, IntPtr lpSource, uint dwMessageId, int dwLanguageId, ref IntPtr lpBuffer, int nSize, IntPtr [] arguments);
public static extern Int32 FormatMessage(FormatMessageFlags flags, IntPtr source, Int32 messageId, Int32 languageId, out String buffer, Int32 size, IntPtr arguments);
public static extern uint FormatMessage(
FormatMessageFlags dwFlags,
IntPtr lpSource,
uint dwMessageId,
uint dwLanguageId,
StringBuilder lpBuffer,
uint nSize,
IntPtr arguments);
public static extern uint NoSetLastErrorFormatMessage([MarshalAs(UnmanagedType.U4)] FormatMessageFlags dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, out IntPtr lpBuffer, uint nSize, IntPtr Arguments);
public extern static int FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource,
int dwMessageId, int dwLanguageId, System.Text.StringBuilder lpBuffer, int nSize, IntPtr[] Arguments);
public static extern uint FormatMessage([MarshalAs(UnmanagedType.U4)] FormatMessageFlags dwFlags, IntPtr lpSource,
uint dwMessageId, uint dwLanguageId, ref IntPtr lpBuffer,
uint nSize, string[] Arguments);
private static extern uint FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, ref IntPtr lpBuffer, uint nSize, IntPtr pArguments);
public static string GetErrorText(int hr)
{
string sRet = null;
int dwBufferLength;
IntPtr ip = IntPtr.Zero;
FormatMessageFlags dwFormatFlags =
FormatMessageFlags.AllocateBuffer |
FormatMessageFlags.IgnoreInserts |
FormatMessageFlags.FromSystem |
FormatMessageFlags.MaxWidthMask;
// Scan both the Windows Media library, and the system library looking for the message
dwBufferLength = FormatMessage(
dwFormatFlags,
s_hModule, // module to get message from (NULL == system)
hr, // error number to get message for
0, // default language
out ip,
0,
null
);
// Not a system message. In theory, you should be able to get both with one call. In practice (at
// least on my 64bit box), you need to make 2 calls.
if (dwBufferLength == 0)
{
if (s_hModule == IntPtr.Zero)
{
// Load the Media Foundation error message dll
s_hModule = LoadLibraryEx(MESSAGEFILE, IntPtr.Zero, LoadLibraryExFlags.LoadLibraryAsDataFile);
}
if (s_hModule != IntPtr.Zero)
{
// If the load succeeds, make sure we look in it
dwFormatFlags |= FormatMessageFlags.FromHmodule;
// Scan both the Windows Media library, and the system library looking for the message
dwBufferLength = FormatMessage(
dwFormatFlags,
s_hModule, // module to get message from (NULL == system)
hr, // error number to get message for
0, // default language
out ip,
0,
null
);
}
}
try
{
// Convert the returned buffer to a string. If ip is null (due to not finding
// the message), no exception is thrown. sRet just stays null. The
// try/finally is for the (remote) possibility that we run out of memory
// creating the string.
sRet = Marshal.PtrToStringUni(ip);
}
finally
{
// Cleanup
if (ip != IntPtr.Zero)
{
LocalFree(ip);
}
}
return(sRet);
}
public static extern int FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource, int dwMessageId, int dwLanguageId, [Out] StringBuilder lpBuffer, int nSize, IntPtr Arguments);
private static extern int FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource,
int dwMessageId, int dwLanguageId, ref IntPtr lpBuffer, int nSize,
IntPtr Arguments);
public static unsafe extern int FormatMessage(FormatMessageFlags dwFlags, void* lpSource, int dwMessageId, int dwLanguageId, StringBuilder lpBuffer, int nSize, IntPtr[] Arguments);
public static extern int FormatMessage(FormatMessageFlags flags, IntPtr source, int messageId, int languageId, StringBuilder buffer, int size, IntPtr arguments);
public static extern int FormatMessage([In] FormatMessageFlags dwFlags, [In] IntPtr lpSource, [In] uint dwMessageId, [In] uint dwLanguageId, out IntPtr lpBuffer, [In] uint nSize, [In] IntPtr Arguments);
/// <summary>
/// Tries to get the error message text using the supplied buffer.
/// </summary>
/// <param name="flags">
/// The formatting options, and how to interpret the lpSource parameter. The low-order byte of dwFlags specifies how the function handles line breaks in the output buffer. The low-order byte can also specify the maximum width of a formatted output line.
/// </param>
/// <param name="source">
/// The location of the message definition. The type of this parameter depends upon the settings in the <paramref name="flags"/> parameter.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_HMODULE"/>: A handle to the module that contains the message table to search.
/// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>: Pointer to a string that consists of unformatted message text. It will be scanned for inserts and formatted accordingly.
/// If neither of these flags is set in dwFlags, then lpSource is ignored.
/// </param>
/// <param name="messageId">
/// The message identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING" />.
/// </param>
/// <param name="languageId">
/// The language identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>.
/// If you pass a specific LANGID in this parameter, FormatMessage will return a message for that LANGID only.If the function cannot find a message for that LANGID, it sets Last-Error to ERROR_RESOURCE_LANG_NOT_FOUND.If you pass in zero, FormatMessage looks for a message for LANGIDs in the following order:
/// Language neutral
/// Thread LANGID, based on the thread's locale value
/// User default LANGID, based on the user's default locale value
/// System default LANGID, based on the system default locale value
/// US English
/// If FormatMessage does not locate a message for any of the preceding LANGIDs, it returns any language message string that is present.If that fails, it returns ERROR_RESOURCE_LANG_NOT_FOUND.
/// </param>
/// <param name="sb">The buffer to use for acquiring the message.</param>
/// <param name="arguments">
/// An array of values that are used as insert values in the formatted message. A %1 in the format string indicates the first value in the Arguments array; a %2 indicates the second argument; and so on.
/// The interpretation of each value depends on the formatting information associated with the insert in the message definition.The default is to treat each value as a pointer to a null-terminated string.
/// By default, the Arguments parameter is of type va_list*, which is a language- and implementation-specific data type for describing a variable number of arguments.The state of the va_list argument is undefined upon return from the function.To use the va_list again, destroy the variable argument list pointer using va_end and reinitialize it with va_start.
/// If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values.Each insert must have a corresponding element in the array.
/// </param>
/// <param name="errorMsg">Receives the resulting error message.</param>
/// <returns><c>true</c> if the attempt is successful; <c>false</c> otherwise.</returns>
private static unsafe bool TryGetErrorMessage(FormatMessageFlags flags, void* source, int messageId, int languageId, StringBuilder sb, IntPtr[] arguments, out string errorMsg)
{
errorMsg = string.Empty;
int result = FormatMessage(
flags | FormatMessageFlags.FORMAT_MESSAGE_ARGUMENT_ARRAY & ~FormatMessageFlags.FORMAT_MESSAGE_ALLOCATE_BUFFER,
source,
messageId,
languageId,
sb,
sb.Capacity + 1,
arguments);
if (result > 0)
{
int i = sb.Length;
while (i > 0)
{
char ch = sb[i - 1];
if (ch > 32 && ch != '.')
{
break;
}
i--;
}
errorMsg = sb.ToString(0, i);
return true;
}
else
{
return false;
}
}
internal static extern int FormatMessage(FormatMessageFlags dwFlags, int lpSource, int dwMessageId, int dwLanguageId, out IntPtr lpBuffer, int nSize, int[] Arguments);
public static int FormatMessage (FormatMessageFlags dwFlags, IntPtr lpSource, uint dwMessageId, int dwLanguageId, ref IntPtr lpBuffer, int nSize, IntPtr [] arguments)
{
throw new System.NotImplementedException();
}
internal static extern int FormatMessage(FormatMessageFlags flags, IntPtr source, int messageId, int languageId,
StringBuilder buffer, int size, IntPtr arguments);
public int FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, StringBuilder lpBuffer, int nSize, IntPtr[] Arguments) => FormatMessage(dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments);
internal static extern int FormatMessage(FormatMessageFlags dwFlags, int lpSource, int dwMessageId, int dwLanguageId, out IntPtr lpBuffer, int nSize, int[] Arguments);
