public void AddRange()
{
CodeTypeParameter tp1 = new CodeTypeParameter();
CodeTypeParameter tp2 = new CodeTypeParameter();
CodeTypeParameter tp3 = new CodeTypeParameter();
CodeTypeParameterCollection coll1 = new CodeTypeParameterCollection();
coll1.Add(tp1);
coll1.Add(tp2);
CodeTypeParameterCollection coll2 = new CodeTypeParameterCollection();
coll2.Add(tp3);
coll2.AddRange(coll1);
Assert.AreEqual(3, coll2.Count, "#1");
Assert.AreEqual(1, coll2.IndexOf(tp1), "#2");
Assert.AreEqual(2, coll2.IndexOf(tp2), "#3");
Assert.AreEqual(0, coll2.IndexOf(tp3), "#4");
CodeTypeParameterCollection coll3 = new CodeTypeParameterCollection();
coll3.Add(tp3);
coll3.AddRange(new CodeTypeParameter[] { tp1, tp2 });
Assert.AreEqual(3, coll2.Count, "#5");
Assert.AreEqual(1, coll2.IndexOf(tp1), "#6");
Assert.AreEqual(2, coll2.IndexOf(tp2), "#7");
Assert.AreEqual(0, coll2.IndexOf(tp3), "#8");
}
public void Add()
{
CodeTypeParameter tp1 = new CodeTypeParameter();
CodeTypeParameter tp2 = new CodeTypeParameter();
CodeTypeParameterCollection coll = new CodeTypeParameterCollection();
Assert.AreEqual(0, coll.Add(tp1), "#1");
Assert.AreEqual(1, coll.Count, "#2");
Assert.AreEqual(0, coll.IndexOf(tp1), "#3");
Assert.AreEqual(1, coll.Add(tp2), "#4");
Assert.AreEqual(2, coll.Count, "#5");
Assert.AreEqual(1, coll.IndexOf(tp2), "#6");
}
public static CodeTypeParameterCollection GenericTypeParameters(Type t)
{
if (!t.IsGenericType) return null;
var p = new CodeTypeParameterCollection();
foreach (var genericParameter in t.GetGenericTypeDefinition().GetGenericArguments())
{
var param = new CodeTypeParameter(genericParameter.Name);
if ((genericParameter.GenericParameterAttributes &
GenericParameterAttributes.ReferenceTypeConstraint) != GenericParameterAttributes.None)
{
param.Constraints.Add(" class");
}
if ((genericParameter.GenericParameterAttributes &
GenericParameterAttributes.NotNullableValueTypeConstraint) != GenericParameterAttributes.None)
{
param.Constraints.Add(" struct");
}
var constraints = genericParameter.GetGenericParameterConstraints();
foreach (var constraintType in constraints)
{
param.Constraints.Add(
new CodeTypeReference(TypeUtils.GetParameterizedTemplateName(constraintType, false,
x => true)));
}
if ((genericParameter.GenericParameterAttributes &
GenericParameterAttributes.DefaultConstructorConstraint) != GenericParameterAttributes.None)
{
param.HasConstructorConstraint = true;
}
p.Add(param);
}
return p;
}
public void Constructor2()
{
CodeTypeParameter tp1 = new CodeTypeParameter();
CodeTypeParameter tp2 = new CodeTypeParameter();
CodeTypeParameterCollection c = new CodeTypeParameterCollection();
c.Add(tp1);
c.Add(tp2);
CodeTypeParameterCollection coll = new CodeTypeParameterCollection(c);
Assert.AreEqual(2, coll.Count, "#1");
Assert.AreEqual(0, coll.IndexOf(tp1), "#2");
Assert.AreEqual(1, coll.IndexOf(tp2), "#3");
}
public static void AddRange(this CodeTypeParameterCollection self, IEnumerable <CodeTypeParameter> ps)
{
foreach (var p in ps)
{
self.Add(p);
}
}
public void AddRange_Self()
{
CodeTypeParameterCollection coll = new CodeTypeParameterCollection();
coll.Add(new CodeTypeParameter());
Assert.AreEqual(1, coll.Count, "#1");
coll.AddRange(coll);
Assert.AreEqual(2, coll.Count, "#2");
}
private void FillGenericParameters(CodeTypeParameterCollection codes, IEnumerable <GenericParameter> defines)
{
foreach (var genericParameter in defines)
{
CodeTypeParameter t = new CodeTypeParameter(genericParameter.FullName);
if (genericParameter.IsContravariant)
{
t.HasConstructorConstraint = true;
}
foreach (var constraint in genericParameter.Constraints)
{
t.Constraints.Add(new CodeTypeReference(constraint.FullName));
}
FillCustomAttribute(t.CustomAttributes, genericParameter.CustomAttributes);
codes.Add(t);
}
}
static void PopulateGenericParameters(IGenericParameterProvider publicType, CodeTypeParameterCollection parameters, HashSet <string> excludeAttributes)
{
foreach (var parameter in publicType.GenericParameters)
{
// A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that
// or add it as a custom attribute
var name = parameter.Name;
if (parameter.IsCovariant)
{
name = "out " + name;
}
if (parameter.IsContravariant)
{
name = "in " + name;
}
var attributeCollection = new CodeAttributeDeclarationCollection();
if (parameter.HasCustomAttributes)
{
PopulateCustomAttributes(parameter, attributeCollection, excludeAttributes);
}
var typeParameter = new CodeTypeParameter(name)
{
HasConstructorConstraint =
parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint
};
typeParameter.CustomAttributes.AddRange(attributeCollection.OfType <CodeAttributeDeclaration>().ToArray());
if (parameter.HasNotNullableValueTypeConstraint)
{
typeParameter.Constraints.Add(" struct"); // Extra space is a hack!
}
if (parameter.HasReferenceTypeConstraint)
{
typeParameter.Constraints.Add(" class");
}
foreach (var constraint in parameter.Constraints.Where(t => t.FullName != "System.ValueType"))
{
// for generic constraints like IEnumerable<T> call to GetElementType() returns TypeReference with Name = !0
typeParameter.Constraints.Add(CreateCodeTypeReference(constraint /*.GetElementType()*/));
}
parameters.Add(typeParameter);
}
}
private static void PopulateGenericParameters(IGenericParameterProvider publicType,
CodeTypeParameterCollection parameters)
{
foreach (var parameter in publicType.GenericParameters)
{
if (parameter.HasCustomAttributes)
{
throw new NotImplementedException("Attributes on type parameters is not supported. And weird");
}
// A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that
// or add it as a custom attribute, which looks even weirder
var name = parameter.Name;
if (parameter.IsCovariant)
{
name = "out " + name;
}
if (parameter.IsContravariant)
{
name = "in " + name;
}
var typeParameter = new CodeTypeParameter(name)
{
HasConstructorConstraint =
parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint
};
if (parameter.HasNotNullableValueTypeConstraint)
{
typeParameter.Constraints.Add(" struct"); // Extra space is a hack!
}
if (parameter.HasReferenceTypeConstraint)
{
typeParameter.Constraints.Add(" class");
}
foreach (var constraint in parameter.Constraints.Where(t => t.FullName != "System.ValueType"))
{
typeParameter.Constraints.Add(CreateCodeTypeReference(constraint.GetElementType()));
}
parameters.Add(typeParameter);
}
}
public void Add_Null()
{
CodeTypeParameterCollection coll = new CodeTypeParameterCollection();
coll.Add((CodeTypeParameter)null);
}
static void PopulateGenericParameters(IGenericParameterProvider publicType, CodeTypeParameterCollection parameters, AttributeFilter attributeFilter, Func <GenericParameter, bool> shouldUseParameter)
{
foreach (var parameter in publicType.GenericParameters.Where(shouldUseParameter))
{
// A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that
// or add it as a custom attribute
var name = parameter.Name;
if (parameter.IsCovariant)
{
name = "out " + name;
}
if (parameter.IsContravariant)
{
name = "in " + name;
}
var attributeCollection = new CodeAttributeDeclarationCollection();
if (parameter.HasCustomAttributes)
{
PopulateCustomAttributes(parameter, attributeCollection, attributeFilter);
}
var typeParameter = new CodeTypeParameter(name)
{
HasConstructorConstraint =
parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint
};
typeParameter.CustomAttributes.AddRange(attributeCollection.OfType <CodeAttributeDeclaration>().ToArray());
var nullableConstraint = parameter.GetNullabilityMap().First();
var unmanagedConstraint = parameter.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.Runtime.CompilerServices.IsUnmanagedAttribute");
if (parameter.HasNotNullableValueTypeConstraint)
{
typeParameter.Constraints.Add(unmanagedConstraint ? " unmanaged" : " struct");
}
if (parameter.HasReferenceTypeConstraint)
{
typeParameter.Constraints.Add(nullableConstraint == true ? " class?" : " class");
}
else if (nullableConstraint == false)
{
typeParameter.Constraints.Add(" notnull");
}
using (NullableContext.Push(parameter))
{
foreach (var constraint in parameter.Constraints.Where(constraint => !IsSpecialConstraint(constraint)))
{
// for generic constraints like IEnumerable<T> call to GetElementType() returns TypeReference with Name = !0
var typeReference = constraint.ConstraintType /*.GetElementType()*/.CreateCodeTypeReference(constraint);
typeParameter.Constraints.Add(typeReference);
}
}
parameters.Add(typeParameter);
}
bool IsSpecialConstraint(GenericParameterConstraint constraint)
{
// struct
if (constraint.ConstraintType is TypeReference reference && reference.FullName == "System.ValueType")
{
return(true);
}
// unmanaged
if (constraint.ConstraintType.IsUnmanaged())
{
return(true);
}
return(false);
}
}
