public void ShouldConvertNonGenericType()
{
var sttc = new StringToTypeTreeConverter();
PureDI.TypeNameTree tt = sttc.Convert("MyClass");
Assert.AreEqual("MyClass", tt.TypeFullName);
}
internal bool Match(Type type, TypeNameTree typeNameTree)
{
// The full name returned by constructed generic types includes details
// of the parameter arguments inluding assembly and version. The name has to be curtailed
// e.g. MyClass`1[[System.Int32, mscorlib, version=4.0.0....]] -> MyClass`1
if (new string(type.FullName.TakeWhile(c => c != '[').ToArray()) == typeNameTree.TypeFullName)
{
IEnumerator <TypeNameTree> typeTreeIter = typeNameTree.GenericArguments.OrderBy(tt => tt.TypeFullName)
.GetEnumerator();
typeTreeIter.MoveNext();
foreach (Type childType in type.GenericTypeArguments.OrderBy(t => t.FullName))
{
if (Match(childType, typeTreeIter.Current))
{
typeTreeIter.MoveNext();
}
else
{
return(false); // children don't match
}
}
return(true); // current type tree and all its children match
}
return(false); // current tree type doesn't match
}
public void ShouldConvertSimpleGenericType()
{
var sttc = new StringToTypeTreeConverter();
PureDI.TypeNameTree tt = sttc.Convert("MyClass<System.Int32>");
Assert.AreEqual("MyClass`1", tt?.TypeFullName);
Assert.AreEqual(1, tt?.GenericArguments.Count);
Assert.AreEqual("System.Int32", tt?.GenericArguments[0]?.TypeFullName);
}
public void ShouldConvertGenericWithNultipleArguments()
{
var sttc = new StringToTypeTreeConverter();
PureDI.TypeNameTree tt = sttc.Convert("MyClass<System.Int32,string>");
Assert.AreEqual("MyClass`2", tt?.TypeFullName);
Assert.AreEqual(2, tt?.GenericArguments.Count);
Assert.AreEqual("System.Int32", tt?.GenericArguments[0]?.TypeFullName);
Assert.AreEqual("string", tt?.GenericArguments[1]?.TypeFullName);
}
public void SHouldConvertGenericWithMultipleLevels2()
{
var sttc = new StringToTypeTreeConverter();
PureDI.TypeNameTree tt = sttc.Convert("MyClass<MyClass2<System.Int32>,MyClass2<MyClass<string,string>>>");
Assert.AreEqual("MyClass`2", tt.TypeFullName);
Assert.AreEqual(2, tt?.GenericArguments.Count);
Assert.AreEqual("MyClass2`1", tt?.GenericArguments[0]?.TypeFullName);
Assert.AreEqual("MyClass2`1", tt?.GenericArguments[1]?.TypeFullName);
Assert.AreEqual("System.Int32", tt?.GenericArguments[0]?.GenericArguments[0]?.TypeFullName);
Assert.AreEqual("MyClass`2", tt?.GenericArguments[1]?.GenericArguments[0]?.TypeFullName);
}
private bool ProcessTypeSpec(IEnumerator <char> typeSpec, TypeNameTree parent)
{
StringBuilder sb = new StringBuilder();
while (typeSpec.MoveNext())
{
char ch;
switch (ch = typeSpec.Current)
{
case '<':
parent.GenericArguments.Add(this);
AddChildren(typeSpec);
this.typeFullName = sb.ToString() + "`" + genericArguments.Count;
sb.Clear();
bool bResult = typeSpec.MoveNext(); // eat the trailing ">"
return(bResult);
case ',':
this.typeFullName = sb.ToString();
sb.Clear();
parent.GenericArguments.Add(this);
return(true);
case '>':
if (sb.ToString() != string.Empty)
{
this.typeFullName = sb.ToString();
sb.Clear();
parent.GenericArguments.Add(this);
}
return(true);
default:
sb.Append(ch);
break;
}
}
if (sb.ToString() != string.Empty)
{
this.typeFullName = sb.ToString();
parent.GenericArguments.Add(this);
}
return(false);
}
private TypeNameTree(IEnumerator <char> typeSpec, TypeNameTree parent, out bool @continue)
{
@continue = ProcessTypeSpec(typeSpec, parent);
}
