/// <summary> /// Builds the lookup table for full type names. /// </summary> /// <param name="assemblies">The assembly lookup table in the data object.</param> private static IReadOnlyDictionary <string, TypeData> CreateTypeLookupTable(IEnumerable <AssemblyData> assemblies) { var typeDict = new Dictionary <string, TypeData>(StringComparer.OrdinalIgnoreCase); foreach (AssemblyData asm in assemblies) { if (asm.Types == null) { continue; } foreach (KeyValuePair <string, IReadOnlyDictionary <string, TypeData> > nspace in asm.Types) { foreach (TypeData type in nspace.Value.Values) { if (TypeNaming.IsGenericName(type.Name)) { string strippedTypeName = TypeNaming.StripGenericQuantifiers(type.Name); string strippedTypeFullName = TypeNaming.AssembleFullName(nspace.Key, strippedTypeName); typeDict[strippedTypeFullName] = type; } string typeFullName = TypeNaming.AssembleFullName(nspace.Key, type.Name); typeDict[typeFullName] = type; } } } return(typeDict); }
private FieldData AssembleField(FieldInfo field) { return(new FieldData() { Type = TypeNaming.GetFullTypeName(field.FieldType) }); }
private EventData AssembleEvent(EventInfo e) { return(new EventData() { HandlerType = TypeNaming.GetFullTypeName(e.EventHandlerType), IsMulticast = e.IsMulticast }); }
private PropertyData AssembleProperty(PropertyInfo property) { return(new PropertyData() { Accessors = GetAccessors(property), Type = TypeNaming.GetFullTypeName(property.PropertyType) }); }
private string[] AssembleConstructor(ConstructorInfo ctor) { var parameters = new List <string>(); foreach (ParameterInfo param in ctor.GetParameters()) { parameters.Add(TypeNaming.GetFullTypeName(param.ParameterType)); } return(parameters.ToArray()); }
private IndexerData AssembleIndexer(PropertyInfo indexer) { var paramTypes = new List <string>(); foreach (ParameterInfo param in indexer.GetIndexParameters()) { paramTypes.Add(TypeNaming.GetFullTypeName(param.ParameterType)); } return(new IndexerData() { Accessors = GetAccessors(indexer), ItemType = TypeNaming.GetFullTypeName(indexer.PropertyType), Parameters = paramTypes.ToArray() }); }
private string[] GetOutputType(IReadOnlyList <PSTypeName> outputType) { if (outputType == null || outputType.Count <= 0) { return(null); } var outputTypeData = new string[outputType.Count]; for (int i = 0; i < outputTypeData.Length; i++) { outputTypeData[i] = outputType[i].Type != null ? TypeNaming.GetFullTypeName(outputType[i].Type) : outputType[i].Name; } return(outputTypeData); }
private MethodData AssembleMethod(List <MethodInfo> methodOverloads) { var overloads = new List <string[]>(); foreach (MethodInfo overload in methodOverloads) { var parameters = new List <string>(); foreach (ParameterInfo param in overload.GetParameters()) { parameters.Add(TypeNaming.GetFullTypeName(param.ParameterType)); } overloads.Add(parameters.ToArray()); } return(new MethodData() { ReturnType = TypeNaming.GetFullTypeName(methodOverloads[0].ReturnType), OverloadParameters = overloads.ToArray() }); }
/// <summary> /// Returns the equivalent <see cref="string" /> representation of the name of this <see cref="Type" /> using the specified naming convention. /// </summary> /// <param name="type">The <see cref="Type" /> to be converted.</param> /// <param name="namingConvention">The <see cref="TypeNaming" /> that specifies the naming convention for the converted <see cref="Type" />.</param> /// <returns> /// An equivalent <see cref="string" /> representation of the name of this <see cref="Type" /> using the specified naming convention. /// </returns> public static string ToCSharpName(this Type type, TypeNaming namingConvention) { Check.ArgumentNull(type, nameof(type)); string name = namingConvention == TypeNaming.FullName ? type.GetNestedFullName() : type.GetNestedName(); string suffix = null; while (type.HasElementType) { suffix = new[] { "[]", "*", "&" }.First(name.EndsWith) + suffix; type = type.GetElementType(); name = namingConvention == TypeNaming.FullName ? type.GetNestedFullName() : type.GetNestedName(); } if (namingConvention == TypeNaming.CSharp) { name = TypeNames.ValueOrDefault(name, name); } if (type.IsGenericType) { string genericClass = name.SubstringUntil("`"); Type[] genericArguments = type.GetGenericArguments(); if (genericClass == nameof(Nullable) && genericArguments.Length == 1) { string nullableType = genericArguments.First().ToCSharpName(namingConvention); return((namingConvention == TypeNaming.CSharp ? nullableType + "?" : nameof(Nullable) + "<" + nullableType + ">") + suffix); } else { return(genericClass + "<" + genericArguments.Select(t => t.ToCSharpName(namingConvention)).AsString(", ") + ">" + suffix); } } else { return(name + suffix); } }
/// <summary> /// Get a data object describing the parameter given by the given metadata object. /// </summary> /// <param name="parameter">The metadata of the parameter to describe.</param> /// <returns>A data object describing the given parameter.</returns> public ParameterData GetSingleParameterData(ParameterMetadata parameter) { var parameterData = new ParameterData() { Dynamic = parameter.IsDynamic }; if (parameter.ParameterType != null) { parameterData.Type = TypeNaming.GetFullTypeName(parameter.ParameterType); } if (parameter.ParameterSets != null && parameter.ParameterSets.Count > 0) { parameterData.ParameterSets = new JsonCaseInsensitiveStringDictionary <ParameterSetData>(); foreach (KeyValuePair <string, ParameterSetMetadata> parameterSet in parameter.ParameterSets) { parameterData.ParameterSets[parameterSet.Key] = GetSingleParameterSetData(parameterSet.Value); } } return(parameterData); }