public static TDelegate BuildDelegate <TDelegate>(string functionBody, string functionNamespace, string[] usingNamespaces, Assembly[] assemblies)
where TDelegate : class
{
Assembler assembler = new Assembler();
assembler.AddSharpmakeAssemblies();
assembler.Assemblies.AddRange(assemblies);
const string className = "AssemblerBuildFunction_Class";
const string methodName = "AssemblerBuildFunction_Method";
// Fix : Bug with -> Path.GetTempFileName
// http://msdn.microsoft.com/en-ca/library/windows/desktop/aa364991(v=vs.85).aspx
// Limit of 65535 limit on files when generating the temp file. New temp file will use
// a new Guid as filename and Sharpmake will clean the temporary files when done by aggregating
// the temp files and deleting them.
// eg. "C:\\fastbuild-work\\85f7d472c25d494ca09f2ea7fe282d50"
//string sourceTmpFile = Path.GetTempFileName();
string sourceTmpFile = Path.Combine(Path.GetTempPath(), (Guid.NewGuid().ToString("N") + ".tmp.sharpmake.cs"));
Type delegateType = typeof(TDelegate);
Error.Valid(IsDelegate(delegateType), "BuildDelegate<TDelegate>(), TDelegate is not a delegate");
MethodInfo methodInfo = GetDelegateMethodInfo(delegateType);
using (StreamWriter writer = new StreamWriter(sourceTmpFile))
{
// add using namespace...
foreach (string usingNamespace in usingNamespaces)
{
writer.WriteLine("using {0};", usingNamespace);
}
writer.WriteLine();
// namespace name
writer.WriteLine("namespace {0}", functionNamespace);
writer.WriteLine("{");
writer.WriteLine(" public static class {0}", className);
writer.WriteLine(" {");
// write method signature
string returnTypeName = methodInfo.ReturnType == typeof(void) ? "void" : methodInfo.ReturnType.FullName;
writer.Write(" public static {0} {1}(", returnTypeName, methodName);
ParameterInfo[] parameters = methodInfo.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
string parametersName = parameters[i].Name;
string parametersType = (parameters[i].ParameterType == typeof(object)) ? "Object" : parameters[i].ParameterType.FullName;
writer.Write("{0}{1} {2}", i == 0 ? "" : ", ", parametersType, parametersName);
}
writer.WriteLine(")");
// write method body
writer.WriteLine(" {");
writer.WriteLine(" {0}" + Environment.NewLine, functionBody.Replace("\n", "\n "));
writer.WriteLine(" }");
writer.WriteLine(" }");
writer.WriteLine("}");
}
// build in memory
Assembly assembly = assembler.Build(builderContext: null, libraryFile: null, sources: sourceTmpFile).Assembly;
InternalError.Valid(assembly != null);
// Try to delete tmp file to prevent pollution, but useful while debugging
//if (!System.Diagnostics.Debugger.IsAttached)
Util.TryDeleteFile(sourceTmpFile);
// Scan assembly to find our tmp class
string fullClassName = functionNamespace + "." + className;
Type buildedType = assembly.GetType(fullClassName);
// get out method to bind into the delegate
MethodInfo builtMethod = buildedType.GetMethod(methodName);
InternalError.Valid(builtMethod != null);
// bind the method
Delegate returnDelegate;
try
{
returnDelegate = builtMethod.CreateDelegate(delegateType);
InternalError.Valid(returnDelegate != null);
}
catch (Exception e)
{
throw new InternalError(e);
}
TDelegate result = returnDelegate as TDelegate;
InternalError.Valid(result != null, "Cannot cast built delegate into user delegate");
return(result);
}
public static TDelegate BuildDelegate <TDelegate>(string sourceFilePath, string fullFunctionName, Assembly[] assemblies)
where TDelegate : class
{
FileInfo fileInfo = new FileInfo(sourceFilePath);
if (!fileInfo.Exists)
{
throw new Error("source file name not found: {0}", sourceFilePath);
}
Type delegateType = typeof(TDelegate);
Error.Valid(IsDelegate(delegateType), "BuildDelegate<FUNC_TYPE>(), FUNC_TYPE is not a delegate");
MethodInfo delegateMethodInfo = GetDelegateMethodInfo(delegateType);
ParameterInfo[] delegateParameterInfos = delegateMethodInfo.GetParameters();
ParameterInfo delegateReturnInfos = delegateMethodInfo.ReturnParameter;
Assembler assembler = new Assembler();
assembler.AddSharpmakeAssemblies();
assembler.Assemblies.AddRange(assemblies);
Assembly assembly = assembler.BuildAssembly(fileInfo.FullName);
List <MethodInfo> matchMethods = new List <MethodInfo>();
foreach (Type type in assembly.GetTypes())
{
MethodInfo[] methodInfos = type.GetMethods();
foreach (MethodInfo methodInfo in methodInfos)
{
string fullName = methodInfo.DeclaringType.FullName + "." + methodInfo.Name;
if (fullFunctionName == fullName &&
methodInfo.IsStatic && methodInfo.GetParameters().Length == delegateMethodInfo.GetParameters().Length)
{
ParameterInfo[] parameterInfos = methodInfo.GetParameters();
ParameterInfo returnInfos = methodInfo.ReturnParameter;
bool equal = (returnInfos.GetType() == delegateReturnInfos.GetType() &&
parameterInfos.Length == delegateParameterInfos.Length);
if (equal)
{
for (int i = 0; i < parameterInfos.Length; ++i)
{
if (parameterInfos[i].GetType() != delegateParameterInfos[i].GetType())
{
equal = false;
break;
}
}
}
if (equal)
{
matchMethods.Add(methodInfo);
}
}
}
}
if (matchMethods.Count != 1)
{
throw new Error("Cannot find method name {0} that match {1} in {2}", fullFunctionName, delegateMethodInfo.ToString(), sourceFilePath);
}
MethodInfo method = matchMethods[0];
// bind the method
Delegate returnDelegate;
try
{
returnDelegate = method.CreateDelegate(delegateType);
InternalError.Valid(returnDelegate != null);
}
catch (Exception e)
{
throw new InternalError(e);
}
TDelegate result = returnDelegate as TDelegate;
InternalError.Valid(result != null, "Cannot cast built delegate into user delegate");
return(result);
}