public static string GetSystemName <T>(this T enumerationValue) where T : struct { var type = enumerationValue.GetType(); if (!type.IsEnum) { throw new ArgumentException(@"EnumerationValue must be of Enum type", nameof(enumerationValue)); } var name = enumerationValue.ToString(); // see if this is one of the valid types if (ValidTypes.Contains(type)) { //Tries to find a DescriptionAttribute for a potential friendly name //for the enum var memberInfo = type.GetMember(enumerationValue.ToString()); if (memberInfo.Length > 0) { var attrs = memberInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false); if (attrs.Length > 0) { //Pull out the description value name += " " + ((DescriptionAttribute)attrs[0]).Description; } } } return(name); }
private void checkType(Type type) { if (!ValidTypes.Contains(type)) { throw new InvalidOperationException($"The requested operation specified a type of {type}, which is invalid for this {nameof(DatabaseBackedStore)}."); } }
public void ValidTests(ValidTypes type, ValidUsers user, ValidDepts dept, ValidDates start, ValidDates end, ValidOptions option) { var request = CreateGetRequest(TypeMapper[type], null, null); GenerateParamValues(TypeToResource[type], user, dept, start, end, option, request); TestPerform(request); }
private void Load(string file) { var stopwatch = new Stopwatch(); stopwatch.Start(); Entries = new SortedDictionary <int, SteamApp>(); var index = 0; var cacheLines = File.ReadAllLines(file); foreach (var line in cacheLines) { try { var steamApp = new SteamApp(line); if (ValidTypes == null || ValidTypes.Contains(steamApp.Type.ToLower())) { Entries.Add(Int32.Parse(steamApp.Id), steamApp); } } catch (Exception ex) { Log.WriteLine($"{ CurrentClassName }.{ Utils.GetCurrentMethodName() }({ file }): index={ index }, line='{ line }', ex={ ex }"); } index++; } stopwatch.Stop(); var duration = stopwatch.ElapsedMilliseconds; Log.WriteLine($"{ CurrentClassName }.{ Utils.GetCurrentMethodName() }({ file }): [{ Entries.Count } entries] in { duration }ms"); CurrentCacheFile = file; }
/// <summary> /// query https://steamdb.info/search/?q=... for new SteamAppId-s /// also adds result to cache /// </summary> /// <param name="gameTitle"></param> /// <returns></returns> private SteamApp[] QuerySteamDb(string gameTitle) { var result = new List <SteamApp>(); var url = $"https://steamdb.info/search/?q={ WebUtility.UrlEncode(gameTitle) }"; var response = WebUtils.WebRequest(url); if (response == null) { return(result.ToArray()); } var tableElementStart = response.IndexOf("<tbody hidden>"); if (tableElementStart < 0) { return(result.ToArray()); } var tableBodyElement = response.Substring(tableElementStart, response.IndexOf("</tbody>", tableElementStart) - tableElementStart + "</tbody>".Length); tableBodyElement = tableBodyElement.Replace("<tbody hidden>", "<tbody>"); var decodedAndCleaned = WebUtility.HtmlDecode(tableBodyElement).Replace("&", string.Empty); var xmlDocument = new XmlDocument(); xmlDocument.LoadXml(decodedAndCleaned); foreach (XmlNode steamAppNode in xmlDocument.DocumentElement.ChildNodes) { var type = steamAppNode.ChildNodes[1].InnerText.ToLower(); if (!ValidTypes.Contains(type)) { continue; } var steamAppId = steamAppNode.Attributes["data-appid"].Value; var title = steamAppNode.ChildNodes[2].InnerText; // remove muted part of title title = Strings.RemoveFromTo(title, "<i class=\"muted\">", "</i>").Trim(); title = title.Trim('\n'); result.Add(SteamApp.Create(steamAppId, type, title)); } // add new steam apps to cache foreach (var newSteamApp in result) { AddOrUpdateSteamApp(newSteamApp); } return(result.ToArray()); }
public static bool AvaiValidCases(ValidTypes type) { var avaiTests = new List <ValidTypes>() { ValidTypes.PhaseClient, ValidTypes.PhaseRecruiter, ValidTypes.PhaseJob, ValidTypes.PhasePerson }; return(avaiTests.Contains(type) ? true : false); }
private void FileDescriptor_ChangedData(SimPe.Interfaces.Files.IPackedFileDescriptor pfd) { if (pfd == null) { return; } if (!ValidTypes.Contains(pfd.Type)) { return; } if (this[pfd.Group, pfd.Instance, pfd.Type] != null) { this[pfd.Group, pfd.Instance, pfd.Type] = null; } }
protected Type GetCastType(XElement setting, XAttribute elementType = null) { string type = null; string itemType = null; string elementTypeValue = null; var typeAttr = setting.Attribute(XName.Get(XmlTags.SETTING_TYPE)); var itemTypeAttr = setting.Attribute(XName.Get(XmlTags.SETTING_ITEMTYPE)); if (elementType != null) { elementTypeValue = elementType.Value; } else if (typeAttr != null) { elementTypeValue = typeAttr.Value; } if (itemTypeAttr != null) { itemType = itemTypeAttr.Value; } ValidTypes typeEnum = ParseType(elementTypeValue); switch (typeEnum) { case ValidTypes.Int: return(typeof(System.Int32)); case ValidTypes.Decimal: return(typeof(System.Decimal)); case ValidTypes.Bit: case ValidTypes.Bool: return(typeof(System.Boolean)); case ValidTypes.List: if (!setting.HasElements) { throw new Exception(String.Format("Type List found with empty elements, unable to get child type.")); } var qualifiedItemType = this.GetCastType(setting.Elements().First(), itemTypeAttr); type = String.Format(LIST_TYPE_MASK, qualifiedItemType.FullName, qualifiedItemType.Assembly.FullName); return(Type.GetType(type)); case ValidTypes.Dictionary: if (!setting.HasElements) { throw new Exception(String.Format("Type Dictionary found with empty elements, unable to get child type.")); } var itemCastedType = this.GetCastType(setting.Elements().First(), itemTypeAttr); type = String.Format(DICTIONARY_TYPE_MASK, itemCastedType.FullName, itemCastedType.Assembly.FullName); return(Type.GetType(type)); case ValidTypes.String: return(typeof(System.String)); case ValidTypes.Custom: default: var t = Type.GetType(elementTypeValue); if (t == null) { throw new LazyDeserializationNeededException(elementTypeValue); // Preparamos el XML para que se deserialze en destino, dado que no tenemos tipo en origen. } return(t); } }
protected object CreateConfigElement(XElement setting, XAttribute elementType = null) { string type = null; XAttribute itemTypeAttr = setting.Attribute(XName.Get(XmlTags.SETTING_ITEMTYPE)); if (setting.Attribute(XName.Get(XmlTags.SETTING_TYPE)) != null) { elementType = setting.Attribute(XName.Get(XmlTags.SETTING_TYPE)); } type = elementType != null ? elementType.Value : String.Empty; Type castType = typeof(System.String); MethodInfo addMethod = null; ValidTypes typeEnum = ParseType(type); switch (typeEnum) { case ValidTypes.Int: return(int.Parse(setting.Attribute(XName.Get(XmlTags.SETTING_VALUE)).Value)); case ValidTypes.Decimal: return(decimal.Parse(setting.Attribute(XName.Get(XmlTags.SETTING_VALUE)).Value, CultureInfo.InvariantCulture)); case ValidTypes.Bit: case ValidTypes.Bool: return(bool.Parse(setting.Attribute(XName.Get(XmlTags.SETTING_VALUE)).Value)); case ValidTypes.List: castType = this.GetCastType(setting, elementType); addMethod = castType.GetMethod(ADD_LIST_METHOD); var list = Activator.CreateInstance(castType); foreach (var element in setting.Elements()) { addMethod.Invoke(list, new object[] { this.CreateConfigElement(element, itemTypeAttr) }); } return(list); case ValidTypes.Dictionary: castType = this.GetCastType(setting, elementType); addMethod = castType.GetMethod(ADD_LIST_METHOD); var dic = Activator.CreateInstance(castType); foreach (var element in setting.Elements(XName.Get(XmlTags.INNER_KEYVALUE))) { var key = element.Attribute(XName.Get(XmlTags.SETTING_KEY)); addMethod.Invoke(dic, new object[] { key.Value, this.CreateConfigElement(element, itemTypeAttr) }); } return(dic); case ValidTypes.String: return(setting.Attribute(XName.Get(XmlTags.SETTING_VALUE)) != null?setting.Attribute(XName.Get(XmlTags.SETTING_VALUE)).Value : setting.Value); case ValidTypes.Custom: default: var serializer = new System.Xml.Serialization.XmlSerializer(this.GetCastType(setting, elementType)); var name = setting.Name.ToString().ToLowerInvariant(); if (name == XmlTags.INNER_ITEM || name == XmlTags.SETTING_TAG) { return(serializer.Deserialize(new StringReader(setting.FirstNode.ToString()))); } else { return(serializer.Deserialize(new StringReader(setting.ToString()))); } } }
public static IEnumerable <object[]> ValidTypeData() { return(ValidTypes.Select(i => new object[] { i })); }