/// <summary> /// Used to create a NormalType to take advantage of caching (avoid parsing more than once) /// </summary> /// <param name="typeString">String representing the CLR type.</param> /// <returns>A NormalType instance</returns> public static NormalType CreateNormalType(string typeString) { if (string.IsNullOrEmpty(typeString)) { return(null); } typeString = typeString.Replace('{', '<').Replace('}', '>').Replace("``", ""); if (CachedTypes.TryGetValue(typeString, out var val)) { return(val); } else { NormalType ret = new NormalType(typeString); CachedTypes[typeString] = ret; return(ret); } }
private IEnumerable <NormalType> _GetSubTypes() { if (string.IsNullOrWhiteSpace(_GenericTypeString)) { yield break; } string genericString = _GenericTypeString; string nestStr = ""; int nestLevel = 0; for (int i = 0; i < genericString.Length; i++) { char ch = genericString[i]; if (ch == '<') { nestLevel++; nestStr += "<"; //if we're in a sub-nest, keep the < ie, the second < in "List<List<int>>" but not the first < } else if (ch == '>') { nestLevel--; nestStr += ">"; } else if (ch == ',' && nestLevel == 0) { yield return(NormalType.CreateNormalType(nestStr)); //generate our generic type link nestStr = ""; } else if (ch == ' ') { //do nothing, ignore spaces } else { nestStr += ch.ToString(); } } if (!string.IsNullOrEmpty(nestStr)) { yield return(NormalType.CreateNormalType(nestStr)); } }
/// <summary> /// Gets the method parameter type names from the member name. /// </summary> /// <returns>The method parameter type name list.</returns> /// <example> /// It will prepend the type kind character (<c>T:</c>) to the type string. /// <para>For <c>(System.String,System.Int32)</c>, returns <c>["T:System.String","T:System.Int32"]</c>.</para> /// It also handle generic type. /// <para>For <c>(System.Collections.Generic.IEnumerable{System.String})</c>, returns <c>["T:System.Collections.Generic.IEnumerable{System.String}"]</c>.</para> /// </example> public IEnumerable <NormalType> GetParamTypes() { if (_ParamTypes.Any()) //using the "new" stuff, get the parameter types from the param tags { return(_ParamTypes.Select(x => NormalType.CreateNormalType(x))); } else if (!_Name.Contains('(')) //if there's no parameters (non method/constructor) { return(Enumerable.Empty <NormalType>()); } else { string paramString = _Name.Split('(').Last().Trim(')'); int delta = 0; string ret = ""; var list = new List <string>(); foreach (var ch in paramString) { if (ch == '{') { delta++; } else if (ch == '}') { delta--; } else if (ch != ',' || delta != 0) { ret += ch.ToString(); } else if (delta == 0 && ch == ',') { list.Add(ret); ret = ""; } } return(list.Select(x => NormalType.CreateNormalType(x))); } }
/// <summary> /// Initializes a new instance of the <see cref="ParamUnit"/> class. /// </summary> /// <param name="element">The param XML element.</param> /// <param name="paramType">The parameter type corresponding to the param XML element.</param> /// <exception cref="ArgumentException">Throw if XML element name is not <c>param</c>.</exception> internal ParamUnit(XElement element, NormalType paramType, MemberName parentName) : base(element, "param", parentName) { _ParamType = paramType; }