public bool Equals(IDotNetType type)
{
Argument.IsNotNull(() => type);
if (!(type is RuntimeType runtimeType))
{
return(false);
}
return(_type.Equals(runtimeType._type));
}
public bool IsSubclassOf(IDotNetType type)
{
Argument.IsNotNull(() => type);
if (!(type is RuntimeType runtimeType))
{
return(false);
}
return(_type.IsSubclassOf(runtimeType._type));
}
public bool Equals(IDotNetType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is NRType))
{
return(false);
}
return(this.type.Equals(((NRType)type).type));
}
public bool IsSubclassOf(IDotNetType type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (!(type is NRType baseType))
{
return(false);
}
return(this.type.GetAllBaseTypeDefinitions().Any(t => t.Equals(baseType.type)));
}
public override bool Equals(object obj)
{
if (this == obj)
{
return(true);
}
IDotNetType type = obj as IDotNetType;
if (type == null)
{
return(false);
}
return(this.DotNetType == type.DotNetType);
}
/// <summary>
/// Extension method that creates the array portion definition of a type definition in C# syntax.
/// </summary>
/// <param name="source">The source type to get the array information to format.</param>
/// <returns>The formatted array syntax for the target type, or null if no array data was provided in the type definition.</returns>
public static string FormatCSharpArraySignatureSyntax(this IDotNetType source)
{
if (source == null)
{
return(null);
}
if (!source.IsArray)
{
return(null);
}
var arraySignatureBuilder = new StringBuilder();
foreach (var sourceArrayDimension in source.ArrayDimensions)
{
arraySignatureBuilder.Append(sourceArrayDimension == 1
? $"{Symbols.ArrayDefinitionStart}{Symbols.ArrayDefinitionEnd}"
: $"{Symbols.ArrayDefinitionStart}{new string(',', sourceArrayDimension - 1)}{Symbols.ArrayDefinitionEnd}");
}
return(arraySignatureBuilder.ToString());
}
/// <summary>
/// Extension method that creates a C# signature for the tuple type.
/// </summary>
/// <param name="source">The target declaration syntax for a tuple.</param>
/// <returns>The formatted tuple or null if data is missing.</returns>
public static string FormatCSharpTupleSignatureSyntax(this IDotNetType source)
{
if (source == null)
{
return(null);
}
if (!source.IsTuple)
{
return(null);
}
if (!source.TupleTypes.Any())
{
return(null);
}
StringBuilder tupleSignature = new StringBuilder(Symbols.ParametersDefinitionStart);
int totalParameters = source.TupleTypes.Count;
int currentParameter = 0;
foreach (var sourceParameter in source.TupleTypes)
{
currentParameter++;
tupleSignature.Append(!sourceParameter.HasDefaultName
? $"{sourceParameter.TupleType.FormatCSharpFullTypeName()} {sourceParameter.Name} "
: sourceParameter.TupleType.FormatCSharpFullTypeName());
if (totalParameters > currentParameter)
{
tupleSignature.Append(", ");
}
}
tupleSignature.Append(Symbols.ParametersDefinitionEnd);
return(tupleSignature.ToString());
}
public bool Equals(IDotNetType type)
{
return(type is UnresolvableType && type.AssemblyQualifiedName == AssemblyQualifiedName);
}
public bool IsSubclassOf(IDotNetType type)
{
return(Equals(type));
}
/// <summary>
/// Extension method that returns a value declaration in the C# language format.
/// </summary>
/// <param name="source">The target type to create the value definition for.</param>
/// <param name="value">The value to be formatted.</param>
/// <returns>The definition of the value formatted for C#</returns>
public static string FormatCSharpValueSyntax(this IDotNetType source, string value)
{
if (source == null)
{
return(null);
}
if (!source.IsLoaded)
{
return(null);
}
if (source.Name == "Type" & source.Namespace == "System")
{
return($"typeof({value})");
}
if (source.IsEnum)
{
try
{
var enumData = source.GetEnumModel();
return(enumData?.FormatCSharpEnumTypeSyntax(value));
}
catch (Exception)
{
return(null);
}
}
if (!source.IsWellKnownType)
{
return(value);
}
string result = null;
switch (source.WellKnownType)
{
case WellKnownLanguageType.Void:
result = Keywords.Void;
break;
case WellKnownLanguageType.Boolean:
result = value.ToLower();
break;
case WellKnownLanguageType.Character:
result = $"'{value}'";
break;
case WellKnownLanguageType.String:
result = $"\"{value}\"";
break;
default:
result = value;
break;
}
return(result);
}
/// <summary>
/// Extension method that generates the default value syntax for a parameter in the C# language.
/// </summary>
/// <param name="source">The target default value to format.</param>
/// <param name="type">The target type of the value to be formatted.</param>
/// <returns>The fully formatted syntax for the default value or null if data was missing.</returns>
public static string FormatCSharpParameterDefaultValueSyntax(this IDotNetParameterDefaultValue source, IDotNetType type)
{
if (source == null)
{
return(null);
}
if (type == null)
{
return(null);
}
string result = null;
switch (source.ValueType)
{
case ParameterDefaultValueType.Value:
result = type.FormatCSharpValueSyntax(source.Value);
break;
case ParameterDefaultValueType.DefaultKeyWord:
result = Keywords.Default;
break;
case ParameterDefaultValueType.NullKeyword:
result = Keywords.Null;
break;
default:
result = null;
break;
}
return(result);
}
/// <summary>
/// Extension method that generates the fully qualified type name from the <see cref="IDotNetType"/> model in the C# format.
/// </summary>
/// <param name="source">The source type to get the full type name from.</param>
/// <returns>The fully qualified namespace and full type definition. Null if the type is missing or not loaded. </returns>
public static string FormatCSharpFullTypeName(this IDotNetType source)
{
if (source == null)
{
return(null);
}
if (!source.IsLoaded)
{
return(null);
}
string typeName = null;
string returnValue = null;
if (source.IsWellKnownType)
{
switch (source.WellKnownType)
{
case WellKnownLanguageType.NotWellKnown:
typeName = null;
break;
case WellKnownLanguageType.Object:
typeName = WellKnownTypes.Object;
break;
case WellKnownLanguageType.Void:
typeName = Keywords.Void;
break;
case WellKnownLanguageType.Boolean:
typeName = WellKnownTypes.Boolean;
break;
case WellKnownLanguageType.Character:
typeName = WellKnownTypes.Character;
break;
case WellKnownLanguageType.Signed8BitInteger:
typeName = WellKnownTypes.SByte;
break;
case WellKnownLanguageType.UnSigned8BitInteger:
typeName = WellKnownTypes.Byte;
break;
case WellKnownLanguageType.Signed16BitInteger:
typeName = WellKnownTypes.Short;
break;
case WellKnownLanguageType.Unsigned16BitInteger:
typeName = WellKnownTypes.Ushort;
break;
case WellKnownLanguageType.Signed32BitInteger:
typeName = WellKnownTypes.Int;
break;
case WellKnownLanguageType.Unsigned32BitInteger:
typeName = WellKnownTypes.Uint;
break;
case WellKnownLanguageType.Signed64BitInteger:
typeName = WellKnownTypes.Long;
break;
case WellKnownLanguageType.Unsigned64BitInteger:
typeName = WellKnownTypes.Ulong;
break;
case WellKnownLanguageType.Decimal:
typeName = WellKnownTypes.Decimal;
break;
case WellKnownLanguageType.Single:
typeName = WellKnownTypes.Float;
break;
case WellKnownLanguageType.Double:
typeName = WellKnownTypes.Double;
break;
case WellKnownLanguageType.Pointer:
typeName = WellKnownTypes.Pointer;
break;
case WellKnownLanguageType.PlatformPointer:
typeName = WellKnownTypes.PlatformPointer;
break;
case WellKnownLanguageType.DateTime:
typeName = WellKnownTypes.Datetime;
break;
case WellKnownLanguageType.String:
typeName = WellKnownTypes.String;
break;
default:
typeName = null;
break;
}
}
else
{
typeName = $"{source.Namespace}.{source.Name}";
}
returnValue = typeName;
if (source.IsGeneric)
{
returnValue = $"{typeName}{source.GenericParameters.FormatCSharpGenericSignatureSyntax()}";
}
if (source.IsArray)
{
returnValue = $"{typeName}{source.FormatCSharpArraySignatureSyntax()}";
}
if (source.IsTuple)
{
returnValue = source.FormatCSharpTupleSignatureSyntax();
}
return(returnValue);
}
public IDependencyPropertyDescriptor GetDependencyPropertyDescriptor(string name, IDotNetType ownerType, IDotNetType targetType)
{
Argument.IsNotNull(() => ownerType);
if (ownerType is RuntimeType runtimeType)
{
return(new RuntimeTypeDependencyPropertyDescriptor(runtimeType.Type, name));
}
if (ownerType is UnresolvableType)
{
return(new UnresolvableDependencyPropertyDescriptor());
}
throw new ArgumentException("Invalid type: " + ownerType.GetType());
}
public IDependencyPropertyDescriptor GetDependencyPropertyDescriptor(string name, IDotNetType ownerType, IDotNetType targetType)
{
if (ownerType == null)
{
throw new ArgumentNullException("ownerType");
}
if (ownerType is NRType)
{
return(new NRTypeDependencyPropertyDescriptor(((NRType)ownerType).Type, name));
}
if (ownerType is UnresolvableType)
{
return(new UnresolvableDependencyPropertyDescriptor());
}
throw new ArgumentException("Invalid IType: " + ownerType.GetType());
}
