Example #1
0
        public static string ResolveDefinition <T>(this string value, string defaultValue = "")
            where T : struct
        {
            DefinitionItemHelper <T> helper = new DefinitionItemHelper <T>();
            DefinitionItemInfo       item   = helper.GetItem(value);

            if (item == null)
            {
                return(defaultValue);
            }
            return(item.Value);
        }
Example #2
0
        public static string GenerateCombinedString(Type type, string value, Func <DefinitionItemInfo, string> stringGet = null)
        {
            DefinitionItemInfo item =
                GenerateItems(type).Single(i => i.Value == value);

            if (stringGet == null)
            {
                return(item.Instance.GetType().Name + "." + item.Value);
            }
            else
            {
                return(stringGet(item));
            }
        }
Example #3
0
 public static DefinitionItemInfo GenerateItem(Type type)
 {
     if (_Cache.ContainsKey(type))
     {
         return(_Cache[type]);
     }
     lock (_Locker)
     {
         if (_Cache.ContainsKey(type))
         {
             return(_Cache[type]);
         }
         var instance = Activator.CreateInstance(type);
         DefinitionItemInfo itemInfo = new DefinitionItemInfo();
         int startPosition           = type.FullName.IndexOf(NamespaceSeparator);
         if (startPosition == -1)
         {
             startPosition = 0;
         }
         itemInfo.Ordinal      = 0;
         itemInfo.Instance     = instance;
         itemInfo.Name         = type.Name;
         itemInfo.Value        = type.Name;
         itemInfo.UniqueString =
             type.FullName.Substring(startPosition)
             .Replace(NamespaceSeparator + ".", string.Empty)
             .Replace('.', '_')
             .Replace('+', '_');
         foreach (DefinitionItemOrdinalAttribute attribute in
                  type.GetCustomAttributes(typeof(DefinitionItemOrdinalAttribute), false))
         {
             itemInfo.Ordinal = attribute.Ordinal;
         }
         foreach (DefinitionItemSettingsAttribute attribute in
                  type.GetCustomAttributes(typeof(DefinitionItemSettingsAttribute), false))
         {
             itemInfo.Caption = attribute.CaptionOrSection;
             if (attribute.IsUserDefined)
             {
                 itemInfo.Caption = Host.Settings.Get <string>(attribute.CaptionOrSection);
             }
         }
         _Cache.Add(type, itemInfo);
         return(itemInfo);
     }
 }
Example #4
0
        /// <summary>
        /// 生成类型下常量的字典项组
        /// </summary>
        public static string Caption <T>(T value)
            where T : struct, IComparable, IConvertible, IFormattable
        {
            var type = typeof(T);

            if (_CacheItems.ContainsKey(type))
            {
                return(_CacheItems[type]
                       .Single(i => i.Value == (Convert.ToInt32(value).ToString())).Caption);
            }

            lock (_LockerItems)
            {
                if (_CacheItems.ContainsKey(type))
                {
                    return(_CacheItems[type]
                           .Single(i => i.Value == (Convert.ToInt32(value).ToString())).Caption);
                }

                List <DefinitionItemInfo> l = new List <DefinitionItemInfo>();
                var instance      = Activator.CreateInstance(type);
                var shouldAdd     = true;
                int startPosition = type.FullName.IndexOf(NamespaceSeparator);
                if (startPosition == -1)
                {
                    startPosition = 0;
                }
                foreach (FieldInfo f in type.GetFields(BindingFlags.Public | BindingFlags.Static))
                {
                    // if (f.Name.Equals("value__")) continue;
                    shouldAdd = true;
                    DefinitionItemInfo itemInfo = new DefinitionItemInfo();
                    itemInfo.Ordinal      = -1;
                    itemInfo.Instance     = instance;
                    itemInfo.Name         = f.Name;
                    itemInfo.Value        = ((int)f.GetValue(null)).ToString();
                    itemInfo.Caption      = f.Name;
                    itemInfo.UniqueString =
                        type.FullName.Substring(startPosition)
                        .Replace(NamespaceSeparator + ".", string.Empty)
                        .Replace('.', '_')
                        .Replace('+', '_') + "_" + f.Name;
                    foreach (DefinitionItemOrdinalAttribute attribute in
                             f.GetCustomAttributes(typeof(DefinitionItemOrdinalAttribute), false))
                    {
                        itemInfo.Ordinal = attribute.Ordinal;
                    }
                    foreach (DefinitionItemSettingsAttribute attribute in
                             f.GetCustomAttributes(typeof(DefinitionItemSettingsAttribute), false))
                    {
                        itemInfo.Caption = attribute.CaptionOrSection;
                        if (attribute.IsUserDefined)
                        {
                            var content = Host.Settings.Get <string>(itemInfo.Caption);
                            itemInfo.Caption = null;
                            shouldAdd        = false;
                            if (string.IsNullOrEmpty(content))
                            {
                                break;
                            }
                            content.SplitEx((parts, i) =>
                            {
                                var pair = parts[i].SplitEx('=');
                                if (pair.Length < 2)
                                {
                                    return;
                                }
                                if (pair[0] == itemInfo.Value)
                                {
                                    itemInfo.Caption = pair[1];
                                    shouldAdd        = true;
                                }
                            }, '|');
                        }
                    }
                    if (itemInfo.Ordinal == -1)
                    {
                        itemInfo.Ordinal = itemInfo.Value.ToIntOrDefault();
                    }
                    if (shouldAdd)
                    {
                        l.Add(itemInfo);
                    }
                }
                l = l.OrderBy(i => i.Ordinal).ToList();
                _CacheItems.Add(type, l);
                return(l.Single(i => i.Value == (Convert.ToInt32(value).ToString())).Caption);
            }
        }
