/// <summary>
/// Finds the constructor.
/// </summary>
/// <param name="Type">The type.</param>
/// <returns>The constructor that should be used</returns>
private ConstructorInfo FindConstructor(Type Type)
{
Contract.Requires <ArgumentNullException>(Type != null, "Type");
var Constructors = Type.GetConstructors();
ConstructorInfo Constructor = null;
foreach (ConstructorInfo TempConstructor in Constructors.OrderByDescending(x => x.GetParameters().Length))
{
bool Found = true;
foreach (ParameterInfo Parameter in TempConstructor.GetParameters())
{
Type ParameterType = Parameter.ParameterType;
if (Parameter.ParameterType.GetInterfaces().Contains(typeof(IEnumerable)) && Parameter.ParameterType.IsGenericType)
{
ParameterType = ParameterType.GetGenericArguments().First();
if (!AppContainer.Keys.Any(x => x.Item1 == ParameterType))
{
Found = false;
break;
}
}
else if (!this.AppContainer.Keys.Contains(new Tuple <Type, string>(ParameterType, "")))
{
Found = false;
break;
}
}
if (Found)
{
Constructor = TempConstructor;
break;
}
}
return(Constructor);
}
} // END public void CompileAndExecute(String pCodeToCompile ...)
/// <summary>
/// This compiles with additional information returned. CompileAndExecute
/// does not return the detailed compiled information.
/// </summary>
/// <param name="pCodeToCompile"></param>
/// <param name="pReferencedAssemblies"></param>
/// <param name="pMainClassName"></param>
/// <param name="pInstanceName"></param>
/// <param name="pExecutionMethodName"></param>
/// <param name="pMethodParameters"></param>
/// <returns></returns>
public List <String> Compile(String pCodeToCompile,
List <String> pReferencedAssemblies,
String pMainClassName,
out String pFullTypeName,
out String pModuleName,
out List <String> pConstructors,
out List <String> pMembers,
out List <String> pFields,
out List <String> pMethods,
out List <String> pProperties)
{
List <String> ReturnVal = new List <String>();
Dictionary <String, String> DOMProviderOptions = null;
CSharpCodeProvider DOMProvider = null;
CompilerParameters DOMCompilerParams = null;
pFullTypeName = "";
pModuleName = "";
pConstructors = new List <String>();
pMembers = new List <String>();
pFields = new List <String>();
pMethods = new List <String>();
pProperties = new List <String>();
try
{
DOMProviderOptions = new Dictionary <String, String>();
DOMProviderOptions.Add(COMPILER_VERSION_KEY, COMPILER_VERSION_SUPPORTED);
DOMProvider = new CSharpCodeProvider(DOMProviderOptions);
DOMCompilerParams = new CompilerParameters();
if (pReferencedAssemblies != null)
{
if (pReferencedAssemblies.Count > 0)
{
foreach (String RefAssembly in pReferencedAssemblies)
{
if (RefAssembly != null)
{
if (RefAssembly.Length > 0)
{
DOMCompilerParams.ReferencedAssemblies.Add(RefAssembly);
} // END if (File.Exists(pExecutableFullPath))
else
{
ReturnVal.Add(String.Format("A reference file was empty.{0}", Environment.NewLine));
}
} // END if (pExecutableFullPath.Length > 0)
else
{
ReturnVal.Add(String.Format("A reference file was null.{0}", Environment.NewLine));
}
} // END foreach (String RefAssembly in pReferencedAssemblies)
} // END if (pReferencedAssemblies.Count > 0)
} // END if (pReferencedAssemblies != null)
// These references will always be there to support the code compiling
if (!DOMCompilerParams.ReferencedAssemblies.Contains("System.dll"))
{
DOMCompilerParams.ReferencedAssemblies.Add("System.dll");
}
if (!DOMCompilerParams.ReferencedAssemblies.Contains("System.Windows.Forms.dll"))
{
DOMCompilerParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");
}
if (!DOMCompilerParams.ReferencedAssemblies.Contains("System.Runtime.Serialization.dll"))
{
DOMCompilerParams.ReferencedAssemblies.Add("System.Runtime.Serialization.dll");
}
// Adds this executable.
DOMCompilerParams.ReferencedAssemblies.Add(System.Reflection.Assembly.GetEntryAssembly().Location);
DOMCompilerParams.GenerateInMemory = true;
DOMCompilerParams.GenerateExecutable = false;
DOMCompilerParams.CompilerOptions = "/optimize";
DOMCompilerParams.IncludeDebugInformation = true;
DOMCompilerParams.MainClass = pMainClassName;
CompilerResults CompileResults = DOMProvider.CompileAssemblyFromSource(DOMCompilerParams, pCodeToCompile);
if (CompileResults != null)
{
if (CompileResults.Errors.Count != 0)
{
foreach (CompilerError oErr in CompileResults.Errors)
{
ReturnVal.Add(String.Format("Error# [{0}] - [{1}] Line# [{2}] Column# [{3}].{4}",
oErr.ErrorNumber.ToString(), oErr.ErrorText, oErr.Line.ToString(),
oErr.Column.ToString(), Environment.NewLine));
} // END foreach (CompilerError oErr in CompileResults.Errors)
} // END if (CompileResults.Errors.Count != 0)
else
{
Type[] ObjectTypes = CompileResults.CompiledAssembly.GetTypes();
// List<String> pMembers, List<String> pFields, List<String> pMethods, List<String> pProperties
if (ObjectTypes.Length > 0)
{
pFullTypeName = ObjectTypes[0].FullName;
Object CompiledObject = CompileResults.CompiledAssembly.CreateInstance(pFullTypeName);
Type CompiledType = CompiledObject.GetType();
pModuleName = CompiledType.Module.ScopeName;
// Beginning here, you could create and populate class instances that
// contain information gleaned from constructors, methods, members,
// properties, etc. and their parameters instead of passing back these
// generalized descriptions.
ConstructorInfo[] TempConstructors = CompiledType.GetConstructors();
foreach (ConstructorInfo TempConstructor in TempConstructors)
{
String StringToAdd = "";
if (TempConstructor.Name == ".ctor")
{
StringToAdd = "void " + ObjectTypes[0].Name;
}
else
{
StringToAdd = "void " + TempConstructor.Name;
}
String ParmString = "";
if (TempConstructor.Module.ScopeName.Equals(pModuleName))
{
ParameterInfo[] TempConstructorParam = TempConstructor.GetParameters();
foreach (ParameterInfo TempParam in TempConstructorParam)
{
ParmString += String.Format("{0} {1}, ", TempParam.ParameterType.FullName, TempParam.Name);
}
}
StringToAdd += "(" + ParmString + ")";
pConstructors.Add(StringToAdd);
}
MemberInfo[] TempDefaultMembers = CompiledType.GetDefaultMembers();
// List<String> pFields, List<String> pMethods, List<String> pProperties
if (TempDefaultMembers.Length > 0)
{
foreach (MemberInfo TempMember in TempDefaultMembers)
{
if (TempMember.Module.ScopeName.Equals(pModuleName))
{
String StringToAdd = "";
StringToAdd = String.Format("{0} {1}, ", TempMember.ReflectedType.FullName, TempMember.Name);
pMembers.Add(StringToAdd);
} // END if (TempMember.Module.ScopeName.Equals(pModuleName))
} // END if (TempDefaultMembers.Length > 0)
} // END if (TempDefaultMembers.Length > 0)
FieldInfo[] TempFields = CompiledType.GetFields();
// List<String> pFields, List<String> pMethods, List<String> pProperties
if (TempFields.Length > 0)
{
foreach (FieldInfo TempField in TempFields)
{
if (TempField.Module.ScopeName.Equals(pModuleName))
{
String StringToAdd = "";
StringToAdd = String.Format("{0} {1}, ", TempField.ReflectedType.FullName, TempField.Name);
pFields.Add(StringToAdd);
} // END if (TempField.Module.ScopeName.Equals(pModuleName))
} // END foreach (FieldInfo TempField in TempFields)
} // END if (TempFields.Length > 0)
MemberInfo[] TempMembers = CompiledType.GetMembers();
// List<String> pProperties
if (TempMembers.Length > 0)
{
foreach (MemberInfo TempMember in TempMembers)
{
if (TempMember.Module.ScopeName.Equals(pModuleName))
{
String StringToAdd = "";
StringToAdd = TempMember.ToString(); // String.Format("{0} {1}, ", TempMember.GetType().FullName, TempMember.Name);
pMembers.Add(StringToAdd);
}
} // END if (TempDefaultMembers.Length > 0)
} // END if (TempDefaultMembers.Length > 0)
MethodInfo[] TempMethods = CompiledType.GetMethods();
foreach (MethodInfo TempMethod in TempMethods)
{
if ((TempMethod.Module.ScopeName.Equals(pModuleName)) && (!TempMethod.IsSpecialName))
{
String StringToAdd = "";
StringToAdd = String.Format("{0} {1}, ", TempMethod.ReturnType.FullName, TempMethod.Name);
ParameterInfo[] TempParams = TempMethod.GetParameters();
String ParmString = "";
foreach (ParameterInfo TempParam in TempParams)
{
String ParamName = TempParam.Name;
String ParamTypeName = TempParam.ParameterType.FullName;
Object DefaultValue = TempParam.DefaultValue;
if (DefaultValue.ToString().Length == 0)
{
ParmString += String.Format("{0} {1}, ", ParamTypeName, ParamName);
}
else
{
ParmString += String.Format("{0} {1}={2}, ", ParamTypeName, ParamName, DefaultValue.ToString());
}
} // END foreach (ParameterInfo TempParam in TempParams)
if (ParmString.EndsWith(", "))
{
ParmString = ParmString.Substring(0, ParmString.Length - 2);
}
StringToAdd += "(" + ParmString + ")";
pMethods.Add(StringToAdd);
} // END if (TempMethod.Module.ScopeName.Equals(pModuleName))
} // END foreach (MethodInfo TempMethod in TempMethods)
PropertyInfo[] TempProperties = CompiledType.GetProperties();
// List<String> pProperties
if (TempProperties.Length > 0)
{
foreach (PropertyInfo TempProperty in TempProperties)
{
if (TempProperty.Module.ScopeName.Equals(pModuleName))
{
String StringToAdd = "";
StringToAdd = String.Format("{0} {1}, ", TempProperty.PropertyType.FullName, TempProperty.Name);
if (TempProperty.CanRead && TempProperty.CanWrite)
{
StringToAdd += " (get/set)";
}
else if (!TempProperty.CanRead && TempProperty.CanWrite)
{
StringToAdd += " (set ONLY)";
}
else if (TempProperty.CanRead && !TempProperty.CanWrite)
{
StringToAdd += " (get ONLY)";
}
else
{
// No action
}
pProperties.Add(StringToAdd);
} // END if (TempProperty.Module.ScopeName.Equals(pModuleName))
} // END if (TempDefaultMembers.Length > 0)
} // END if (TempDefaultMembers.Length > 0)
} // END if (ObjectTypes.Length > 0)
else
{
ReturnVal.Add("No defined types found in the compiled object.");
}
} // END else of [if (CompileResults.Errors.Count != 0)]
} // END if (CompileResults != null)
else
{
ReturnVal.Add("No compiled object created.");
} // END else of [if (CompileResults != null)]
} // END try
catch (Exception exUnhandled)
{
// Insert your exception handling code here.
// This is only temporary.
System.Windows.Forms.MessageBox.Show(String.Format("Error Message [{0}]{1}Error Source [{2}]",
exUnhandled.Message,
Environment.NewLine,
exUnhandled.Source),
"Error",
System.Windows.Forms.MessageBoxButtons.OK,
System.Windows.Forms.MessageBoxIcon.Error);
} // END catch (Exception exUnhandled)
finally
{
if (DOMProviderOptions != null)
{
DOMProviderOptions.Clear();
DOMProviderOptions = null;
}
if (DOMProvider != null)
{
DOMProvider.Dispose();
DOMProvider = null;
}
if (DOMCompilerParams != null)
{
DOMCompilerParams = null;
}
} // END finally
return(ReturnVal);
} // END public void CompileAndExecute(String pCodeToCompile ...)
