public static ListItemCollection BuildListFromEnum(Enum objEnum) { ListItemCollection colListItems = new ListItemCollection(); ListItem liItem; SortedList colSortedListItems = new SortedList(); foreach (int value in Enum.GetValues(objEnum.GetType())) { liItem = new ListItem(); liItem.Value = value.ToString(); liItem.Text = StringEnum.GetStringValue((Enum)Enum.Parse(objEnum.GetType(), value.ToString(), true)); if (liItem.Text != string.Empty) { colSortedListItems.Add(liItem.Text, liItem); } liItem = null; } foreach (ListItem liListItem in colSortedListItems.GetValueList()) { colListItems.Add(liListItem); } return colListItems; }
public static System.Enum EnumPopup(Rect rect, string label, System.Enum enumerator, string[] minus) { System.Array optionsEnums = System.Enum.GetValues(enumerator.GetType()); string[] options = System.Enum.GetNames(enumerator.GetType()); string selectedName = System.Enum.GetName(enumerator.GetType(), enumerator); List <string> OriginalListOptions = ArrayUtility.ArrayToList(options); List <string> FilteredListOptions = ArrayUtility.ArrayToList(options); for (int i = 0; i < minus.Length; i++) { if (FilteredListOptions.Contains(minus[i])) { FilteredListOptions.Remove(minus[i]); } } int selectedIndex = FilteredListOptions.IndexOf(selectedName); selectedIndex = EditorGUI.Popup(rect, label, selectedIndex, FilteredListOptions.ToArray()); if (selectedIndex < 0) { selectedIndex = 0; } selectedName = FilteredListOptions[selectedIndex]; int nonfilteredSelectedIndex = OriginalListOptions.IndexOf(selectedName); return((System.Enum)(optionsEnums.GetValue(nonfilteredSelectedIndex))); }
public static List <System.Enum> GetFlagValues(this System.Enum enumFlags) { List <System.Enum> flagValues = new List <System.Enum>(); long flagsNumber = System.Convert.ToInt64(enumFlags); if (Math.IsPowerOfTwo(flagsNumber)) { flagValues.Add((System.Enum)System.Enum.ToObject(enumFlags.GetType(), flagsNumber)); return(flagValues); } int bits = (int)System.Math.Ceiling(System.Math.Log(flagsNumber, 2)); for (int i = 0; i <= bits; i++) { long bitValue = 1L << i; if ((flagsNumber & bitValue) == 0L) { continue; } flagValues.Add((System.Enum)System.Enum.ToObject(enumFlags.GetType(), bitValue)); } return(flagValues); }
private static Attribute GetAttribute(Type t, Enum e) { var name = Enum.GetName(e.GetType(), e); var fieldInfo = e.GetType().GetField(name); return Attribute.GetCustomAttribute(fieldInfo, t); }
/// <summary> /// Retrieves the message format from the DefaultMessage attribute decorating the /// message code /// </summary> /// <param name="code"></param> /// <returns></returns> protected string GetMessageFormat(Enum code) { System.Reflection.FieldInfo fi = code.GetType().GetField(code.ToString()); var attributes = (DefaultMessageAttribute[])fi.GetCustomAttributes(typeof(DefaultMessageAttribute), false); return (attributes.Length > 0) ? attributes[0].Message : code.GetType().DeclaringType.FullName + "." + code.ToString(); }
public static bool AnyFlag(this Enum baseEnum, Enum value) { if (!baseEnum.GetType().IsEquivalentTo(value.GetType())) { throw ExceptionHelper.EnumTypeDoesNotMatch(value.GetType(), baseEnum.GetType()); } return ((ToUInt64(baseEnum) & ToUInt64(value)) != 0); }
private void EvaluateEnum( Enum e ) { Console.WriteLine( "Name: " + e.GetType().Name ); Console.WriteLine( "Underlying Type: " + Enum.GetUnderlyingType( e.GetType() ) ); Array values = Enum.GetValues(e.GetType()); for (int i = 0; i < values.Length; i++) Console.WriteLine("Name: {0}, Value:{0:D}", values.GetValue(i)); }
static void CheckEnumHasFlagAttribute(Enum actual) { #if NewReflection if (!actual.GetType().GetTypeInfo().IsDefined(typeof(FlagsAttribute), false)) #else if (!actual.GetType().IsDefined(typeof(FlagsAttribute), false)) #endif { throw new ArgumentException("Enum doesn't have Flags attribute", nameof(actual)); } }
public EnumDialog(Enum input) { this.InitializeComponent(); this._enumType = input.GetType(); foreach (var name in Enum.GetNames(input.GetType())) { this.comboBox1.Items.Add(name); } this.comboBox1.Text = input.ToString(); }
private static void EvaluateEnum(Enum e) { Console.WriteLine(String.Format("Information about {0}", e.GetType().Name)); Console.WriteLine(String.Format("Underlying type: {0}", e.GetTypeCode())); var enumData = Enum.GetValues(e.GetType()); foreach (var item in enumData) { Console.WriteLine(String.Format("Name: {0} Value: {0:d} ", item)); } Console.WriteLine(); }
public static bool EnumTryParse(string value, ref System.Enum e) { foreach (string name in System.Enum.GetNames(e.GetType())) { if (name == value) { e = (System.Enum)System.Enum.Parse(e.GetType(), value); return(true); } } return(false); }
static void EvaluateEnum(Enum e) { Console.WriteLine("=> Information about {0}", e.GetType().Name); Console.WriteLine("Underlying storage type: {0}", Enum.GetUnderlyingType(e.GetType())); Array enumData = Enum.GetValues(e.GetType()); //var x = enumData[0]; Console.WriteLine("This enum has {0} members", enumData.Length); for(int i = 0; i < enumData.Length; i++) { Console.WriteLine("Name: {0}, Value {0:D}", enumData.GetValue(i)); } Console.WriteLine(); }
private static IList<byte> BytesFromPspIso( Stream iso, Enum file, int offset, int size ) { if ( file.GetType() == typeof( FFTPack.Files ) ) { return FFTPack.GetFileFromIso( iso, pspIsoInfo, (FFTPack.Files)file ).Sub( offset, offset + size - 1 ); } else if ( file.GetType() == typeof( PatcherLib.Iso.PspIso.Sectors ) ) { return PatcherLib.Iso.PspIso.GetFile( iso, pspIsoInfo, (PatcherLib.Iso.PspIso.Sectors)file, offset, size ); } else { throw new ArgumentException(); } }
/// <summary> /// ��ȡö��DescriptionAttribute ֵ /// </summary> /// <param name="eEnum"></param> /// <returns></returns> public static string GetDescription(Enum eEnum) { Type enumType = eEnum.GetType(); FieldInfo fi = enumType.GetField(Enum.GetName(enumType, eEnum)); DescriptionAttribute dna = (DescriptionAttribute)Attribute.GetCustomAttribute(fi, typeof(DescriptionAttribute)); return dna == null ? string.Empty : dna.Description; }
public static string GetEnumRemark(Enum value) { Type type = value.GetType(); string cacheKey = string.Format("{0}_Remark_{1}", type.Name, value); if (_cache.ContainsKey(cacheKey)) return _cache[cacheKey]; else { FieldInfo fieldInfo = type.GetField(value.ToString()); string remark = string.Empty; try { object[] attrs = fieldInfo.GetCustomAttributes(typeof(RemarkAttribute), false); foreach (RemarkAttribute attr in attrs) { remark = attr.Remark; } if (!string.IsNullOrEmpty(remark)) _cache.SafeAdd(cacheKey, remark); } catch (Exception ex) { logger.Error(ex); } return remark; } }
public static string EnumToString(Enum enumValue) { StringBuilder enumValueAsString = new StringBuilder(); Type enumType = enumValue.GetType(); string[] enumToStringParts = enumValue.ToString().Split(ENUM_FLAGGED_VALUE_SEPERATOR_CHARACTER); foreach (string enumValueStringPart in enumToStringParts) { FieldInfo enumValueField = enumType.GetField(enumValueStringPart.Trim()); EnumValueDescriptionAttribute[] enumDesc = enumValueField.GetCustomAttributes(typeof(EnumValueDescriptionAttribute), false) as EnumValueDescriptionAttribute[]; if (enumValueAsString.Length > 0) { enumValueAsString.Append(ENUM_FLAGGED_VALUE_SEPERATOR_CHARACTER); } if (enumDesc.Length == 1) { enumValueAsString.Append(enumDesc[0].Description); } else { enumValueAsString.Append(enumValueStringPart); } } return enumValueAsString.ToString(); }
/// <summary> /// Gets a string value for a particular enum value. /// </summary> /// <param name="value">Value.</param> /// <returns>String Value associated via a <see cref="DescriptionAttribute"/> attribute, or null if not found.</returns> public static string GetStringValue(Enum value) { string output = null; var type = value.GetType(); if (StringValues.ContainsKey(value)) output = ((DescriptionAttribute)StringValues[value]).Description; else { var fi = type.GetField(value.ToString()); var attrs = fi.GetCustomAttributes(typeof(DescriptionAttribute), false) as DescriptionAttribute[]; // ReSharper disable PossibleNullReferenceException if (attrs.Length > 0) { // ReSharper restore PossibleNullReferenceException if (!StringValues.Contains(value)) { StringValues.Add(value, attrs[0]); } output = attrs[0].Description; } } return output; }
/// <summary> /// Check to see if a flags enumeration has a specific flag set. /// </summary> /// <param name="variable">Flags enumeration to check</param> /// <param name="value">Flag to check for</param> /// <returns></returns> public static bool HasFlag(this Enum variable, Enum value) { if (variable == null) { return false; } if (value == null) { throw new ArgumentNullException("value"); } // Not as good as the .NET 4 version of this function, but should be good enough if (!Enum.IsDefined(variable.GetType(), value)) { throw new ArgumentException(string.Format( "Enumeration type mismatch. The flag is of type '{0}', was expecting '{1}'.", value.GetType(), variable.GetType())); } ulong num = Convert.ToUInt64(value); return ((Convert.ToUInt64(variable) & num) == num); }
public static void Parse(string value, bool ignoreCase, Enum expected) { SimpleEnum result; if (!ignoreCase) { Assert.True(Enum.TryParse(value, out result)); Assert.Equal(expected, result); Assert.Equal(expected, Enum.Parse(expected.GetType(), value)); } Assert.True(Enum.TryParse(value, ignoreCase, out result)); Assert.Equal(expected, result); Assert.Equal(expected, Enum.Parse(expected.GetType(), value, ignoreCase)); }
/// <summary> /// 列挙体に設定された文字列を取得する /// </summary> /// <param name="value">文字列が付加された列挙子</param> /// <returns>設定された文字列</returns> public static string GetStringValue(Enum value) { if (value == null) return null; // すでにキャッシュしたものがあればそれを返す if (m_Cashe.ContainsKey(value)) { return m_Cashe[value]; } // キャッシュになければ新しく取得 Type enumType = value.GetType(); string name = Enum.GetName(enumType, value); StringEnumAttribute[] attributes = (StringEnumAttribute[])enumType.GetField(name).GetCustomAttributes(typeof(StringEnumAttribute), false); if (attributes.Length > 0) { // 属性があれば取得する string stringValue = attributes[0].m_StringValue; // キャッシュとして保存しておく m_Cashe[value] = stringValue; return stringValue; } else { // 属性がなければ無ければ空の値をキャッシュに保存してから返す // キャッシュとして保存しておく m_Cashe[value] = NoDataValue; return NoDataValue; } }
public static string GetStringValue(Enum value) { string output; var type = value.GetType(); if (StringValues.ContainsKey(value)) { output = StringValues[value].Value; } else { var fi = type.GetField(value.ToString()); var attrs = fi.GetCustomAttributes(typeof (StringValueAttribute), false) as StringValueAttribute[]; if (attrs != null && attrs.Length > 0) { output = attrs[0].Value; // Put it in the cache. lock(StringValues) { // Double check if (!StringValues.ContainsKey(value)) { StringValues.Add(value, attrs[0]); } } } else { return value.ToString(); } } return output; }
internal static string EnumToTranslation(this ResourceManager r, Enum value) { var type = value.GetType(); var name = Enum.GetName(type, value); var key = type.Name + name; return r.GetString(key) ?? "Key: " + key; }
public override void SelectConcept(Enum concept) { base.SelectConcept(concept); if(concept.GetType().Equals(typeof(DataAccessConceptsList))) { switch((DataAccessConceptsList)concept) { case DataAccessConceptsList.WorkingWithFilesExamples: conceptExecutionClass = new WorkingWithFilesExamples(); break; case DataAccessConceptsList.WorkingWithStreams: conceptExecutionClass = new WorkingWithStreams(); break; case DataAccessConceptsList.WorkingWithADO_DOTNET_Concepts: conceptExecutionClass = new WorkingWithADO_DOTNET_Concepts(); break; case DataAccessConceptsList.WorkingWithXMLConcepts: conceptExecutionClass = new WorkingWithXMLExamples(); break; case DataAccessConceptsList.LINQExamples: conceptExecutionClass = new LINQExamples(); break; case DataAccessConceptsList.SerializationAndDeserializationExamples: conceptExecutionClass = new SerializationAndDeserializationExamples(); break; case DataAccessConceptsList.ImplementingClassHierarchy: conceptExecutionClass = new ClassHierarchyExample(); break; } } }
/// <summary> /// Retrieve the description on the enum, e.g. /// [Description("Bright Pink")] /// BrightPink = 2, /// Then when you pass in the enum, it will retrieve the description /// </summary> /// <param name="en">The Enumeration</param> /// <returns>A string representing the friendly name</returns> public static EnumDescription GetDescription(Enum en) { Type type = en.GetType(); string description = string.Empty; EnumDescription enumDescription = new EnumDescription() { EnumValue = en, EnumMemberName = en.ToString() }; MemberInfo[] memInfo = type.GetMember(en.ToString()); description = en.ToString(); if (memInfo != null && memInfo.Length > 0) { object[] attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false); if (attrs != null && attrs.Length > 0) { description = ((DescriptionAttribute)attrs[0]).Description; } } enumDescription.Description = description; return enumDescription; }
public static string GetStringValue(Enum value) { // Get the enum Type. var type = value.GetType(); // Check if the enum already exits in the Dictionary. if (StringValues.ContainsKey(value)) return StringValues[value].Value; // Get the enum field info. FieldInfo fi = type.GetField(value.ToString()); // Convert the enums to the strings. EnumToStringAttribute[] attrs = fi.GetCustomAttributes(typeof(EnumToStringAttribute), false) as EnumToStringAttribute[]; // if the attributes are null or if the length of the array is equal to 0 or 0, return null. if (attrs != null && attrs.Length <= 0) return null; if (attrs == null) return null; // add the enum to the Dictionary. StringValues.Add(value, attrs[0]); // Return the string. return attrs[0].Value; }
public static string GetEnumDescription(Enum enumValue) { FieldInfo fieldInfo = enumValue.GetType().GetField(enumValue.ToString()); List<DescriptionAttribute> attributes = fieldInfo.GetCustomAttributes<DescriptionAttribute>(false).ToList(); return attributes.Count > 0 ? attributes[0].Description : enumValue.ToString(); }
public static string GetStringValue(Enum value) { string output = null; Type type = value.GetType(); //Check first in our cached results... if (_stringValues.ContainsKey(value)) output = (_stringValues[value] as StringValueAttribute).Value; else { //Look for our 'StringValueAttribute' //in the field's custom attributes FieldInfo fi = type.GetField(value.ToString()); StringValueAttribute[] attrs = fi.GetCustomAttributes(typeof(StringValueAttribute), false) as StringValueAttribute[]; if (attrs.Length > 0) { _stringValues.Add(value, attrs[0]); output = attrs[0].Value; } } return output; }
/// <summary> /// Gets Enum Value's Description Attribute /// </summary> /// <param name="value">The value you want the description attribute for</param> /// <returns>The description, if any, else it's .ToString()</returns> public static string GetEnumDescription(Enum value) { FieldInfo fi = value.GetType().GetField(value.ToString()); var attributes = (DescriptionAttribute[])fi.GetCustomAttributes( typeof(DescriptionAttribute), false); return (attributes.Length > 0) ? attributes[0].Description : value.ToString(); }
public bool Equals (Enum e) { if (e == null) return false; else return e.GetType () == typeof (Days); }
public static string ToDescription(Enum value) { var attributes = (DescriptionAttribute[]) value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false); return attributes.Length > 0 ? attributes[0].Description : value.ToString(); }
private static string GetEnumDescription(Enum value) { if (value == null) return null; var type = value.GetType().GetTypeInfo(); var res = value.ToString(); if (type.CustomAttributes.Any(t => t.AttributeType == typeof(FlagsAttribute))) { var members = type.AsType().GetMembers(); var conversion = members.SelectMany(t => t.GetCustomAttributes(typeof(DescriptionAttribute), false).Select(a => new KeyValuePair<string, string>(t.Name, ((DescriptionAttribute)a).Description))).ToDictionary(t => t.Key, t => t.Value); res = string.Join(",", res.Split(',').Select(t => t.Trim()).Select(t => conversion.ContainsKey(t) ? conversion[t] : t)); } else { var memInfo = type.AsType().GetMember(value.ToString()); if (memInfo.Length > 0) { var attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false).ToList(); if (attrs.Any()) res = ((DescriptionAttribute)attrs.First()).Description; } } return res; }
private static TAttribute GetAttribute <TAttribute>(this Enum enumValue) where TAttribute : Attribute { return(enumValue?.GetType() .GetMember(enumValue.ToString()) .First() .GetCustomAttribute <TAttribute>()); }
/// <summary> /// Enumeration valued field. /// </summary> /// <param name="Node">Node</param> /// <param name="FieldName">Name of field</param> /// <param name="StringIds">Corresponding String IDs</param> /// <param name="Timepoint">Timepoint of field value.</param> /// <param name="Value">Value</param> /// <param name="Type">Type of value.</param> public FieldEnum(string NodeId, string FieldName, FieldLanguageStep[] StringIds, DateTime Timepoint, Enum Value, ReadoutType Type) : base(NodeId, FieldName, StringIds, Timepoint, Type) { this.value = Value.ToString(); this.dataType = Value.GetType ().FullName; }
public static T GetAttribute <T>(this System.Enum e) where T : System.Attribute { System.Type type = e.GetType(); FieldInfo fieldInfo = type.GetField(System.Enum.GetName(type, e)); return(fieldInfo.GetCustomAttribute <T>()); }
public int BunnyMask(GUIContent content, Enum enumValue) { var enumType = enumValue.GetType(); var enumNames = Enum.GetNames(enumType); var enumValues = Enum.GetValues(enumType) as int[]; return BunnyMask(content, Convert.ToInt32(enumValue), enumValues, enumNames); }
/// <summary> /// An object extension method that gets description attribute. /// </summary> /// <param name="value">The value to act on.</param> /// <returns>The description attribute.</returns> public static string?GetDescription(this Enum value) { var attr = value?.GetType() ?.GetField(value.ToString()) ?.GetCustomAttribute <DescriptionAttribute>(); return(attr?.Description); }
public void RenderDynamicEnum(string Label, System.Enum Enum, ref string Val) { List <string> Names = System.Enum.GetNames(Enum.GetType()).ToList(); if (!Names.Contains(Val) && Names.Count > 0) { Val = Names [0]; } var Value = (System.Enum)System.Enum.Parse(Enum.GetType(), Val); Value = EditorGUILayout.EnumPopup(Label, Value); var ParseValue = System.Enum.Parse(Value.GetType(), Value.ToString()); Val = (string)ParseValue.ToString(); }
//--------------------------------------- // IGUIHelper interface stuff: //--------------------------------------- public System.Enum EnumField(string label, System.Enum selected) { #if UNITY_IPHONE && !(UNITY_3_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5 || UNITY_3_6 || UNITY_3_7 || UNITY_3_8 || UNITY_3_9) GUILayout.Label(label); return((System.Enum)System.Enum.ToObject(selected.GetType(), EditorGUILayout.Popup((int)selected, System.Enum.GetNames(selected.GetType()), GUILayout.Width(150f)))); #else return(EditorGUILayout.EnumPopup(label, selected, GUILayout.Width(220f))); #endif }
public void RenderDynamicEnum(string Label, System.Enum Enum, ref int Index) { string[] Names = System.Enum.GetNames(Enum.GetType()); if (Names.Length > 0) { var Val = (System.Enum)System.Enum.Parse(Enum.GetType(), Names [0]); if (Names.Length > Index && Names.Length > 0) { Val = (System.Enum)System.Enum.Parse(Enum.GetType(), Names [Index]); } Val = EditorGUILayout.EnumPopup(Label, Val); // to int again var value = System.Enum.Parse(Val.GetType(), Val.ToString()); Index = System.Convert.ToInt32(value); } }
public static string GetEnumDesc(System.Enum obj) { string objName = obj.ToString(); System.Type t = obj.GetType(); FieldInfo fi = t.GetField(objName); System.ComponentModel.DescriptionAttribute[] arrDesc = (System.ComponentModel.DescriptionAttribute[])fi.GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false); return(arrDesc != null && arrDesc.Length > 0 ? arrDesc[0].Description : ""); }
/// <summary> /// An object extension method that gets description attribute. /// </summary> /// <param name="value">The value to act on.</param> /// <returns>The description attribute.</returns> public static string GetCustomAttributeDescription(this System.Enum value) { var attribute = value .GetType() .GetField(value.ToString()) .GetCustomAttributes(typeof(DescriptionAttribute), false) .FirstOrDefault() as DescriptionAttribute; return(attribute?.Description); }
// This method will print out the details of any enum. static void EvaluateEnum(System.Enum e) { Console.WriteLine("=> Information about {0}", e.GetType().Name); Console.WriteLine("Underlying storage type: {0}", Enum.GetUnderlyingType(e.GetType())); // Get all name/value pairs for incoming parameter. Array enumData = Enum.GetValues(e.GetType()); Console.WriteLine("This enum has {0} members.", enumData.Length); // Now show the string name and associated value. for (int i = 0; i < enumData.Length; i++) { Console.WriteLine("Name: {0}, Value: {1:D}", enumData.GetValue(i), enumData.GetValue(i)); } Console.WriteLine(); }
/// <summary> /// 获取枚举值 /// </summary> /// <param name="instance">枚举实例</param> public static int Value(this System.Enum instance) { Type type = instance.GetType(); string value = instance.SafeString(); if (string.IsNullOrWhiteSpace(value)) { throw new ArgumentNullException(nameof(instance)); } return((int)System.Enum.Parse(type, instance.ToString(), true)); }
public static string GetDescription(this System.Enum e) { var fi = e.GetType().GetField(e.ToString()); var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false); if (attributes.Length > 0) { return(attributes[0].Description); } return(e.ToString()); }
/// <summary> /// A convenience method to reduce the hassle of obtaining the /// attribute instance associated with an enum value. /// </summary> /// <typeparam name="TAttribute">An attribute type</typeparam> /// <param name="value">The enum value </param> /// <returns>The <typeparamref name="TAttribute"/>instance associated /// with the <paramref name="value"/> or null if no attribute exists</returns> public static TAttribute GetAttribute <TAttribute>(this System.Enum value) where TAttribute : System.Attribute { var type = value.GetType(); var name = System.Enum.GetName(type, value); return(type.GetField(name) // I prefer to get attributes this way .GetCustomAttributes(false) .OfType <TAttribute>() .SingleOrDefault()); }
public static string GetCode(this System.Enum value) { var typeInfo = value.GetType(); var attributes = typeInfo.GetCustomAttributes(typeof(CodeAttribute), false).Cast <CodeAttribute>().ToArray(); if ((attributes?.Count() ?? 0) <= 0) { return(null); } return(attributes[0].Code); }
private static void EvaluateEnum(System.Enum e) { ConsoleColor prevColor = Console.ForegroundColor; Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("=> Information about {0}", e.GetType().Name); Console.WriteLine("Underlying storage type: {0}", Enum.GetUnderlyingType(e.GetType())); // Get all name/value pairs for incoming parameter. Array enumData = Enum.GetValues(e.GetType()); Console.WriteLine("This enum has {0} members.", enumData.Length); // Now show the string anme and associated value, using the D format // flag (see Chapter3). for (int i = 0; i < enumData.Length; i++) { Console.WriteLine("Name: {0}, Value: {0:D}", enumData.GetValue(i)); } Console.ForegroundColor = prevColor; Console.WriteLine(); }
/// <summary> /// 获得枚举字段的特性(Attribute),该属性不允许多次定义。 /// </summary> public static string GetAttributeValue(System.Enum thisValue) { FieldInfo field = thisValue.GetType().GetField(thisValue.ToString()); var attr = (Attribute.GetCustomAttribute(field, typeof(EnumAttributeDesc)) as EnumAttributeDesc); if (attr == null) { return(string.Empty); } return((Attribute.GetCustomAttribute(field, typeof(EnumAttributeDesc)) as EnumAttributeDesc).Value); }
public static string GetEnumDescription(System.Enum value) { var fi = value.GetType().GetField(value.ToString()); var attributes = (DescriptionAttribute[])fi.GetCustomAttributes( typeof(DescriptionAttribute), false); return(attributes.Length > 0 ? attributes[0].Description : value.ToString()); }
private static void Debug_ValidateMask(System.Enum value, uint mask) { Type t = value.GetType(); uint newmask = 0; foreach (int iVal in Enum.GetValues(t)) { newmask = newmask | (uint)iVal; } System.Diagnostics.Debug.Assert(newmask == mask, "Mask not valid in IsEnumValid!"); }
public static List <OrderedPair <int, string> > GetNameValuePairs(this System.Enum enumToUse) { var typeOfEnum = enumToUse.GetType(); var orderedNameValuePairs = new List <OrderedPair <int, string> >(); foreach (var value in System.Enum.GetValues(typeOfEnum)) { orderedNameValuePairs.Add(new OrderedPair <int, string>(Convert.ToInt32(value), ((System.Enum)value).GetDescription())); } return(orderedNameValuePairs); }
public static string StringValueOf(System.Enum value) { FieldInfo fi = value.GetType().GetField(value.ToString()); var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false); if (attributes.Length > 0) { return(attributes[0].Description); } return(value.ToString()); }
/// <summary> /// 读取 <see cref="System.Enum"/> 标记 <see cref="System.ComponentModel.DescriptionAttribute"/> 的值 /// </summary> /// <param name="value">原始 <see cref="System.Enum"/> 值</param> /// <returns></returns> public static string GetDescription(this System.Enum value) { if (value == null) { return(string.Empty); } FieldInfo fieldInfo = value.GetType().GetField(value.ToString()); DescriptionAttribute attribute = fieldInfo.GetCustomAttribute <DescriptionAttribute> (false); return(attribute.Description); }
public static IEnumerable <System.Enum> EnumerateSettedUpFlags(this System.Enum flags) { foreach (var value in System.Enum.GetValues(flags.GetType()).Cast <System.Enum>()) { var hasFlag = flags.HasFlag(value); if (hasFlag) { yield return(value); } } }
/// <summary> /// 获得枚举的 value--->EnumDescription 对应字典 /// </summary> /// <param name="enum"></param> /// <returns></returns> public static Dictionary <int, string> GetDesciptions(this System.Enum @enum) { Dictionary <int, string> result = new Dictionary <int, string>(); string[] values = System.Enum.GetNames(@enum.GetType()); if (values == null || values.Length <= 0) { return(result); } for (int i = 0; i < values.Length; i++) { result[i] = ""; } foreach (string key in values) { int i = (int)System.Enum.Parse(@enum.GetType(), key); result[i] = GetDescription(System.Enum.Parse(@enum.GetType(), key).GetType()); } return(result); }
public static bool IsEnumValid_NotSequential(System.Enum enumValue, int value, params int[] enumValues) { System.Diagnostics.Debug.Assert(Enum.GetValues(enumValue.GetType()).Length == enumValues.Length, "Not all the enum members were passed in."); for (int i = 0; i < enumValues.Length; i++) { if (enumValues[i] == value) { return(true); } } return(false); }
/// <summary> /// get enum description for specific enum /// </summary> /// <param name="enum"></param> /// <param name="enumname"></param> /// <returns></returns> public static string ToDescriptionString(this System.Enum @enum, string enumname) { try { var attribute = @enum.GetType().GetField(enumname).GetCustomAttributes(typeof(DescriptionAttribute), true).FirstOrDefault(); return(attribute == null? @enum.ToString() : ((DescriptionAttribute)attribute).Description); } catch { return(null); } }
/// <summary> /// 根据枚举类型和枚举值获取枚举描述 /// </summary> /// <returns></returns> public static string ToDescription(this System.Enum value) { if (value == null) { return(""); } Type type = value.GetType(); string enumText = System.Enum.GetName(type, value); return(GetDescription(type, enumText)); }
/// <summary> /// 将一个标记了 <see cref="FlagsAttribute "/> 特性的枚举值分解成其包含已合并的多个该类型的枚举值。 /// 例如通过对枚举值 BindingFlags.GetField | BindingFlags.GetProperty 指定该方法,将会返回一个数组 { BindingFlags.GetField, BindingFlags.GetProperty }。 /// 如果传入的枚举参数所属的枚举类型未标记 <see cref="FlagsAttribute "/> 特性,该方法将会抛出异常。 /// 注意,传入的泛型参数 <typeparamref name="T"/> 必须与枚举值 <paramref name="_this"/> 的相同。 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="_this"></param> /// <returns></returns> public static T[] Decompose <T>(this System.Enum _this) where T : struct { Type thisType = _this.GetType(); Type enumType = typeof(T); if (thisType != enumType) { throw new ArgumentException(string.Format("传入的枚举值 {0} 其类型为 {1},与被转换的目标类型 {2} 不一致。", _this, thisType, enumType)); } return(Decompose(_this).Select(item => (T)(object)item).ToArray()); }
public bool IsValid(T objectToValidate) { if (objectToValidate != null) { System.Enum enumToCheck = _enumToCheck(objectToValidate); Type enumType = enumToCheck.GetType(); string enumName = System.Enum.GetName(enumType, enumToCheck); return(System.Enum.GetNames(enumType).Any(name => name == enumName)); } return(false); }