/// <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);
}