public string ToStmt(CgMember cgMem, string cgNamespace, string cgInvokeOnName)
{
var paramNames = string.Format("({0});",
string.Join(",",
cgMem.Args.Select(
x => x.ArgType.StartsWith("ref ") ? string.Format("ref {0}", x.ArgName) : x.ArgName)));
if (cgMem.IsCtor)
{
return(string.Format("new {0}{1}", cgMem.TypeName, paramNames));
}
var stmtBldr = new StringBuilder();
if (!string.IsNullOrWhiteSpace(cgNamespace))
{
stmtBldr.AppendFormat("{0}.", cgNamespace);
}
if (!string.IsNullOrWhiteSpace(cgInvokeOnName))
{
stmtBldr.AppendFormat("{0}.", cgInvokeOnName);
}
stmtBldr.Append(cgMem.Name);
stmtBldr.Append(paramNames);
return(cgMem.TypeName == "void" ? stmtBldr.ToString() : string.Format("return {0}", stmtBldr));
}
public void TestGetMyEndEnclosure()
{
var testCgMem = new CgMember()
{
Name = "ddlScreeningLocation_SelectedIndexChanged",
Args =
new List <CgArg>
{
new CgArg {
ArgName = "sender", ArgType = "object"
},
new CgArg {
ArgName = "e", ArgType = "EventArgs"
}
},
IsMethod = true,
PdbModuleSymbols = new ModuleSymbols()
{
firstLine = new PdbLineNumber()
{
lineNumber = 356
}, lastLine = new PdbLineNumber()
{
lineNumber = 359
}
},
AccessModifier = CgAccessModifier.Family
};
var testSrcFile = TestFileContent;
var testResult = testCgMem.GetMyEndEnclosure(testSrcFile);
Console.WriteLine(string.Format("{0},{1}", testResult.Item1, testResult.Item2));
}
public void TestMyStartEnclosure()
{
var testCgMem = new CgMember()
{
Name = "GetYoMommaTypes",
IsMethod = true,
PdbModuleSymbols = new ModuleSymbols()
{
lastLine = new PdbLineNumber()
{
lineNumber = 365
}, firstLine = new PdbLineNumber()
{
lineNumber = 445
}
},
AccessModifier = CgAccessModifier.Family
};
var testResult = testCgMem.GetMyStartEnclosure(TestFileContent);
Assert.IsNotNull(testResult);
Assert.AreEqual(362, testResult.Item1);
Assert.AreEqual(1, testResult.Item2);
Console.WriteLine(string.Format("{0},{1}", testResult.Item1, testResult.Item2));
testCgMem = new CgMember()
{
Name = "ddlScreeningLocation_SelectedIndexChanged",
Args =
new List <CgArg>
{
new CgArg {
ArgName = "sender", ArgType = "object"
},
new CgArg {
ArgName = "e", ArgType = "EventArgs"
}
},
IsMethod = true,
PdbModuleSymbols = new ModuleSymbols()
{
lastLine = new PdbLineNumber()
{
lineNumber = 453
}, firstLine = new PdbLineNumber()
{
lineNumber = 458
}
},
AccessModifier = CgAccessModifier.Family
};
testResult = testCgMem.GetMyStartEnclosure(TestFileContent);
Assert.IsNotNull(testResult);
Assert.AreEqual(453, testResult.Item1);
Assert.AreEqual(1, testResult.Item2);
Console.WriteLine(string.Format("{0},{1}", testResult.Item1, testResult.Item2));
}
public void TestToCsDecl()
{
var testSubject = new CgMember()
{
Args =
new List <CgArg>
{
new CgArg {
ArgName = "param1", ArgType = "int"
},
new CgArg {
ArgName = "param2", ArgType = "string"
},
new CgArg {
ArgName = "param3", ArgType = "bool"
}
},
Name = "MyMethodName",
TypeName = "System.String",
AccessModifier = CgAccessModifier.Public
};
var testResult = NoFuture.Gen.Settings.LangStyle.ToDecl(testSubject);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.IsTrue(testResult.StartsWith(testSubject.TypeName));
Console.WriteLine(testResult);
testResult = NoFuture.Gen.Settings.LangStyle.ToDecl(testSubject, true);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.IsTrue(testResult.StartsWith($"public {testSubject.TypeName}"));
Console.WriteLine(testResult);
testSubject.TypeName = "MyNamespace.Here.MyTypeName";
testSubject.Name = ".ctor";
testSubject.IsCtor = true;
testResult = NoFuture.Gen.Settings.LangStyle.ToDecl(testSubject);
Assert.IsNotNull(testResult);
Console.WriteLine(testResult);
testSubject = new CgMember()
{
Name = "SomeProperty",
TypeName = "System.String",
AccessModifier = CgAccessModifier.Public,
HasGetter = true,
HasSetter = true,
};
testResult = NoFuture.Gen.Settings.LangStyle.ToDecl(testSubject, true);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.IsTrue(testResult.Contains("get;"));
Assert.IsTrue(testResult.Contains("set;"));
Console.WriteLine(testResult);
}
public string ToInvokeRegex(CgMember cgMem, params string[] varNames)
{
if (string.IsNullOrWhiteSpace(cgMem.Name))
{
return(".");
}
var regexPattern = new StringBuilder();
if (cgMem.MyCgType != null && (cgMem.IsEnum || cgMem.IsStatic || cgMem.MyCgType.IsEnum))
{
regexPattern.Append(cgMem.MyCgType.RegexPatternName);
}
else
{
if (varNames.Length > 0)
{
regexPattern.Append("(");
regexPattern.Append(string.Join(@"\x2e|",
varNames.Select(x => x.EscapeString())));
regexPattern.Append(@"\x2e");
regexPattern.Append(")");
}
else
{
regexPattern.Append(@"((this\x2e)|(?<!\.))");
}
}
regexPattern.AppendFormat(@"\b{0}\b", cgMem.Name);
if (cgMem.IsGeneric)
{
//needs to handle crazy shit like 'global::System.Tuple<int, Func<Mynamespace.MyType, global::System.Int64>>'
regexPattern.Append(@"\x3c.*?\x3e");
}
if (cgMem.MyCgType != null && cgMem.MyCgType.IsEnum && cgMem.MyCgType.EnumValueDictionary.Values.Count > 0)
{
regexPattern.Append("(");
regexPattern.Append(string.Join("|", cgMem.MyCgType.EnumValueDictionary.Values.SelectMany(x => x)));
regexPattern.Append(")");
}
else if (cgMem.Args.Count > 0)
{
regexPattern.AppendFormat(@"\s*?\({0}\)", string.Join(@"\,", cgMem.Args.Select(x => x.AsInvokeRegexPattern)));
}
else if (cgMem.IsMethod)
{
regexPattern.Append(@"\(\s*?\)");
}
return(regexPattern.ToString());
}
public CgArg ToParam(CgMember cgMem, bool asFunctionPtr)
{
if (!asFunctionPtr)
{
var isReadOnlyProp = cgMem.HasGetter && !cgMem.HasSetter;
var addByRef = (cgMem.TypeName == "string" || cgMem.TypeName == "System.String" ||
IsPrimitiveTypeName(cgMem.TypeName)) && !isReadOnlyProp;
return(new CgArg
{
ArgName = cgMem.Name,
ArgType = (addByRef ? string.Format("ref {0}", cgMem.TypeName) : cgMem.TypeName)
});
}
if (string.IsNullOrWhiteSpace(cgMem.TypeName) || cgMem.TypeName == "void" || cgMem.TypeName == "System.Void")//as an Action
{
if (cgMem.Args.Count <= 0)
{
return new CgArg {
ArgName = cgMem.Name, ArgType = "Action"
}
}
;
var actBldr = new StringBuilder();
actBldr.Append("Action<");
actBldr.Append(string.Join(", ", cgMem.Args.Select(x => x.ArgType)));
actBldr.Append(">");
return(new CgArg {
ArgName = cgMem.Name, ArgType = actBldr.ToString()
});
}
var funcBldr = new StringBuilder();
funcBldr.Append("Func<");
if (cgMem.Args.Count > 0)
{
funcBldr.Append(string.Join(", ", cgMem.Args.Select(x => x.ArgType)));
funcBldr.Append(", ");
}
funcBldr.AppendFormat("{0}>", cgMem.TypeName);
return(new CgArg {
ArgName = cgMem.Name, ArgType = funcBldr.ToString()
});
}
public void TestCgMemberEquals()
{
var args1 = new List <CgArg>
{
new CgArg {
ArgName = "NameOne", ArgType = "TypeOne"
},
new CgArg {
ArgName = "NameTwo", ArgType = "TypeTwo"
},
new CgArg {
ArgName = "NameThree", ArgType = "TypeThree"
}
};
var args2 = new List <CgArg>
{
new CgArg {
ArgName = "NameThree", ArgType = "TypeThree"
},
new CgArg {
ArgName = "NameTwo", ArgType = "TypeTwo"
},
new CgArg {
ArgName = "NameOne", ArgType = "TypeOne"
}
};
var cgOne = new CgMember()
{
Args = args1,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
var cgTwo = new CgMember()
{
Args = args2,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
Assert.IsTrue(cgOne.Equals(cgTwo));
}
/// <summary>
/// Gets the <see cref="PropertyInfo"/> as a code gen member (<see cref="CgMember"/>)
/// </summary>
/// <param name="pi"></param>
/// <param name="valueTypeOnly"></param>
/// <param name="enumValueDictionary"></param>
/// <returns></returns>
public static CgMember GetAsCgMember(PropertyInfo pi, bool valueTypeOnly,
Dictionary<string, string[]> enumValueDictionary)
{
if (pi == null)
return null;
var piType = pi.NfPropertyType();
if (valueTypeOnly && piType.NfBaseType() != null &&
piType.NfBaseType().Name != VALUE_TYPE)
return null;
var cgMem = new CgMember
{
TypeName = Settings.LangStyle.TransformClrTypeSyntax(piType),
IsEnumerableType = NfTypeName.IsEnumerableReturnType(piType),
Name = pi.Name,
MetadataToken = pi.MetadataToken
};
if (pi.CanRead)
{
cgMem.HasGetter = true;
if (pi.NfGetGetMethod() != null)
cgMem.IsStatic = pi.NfGetGetMethod().IsStatic;
}
if (pi.CanWrite)
{
cgMem.HasSetter = true;
if (pi.NfGetSetMethod() != null)
cgMem.IsStatic = pi.NfGetSetMethod().IsStatic;
}
string[] enumVals;
if (NfTypeName.IsEnumType(piType, out enumVals) && enumValueDictionary != null)
{
cgMem.IsEnum = true;
var clearName = NfTypeName.GetLastTypeNameFromArrayAndGeneric(cgMem.TypeName, "<");
if (!enumValueDictionary.ContainsKey(clearName))
{
enumValueDictionary.Add(clearName, enumVals);
}
}
return cgMem;
}
public string ToDecl(CgMember cgMem, bool includesAccessModifier = false)
{
if (cgMem == null)
{
return(string.Empty);
}
var cgArgs = cgMem.Args.Select(cgArg => $"{cgArg.ArgType} {cgArg.ArgName}").ToList();
var accessMod = includesAccessModifier ? TransposeCgAccessModToString(cgMem.AccessModifier) + " " : string.Empty;
var args = string.Join(", ", cgArgs);
if (cgMem.IsCtor)
{
var ctorName = NfReflect.GetTypeNameWithoutNamespace(cgMem.TypeName);
return($"{accessMod}{ctorName}({args})");
}
if (cgArgs.Any() || cgMem.IsMethod)
{
//TODO - this is only going to work for when there is only one generic arg
return(cgMem.IsGeneric && !cgMem.IsCtor
? $"{accessMod}{cgMem.TypeName} {cgMem.Name}<{cgMem.TypeName}>({args})"
: $"{accessMod}{cgMem.TypeName} {cgMem.Name}({args})");
}
var propSyntax = "";
if (cgMem.HasSetter || cgMem.HasGetter)
{
propSyntax += " { ";
if (cgMem.HasGetter)
{
propSyntax += "get; ";
}
if (cgMem.HasSetter)
{
propSyntax += "set; ";
}
propSyntax += "}";
}
return($"{accessMod}{cgMem.TypeName} {cgMem.Name}{propSyntax}");
}
public string ToSignatureRegex(CgMember cgMem)
{
var regexPattern = new StringBuilder();
regexPattern.Append(@"(\b" + TransposeCgAccessModToString(cgMem.AccessModifier) + @"\b)");
if (cgMem.AccessModifier == CgAccessModifier.Assembly)
{
regexPattern.Append("?");
}
regexPattern.Append(@"([^\x2c\x3b\x7d\x7b]+?)");
regexPattern.AppendFormat(@"\b{0}\b", cgMem.Name);
if (cgMem.IsGeneric)
{
//needs to handle crazy shit like 'global::System.Tuple<int, Func<Mynamespace.MyType, global::System.Int64>>'
regexPattern.Append(@"\x3c.*?\x3e");
}
if (!cgMem.IsMethod)
{
return(regexPattern.ToString());
}
if (cgMem.Args.Count <= 0)
{
regexPattern.Append(@"\(\s*?\)");
return(regexPattern.ToString());
}
var simpleArgTypes =
cgMem.Args.Select(
x =>
@"\s*\b" +
NfReflect.GetTypeNameWithoutNamespace(x.ArgType).EscapeString() +
@"\b\s*([^\,]+?)").ToList();
regexPattern.AppendFormat(@"\s*\({0}\)", string.Join(@"\,", simpleArgTypes));
return(regexPattern.ToString());
}
public void TestAsInvokeRegexPattern02()
{
var testSubject = new CgMember()
{
Name = "ToString",
TypeName = "System.String",
IsMethod = true
};
var testResult = testSubject.AsInvokeRegexPattern();
var testCompare =
"command.Parameters.Add(new SqlParameter(\"@createUser\", Convert.ToString(Session[SessionContants.LoggedInEntityId])));";
Assert.IsFalse(System.Text.RegularExpressions.Regex.IsMatch(testCompare, testResult));
Console.WriteLine(testResult);
testCompare = "somethingElse.InvokeMe(4,true,\"sd\");var mysomething=ToString()";
Assert.IsTrue(System.Text.RegularExpressions.Regex.IsMatch(testCompare, testResult));
}
public void TestToCsStmt()
{
var testSubject = new CgMember()
{
Args =
new List <CgArg>
{
new CgArg {
ArgName = "param1", ArgType = "int"
},
new CgArg {
ArgName = "param2", ArgType = "string"
},
new CgArg {
ArgName = "param3", ArgType = "bool"
}
},
Name = "MyMethodName",
TypeName = "System.String"
};
var testResult = NoFuture.Gen.Settings.LangStyle.ToStmt(testSubject, "MyNamespace.Here", "MyTypeName");
Console.WriteLine(testResult);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.IsTrue(testResult.StartsWith("return"));
testSubject.TypeName = "void";
testResult = NoFuture.Gen.Settings.LangStyle.ToStmt(testSubject, "MyNamespace.Here", "MyTypeName");
Console.WriteLine(testResult);
Assert.IsTrue(testResult.StartsWith("MyNamespace"));
testSubject.TypeName = "MyNamespace.Here.MyTypeName";
testSubject.Name = ".ctor";
testSubject.IsCtor = true;
testResult = NoFuture.Gen.Settings.LangStyle.ToStmt(testSubject, null, null);
Assert.IsNotNull(testResult);
Assert.AreEqual("new MyNamespace.Here.MyTypeName(param1,param2,param3);", testResult);
Console.WriteLine(testResult);
}
public void TestContainsThisMember()
{
var args1 = new List<CgArg>
{
new CgArg {ArgName = "NameOne", ArgType = "TypeOne"},
new CgArg {ArgName = "NameTwo", ArgType = "TypeTwo"},
new CgArg {ArgName = "NameThree", ArgType = "TypeThree"}
};
var args2 = new List<CgArg>
{
new CgArg {ArgName = "NameThree", ArgType = "TypeThree"},
new CgArg {ArgName = "NameTwo", ArgType = "TypeTwo"},
new CgArg {ArgName = "NameOne", ArgType = "TypeOne"}
};
var cgOne = new CgMember()
{
Args = args1,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
var cgTwo = new CgMember()
{
Args = args2,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
var testSubject = new CgType();
testSubject.Methods.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
testSubject = new CgType();
testSubject.Fields.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
testSubject = new CgType();
testSubject.Events.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
testSubject = new CgType();
testSubject.Properties.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
}
public void TestCgMemberEquals()
{
var args1 = new List<CgArg>
{
new CgArg {ArgName = "NameOne", ArgType = "TypeOne"},
new CgArg {ArgName = "NameTwo", ArgType = "TypeTwo"},
new CgArg {ArgName = "NameThree", ArgType = "TypeThree"}
};
var args2 = new List<CgArg>
{
new CgArg {ArgName = "NameThree", ArgType = "TypeThree"},
new CgArg {ArgName = "NameTwo", ArgType = "TypeTwo"},
new CgArg {ArgName = "NameOne", ArgType = "TypeOne"}
};
var cgOne = new CgMember()
{
Args = args1,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
var cgTwo = new CgMember()
{
Args = args2,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
Assert.IsTrue(cgOne.Equals(cgTwo));
}
public void TestCodeBlockUseMyLocals()
{
var inputString = new String[]
{
" objZuluUIController = new ZuluUIController();",
" DataSet dsGetSecurityQuestions = objZuluUIController.GetZuluSecurityQuestions(DropdownConstants.ZuluSECURITYQUESTIONS);",
" ddlSecurityQuestion.DataSource = dsGetSecurityQuestions;",
" ddlSecurityQuestion.DataTextField = \"ItemName\";",
" ddlSecurityQuestion.DataValueField = \"ItemAbbreviation\";",
" ddlSecurityQuestion.DataBind();",
" ddlSecurityQuestion.Items.Insert(0, string.Format(\" '{0}'\",\"------------------- Select a question -------------------\");",
" }",
" catch (Exception ex)",
" {",
" MyNamespace.CRM.Common.Utitility.CommonMethods.LogException(\"\",ex);",
" throw ex;",
" }",
" }",
""
};
var args1 = new List<CgArg>
{
new CgArg {ArgName = "objZuluUIController", ArgType = "TypeOne"},
new CgArg {ArgName = "ddlSecurityQuestion", ArgType = "TypeTwo"},
};
var args2 = new List<CgArg>
{
new CgArg {ArgName = "objZuluUIController", ArgType = "TypeOne"},
new CgArg {ArgName = "ddlSecurityQuestion", ArgType = "TypeTwo"},
new CgArg {ArgName = "NameOne", ArgType = "TypeOne"}
};
//however expect that if arg name furthest left has no match then the result as false
var args3 = new List<CgArg>
{
new CgArg {ArgName = "NameOne", ArgType = "TypeOne"},
new CgArg {ArgName = "objZuluUIController", ArgType = "TypeOne"},
new CgArg {ArgName = "ddlSecurityQuestion", ArgType = "TypeTwo"}
};
var testSubject = new CgMember()
{
Args = args1,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
Assert.AreEqual(2, testSubject.CodeBlockUsesMyArgs(inputString));
testSubject.Args = args2;
//if it can't find all three , it check for first two, then just one
Assert.AreEqual(2, testSubject.CodeBlockUsesMyArgs(inputString));
testSubject.Args = args3;
Assert.AreEqual(0, testSubject.CodeBlockUsesMyArgs(inputString));
}
public void TestCgMemberCompare()
{
var testSubject = new CgMemberCompare();
Assert.AreEqual(0, testSubject.Compare(null, null));
var less = new CgMember
{
Args =
new List <CgArg>()
{
new CgArg {
ArgName = "ddl", ArgType = "System.Web.UI.WebControls.DropDownList"
},
new CgArg {
ArgName = "lookupMstrDescription", ArgType = "string"
}
},
Name = "less",
TypeName = "void"
};
var middle = new CgMember
{
Args =
new List <CgArg>()
{
new CgArg {
ArgName = "ddl", ArgType = "System.Web.UI.WebControls.DropDownList"
},
new CgArg {
ArgName = "lookupMstrDescription", ArgType = "string"
},
new CgArg {
ArgName = "Id", ArgType = "bool"
}
},
Name = "middle",
TypeName = "void"
};
var most = new CgMember
{
Args =
new List <CgArg>()
{
new CgArg {
ArgName = "ddl", ArgType = "System.Web.UI.WebControls.DropDownList"
},
new CgArg {
ArgName = "lookupMstrDescription", ArgType = "string"
},
new CgArg {
ArgName = "defaultValue", ArgType = "string"
}
},
Name = "most",
TypeName = "void"
};
var deadLast = new CgMember
{
Name = "deadLast",
TypeName = "void"
};
var myCgType = new CgType();
myCgType.Methods.AddRange(new List <CgMember>()
{
deadLast, middle, less, most
});
foreach (var obj in myCgType.SortedMethods)
{
var cg = obj as CgMember;
Console.WriteLine(string.Format("----{0}", cg.Name));
foreach (var arg in cg.Args)
{
Console.WriteLine(arg.ToString());
}
}
}
public void TestCgMemberCompare()
{
var testSubject = new CgMemberCompare();
Assert.AreEqual(0, testSubject.Compare(null, null));
var less = new CgMember
{
Args =
new List<CgArg>()
{
new CgArg {ArgName = "ddl", ArgType = "System.Web.UI.WebControls.DropDownList"},
new CgArg {ArgName = "lookupMstrDescription", ArgType = "string"}
},
Name = "less",
TypeName = "void"
};
var middle = new CgMember
{
Args =
new List<CgArg>()
{
new CgArg {ArgName = "ddl", ArgType = "System.Web.UI.WebControls.DropDownList"},
new CgArg {ArgName = "lookupMstrDescription", ArgType = "string"},
new CgArg {ArgName = "Id", ArgType = "bool"}
},
Name = "middle",
TypeName = "void"
};
var most = new CgMember
{
Args =
new List<CgArg>()
{
new CgArg {ArgName = "ddl", ArgType = "System.Web.UI.WebControls.DropDownList"},
new CgArg {ArgName = "lookupMstrDescription", ArgType = "string"},
new CgArg {ArgName = "defaultValue", ArgType = "string"}
},
Name = "most",
TypeName = "void"
};
var deadLast = new CgMember
{
Name = "deadLast",
TypeName = "void"
};
var myCgType = new CgType() { Methods = new List<CgMember>() { deadLast, middle, less, most } };
foreach (var obj in myCgType.SortedMethods)
{
var cg = obj as CgMember;
System.Diagnostics.Debug.WriteLine(string.Format("----{0}", cg.Name));
foreach (var arg in cg.Args)
{
System.Diagnostics.Debug.WriteLine(arg.ToString());
}
}
}
/// <summary>
/// Gets a method as a code gen member type
/// </summary>
/// <param name="mti"></param>
/// <param name="getCallvirtMetadataTokens"></param>
/// <returns></returns>
public static CgMember GetAsCgMember(MethodInfo mti, bool getCallvirtMetadataTokens = false)
{
if (mti == null)
return null;
string propName;
if (NfTypeName.IsClrMethodForProperty(mti.Name, out propName))
return null;
if (NfTypeName.IsClrGeneratedType(mti.Name))
//these appear as '<SomeNameOfMethodAlreadyAdded>b__kifkj(...)'
return null;
var miReturnType = mti.NfReturnType();
var cgMem = new CgMember
{
Name = mti.Name,
TypeName = Settings.LangStyle.TransformClrTypeSyntax(miReturnType),
IsStatic = mti.IsStatic,
IsGeneric = mti.IsGenericMethod,
IsEnumerableType = NfTypeName.IsEnumerableReturnType(miReturnType),
IsMethod = true,
MetadataToken = mti.MetadataToken
};
if(mti.IsAssembly)
cgMem.AccessModifier = CgAccessModifier.Assembly;
if(mti.IsFamily)
cgMem.AccessModifier = CgAccessModifier.Family;
if(mti.IsFamilyAndAssembly)
cgMem.AccessModifier = CgAccessModifier.FamilyAssembly;
if(mti.IsPrivate)
cgMem.AccessModifier = CgAccessModifier.Private;
if(mti.IsPublic)
cgMem.AccessModifier = CgAccessModifier.Public;
foreach (var parameterInfo in mti.GetParameters())
{
var paramType = parameterInfo.NfParameterType();
var cgArg = new CgArg
{
ArgName = parameterInfo.Name,
ArgType = Settings.LangStyle.TransformClrTypeSyntax(paramType)
};
cgMem.Args.Add(cgArg);
}
cgMem.MethodBodyIL = Convert.ToBase64String(Asm.GetMethodBody(mti));
if (!getCallvirtMetadataTokens)
return cgMem;
cgMem.opCodeCallsAndCallvirtsMetadatTokens.AddRange(Asm.GetCallsMetadataTokens(mti));
return cgMem;
}
public void TestAsInvokeRegexPattern()
{
var testSubject = new CgMember()
{
Args =
new List<CgArg>
{
new CgArg {ArgName = "param1", ArgType = "int"},
new CgArg {ArgName = "param2", ArgType = "string"},
new CgArg {ArgName = "param3", ArgType = "bool"}
},
Name = "MyMethodName",
TypeName = "System.String"
};
var testResult = testSubject.AsInvokeRegexPattern();
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.AreNotEqual(".",testResult);
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsTrue(System.Text.RegularExpressions.Regex.IsMatch("MyMethodName(11,\"a string literal\",true)",testResult));
testSubject.IsStatic = true;
testSubject.MyCgType = new CgType {Namespace = "NoFuture.TestNs", Name = "Something"};
testSubject.IsGeneric = true;
testResult = testSubject.AsInvokeRegexPattern();
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsNotNull(testResult);
testSubject.IsStatic = false;
testResult = testSubject.AsInvokeRegexPattern("myVar", "myVar.ItsTypes.Types.Type");
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsNotNull(testResult);
testSubject.MyCgType.IsEnum = true;
testSubject.IsGeneric = false;
testSubject.Name = "MyEnum";
testSubject.MyCgType.EnumValueDictionary.Add("MyType", new[] { "Instance", "NonPublic", "Public", "DeclaredOnly" });
testResult = testSubject.AsInvokeRegexPattern();
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsNotNull(testResult);
testSubject = new CgMember()
{
Name = "MyPropertyName",
TypeName = "System.String"
};
testResult = testSubject.AsInvokeRegexPattern();
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.AreNotEqual(".", testResult);
System.Diagnostics.Debug.WriteLine(testResult);
}
public string ToDecl(CgMember cgMem, bool includesAccessModifier = false)
{
var cgArgs = cgMem.Args.Select(cgArg => String.Format("{0} {1}", cgArg.ArgType, cgArg.ArgName)).ToList();
var cgSig = string.Join(",", cgArgs);
var tn = cgMem.IsCtor ? string.Empty : cgMem.TypeName;
var n = cgMem.IsCtor
? NfTypeName.GetTypeNameWithoutNamespace(cgMem.TypeName)
: string.Format(" {0}", cgMem.Name);
cgSig = cgSig.Length > 0 || cgMem.IsCtor || cgMem.IsMethod
? string.Format("{0}{1}({2})", tn, n, cgSig)
: string.Format("{0}{1}", tn, n);
return includesAccessModifier
? string.Format("{0} {1}", TransposeCgAccessModToString(cgMem.AccessModifier), cgSig)
: cgSig;
}
public void TestToCsParam()
{
var testSubject = new CgMember()
{
Args =
new List<CgArg>
{
new CgArg {ArgName = "param1", ArgType = "int"},
new CgArg {ArgName = "param2", ArgType = "string"},
new CgArg {ArgName = "param3", ArgType = "bool"}
},
Name = "MyMethodName",
TypeName = "System.String"
};
var testResult = NoFuture.Gen.Settings.LangStyle.ToParam(testSubject, true);
Assert.IsNotNull(testResult);
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsTrue(testResult.ToString().StartsWith("Func<"));
}
public string GetEnclosureCloseToken(CgMember cgMem)
{
return C_CLOSE_CURLY.ToString();
}
public string GetEnclosureOpenToken(CgMember cgMem)
{
return C_OPEN_CURLY.ToString();
}
public void TestContainsThisMember()
{
var args1 = new List <CgArg>
{
new CgArg {
ArgName = "NameOne", ArgType = "TypeOne"
},
new CgArg {
ArgName = "NameTwo", ArgType = "TypeTwo"
},
new CgArg {
ArgName = "NameThree", ArgType = "TypeThree"
}
};
var args2 = new List <CgArg>
{
new CgArg {
ArgName = "NameThree", ArgType = "TypeThree"
},
new CgArg {
ArgName = "NameTwo", ArgType = "TypeTwo"
},
new CgArg {
ArgName = "NameOne", ArgType = "TypeOne"
}
};
var cgOne = new CgMember()
{
Args = args1,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
var cgTwo = new CgMember()
{
Args = args2,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
var testSubject = new CgType();
testSubject.Methods.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
testSubject = new CgType();
testSubject.Fields.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
testSubject = new CgType();
testSubject.Events.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
testSubject = new CgType();
testSubject.Properties.Add(cgOne);
Assert.IsTrue(testSubject.ContainsThisMember(cgTwo));
}
public void TestCodeBlockUseMyLocals()
{
var inputString = new String[]
{
" objZuluUIController = new ZuluUIController();",
" DataSet dsGetSecurityQuestions = objZuluUIController.GetZuluSecurityQuestions(DropdownConstants.ZuluSECURITYQUESTIONS);",
" ddlSecurityQuestion.DataSource = dsGetSecurityQuestions;",
" ddlSecurityQuestion.DataTextField = \"ItemName\";",
" ddlSecurityQuestion.DataValueField = \"ItemAbbreviation\";",
" ddlSecurityQuestion.DataBind();",
" ddlSecurityQuestion.Items.Insert(0, string.Format(\" '{0}'\",\"------------------- Select a question -------------------\");",
" }",
" catch (Exception ex)",
" {",
" MyNamespace.CRM.Common.Utitility.CommonMethods.LogException(\"\",ex);",
" throw ex;",
" }",
" }",
""
};
var args1 = new List <CgArg>
{
new CgArg {
ArgName = "objZuluUIController", ArgType = "TypeOne"
},
new CgArg {
ArgName = "ddlSecurityQuestion", ArgType = "TypeTwo"
},
};
var args2 = new List <CgArg>
{
new CgArg {
ArgName = "objZuluUIController", ArgType = "TypeOne"
},
new CgArg {
ArgName = "ddlSecurityQuestion", ArgType = "TypeTwo"
},
new CgArg {
ArgName = "NameOne", ArgType = "TypeOne"
}
};
//however expect that if arg name furthest left has no match then the result as false
var args3 = new List <CgArg>
{
new CgArg {
ArgName = "NameOne", ArgType = "TypeOne"
},
new CgArg {
ArgName = "objZuluUIController", ArgType = "TypeOne"
},
new CgArg {
ArgName = "ddlSecurityQuestion", ArgType = "TypeTwo"
}
};
var testSubject = new CgMember()
{
Args = args1,
HasGetter = true,
HasSetter = true,
TypeName = "MyCgMember",
Name = "MyCgType"
};
Assert.AreEqual(2, testSubject.CodeBlockUsesMyArgs(inputString));
testSubject.Args = args2;
//if it can't find all three , it check for first two, then just one
Assert.AreEqual(2, testSubject.CodeBlockUsesMyArgs(inputString));
testSubject.Args = args3;
Assert.AreEqual(0, testSubject.CodeBlockUsesMyArgs(inputString));
}
public void TestMyStartEnclosure()
{
var testCgMem = new CgMember()
{
Name = "GetYoMommaTypes",
IsMethod = true,
PdbModuleSymbols = new ModuleSymbols(){lastLine = new PdbLineNumber(){lineNumber = 365}, firstLine = new PdbLineNumber(){lineNumber = 445}},
AccessModifier = CgAccessModifier.Family
};
var testResult = testCgMem.GetMyStartEnclosure(TestFileContent);
Assert.IsNotNull(testResult);
Assert.AreEqual(362, testResult.Item1);
Assert.AreEqual(1,testResult.Item2);
System.Diagnostics.Debug.WriteLine(string.Format("{0},{1}", testResult.Item1, testResult.Item2));
testCgMem = new CgMember()
{
Name = "ddlScreeningLocation_SelectedIndexChanged",
Args =
new List<CgArg>
{
new CgArg {ArgName = "sender", ArgType = "object"},
new CgArg {ArgName = "e", ArgType = "EventArgs"}
},
IsMethod = true,
PdbModuleSymbols = new ModuleSymbols() { lastLine = new PdbLineNumber() { lineNumber = 453 }, firstLine = new PdbLineNumber() { lineNumber = 458 } },
AccessModifier = CgAccessModifier.Family
};
testResult = testCgMem.GetMyStartEnclosure(TestFileContent);
Assert.IsNotNull(testResult);
Assert.AreEqual(354, testResult.Item1);
Assert.AreEqual(1, testResult.Item2);
System.Diagnostics.Debug.WriteLine(string.Format("{0},{1}", testResult.Item1, testResult.Item2));
}
/// <summary>
/// Gets the <see cref="FieldInfo"/> as a code gen member (<see cref="CgMember"/>)
/// </summary>
/// <param name="fi"></param>
/// <param name="valueTypeOnly"></param>
/// <param name="enumValueDictionary"></param>
/// <returns></returns>
public static CgMember GetAsCgMember(FieldInfo fi, bool valueTypeOnly,
Dictionary<string, string[]> enumValueDictionary)
{
if (fi == null)
return null;
if (NfTypeName.IsClrGeneratedType(fi.Name))
return null;
var fiType = fi.NfFieldType();
if (valueTypeOnly && fiType.NfBaseType() != null && fiType.NfBaseType().Name != VALUE_TYPE)
return null;
var cgMem = new CgMember
{
TypeName = Settings.LangStyle.TransformClrTypeSyntax(fiType),
IsEnumerableType = NfTypeName.IsEnumerableReturnType(fiType),
Name = fi.Name,
IsStatic = fi.IsStatic,
MetadataToken = fi.MetadataToken
};
string[] enumVals;
if (NfTypeName.IsEnumType(fiType, out enumVals) && enumValueDictionary != null)
{
cgMem.IsEnum = true;
var clearName = NfTypeName.GetLastTypeNameFromArrayAndGeneric(cgMem.TypeName, "<");
if (!enumValueDictionary.ContainsKey(clearName))
{
enumValueDictionary.Add(clearName, enumVals);
}
}
return cgMem;
}
public void TestAsInvokeRegexPattern()
{
var testSubject = new CgMember()
{
Args =
new List <CgArg>
{
new CgArg {
ArgName = "param1", ArgType = "int"
},
new CgArg {
ArgName = "param2", ArgType = "string"
},
new CgArg {
ArgName = "param3", ArgType = "bool"
}
},
Name = "MyMethodName",
TypeName = "System.String"
};
var testResult = testSubject.AsInvokeRegexPattern();
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.AreNotEqual(".", testResult);
Console.WriteLine(testResult);
Assert.IsTrue(System.Text.RegularExpressions.Regex.IsMatch("MyMethodName(11,\"a string literal\",true)", testResult));
testSubject.IsStatic = true;
testSubject.MyCgType = new CgType {
Namespace = "NoFuture.TestNs", Name = "Something"
};
testSubject.IsGeneric = true;
testResult = testSubject.AsInvokeRegexPattern();
Console.WriteLine(testResult);
Assert.IsNotNull(testResult);
testSubject.IsStatic = false;
testResult = testSubject.AsInvokeRegexPattern("myVar", "myVar.ItsTypes.Types.Type");
Console.WriteLine(testResult);
Assert.IsNotNull(testResult);
testSubject.MyCgType.IsEnum = true;
testSubject.IsGeneric = false;
testSubject.Name = "MyEnum";
testSubject.MyCgType.EnumValueDictionary.Add("MyType", new[] { "Instance", "NonPublic", "Public", "DeclaredOnly" });
testResult = testSubject.AsInvokeRegexPattern();
Console.WriteLine(testResult);
Assert.IsNotNull(testResult);
testSubject = new CgMember()
{
Name = "MyPropertyName",
TypeName = "System.String"
};
testResult = testSubject.AsInvokeRegexPattern();
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.AreNotEqual(".", testResult);
Console.WriteLine(testResult);
}
/// <summary>
/// Gets a constructor as a code gen member type
/// </summary>
/// <param name="ci"></param>
/// <param name="typeName"></param>
/// <param name="getCallvirtMetadataTokens"></param>
/// <returns></returns>
public static CgMember GetAsCgMember(ConstructorInfo ci, string typeName, bool getCallvirtMetadataTokens = false)
{
if (ci == null || string.IsNullOrWhiteSpace(typeName))
return null;
var cgMem = new CgMember
{
Name = Constants.CTOR_NAME,
IsCtor = true,
TypeName = typeName,
MetadataToken = ci.MetadataToken
};
foreach (var parameterInfo in ci.GetParameters())
{
var paramType = parameterInfo.NfParameterType();
var cgArg = new CgArg
{
ArgName = parameterInfo.Name,
ArgType = Settings.LangStyle.TransformClrTypeSyntax(paramType)
};
cgMem.Args.Add(cgArg);
}
if (!getCallvirtMetadataTokens) return cgMem;
cgMem.opCodeCallsAndCallvirtsMetadatTokens.AddRange(Asm.GetCallsMetadataTokens(ci));
return cgMem;
}
public void TestGetMyEndEnclosure()
{
var testCgMem = new CgMember()
{
Name = "ddlScreeningLocation_SelectedIndexChanged",
Args =
new List<CgArg>
{
new CgArg {ArgName = "sender", ArgType = "object"},
new CgArg {ArgName = "e", ArgType = "EventArgs"}
},
IsMethod = true,
PdbModuleSymbols = new ModuleSymbols() { firstLine = new PdbLineNumber() { lineNumber = 356 }, lastLine = new PdbLineNumber() { lineNumber = 359 } },
AccessModifier = CgAccessModifier.Family
};
var testSrcFile = TestFileContent;
var testResult = testCgMem.GetMyEndEnclosure(testSrcFile);
System.Diagnostics.Debug.WriteLine(string.Format("{0},{1}", testResult.Item1, testResult.Item2));
}
/// <summary>
/// Converts the .NET type into the custom Code Gen type
/// </summary>
/// <param name="asmType"></param>
/// <param name="valueTypeOnly">
/// Will only export Fields and Properties whose base type extends System.ValueType
/// </param>
/// <param name="resolveDependencies">
/// Switch to have the IL of the type parsed and all dependent calls Metadata tokens added.
/// </param>
/// <returns></returns>
public static CgType GetCgOfType(this Type asmType, bool valueTypeOnly, bool resolveDependencies = false)
{
var cgType = new CgType();
if (asmType == null || NfTypeName.IsIgnoreType(asmType) || NfTypeName.IsClrGeneratedType(asmType))
return null;
//use the logic in TypeName to get the namespace and class name so its not tied to having the assembly
var cgTypeName = new NfTypeName(asmType.AssemblyQualifiedName);
//make sure there is always some kind of namespace
cgType.Namespace = string.IsNullOrWhiteSpace(cgTypeName.Namespace)
? asmType.Assembly.GetName().Name
: cgTypeName.Namespace;
cgType.IsContrivedNamespace = string.IsNullOrWhiteSpace(cgTypeName.Namespace);
cgType.Name = cgTypeName.ClassName;
cgType.AssemblyQualifiedName = asmType.AssemblyQualifiedName;
cgType.IsEnum = NfTypeName.IsEnumType(asmType);
var cgTypesInterfaces = asmType.GetInterfaces();
cgType.MetadataToken = asmType.MetadataToken;
Func<CgType, string, bool> alreadyPresentHerein =
(cg, nextName) =>
(cg.Properties.FirstOrDefault(
cgP => string.Equals(cgP.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null
||
cg.Fields.FirstOrDefault(
cgF => string.Equals(cgF.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null
||
cg.Events.FirstOrDefault(
cgE => string.Equals(cgE.Name, nextName, StringComparison.OrdinalIgnoreCase)) != null)
;
//have events go first since they tend to be speard across fields and properties
foreach (
var evtInfo in
asmType.GetEvents(NfConfig.DefaultFlags))
{
var evtHandlerType = evtInfo.NfEventHandlerType().ToString();
var cgMem = new CgMember
{
Name = evtInfo.Name,
TypeName = evtHandlerType,
MetadataToken = evtInfo.MetadataToken
};
cgType.Events.Add(cgMem);
}
var asmMembers =
asmType.GetMembers(NfConfig.DefaultFlags);
foreach (var mi in asmMembers)
{
if (alreadyPresentHerein(cgType, mi.Name))
continue;
try
{
if (mi.MemberType == MemberTypes.Property)
{
var pi = mi as PropertyInfo;
var cgm = GetAsCgMember(pi, valueTypeOnly, cgType.EnumValueDictionary);
if (cgm == null)
continue;
if (resolveDependencies)
{
var propMi = NfTypeName.GetMethodsForProperty(pi, asmType);
foreach (var pim in propMi)
{
cgm.opCodeCallsAndCallvirtsMetadatTokens.AddRange(Asm.GetCallsMetadataTokens(pim));
}
}
cgType.Properties.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
throw;
cgType.Properties.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
HasGetter = true,
HasSetter = true,
SkipIt = true
});
}
try
{
if (mi.MemberType == MemberTypes.Event)
{
continue;//these have already been handled
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
continue;
}
try
{
if (mi.MemberType == MemberTypes.Field)
{
var fi = mi as FieldInfo;
var cgm = GetAsCgMember(fi, valueTypeOnly, cgType.EnumValueDictionary);
if (cgm == null)
continue;
cgType.Fields.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
throw;
cgType.Fields.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
SkipIt = true
});
}
try
{
if (!valueTypeOnly && mi.MemberType == MemberTypes.Method)
{
var mti = mi as MethodInfo;
var cgm = GetAsCgMember(mti, resolveDependencies);
if (cgm == null)
continue;
cgm.IsInterfaceImpl = IsInterfaceImpl(mti, cgTypesInterfaces);
cgType.Methods.Add(cgm);
}
if (!valueTypeOnly && mi.MemberType == MemberTypes.Constructor)
{
var ci = mi as ConstructorInfo;
var tn = (string.IsNullOrWhiteSpace(cgTypeName.Namespace)
? cgTypeName.ClassName
: $"{cgTypeName.Namespace}.{cgTypeName.ClassName}");
var cgm = GetAsCgMember(ci, tn, resolveDependencies);
if (cgm == null)
continue;
cgType.Methods.Add(cgm);
}
}
catch (Exception ex)
{
Asm.AddLoaderExceptionToLog(null, ex);
if (!Settings.IgnoreReflectionMissingAsmError)
throw;
cgType.Methods.Add(new CgMember
{
Name = mi.Name,
TypeName = DF_TYPE_NAME,
SkipIt = true
});
}
}
if (resolveDependencies)
{
ResolveAllMetadataTokens(cgType, asmType.Assembly.ManifestModule);
}
return cgType;
}
public void TestAsInvokeRegexPattern02()
{
var testSubject = new CgMember()
{
Name = "ToString",
TypeName = "System.String",
IsMethod = true
};
var testResult = testSubject.AsInvokeRegexPattern();
var testCompare =
"command.Parameters.Add(new SqlParameter(\"@createUser\", Convert.ToString(Session[SessionContants.LoggedInEntityId])));";
Assert.IsFalse(System.Text.RegularExpressions.Regex.IsMatch(testCompare, testResult));
System.Diagnostics.Debug.WriteLine(testResult);
testCompare = "somethingElse.InvokeMe(4,true,\"sd\");var mysomething=ToString()";
Assert.IsTrue(System.Text.RegularExpressions.Regex.IsMatch(testCompare, testResult));
}
/// <summary>
/// Resolves all MetadataTokens present in <see cref="cgm"/> using the <see cref="manifestModule"/>
/// </summary>
/// <param name="cgm"></param>
/// <param name="manifestModule"></param>
/// <param name="memberInfoCache">
/// Optional cache dictionary for use when this is being called within a loop, helps performance.
/// </param>
/// <param name="ignoreAssemblyFullNames">
/// Optional list of fully-qualified assembly names whose members should NOT be added (e.g. mscorlib).
/// </param>
/// <param name="maxErrors">The max number of exceptions to be incurred before abandoning.</param>
/// <returns>Count of errors encountered, will range from 0 to <see cref="maxErrors"/></returns>
public static int ResolveCgMemberMetadataTokens(CgMember cgm, Module manifestModule,
Dictionary<int, MemberInfo> memberInfoCache, string[] ignoreAssemblyFullNames, int maxErrors = 5)
{
if (cgm == null)
return maxErrors;
if (manifestModule == null)
return maxErrors;
var errorCount = 0;
//for each method, get all invoked metadata tokens
foreach (var metadataToken in cgm.opCodeCallsAndCallvirtsMetadatTokens)
{
try
{
MemberInfo runtimeMem = null;
//resolve invoked metadata token to a member type
if (memberInfoCache != null && memberInfoCache.ContainsKey(metadataToken))
{
runtimeMem = memberInfoCache[metadataToken];
}
else
{
runtimeMem = manifestModule.ResolveMember(metadataToken);
}
if (runtimeMem == null)
continue;
var declaringType = runtimeMem.DeclaringType;
var declaringTypeAsmName = declaringType?.AssemblyQualifiedName;
if (string.IsNullOrWhiteSpace(declaringTypeAsmName))
continue;
if (ignoreAssemblyFullNames != null && ignoreAssemblyFullNames.Any(declaringTypeAsmName.EndsWith))
continue;
//add to cache for performance
if (memberInfoCache != null && !memberInfoCache.ContainsKey(metadataToken))
memberInfoCache.Add(metadataToken, runtimeMem);
var runtimeMi = runtimeMem as MethodInfo;
if (runtimeMi != null)
{
var ncgm = GetAsCgMember(runtimeMi, false);
if (ncgm == null)
continue;
ncgm.MetadataToken = metadataToken;
ncgm.DeclaringTypeAsmName = declaringTypeAsmName;
cgm.OpCodeCallAndCallvirts.Add(ncgm);
continue;
}
var runtimePi = runtimeMem as PropertyInfo;
if (runtimePi != null)
{
var ncgm = GetAsCgMember(runtimePi, false, null);
if (ncgm == null)
continue;
ncgm.MetadataToken = metadataToken;
ncgm.DeclaringTypeAsmName = declaringTypeAsmName;
cgm.OpCodeCallAndCallvirts.Add(ncgm);
continue;
}
var runtimeFi = runtimeMem as FieldInfo;
if (runtimeFi == null)
continue;
var fiCgm = GetAsCgMember(runtimeFi, false, null);
if (fiCgm == null)
continue;
fiCgm.MetadataToken = metadataToken;
fiCgm.DeclaringTypeAsmName = declaringTypeAsmName;
cgm.OpCodeCallAndCallvirts.Add(fiCgm);
}
catch
{
errorCount += 1;
if (errorCount > maxErrors)
break;
}
}
return errorCount;
}
public void TestToCsStmt()
{
var testSubject = new CgMember()
{
Args =
new List<CgArg>
{
new CgArg {ArgName = "param1", ArgType = "int"},
new CgArg {ArgName = "param2", ArgType = "string"},
new CgArg {ArgName = "param3", ArgType = "bool"}
},
Name = "MyMethodName",
TypeName = "System.String"
};
var testResult = NoFuture.Gen.Settings.LangStyle.ToStmt(testSubject, "MyNamespace.Here", "MyTypeName");
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsNotNull(testResult);
Assert.AreNotEqual(string.Empty, testResult);
Assert.IsTrue(testResult.StartsWith("return"));
testSubject.TypeName = "void";
testResult = NoFuture.Gen.Settings.LangStyle.ToStmt(testSubject, "MyNamespace.Here", "MyTypeName");
System.Diagnostics.Debug.WriteLine(testResult);
Assert.IsTrue(testResult.StartsWith("MyNamespace"));
testSubject.TypeName = "MyNamespace.Here.MyTypeName";
testSubject.Name = ".ctor";
testSubject.IsCtor = true;
testResult = NoFuture.Gen.Settings.LangStyle.ToStmt(testSubject, null, null);
Assert.IsNotNull(testResult);
Assert.AreEqual("new MyNamespace.Here.MyTypeName(param1,param2,param3);", testResult);
System.Diagnostics.Debug.WriteLine(testResult);
}
public void TestToSignatureRegex()
{
var testCgMember = new CgMember() {Name = "PopulateDdlForSomething"};
testCgMember.Args.Add(new CgArg(){ArgName = "ddl", ArgType = "DropDownList"});
testCgMember.Args.Add(new CgArg() { ArgName = "cname", ArgType = "string" });
testCgMember.IsMethod = true;
var testInput = Settings.LangStyle.ToSignatureRegex(testCgMember);
Assert.IsNotNull(testInput);
Assert.IsTrue(Regex.IsMatch(" public void PopulateDdlForSomething(DropDownList ddl, string strAccountId)", testInput, RegexOptions.IgnoreCase));
testCgMember = new CgMember() { Name = "GetKeeperMasterDetailsForBizIDsForEmail" };
testCgMember.Args.Add(new CgArg() { ArgName = "strClinicIDs", ArgType = "string" });
testCgMember.IsMethod = true;
testInput = Settings.LangStyle.ToSignatureRegex(testCgMember);
Assert.IsNotNull(testInput);
Assert.IsTrue(Regex.IsMatch(" public List<KeeperMaster> GetKeeperMasterDetailsForBizIDsForEmail(string strClinicIDs)", testInput, RegexOptions.IgnoreCase));
testCgMember = new CgMember() { Name = "AProperty" };
testCgMember.IsMethod = false;
testCgMember.HasGetter = true;
testCgMember.HasGetter = true;
testCgMember.AccessModifier = CgAccessModifier.Family;
testInput = Settings.LangStyle.ToSignatureRegex(testCgMember);
Assert.IsNotNull(testInput);
System.Diagnostics.Debug.WriteLine(testInput);
Assert.IsTrue(Regex.IsMatch(" protected string AProperty",testInput));
}
public string ToSignatureRegex(CgMember cgMem)
{
var regexPattern = new StringBuilder();
regexPattern.Append(@"(\b" + TransposeCgAccessModToString(cgMem.AccessModifier) + @"\b)");
if (cgMem.AccessModifier == CgAccessModifier.Assembly)
regexPattern.Append("?");
regexPattern.Append(@"([^\x2c\x3b\x7d\x7b]+?)");
regexPattern.AppendFormat(@"\b{0}\b", cgMem.Name);
if (cgMem.IsGeneric)
{
//needs to handle crazy shit like 'global::System.Tuple<int, Func<Mynamespace.MyType, global::System.Int64>>'
regexPattern.Append(@"\x3c.*?\x3e");
}
if (!cgMem.IsMethod)
return regexPattern.ToString();
if (cgMem.Args.Count <= 0)
{
regexPattern.Append(@"\(\s*?\)");
return regexPattern.ToString();
}
var simpleArgTypes =
cgMem.Args.Select(
x =>
@"\s*\b" +
NfTypeName.GetTypeNameWithoutNamespace(x.ArgType).EscapeString() +
@"\b\s*([^\,]+?)").ToList();
regexPattern.AppendFormat(@"\s*\({0}\)", string.Join(@"\,", simpleArgTypes));
return regexPattern.ToString();
}
public string GetEnclosureOpenToken(CgMember cgMem)
{
return(C_OPEN_CURLY.ToString());
}
public string ToStmt(CgMember cgMem, string cgNamespace, string cgInvokeOnName)
{
var paramNames = string.Format("({0});",
string.Join(",",
cgMem.Args.Select(
x => x.ArgType.StartsWith("ref ") ? string.Format("ref {0}", x.ArgName) : x.ArgName)));
if (cgMem.IsCtor)
return string.Format("new {0}{1}", cgMem.TypeName, paramNames);
var stmtBldr = new StringBuilder();
if (!string.IsNullOrWhiteSpace(cgNamespace))
stmtBldr.AppendFormat("{0}.", cgNamespace);
if (!string.IsNullOrWhiteSpace(cgInvokeOnName))
stmtBldr.AppendFormat("{0}.", cgInvokeOnName);
stmtBldr.Append(cgMem.Name);
stmtBldr.Append(paramNames);
return cgMem.TypeName == "void" ? stmtBldr.ToString() : string.Format("return {0}", stmtBldr);
}
public string ToInvokeRegex(CgMember cgMem, params string[] varNames)
{
if (string.IsNullOrWhiteSpace(cgMem.Name))
return ".";
var regexPattern = new StringBuilder();
if (cgMem.MyCgType != null && (cgMem.IsEnum || cgMem.IsStatic || cgMem.MyCgType.IsEnum))
{
regexPattern.Append(cgMem.MyCgType.RegexPatternName);
}
else
{
if (varNames.Length > 0)
{
regexPattern.Append("(");
regexPattern.Append(string.Join(@"\x2e|",
varNames.Select(x => x.EscapeString())));
regexPattern.Append(@"\x2e");
regexPattern.Append(")");
}
else
{
regexPattern.Append(@"((this\x2e)|(?<!\.))");
}
}
regexPattern.AppendFormat(@"\b{0}\b", cgMem.Name);
if (cgMem.IsGeneric)
{
//needs to handle crazy shit like 'global::System.Tuple<int, Func<Mynamespace.MyType, global::System.Int64>>'
regexPattern.Append(@"\x3c.*?\x3e");
}
if (cgMem.MyCgType != null && cgMem.MyCgType.IsEnum && cgMem.MyCgType.EnumValueDictionary.Values.Count > 0)
{
regexPattern.Append("(");
regexPattern.Append(string.Join("|", cgMem.MyCgType.EnumValueDictionary.Values.SelectMany(x => x)));
regexPattern.Append(")");
}
else if (cgMem.Args.Count > 0)
regexPattern.AppendFormat(@"\s*?\({0}\)", string.Join(@"\,", cgMem.Args.Select(x => x.AsInvokeRegexPattern)));
else if (cgMem.IsMethod)
regexPattern.Append(@"\(\s*?\)");
return regexPattern.ToString();
}
public string GetEnclosureCloseToken(CgMember cgMem)
{
return(C_CLOSE_CURLY.ToString());
}
public CgArg ToParam(CgMember cgMem, bool asFunctionPtr)
{
if (!asFunctionPtr)
{
var isReadOnlyProp = cgMem.HasGetter && !cgMem.HasSetter;
var addByRef = (cgMem.TypeName == "string" || cgMem.TypeName == "System.String" ||
IsPrimitiveTypeName(cgMem.TypeName)) && !isReadOnlyProp;
return new CgArg
{
ArgName = cgMem.Name,
ArgType = (addByRef ? string.Format("ref {0}", cgMem.TypeName) : cgMem.TypeName)
};
}
if (string.IsNullOrWhiteSpace(cgMem.TypeName) || cgMem.TypeName == "void" || cgMem.TypeName == "System.Void")//as an Action
{
if (cgMem.Args.Count <= 0)
return new CgArg { ArgName = cgMem.Name, ArgType = "Action" };
var actBldr = new StringBuilder();
actBldr.Append("Action<");
actBldr.Append(string.Join(", ", cgMem.Args.Select(x => x.ArgType)));
actBldr.Append(">");
return new CgArg { ArgName = cgMem.Name, ArgType = actBldr.ToString() };
}
var funcBldr = new StringBuilder();
funcBldr.Append("Func<");
if (cgMem.Args.Count > 0)
{
funcBldr.Append(string.Join(", ", cgMem.Args.Select(x => x.ArgType)));
funcBldr.Append(", ");
}
funcBldr.AppendFormat("{0}>", cgMem.TypeName);
return new CgArg { ArgName = cgMem.Name, ArgType = funcBldr.ToString() };
}
/// <summary>
/// Test for if <see cref="someMember"/> belongs to this instance.
/// </summary>
/// <param name="someMember"></param>
/// <returns></returns>
public bool ContainsThisMember(CgMember someMember)
{
if (Properties.Any(p => p.Equals(someMember)))
return true;
if (Fields.Any(f => f.Equals(someMember)))
return true;
if (Events.Any(e => e.Equals(someMember)))
return true;
if (Methods.Any(m => m.Equals(someMember)))
return true;
return false;
}