Example #5
0
 public static List <DefinitionItemInfo> GenerateItems(Type type)
 {
     if (type == null)
     {
         throw new ArgumentException("type");
     }
     if (_CacheItems.ContainsKey(type))
     {
         return(_CacheItems[type].ToList());
     }
     lock (_LockerItems)
     {
         if (_CacheItems.ContainsKey(type))
         {
             return(_CacheItems[type].ToList());
         }
         List <DefinitionItemInfo> l = new List <DefinitionItemInfo>();
         var instance      = Activator.CreateInstance(type);
         var shouldAdd     = true;
         int startPosition = type.FullName.IndexOf(NamespaceSeparator);
         if (startPosition == -1)
         {
             startPosition = 0;
         }
         foreach (FieldInfo f in type.GetFields())
         {
             shouldAdd = true;
             DefinitionItemInfo itemInfo = new DefinitionItemInfo();
             itemInfo.Ordinal      = 0;
             itemInfo.Instance     = instance;
             itemInfo.Name         = f.Name;
             itemInfo.Value        = f.GetValue(null).ToString();
             itemInfo.Caption      = f.Name;
             itemInfo.UniqueString =
                 type.FullName.Substring(startPosition)
                 .Replace(NamespaceSeparator + ".", string.Empty)
                 .Replace('.', '_')
                 .Replace('+', '_') + "_" + f.Name;
             foreach (DefinitionItemOrdinalAttribute attribute in
                      f.GetCustomAttributes(typeof(DefinitionItemOrdinalAttribute), false))
             {
                 itemInfo.Ordinal = attribute.Ordinal;
             }
             foreach (DefinitionItemSettingsAttribute attribute in
                      f.GetCustomAttributes(typeof(DefinitionItemSettingsAttribute), false))
             {
                 itemInfo.Caption = attribute.CaptionOrSection;
                 if (attribute.IsUserDefined)
                 {
                     var content = Host.Settings.Get <string>(itemInfo.Caption);
                     itemInfo.Caption = null;
                     shouldAdd        = false;
                     if (string.IsNullOrEmpty(content))
                     {
                         break;
                     }
                     content.SplitEx((parts, i) =>
                     {
                         var pair = parts[i].SplitEx('=');
                         if (pair.Length < 2)
                         {
                             return;
                         }
                         if (pair[0] == itemInfo.Value)
                         {
                             itemInfo.Caption = pair[1];
                             shouldAdd        = true;
                         }
                     }, '|');
                 }
             }
             if (shouldAdd)
             {
                 l.Add(itemInfo);
             }
         }
         l = l.OrderBy(i => i.Ordinal).ToList();
         _CacheItems.Add(type, l);
         return(l.ToList());
     }
 }
Example #6
0
 public DefinitionItemHelper(Type type)
 {
     _Items.AddRange(DefinitionHelper.GenerateItems(type));
     _MasterItem = DefinitionHelper.GenerateItem(type);
 }