/// <summary> Creates a new signature of a `interface`. </summary>
public static TypeSignature Interface(string name, TypeOrNamespace parent, Accessibility accessibility, params GenericParameter[] genericParameters) =>
new TypeSignature(name, parent, "interface",
accessibility: accessibility,
canOverride: true,
isAbstract: true,
isValueType: false,
typeParameters: genericParameters.ToImmutableArray()
);
/// <summary> Creates a new signature of a `class`. </summary>
public static TypeSignature Class(string name, TypeOrNamespace parent, Accessibility accessibility, bool canOverride = true, bool isAbstract = false, params GenericParameter[] genericParameters) =>
new TypeSignature(name, parent, "class",
accessibility: accessibility,
canOverride: canOverride,
isAbstract: isAbstract,
isValueType: false,
typeParameters: genericParameters.ToImmutableArray()
);
public void LoadCoreTypes()
{
var stringT = TypeSignature.FromType(typeof(string));
var dateTimeT = cx.FindTypeDef("System.DateTime");
Assert.False(stringT.CanOverride);
Assert.Empty(stringT.TypeParameters);
Assert.Equal("String", stringT.Name);
Assert.Equal("DateTime", dateTimeT.Name);
Assert.Equal(TypeOrNamespace.NamespaceSignature(NamespaceSignature.System), dateTimeT.Parent);
Assert.Equal(dateTimeT.Parent, stringT.Parent);
var enumerableT = TypeSignature.FromType(typeof(IEnumerable <>));
check.CheckJsonObject(new { stringT, dateTimeT, enumerableT });
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
unchecked {
return(((TypeOrNamespace != null ? TypeOrNamespace.GetHashCode() : 0) * 397) ^ (AssemblyNameOrFile != null ? AssemblyNameOrFile.GetHashCode() : 0));
}
}
public void NestedTypesWithInheritance()
{
var rootType = TypeSignature.Class("MyType", ns, Accessibility.APublic);
var type1 = TypeSignature.Class("A", rootType, Accessibility.APublic);
var type2 = type1.With(name: "B");
var typeDef = TypeDef.Empty(rootType).With(members: ImmutableArray.Create <MemberDef>(
new TypeDef(type1, null, ImmutableArray <SpecializedType> .Empty, ImmutableArray <MemberDef> .Empty),
new TypeDef(type2, new SpecializedType(type1, ImmutableArray <TypeReference> .Empty), ImmutableArray <SpecializedType> .Empty, ImmutableArray <MemberDef> .Empty)
));
cx.AddType(typeDef);
var rootType2 = typeDef.Signature.With(name: "MyType2");
cx.AddType(typeDef.With(
signature: rootType2,
extends: new SpecializedType(type2, ImmutableArray <TypeReference> .Empty),
members: typeDef.Members.OfType <TypeDef>().Select(m => m.With(signature: m.Signature.With(parent: TypeOrNamespace.TypeSignature(rootType2)))).ToImmutableArray <MemberDef>()
));
check.CheckOutput(cx);
}
/// <summary> Creates a new signature of a `sealed class` (i.e. class that can not be extended). </summary> public static TypeSignature SealedClass(string name, TypeOrNamespace parent, Accessibility accessibility, params GenericParameter[] genericParameters) => Class(name, parent, accessibility, canOverride: false, isAbstract: false, genericParameters);
