public static string FormatErrorString(this System.Enum enumeration, CultureInfo culture, params object[] information) { Type enumType = enumeration.GetType(); ResourceInfo info = ResourceManagerCache.ResourceInfoForType(enumType); if (culture == null) { culture = info.CultureOverride ?? GlobalCultureOverride; } string formatName = enumeration.ToString(); ResourceManager rm = info.ResourceManager; string errorFormat = rm.GetString(string.Concat(enumType.Name, ".", formatName), culture) ?? rm.GetString(formatName, culture); if (errorFormat == null) { throw new NotSupportedException(ErrorCode.MissingStringDefinition.FormatErrorString(enumType.Name, formatName)); } // TODO: Add prefix information for string... string finalFormat = rm.GetString("_ErrorMessageFormat", culture) ?? "{2}({1}): {0}"; return(string.Format(CultureInfo.InvariantCulture, finalFormat, string.Format(culture, errorFormat, information), // {0} is the formatted error message ((IConvertible)enumeration).ToInt32(CultureInfo.CurrentCulture), // {1} is the number assigned to the enumeration enumType.Namespace, // {2} is the namespace of the enumeration type enumType.Name, // {3} is the name of the enumeration type enumeration.ToString())); // {4} is the name of the enumeration field }
/// <summary> /// Construct a <see cref="ResourceInfo"/> object. /// </summary> /// <param name="type"></param> internal ResourceInfo(Type type) { m_ResourceType = type; // Determine Resource Manager to use ErrorStringResourceAttribute attr = (ErrorStringResourceAttribute)(type.GetCustomAttributes(typeof(ErrorStringResourceAttribute), true).FirstOrDefault()) ?? (ErrorStringResourceAttribute)(m_ResourceType.Assembly.GetCustomAttributes(typeof(ErrorStringResourceAttribute), true).FirstOrDefault()) ?? new ErrorStringResourceAttribute("ErrorStrings", type); if (attr.IsRedirect) { ResourceManager = ResourceManagerCache.ResourceInfoForType(attr.Redirect).ResourceManager; } else { ResourceManager = new ResourceManager(attr.Path, type.Assembly); } ErrorExceptionAttribute exceptionAttr = (ErrorExceptionAttribute)(type.GetCustomAttributes(typeof(ErrorExceptionAttribute), true).FirstOrDefault()); DefaultExceptionConstructor = (exceptionAttr == null ? typeof(ApplicationException) : exceptionAttr.ExceptionType) .GetConstructor(new Type[] { typeof(string) }); if (DefaultExceptionConstructor == null) { throw ErrorCode.ExceptionDoesNotContainProperConstructor_String.Exception(exceptionAttr.ExceptionType); } }
/// <summary> /// Sets the <see cref="CultureInfo"/> to be used for resource management lookups for the given type. /// </summary> /// <param name="type">The type to associate the <c>culture</c> to.</param> /// <param name="culture">The <see cref="CultureInfo"/> to associate.</param> /// <returns>The previoud <see cref="CultureInfo"/> setting.</returns> public static CultureInfo SetErrorManagementCultureInfoOverride(this Type type, CultureInfo culture) { ResourceInfo info = ResourceManagerCache.ResourceInfoForType(type); CultureInfo oldValue = info.CultureOverride; info.CultureOverride = culture; return(oldValue); }
/// <summary> /// Create an exception for an error code. /// </summary> /// <param name="enumeration">The enumeration field specifying the error to create.</param> /// <param name="information">Formatting information specific to the error string.</param> /// <returns></returns> public static Exception Exception(this System.Enum enumeration, params object[] information) { Type enumerationType = enumeration.GetType(); ConstructorInfo constructor; object[] attrs = enumerationType.GetField(enumeration.ToString()).GetCustomAttributes(typeof(ErrorExceptionAttribute), true); if (attrs == null || attrs.Length == 0) { constructor = ResourceManagerCache.ResourceInfoForType(enumerationType).DefaultExceptionConstructor; } else { ErrorExceptionAttribute attribute = (ErrorExceptionAttribute)(attrs[0]); constructor = attribute.ExceptionType.GetConstructor(new Type[] { typeof(string) }); if (constructor == null) { throw ErrorCode.ExceptionDoesNotContainProperConstructor_String.Exception(attribute.ExceptionType); } } return((Exception)constructor.Invoke(new object[] { enumeration.FormatErrorString(information) })); }