/// <summary>Indicates whether the current object is equal to another object of type <see cref="System.String"/>.
/// </summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns><c>true</c> if the current object is equal to the other parameter; otherwise, <c>false</c>.</returns>
public bool Equals(string other)
{
if (other == null)
{
return(false);
}
return(StringRepresentation.IDString == IdentifierString.GetIDString(other));
}
/// <summary>Gets the <see cref="System.String"/> representation of a specific enumeration item.
/// </summary>
/// <param name="value">The element of a specific enumeration.</param>
/// <param name="resourceManager">The resource manager, perhaps <c>null</c> if no resource manager is available for <paramref name="value"/>.</param>
/// <returns>The <see cref="System.String"/> representation of <paramref name="value"/> taken into account the <paramref name="resourceManager"/>,
/// i.e. <see cref="LanguageStringAttribute"/> if != <c>null</c>; otherwise <see cref="StringAttribute"/> is used if available;
/// otherwise the return value of the <c>ToString()</c> method of <paramref name="value"/> will be returned.</returns>
private static string GetFormatString(TEnum value, ResourceManager resourceManager)
{
if (resourceManager != null) // try language dependent string representation
{
LanguageStringAttribute languageStringAttribute = EnumAttribute.Create <LanguageStringAttribute>(value);
if (languageStringAttribute != null)
{
return(IdentifierString.GetIDString(resourceManager.GetString(languageStringAttribute.ResourcePropertyName, Thread.CurrentThread.CurrentUICulture), false));
}
}
StringAttribute stringAttribute = EnumAttribute.Create <StringAttribute>(value);
if (stringAttribute != null)
{
return(IdentifierString.GetIDString(stringAttribute.StringRepresentation, false));
}
return(IdentifierString.GetIDString(value.ToString(), false));
}
/// <summary>Converts the string representation of an enumeration item to its enumeration item equivalent.</summary>
/// <param name="stringRepresentation">The <see cref="System.String"/> representation to search for.</param>
/// <param name="value">The element of the enumeration with respect to <paramref name="stringRepresentation"/> (output).</param>
/// <param name="enumStringRepresentationUsage">The method how to compute the string representation of the items of the
/// enumeration represented by <typeparamref name="TEnum"/>.</param>
/// <returns>A value indicating whether <paramref name="value"/> contains valid data.</returns>
/// <remarks>White spaces etc. will be ignored.</remarks>
/// <exception cref="ArgumentException">Thrown, if <typeparamref name="TEnum"/> does not represent an enumeration.</exception>
public static bool TryParse(string stringRepresentation, out TEnum value, EnumStringRepresentationUsage enumStringRepresentationUsage = EnumStringRepresentationUsage.LanguageStringAttribute)
{
if (typeof(TEnum).IsEnum == false)
{
throw new ArgumentException(String.Format(ExceptionMessages.ArgumentIsInvalid, "TEnum: " + typeof(TEnum).ToString()));
}
if ((stringRepresentation == null) || (stringRepresentation.Length == 0))
{
value = default;
return(false);
}
string stringRepresentationID = IdentifierString.GetIDString(stringRepresentation, false);
if (enumStringRepresentationUsage == EnumStringRepresentationUsage.ToStringMethod)
{
return(Enum.TryParse <TEnum>(stringRepresentationID.Replace(EnumString.FlagsEnumSeparatorChar, EnumString.dotNetFlagsEnumSeparatorChar), true, out value));
}
ResourceManager resourceManager = null;
Type enumerationType = typeof(TEnum);
if (enumStringRepresentationUsage == EnumStringRepresentationUsage.LanguageStringAttribute)
{
if (Attribute.GetCustomAttribute(enumerationType, typeof(LanguageResourceAttribute)) is LanguageResourceAttribute languageResourceFile)
{
resourceManager = new ResourceManager(languageResourceFile.FullResourceName, enumerationType.Assembly);
}
}
/* if the enumeration contains the 'Flags' attribute, we assume that the input is given with respect to some
* comma separated (see 'FlagsEnumSeparatorChar') list and the return value will be the bitwise OR relation of the corresponding elements. */
if (enumerationType.GetCustomAttributes(typeof(FlagsAttribute), false).Length == 0) // no [Flags] attribute available
{
foreach (TEnum enumValue in Enum.GetValues(enumerationType)) // linear is no problem because the number of elements is in general very small
{
if (GetFormatString(enumValue, resourceManager) == stringRepresentationID)
{
value = enumValue;
return(true);
}
} // it is not a Flag, but perhaps a bitwise OR combination (which is unusual for a non-flag enumeration)
}
/* split the strings into a list of strings, where the 'FlagsEnumSeparatorChar' is take into
* account, transform each of the sub-strings to some ID-representation, compare to the elements
* of the given list and build a new string, which will be used for the Parse-Method of System.Enum.
* Here, we can not apply '|=' to the matched elements, that's the reason to do it this way:
*/
StringBuilder bString = new StringBuilder();
foreach (string subString in stringRepresentationID.Split(EnumString.FlagsEnumSeparatorChar))
{
foreach (TEnum enumValue in Enum.GetValues(enumerationType)) // linear is no problem because the number of elements is in general very small
{
if (GetFormatString(enumValue, resourceManager) == subString)
{
if (bString.Length > 0)
{
bString.Append(EnumString.dotNetFlagsEnumSeparatorChar);
}
bString.Append(enumValue.ToString()); // transform to the internal string representation
}
}
}
return(Enum.TryParse <TEnum>(bString.ToString(), true, out value));
}
/// <summary>Compares the current object with another object of type <see cref="System.String"/>.
/// </summary>
/// <param name="other">An object to compare with this object.</param>
/// <returns>
/// A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has the following meanings:
/// Less than zero: This object is less than the <paramref name="other"/> parameter.
/// Zero: This object is equal to <paramref name="other"/>.
/// Greater than zero: This object is greater than <paramref name="other"/>.
/// </returns>
/// <remarks>The <see cref="IdentifierString"/> representation of <paramref name="other"/> is used for the comparisson,
/// i.e. ignoring white spaces etc.</remarks>
public int CompareTo(string other)
{
return(StringRepresentation.IDString.CompareTo(IdentifierString.GetIDString(other)));
}