/// <inheritdoc/>
public new DotNetQualifiedTypeName GetLocalized(DotNetQualifiedName other)
{
DotNetQualifiedTypeName clone = this.Clone();
clone.Localize(other);
return(clone);
}
/// <summary>
/// Load additional documentation information from the assembly itself.
/// </summary>
public virtual void AddAssemblyInfo(FieldInfo fieldInfo)
{
if (fieldInfo.Attributes.IsConstant())
{
Category = FieldCategory.Constant;
}
else if (fieldInfo.IsInitOnly)
{
Category = FieldCategory.ReadOnly;
}
else
{
Category = FieldCategory.Normal;
}
if (fieldInfo.IsPublic)
{
AccessModifier = AccessModifier.Public;
}
else if (fieldInfo.IsFamily)
{
AccessModifier = AccessModifier.Protected;
}
else if (fieldInfo.IsAssembly)
{
AccessModifier = AccessModifier.Internal;
}
else if (fieldInfo.IsFamilyOrAssembly)
{
AccessModifier = AccessModifier.InternalProtected;
}
else
{
AccessModifier = AccessModifier.Private;
}
if (fieldInfo.IsStatic)
{
IsStatic = true;
}
if (Category == FieldCategory.Constant)
{
try
{
ConstantValue = fieldInfo.GetRawConstantValue();
}
catch (Exception)
{
//System.InvalidOperationException: Operation is not valid due to the current state of the object.
}
}
TypeName = DotNetQualifiedTypeName.FromAssemblyInfo(fieldInfo.FieldType);
}
/// <summary>
/// Returns deep clone of parameter.
/// </summary>
public DotNetParameter Clone()
{
DotNetQualifiedTypeName clonedTypeName = null;
if (TypeName != null)
{
clonedTypeName = TypeName.Clone();
}
return(new DotNetParameter(clonedTypeName, Category));
}
/// <summary>
/// Parses a .Net XML documentation parameter type name.
/// </summary>
public static DotNetParameter FromVisualStudioXml(string typeName)
{
ParameterCategory category = ParameterCategory.Normal;
if (typeName.Contains("@"))
{
category = ParameterCategory.OutOrRef;
}
typeName = typeName.Replace("@", "");
return(new DotNetParameter(DotNetQualifiedTypeName.FromVisualStudioXml(typeName), category));
}
/// <summary>
/// Load additional documentation information from the assembly itself.
/// </summary>
public virtual void AddAssemblyInfo(PropertyInfo propertyInfo)
{
GetterMethod = DotNetPropertyMethod.FromAssemblyInfo(propertyInfo.GetGetMethod(true)); //true means also return non-public methods
SetterMethod = DotNetPropertyMethod.FromAssemblyInfo(propertyInfo.GetSetMethod(true));
TypeName = DotNetQualifiedTypeName.FromAssemblyInfo(propertyInfo.PropertyType);
Category = FieldCategory.Normal;
if (HasGetterMethod && GetterMethod.IsAbstract &&
HasSetterMethod && SetterMethod.IsAbstract)
{
Category = FieldCategory.Abstract;
}
}
/// <summary>
/// Returns deep clone of qualified name.
/// </summary>
public new DotNetQualifiedTypeName Clone()
{
DotNetQualifiedTypeName clonedFullNamespace = null;
if (FullNamespace != null)
{
clonedFullNamespace = FullTypeNamespace.Clone();
}
List <DotNetQualifiedTypeName> clonedGenericTypeParameters = GenericTypeParameters.Select(gtp => gtp.Clone()).ToList();
return(new DotNetQualifiedTypeName(localName, clonedGenericTypeParameters, clonedFullNamespace));
}
/// <summary>
/// Returns true if signatures match. Looks at types only, not at names.
/// </summary>
public bool MatchesSignature(ParameterInfo parameterInfo)
{
if (TypeName is DotNetReferenceClassGeneric)
{
return((TypeName as DotNetReferenceClassGeneric).MatchesSignature(parameterInfo.ParameterType));
}
else if (TypeName is DotNetReferenceMethodGeneric)
{
return((TypeName as DotNetReferenceMethodGeneric).MatchesSignature(parameterInfo.ParameterType));
}
else
{
string otherName = DotNetQualifiedTypeName.FromAssemblyInfo(parameterInfo.ParameterType).FullName;
return(FullTypeName == otherName);
}
}
/// <summary>
/// Returns true if this method's parameter list matches the reflected ParameterInfo.
/// </summary>
public bool MatchesArguments(ParameterInfo[] otherParameters)
{
if (Parameters.Count != otherParameters.Length)
{
return(false);
}
for (int i = 0; i < Parameters.Count; i++)
{
string otherName = DotNetQualifiedTypeName.FromAssemblyInfo(otherParameters[i].ParameterType).FullName;
if (Parameters[i].FullTypeName != otherName)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Parses a .Net XML documentation type name.
/// Not intended for type declarations. Intended for field types, property types, parameter types, and return types.
/// </summary>
public static new DotNetQualifiedTypeName FromVisualStudioXml(string typeName)
{
if (String.IsNullOrEmpty(typeName))
{
return(new DotNetQualifiedTypeName());
}
if (DotNetReferenceClassGeneric.HasExpectedVisualStudioXmlFormat(typeName))
{
return(DotNetReferenceClassGeneric.FromVisualStudioXml(typeName));
}
if (DotNetReferenceMethodGeneric.HasExpectedVisualStudioXmlFormat(typeName))
{
return(DotNetReferenceMethodGeneric.FromVisualStudioXml(typeName));
}
string[] dotDelimited = typeName.SplitIgnoreNested('.');
string localName = dotDelimited.Last();
string fullNamespace = (dotDelimited.Length == 1) ? null : String.Join(".", dotDelimited.Take(dotDelimited.Length - 1).ToArray());
//fully qualified generic type parameters
//such as System.Collections.Generic.List<T> which are formatted as System.Collections.Generic.List{`0}
List <DotNetQualifiedTypeName> parameters = new List <DotNetQualifiedTypeName>();
if (localName.EndsWith("}"))
{
string parameterSignature = localName.Substring(localName.IndexOf("{")).RemoveOuterBraces();
localName = localName.Substring(0, localName.IndexOf("{"));
parameters = parameterSignature.SplitIgnoreNested(',').Select(p => DotNetQualifiedTypeName.FromVisualStudioXml(p)).ToList();
}
if (String.IsNullOrEmpty(fullNamespace))
{
return(new DotNetQualifiedTypeName(localName, parameters));
}
return(new DotNetQualifiedTypeName(localName, parameters, DotNetQualifiedTypeName.FromVisualStudioXml(fullNamespace)));
}
/// <param name="localName"></param>
/// <param name="genericTypeParameters">List of generic-type parameters within this type.</param>
/// <param name="fullNamespace"></param>
/// <exception cref="ArgumentException"><paramref name="genericTypeParameters"/> cannot be null.</exception>
public DotNetQualifiedTypeName(string localName, List <DotNetQualifiedTypeName> genericTypeParameters, DotNetQualifiedTypeName fullNamespace)
{
if (genericTypeParameters == null)
{
throw new ArgumentException("GenericTypeParameters list cannot be null.", "genericTypeParameters");
}
this.localName = localName;
this.FullNamespace = fullNamespace;
GenericTypeParameters.AddRange(genericTypeParameters);
}
/// <summary></summary>
public DotNetQualifiedTypeName(string localName, DotNetQualifiedTypeName fullNamespace)
{
this.localName = localName;
this.FullNamespace = fullNamespace;
}
/// <summary>
/// Parses a System.Reflection.AssemblyInfo full name.
/// </summary>
/// <list>
/// <item>The escape character is backslash (\)</item>
/// <item>Nested types are separated with '+' instead of '.'</item>
/// <item>Class declaration of generic types are shown the same as .Net XML documentation: MyType`1 for one generic type</item>
/// <item>When a generic type is defined: System.Collections.Generic.List`1[U], where U is the type alias from the class declaration</item>
/// </list>
/// <param name="type"></param>
/// <param name="bubbleUpParameters">Optional. When reflection gives type information about a generic type nested inside a generic type, all the generic-type-arguments are listed in the inner-most type. This is for passing that information back up the chain of types.</param>
public static DotNetQualifiedTypeName FromAssemblyInfo(Type type, List <DotNetQualifiedTypeName> bubbleUpParameters = null)
{
if (type == null)
{
return(new DotNetQualifiedTypeName());
}
string typeName = type.FullName;
if (String.IsNullOrEmpty(typeName))
{
typeName = type.Name; //for generic types
}
typeName = typeName.Replace("@", "").Replace("&", ""); //out and ref modifiers do not differentiate method signatures
typeName = typeName.ReplaceUnescapedCharacters('\\', '+', '.');
if (String.IsNullOrEmpty(typeName))
{
typeName = ""; //todo: this should not be necessary, track down case in EarlyDocs
}
List <DotNetQualifiedTypeName> parameters = new List <DotNetQualifiedTypeName>();
int genericParameterCount = 0;
if (!type.IsGenericParameter)
{
if (type.ContainsGenericParameters) //generic type, with parameters unspecified
{
if (bubbleUpParameters != null && bubbleUpParameters.Count > 0) //actually, this is a generic type with specific parameter types that has a nested generic type within it
{
parameters = new List <DotNetQualifiedTypeName>(bubbleUpParameters);
}
else
{
parameters = type.GetGenericArguments().Select(a => FromAssemblyInfo(a)).ToList();
}
if (typeName.Contains("["))
{
typeName = typeName.Substring(0, typeName.IndexOf("["));
}
Int32.TryParse(typeName.Substring(typeName.LastIndexOf("`") + 1), out genericParameterCount);
typeName = typeName.Substring(0, typeName.LastIndexOf("`"));
}
else if (type.GetGenericArguments().Length > 0) //generic type, with specific parameter types
{
//TODO is this all correct? what case where these commented out statements meant to handle?
//int parameterPosition = 0;
foreach (Type parameter in type.GetGenericArguments())
{
parameters.Add(FromAssemblyInfo(parameter));
//parameters.Add(new DotNetReferenceClassGeneric(parameterPosition, parameter.Name));
//parameterPosition++;
}
typeName = typeName.Substring(0, typeName.IndexOf("["));
string numberString = typeName.Substring(typeName.LastIndexOf("`") + 1);
Int32.TryParse(numberString, out genericParameterCount);
typeName = typeName.Substring(0, typeName.LastIndexOf("`"));
if (bubbleUpParameters != null)
{
if (parameters.Count > bubbleUpParameters.Count)
{
throw new Exception("Type has more generic-type-parameters than expected.");
}
int remainder = bubbleUpParameters.Count - parameters.Count;
parameters = bubbleUpParameters.Skip(remainder).ToList();
bubbleUpParameters = bubbleUpParameters.Take(remainder).ToList();
}
}
}
int divider = typeName.LastIndexOf('.');
string localName = typeName;
string fullNamespaceString = null;
if (divider != -1)
{
localName = typeName.Substring(divider + 1);
fullNamespaceString = typeName.Substring(0, divider);
}
if (String.IsNullOrEmpty(fullNamespaceString))
{
return(new DotNetQualifiedTypeName(localName, parameters));
}
//so, if a generic type is nested inside another generic type, the Assembly info returns the full list of expected generic parameters to the innermost generic type
//which means I need to pass them back up
List <DotNetQualifiedTypeName> outerParameters = null;
if (genericParameterCount < parameters.Count)
{
outerParameters = parameters.Take(parameters.Count - genericParameterCount).ToList();
parameters = parameters.Skip(outerParameters.Count).ToList();
}
DotNetQualifiedTypeName fullNamespace = null;
if (type.DeclaringType != null)
{
fullNamespace = DotNetQualifiedTypeName.FromAssemblyInfo(type.DeclaringType, outerParameters);
}
else
{
fullNamespace = DotNetQualifiedTypeName.FromAssemblyInfo(fullNamespaceString);
}
return(new DotNetQualifiedTypeName(localName, parameters, fullNamespace));
}
/// <param name="typeName">Fully qualified data type name.</param>
/// <param name="category">Category of parameter.</param>
public DotNetParameter(DotNetQualifiedTypeName typeName, ParameterCategory category)
{
TypeName = typeName;
Category = category;
}
/// <remarks>Category defaults to Normal.</remarks>
/// <param name="typeName">Fully qualified data type name.</param>
public DotNetParameter(DotNetQualifiedTypeName typeName)
{
TypeName = typeName;
Category = ParameterCategory.Normal;
}
/// <summary>
/// Load additional documentation information from the assembly itself.
/// </summary>
public void AddAssemblyInfo(EventInfo eventInfo)
{
TypeName = DotNetQualifiedTypeName.FromAssemblyInfo(eventInfo.EventHandlerType);
}