/// <summary>
/// 获取枚举类型中的所有枚举项
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public static IList<EnumItem> GetEnumItems(System.Type t)
{
try
{
List<EnumItem> returnlist = new List<EnumItem>();
Array getEnumLists = Enum.GetValues(t);
if (getEnumLists != null)
{
if (getEnumLists.Length > 0)
{
for (int i = 0; i < getEnumLists.Length; i++)
{
EnumItem entity = new EnumItem();
string getEnumName = GetDescription(t, getEnumLists.GetValue(i));
entity.Name = getEnumName;
string getEnumValue = Convert.ToInt32(getEnumLists.GetValue(i)).ToString();
entity.Value = getEnumValue;
returnlist.Add(entity);
}
}
}
return returnlist;
}
catch (Exception)
{
throw;
}
}
// When set up for an argument
public override void SetupArgument(TypeHandlerAttribute attr, ArgumentInfo arginfo)
{
defaultvalue = new EnumItem("0", "0");
base.SetupArgument(attr, arginfo);
// Create enum list reference
list = CreateEnumList();
// Add default value
list.Insert(0, defaultvalue);
}
private static void ApplyDefault(OpenApiSchema schema, object defaultValue)
{
if (defaultValue.GetType().IsEnum)
{
schema.Default = new OpenApiString(EnumItem.Format(defaultValue));
}
else
{
schema.Default = new OpenApiString(defaultValue.ToString());
}
}
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
EnumItem enumItem = value as EnumItem;
if (enumItem == null)
{
return(0);
}
var enumValue = Enum.Parse(enumItem.Type, enumItem.Name);
return(enumValue);
}
private void BindNode()
{
m_BindState = false;
CBB_LeftParameterType.Items.Clear();
CBB_RightParameterType.Items.Clear();
CBB_RightParameter.Items.Clear();
CBB_CompareType.Items.Clear();
CustomEnum variableCustomEnum = MainForm.Instance.NodeTemplate.FindEnum("VariableType");
for (int i = 0; i < variableCustomEnum.Enums.Count; i++)
{
EnumItem enumItem = variableCustomEnum.Enums[i];
CBB_LeftParameterType.Items.Add(enumItem.EnumStr);
CBB_RightParameterType.Items.Add(enumItem.EnumStr);
}
//绑定左边参数类型
FieldDesigner leftFieldDesigner = m_Node.FindFieldByName("LeftType");
EnumFieldDesigner leftEnumFieldDesigner = leftFieldDesigner.Field as EnumFieldDesigner;
CBB_LeftParameterType.SelectedIndex = leftEnumFieldDesigner.ValueIndex;
//绑定右边参数类型
FieldDesigner rightFieldDesigner = m_Node.FindFieldByName("RightType");
EnumFieldDesigner rightEnumFieldDesigner = rightFieldDesigner.Field as EnumFieldDesigner;
CBB_RightParameterType.SelectedIndex = rightEnumFieldDesigner.ValueIndex;
//绑定左边参数名
BindLeftParameter(leftEnumFieldDesigner.Value);
//绑定右边参数
BindRightParameter(rightEnumFieldDesigner.Value);
//绑定比较类型
CustomEnum compareCustomEnum = MainForm.Instance.NodeTemplate.FindEnum("CompareType");
for (int i = 0; i < compareCustomEnum.Enums.Count; i++)
{
EnumItem enumItem = compareCustomEnum.Enums[i];
CBB_CompareType.Items.Add(enumItem.EnumStr);
}
FieldDesigner compareTypeFieldDesigner = m_Node.FindFieldByName("CompareType");
EnumFieldDesigner compareEnumFieldDesigner = compareTypeFieldDesigner.Field as EnumFieldDesigner;
CBB_CompareType.SelectedIndex = compareEnumFieldDesigner.ValueIndex;
m_BindState = true;
}
public CodeWriter GetValue( EnumItem item )
{
var writer = new CodeWriter();
writer.AppendText( ConvertName( item.Name ) );
writer.Indent = 0;
writer.Append( " = " );
writer.AppendText( item.Value );
writer.Indent = 0;
writer.Append( "," );
return writer;
}
public ServerMessagesViewModel()
{
if (WpfUtil.IsInDesignMode)
{
return;
}
foreach (var messageType in EnumItem <ServerMessageType> .GetEnumItems())
{
_count.Add(messageType.Value, new MessageTypeItem <ServerMessageType>(messageType, ServerMessageViewModel.GetIcon, ServerMessageViewModel.GetIconFill, RefreshQueryResults));
}
Init();
this.Add = new DelegateCommand(() => {
new ServerMessageViewModel(new ServerMessageData {
Id = Guid.NewGuid(),
MessageType = ServerMessageType.Info.GetName(),
Provider = "admin",
Content = string.Empty,
Timestamp = DateTime.MinValue
}).Edit.Execute(FormType.Add);
});
this.ClearKeyword = new DelegateCommand(() => {
this.Keyword = string.Empty;
});
this.Clear = new DelegateCommand(() => {
this.ShowDialog(new DialogWindowViewModel(message: "确定清空吗？", title: "确认", onYes: () => {
VirtualRoot.Execute(new ClearServerMessages());
}));
});
VirtualRoot.BuildEventPath <ServerMessagesClearedEvent>("清空了本地存储的服务器消息后刷新Vm内存", LogEnum.DevConsole,
action: message => {
UIThread.Execute(() => {
Init();
});
});
VirtualRoot.BuildEventPath <NewServerMessageLoadedEvent>("从服务器加载了新消息后刷新Vm内存", LogEnum.DevConsole,
action: message => {
UIThread.Execute(() => {
foreach (var item in message.Data)
{
var vm = new ServerMessageViewModel(item);
_serverMessageVms.Insert(0, vm);
if (IsSatisfyQuery(vm))
{
_queyResults.Insert(0, vm);
}
}
OnPropertyChanged(nameof(IsNoRecord));
});
});
_serverMessageVms = new ObservableCollection <ServerMessageViewModel>(NTMinerRoot.Instance.ServerMessageSet.Select(a => new ServerMessageViewModel(a)));
}
public static LinkedList <EnumItem <Corpus.Tag.NT> > roleTag(LinkedList <Vertex> vertexList, WordNet wordNetAll)
{
LinkedList <EnumItem <Corpus.Tag.NT> > tagList = new LinkedList <EnumItem <Corpus.Tag.NT> >();
foreach (Vertex vertex in vertexList)
{
// 构成更长的
Nature nature = vertex.guessNature();
switch (nature)
{
case Nature.nz:
{
if (vertex.getAttribute().totalFrequency <= 1000)
{
tagList.AddLast(new EnumItem <Corpus.Tag.NT>(Corpus.Tag.NT.F, 1000));
}
else
{
break;
}
}
continue;
case Nature.ni:
case Nature.nic:
case Nature.nis:
case Nature.nit:
{
EnumItem <Corpus.Tag.NT> ntEnumItem = new EnumItem <Corpus.Tag.NT>(Corpus.Tag.NT.K, 1000);
ntEnumItem.addLabel(Corpus.Tag.NT.D, 1000);
tagList.AddLast(ntEnumItem);
}
continue;
case Nature.m:
{
EnumItem <Corpus.Tag.NT> ntEnumItem = new EnumItem <Corpus.Tag.NT>(Corpus.Tag.NT.M, 1000);
tagList.AddLast(ntEnumItem);
}
continue;
}
EnumItem <Corpus.Tag.NT> NTEnumItem = OrganizationDictionary.dictionary.get(vertex.word); // 此处用等效词，更加精准
if (NTEnumItem == null)
{
NTEnumItem = new EnumItem <Corpus.Tag.NT>(Corpus.Tag.NT.Z, OrganizationDictionary.transformMatrixDictionary.getTotalFrequency(Corpus.Tag.NT.Z));
}
tagList.AddLast(NTEnumItem);
}
return(tagList);
}
//设置多选下拉列表_公司和事业部
private void SetMulComboCompany()
{
//定义List<EnumItem>用于存储下拉列表枚举值；
List <EnumItem> list = new List <EnumItem>();
//外贸公司
EnumItem item1 = new EnumItem();
item1.Caption = new LocaleValue("外贸公司", base.Context.UserLocale.LCID);
item1.EnumId = "外贸公司";
item1.Value = "外贸公司";
list.Add(item1);
//知客
EnumItem item2 = new EnumItem();
item2.Caption = new LocaleValue("知客", base.Context.UserLocale.LCID);
item2.EnumId = "知客";
item2.Value = "知客";
list.Add(item2);
//千源
EnumItem item3 = new EnumItem();
item3.Caption = new LocaleValue("千源", base.Context.UserLocale.LCID);
item3.EnumId = "千源";
item3.Value = "千源";
list.Add(item3);
string sql = string.Format(@" SELECT DISTINCT
DEP_L.FNAME
FROM T_BD_DEPARTMENT DEP
LEFT JOIN T_BD_DEPARTMENT_L DEP_L
ON DEP.FDEPTID = DEP_L.FDEPTID AND DEP_L.FLOCALEID = '2052'
WHERE DEP.FDOCUMENTSTATUS = 'C' AND DEP.FFORBIDSTATUS = 'A' AND DEP_L.FNAME LIKE '%事业部%'
ORDER BY DEP_L.FNAME
");
DynamicObjectCollection result = DBUtils.ExecuteDynamicObject(this.Context, sql);
if (result != null && result.Count > 0)
{
foreach (DynamicObject obj in result)
{
string name = Convert.ToString(obj["FNAME"]);
EnumItem item = new EnumItem();
item.Caption = new LocaleValue(name, base.Context.UserLocale.LCID);
item.EnumId = string.Format("{0}", name);
item.Value = string.Format("{0}", name);
list.Add(item);
}
}
//SetComboItems绑定值
this.View.GetControl <ComboFieldEditor>("FCompany_Filter").SetComboItems(list);
this.View.Model.SetValue("FCompany_Filter", "外贸公司");
}
public static LinkedList <EnumItem <Corpus.Tag.NS> > roleTag(LinkedList <Vertex> vertexList, WordNet wordNetAll)
{
LinkedList <EnumItem <Corpus.Tag.NS> > tagList = new LinkedList <EnumItem <Corpus.Tag.NS> >();
LinkedList <Vertex> .Enumerator listIterator = vertexList.GetEnumerator();
// int line = 0;
while (listIterator.MoveNext())
{
Vertex vertex = listIterator.Current;
// 构成更长的
// if (Nature.ns == vertex.getNature() && vertex.getAttribute().totalFrequency <= 1000)
// {
// String value = vertex.realWord;
// int longestSuffixLength = PlaceSuffixDictionary.dictionary.getLongestSuffixLength(value);
// int wordLength = value.length() - longestSuffixLength;
// if (longestSuffixLength != 0 && wordLength != 0)
// {
// listIterator.remove();
// for (int l = 0, tag = NS.D.ordinal(); l < wordLength; ++l, ++tag)
// {
// listIterator.add(wordNetAll.getFirst(line + l));
// tagList.add(new EnumItem<>(NS.values()[tag], 1000));
// }
// listIterator.add(wordNetAll.get(line + wordLength, longestSuffixLength));
// tagList.add(new EnumItem<>(NS.H, 1000));
// line += vertex.realWord.length();
// continue;
// }
// }
if (Nature.ns == vertex.getNature() && vertex.getAttribute().totalFrequency <= 1000)
{
if (vertex.realWord.Length < 3) // 二字地名，认为其可以再接一个后缀或前缀
{
tagList.AddLast(new EnumItem <Corpus.Tag.NS>(Corpus.Tag.NS.H, (int)Corpus.Tag.NS.G));
}
else
{
tagList.AddLast(new EnumItem <Corpus.Tag.NS>(Corpus.Tag.NS.G)); // 否则只可以再加后缀
}
continue;
}
EnumItem <Corpus.Tag.NS> NSEnumItem = PlaceDictionary.dictionary.get(vertex.word); // 此处用等效词，更加精准
if (NSEnumItem == null)
{
NSEnumItem = new EnumItem <Corpus.Tag.NS>(Corpus.Tag.NS.Z, PlaceDictionary.transformMatrixDictionary.getTotalFrequency(Corpus.Tag.NS.Z));
}
tagList.AddLast(NSEnumItem);
// line += vertex.realWord.length();
}
return(tagList);
}
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (!TypeHelper.IsSerializeAttribute(context.Type) &&
!TypeHelper.IsEnumerable(context.Type) &&
context.Type != typeof(object))
{
//if (context.Type.Name == "UserReg")
//{ }
schema.Type = "object";
schema.Properties.Clear();
schema.AdditionalPropertiesAllowed = true;
OpenApiSchema baseSchema = GetBaseSchema(context);
if (baseSchema != null)
{
schema.AllOf = new List <OpenApiSchema> {
baseSchema
};
}
if (TypeHelper.IsBaseType(context.Type, typeof(DBItem)))
{
var table = DBTable.GetTableAttributeInherit(context.Type);
if (table != null)
{
ApplyTable(schema, context, table);
return;
}
}
ApplyObject(schema, context);
}
else if (context.Type.IsEnum)
{
var items = EnumItem.GetEnumItems(context.Type);
var namesArray = new OpenApiArray();
namesArray.AddRange(items.Select(p => new OpenApiString(p.Name)));
schema.Extensions.Add("x-enumNames", namesArray);
var textArray = new OpenApiArray();
textArray.AddRange(items.Select(p => new OpenApiString(p.Text)));
schema.Extensions.Add("x-enumMembers", textArray);
if (context.Type.GetCustomAttribute <FlagsAttribute>() != null)
{
schema.Extensions.Add("x-flags", new OpenApiInteger(Enum.GetValues(context.Type).Cast <int>().First()));
}
}
}
private void CreateEnumItems(EnumControl control, IEnumerable newItems)
{
foreach (EnumItemElement newItem in newItems)
{
var item = new EnumItem();
item.DataContext = newItem;
SetBinding(item, EnumItem.ItemNameProperty, "Name");
SetBinding(item, EnumItem.LabelProperty, "Label");
//SetBinding(item, EnumItem.ValueProperty, "Value");
control.Items.Add(item);
}
}
public override DataItem CreateData(UndoRedoManager undoRedo)
{
var item = new EnumItem(this, undoRedo);
item.Value = Default;
foreach (var att in Attributes)
{
var attItem = att.CreateData(undoRedo);
item.Attributes.Add(attItem);
}
return(item);
}
public static IEnumItem[] GetEnumItems <T>()
{
var items = Enum.GetValues(typeof(T));
var result = new List <IEnumItem>();
foreach (var item in items)
{
var vt = new EnumItem {
Value = (int)item, Text = item.ToString()
};
result.Add(vt);
}
return(result.ToArray());
}
private void dyLoadLeaveType()
{
string FDocumentStatus = CZ_GetCommonField("DocumentStatus");
if (FDocumentStatus == "Z" || FDocumentStatus == "A" || FDocumentStatus == "D")
{
//获取请假类别
List <EnumItem> list = new List <EnumItem>();
string sql = @"select FCAPTION,fi.FENUMID,FVALUE from T_META_FORMENUMITEM fi
inner join T_META_FORMENUMITEM_L fil on fil.FENUMID=fi.FENUMID
inner join T_META_FORMENUM_L fl on fl.FID=fi.FID
where fl.FNAME='OA请假类别'";
var obj = CZDB_GetData(sql);
sql = "EXEC proc_czly_GetSalesmanIdByUserId @FUserId='" + this.Context.UserId.ToString() + "'";
var Smans = CZDB_GetData(sql);
if (Smans.Count > 0)
{
foreach (var row in obj)
{
if (row["FVALUE"].ToString() == "3")
{
continue;
}
EnumItem item = new EnumItem();
item.Caption = new Kingdee.BOS.LocaleValue(row["FCAPTION"].ToString());
item.EnumId = row["FENUMID"].ToString();
item.Value = row["FVALUE"].ToString();
list.Add(item);
}
}
else
{
foreach (var row in obj)
{
if (row["FVALUE"].ToString() == "20")
{
continue;
}
EnumItem item = new EnumItem();
item.Caption = new Kingdee.BOS.LocaleValue(row["FCAPTION"].ToString());
item.EnumId = row["FENUMID"].ToString();
item.Value = row["FVALUE"].ToString();
list.Add(item);
}
}
//this.View.ShowMessage(list.Count.ToString());
this.View.GetControl <ComboFieldEditor>("FLeaveType").SetComboItems(list);
}
}
public override void SetValue(object value)
{
this.value = null;
// Input null?
if (value == null)
{
this.value = new EnumItem("", "");
}
else
{
// No match found yet?
if (this.value == null)
{
// First try to match the value against the enum values
foreach (EnumItem item in list)
{
// Matching value?
if (item.Value == value.ToString())
{
// Set this value
this.value = item;
}
}
}
// No match found yet?
if (this.value == null)
{
// Try to match against the titles
foreach (EnumItem item in list)
{
// Matching value?
if (item.Title.ToLowerInvariant() == value.ToString().ToLowerInvariant())
{
// Set this value
this.value = item;
}
}
}
// Still no match found?
if (this.value == null)
{
// Make a dummy value
this.value = new EnumItem(value.ToString(), value.ToString());
}
}
}
// When set up for a universal field
public override void SetupField(TypeHandlerAttribute attr, UniversalFieldInfo fieldinfo)
{
defaultvalue = (fieldinfo != null ? new EnumItem(fieldinfo.Default.ToString(), fieldinfo.Default.ToString()) : new EnumItem("0", "0")); //mxd
base.SetupField(attr, fieldinfo);
// Keep enum list reference
if (fieldinfo != null)
{
list = fieldinfo.Enum;
}
else
{
list = new EnumList();
}
}
public static EnumItem <T> GetEnum <T>(this Type enumType, int value) where T : Attribute
{
EnumItem <T> result = null;
var list = GetEnumListItem <T>(enumType);
foreach (var item in list)
{
if (item.Value == value)
{
result = item;
break;
}
}
return(result);
}
/// <summary>
/// 获取枚举的相关信息
/// </summary>
/// <param name="e">枚举的类型</param>
/// <returns></returns>
public static List <EnumItem> GetEnumItems(Type e)
{
List <EnumItem> itemList = new List <EnumItem>();
foreach (Enum v in Enum.GetValues(e))
{
EnumItem item = v.GetBaseDescription();
item.EnumKey = Convert.ToInt32(v);
item.EnumValue = v.ToString();
itemList.Add(item);
}
return(itemList);
}
public static EnumItem GetEnum(this Type enumType, string nameOrDescript)
{
EnumItem result = null;
var list = GetEnumListItem(enumType);
foreach (var item in list)
{
if (item.Name == nameOrDescript || item.Description == nameOrDescript)
{
result = item;
break;
}
}
return(result);
}
public static T DescriptionToEnum <T>(this string desStr)
{
T enumT = default(T);
IList <EnumItem> items = EnumExtensions.ToListEnumItem <T>();
EnumItem item = items.Where(e => e.EnumDescript == desStr).FirstOrDefault();
if (item != null && !string.IsNullOrEmpty(item.EnumDescript))
{
if (Enum.IsDefined(typeof(T), item.EnumKey))
{
enumT = (T)Enum.Parse(typeof(T), item.EnumKey);
}
}
return(enumT);
}
private void CBB_CompareType_SelectedIndexChanged(object sender, EventArgs e)
{
if (!m_BindState)
{
return;
}
CustomEnum compareCustomEnum = MainForm.Instance.NodeTemplate.FindEnum("CompareType");
EnumItem enumItem = compareCustomEnum.FindEnum(CBB_CompareType.Text.Trim());
FieldDesigner compareFieldDesigner = m_Node.FindFieldByName("CompareType");
EnumFieldDesigner compareEnumFieldDesigner = compareFieldDesigner.Field as EnumFieldDesigner;
compareEnumFieldDesigner.Value = enumItem.EnumStr;
}
public static EnumItem GetEnum(this Type enumType, int value)
{
EnumItem result = null;
var list = GetEnumListItem(enumType);
foreach (var item in list)
{
if (item.Value == value)
{
result = item;
break;
}
}
return(result);
}
private MinerClientsViewModel()
{
this._mineStatusEnumItem = this.MineStatusEnumItems.FirstOrDefault(a => a.Value == MineStatus.All);
this._mainCoin = CoinViewModel.PleaseSelect;
this._dualCoin = CoinViewModel.PleaseSelect;
this._selectedMineWork = MineWorkViewModel.PleaseSelect;
this._selectedMinerGroup = MinerGroupViewModel.PleaseSelect;
this._mainCoinPool = _mainCoin.OptionPools.First();
this._dualCoinPool = _dualCoin.OptionPools.First();
this._mainCoinWallet = WalletViewModel.PleaseSelect;
this._dualCoinWallet = WalletViewModel.PleaseSelect;
this.PageUp = new DelegateCommand(() => {
this.MinerClientPageIndex = this.MinerClientPageIndex - 1;
});
this.PageDown = new DelegateCommand(() => {
this.MinerClientPageIndex = this.MinerClientPageIndex + 1;
});
this.PageFirst = new DelegateCommand(() => {
this.MinerClientPageIndex = 1;
});
this.PageLast = new DelegateCommand(() => {
this.MinerClientPageIndex = MinerClientPageCount;
});
this.PageRefresh = new DelegateCommand(() => {
QueryMinerClients();
});
this.ManageCoin = new DelegateCommand <CoinViewModel>((coinVm) => {
CoinPageViewModel.Current.CurrentCoin = coinVm;
CoinPage.ShowWindow();
});
this.ManagePool = new DelegateCommand <CoinViewModel>((coinVm) => {
this.ManageCoin.Execute(coinVm);
CoinPageViewModel.Current.SwitchToPoolTab();
});
this.ManageWallet = new DelegateCommand <CoinViewModel>((coinVm) => {
this.ManageCoin.Execute(coinVm);
CoinPageViewModel.Current.SwitchToWalletTab();
});
System.Timers.Timer t = new System.Timers.Timer(50);
t.Elapsed += (object sender, System.Timers.ElapsedEventArgs e) => {
if (this._logoRotateTransformAngle > 3600000)
{
this._logoRotateTransformAngle = 0;
}
this.LogoRotateTransformAngle += 50;
};
t.Start();
}
static Dictionary<long, EnumItem> createEnumMap(Type t)
{
Dictionary<long, EnumItem> _map = new Dictionary<long, EnumItem>();
FieldInfo[] fields = t.GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo f in fields)
{
long v = Convert.ToInt64(f.GetValue(null));
DescriptionAttribute[] ds = (DescriptionAttribute[])f.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (ds.Length > 0)
{
_map[v] = new EnumItem { Value = v, Description = ds[0].Description };
}
}
return _map;
}
public static List <EnumItem> GetList(Type type)
{
List <EnumItem> arraylist = new List <EnumItem>();
var values = Enum.GetValues(type);
foreach (Enum v in values)
{
EnumItem item = new EnumItem();
item.Text = GetDescription(v);
item.Value = Convert.ToInt32(v).ToString();
arraylist.Add(item);
}
return(arraylist);
}
public override object EditValue(ITypeDescriptorContext context, IServiceProvider provider, object value)
{
_editorService = (IWindowsFormsEditorService)provider.GetService(typeof(IWindowsFormsEditorService));
ListBox listBox = new ListBox();
listBox.DisplayMember = "Name"; // EnumItem 'Name' property
listBox.IntegralHeight = true;
listBox.SelectionMode = SelectionMode.One;
listBox.MouseClick += OnListBoxMouseClick;
listBox.KeyDown += OnListBoxKeyDown;
listBox.PreviewKeyDown += OnListBoxPreviewKeyDown;
Type enumType = value.GetType();
if (!enumType.IsEnum)
{
throw new InvalidOperationException();
}
foreach (FieldInfo fi in enumType.GetFields(BindingFlags.Public | BindingFlags.Static))
{
EnumItem item = new EnumItem();
item.Value = fi.GetValue(null);
object[] atts = fi.GetCustomAttributes(typeof(DescriptionAttribute), true);
if (atts != null && atts.Length > 0)
{
item.Name = ((DescriptionAttribute)atts[0]).Description;
}
else
{
item.Name = fi.Name;
}
int index = listBox.Items.Add(item);
if (fi.Name == value.ToString())
{
listBox.SetSelected(index, true);
}
}
_cancel = false;
_editorService.DropDownControl(listBox);
if (_cancel || listBox.SelectedIndices.Count == 0)
{
return(value);
}
return(((EnumItem)listBox.SelectedItem).Value);
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value == null)
{
return(null);
}
var list = parameter as List <EnumItem>;
if (list != null)
{
EnumItem temp = list.FirstOrDefault(e => e.Name == value.ToString());
if (temp != null)
{
temp.IsSelected = true;
return(temp);
}
}
return(null);
}
/// <summary>
/// 生成代码文本
/// </summary>
/// <param name="enumInfo">枚举信息</param>
/// <param name="namespacePfx">命名空间前辍</param>
/// <returns>枚举名</returns>
public string BuilderCodeText(EnumInfo enumInfo, string namespacePfx)
{
string name = $"{enumInfo.Code.FristUpper()}Enum";
if (generatorNames.Contains(name))
{
return(name);
}
StringBuilder itemCode = new StringBuilder();
for (int i = 0; i < enumInfo.Items.Length; i++)
{
EnumItem enumItem = enumInfo.Items[i];
itemCode.Append(ItemTemplate
.Replace("|Description|", enumItem.Desc)
.Replace("|CODE|", enumItem.Code)
.Replace("|VALUE|", enumItem.Value.ToString()));
if (i == enumInfo.Items.Length - 1)
{
continue;
}
itemCode.AppendLine();
itemCode.AppendLine();
}
string desc = string.IsNullOrWhiteSpace(enumInfo.Desc) ? name : enumInfo.Desc;
string codeText = ClassTemplate
.Replace("|NamespacePfx|", namespacePfx)
.Replace("|Description|", desc)
.Replace("|Name|", name)
.Replace("|Item|", itemCode.ToString());
FOLDER_ROOT.CreateNotExistsDirectory();
$"{FOLDER_ROOT}{name}.cs".WriteFileContent(codeText);
generatorNames.Add(name);
return(name);
}
/// <summary>
/// 获取枚举项
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static List <EnumItem> GetEnumItems(this Type type)
{
if (!type.IsEnum)
{
throw new ArgumentException($"类型:{type.FullName}不是有效的枚举类型。");
}
var result = new List <EnumItem>();
foreach (var item in Enum.GetValues(type))
{
var tmp = new EnumItem();
tmp.Value = (int)item;
tmp.Name = Enum.GetName(type, item);
result.Add(tmp);
}
return(result);
}
public static IEnumItem GetEnumItem(Type enumType, Enum item)
{
var name = item.ToString();
var mi = enumType.GetMember(name).First();
var dtAttribute = mi.GetCustomAttributes(typeof(DisplayTextAttribute), false).FirstOrDefault();
var text = name;
if (dtAttribute != null)
{
text = (dtAttribute as DisplayTextAttribute).DisplayText;
}
var enumItem = new EnumItem {
Value = Convert.ToInt32(item), Name = item.ToString(), Text = text
};
return(enumItem);
}
/*--------------------------------------------------------------------------------------------*/
private static Dictionary <string, object> BuildEnumItem(EnumItem pItem)
{
PropertyInfo[] props = pItem.GetType().GetProperties();
var map = new Dictionary <string, object>();
foreach (PropertyInfo pi in props)
{
object val = pi.GetValue(pItem, null);
if (val == null || (val as string) == "")
{
continue;
}
map.Add(pi.Name, val);
}
return(map);
}
public void Add(EnumItem enumItem)
{
this.KeyedEnumItems.Add(enumItem);
this.ValuedEnumItems.Add(enumItem);
}
/// <summary>
/// Analyze a enum type.
/// </summary>
/// <param name="helper">A htmlhelper.</param>
/// <param name="type">Type of enum.</param>
/// <returns></returns>
public static EnumItem[] EnumAnalyze(this HtmlHelper helper, Type type)
{
if (!type.IsEnum)
throw new ArgumentException(type.Name + " is not a enum type.");
if (!_EnumCache.ContainsKey(type))
{
var fields = type.GetFields(BindingFlags.Static | BindingFlags.Public);
EnumItem[] list = new EnumItem[fields.Length];
Type enumType = Enum.GetUnderlyingType(type);
for (int i = 0; i < fields.Length; i++)
{
var field = fields[i];
EnumItem item = new EnumItem();
DisplayAttribute display = field.GetCustomAttribute<DisplayAttribute>();
if (display == null)
item.Name = field.Name;
else
item.Name = display.Name;
item.Value = Convert.ChangeType(field.GetValue(null), enumType);
list[i] = item;
}
_EnumCache.Add(type, list);
}
return _EnumCache[type];
}
