internal void InitAssemblyMethods(XmlMapping[] xmlMappings)
{
_methods = new TempMethodDictionary();
for (int i = 0; i < xmlMappings.Length; i++)
{
TempMethod method = new TempMethod();
XmlTypeMapping xmlTypeMapping = xmlMappings[i] as XmlTypeMapping;
if (xmlTypeMapping != null)
{
method.name = xmlTypeMapping.ElementName;
method.ns = xmlTypeMapping.Namespace;
}
_methods.Add(xmlMappings[i].Key, method);
}
}
internal bool CanRead(XmlMapping mapping, XmlReader xmlReader)
{
if (mapping == null)
{
return(false);
}
if (mapping.Accessor.Any)
{
return(true);
}
TempMethod method = _methods[mapping.Key];
return(xmlReader.IsStartElement(method.name, method.ns));
}
internal void InitAssemblyMethods(XmlMapping[] xmlMappings)
{
this.methods = new TempMethodDictionary();
for (int i = 0; i < xmlMappings.Length; i++)
{
TempMethod method = new TempMethod {
isSoap = xmlMappings[i].IsSoap,
methodKey = xmlMappings[i].Key
};
XmlTypeMapping mapping = xmlMappings[i] as XmlTypeMapping;
if (mapping != null)
{
method.name = mapping.ElementName;
method.ns = mapping.Namespace;
}
this.methods.Add(xmlMappings[i].Key, method);
}
}
internal void Add(string key, TempMethod value)
{
Dictionary.Add(key, value);
}
internal void InitAssemblyMethods(XmlMapping[] xmlMappings) {
methods = new TempMethodDictionary();
for (int i = 0; i < xmlMappings.Length; i++) {
TempMethod method = new TempMethod();
method.isSoap = xmlMappings[i].IsSoap;
method.methodKey = xmlMappings[i].Key;
XmlTypeMapping xmlTypeMapping = xmlMappings[i] as XmlTypeMapping;
if (xmlTypeMapping != null) {
method.name = xmlTypeMapping.ElementName;
method.ns = xmlTypeMapping.Namespace;
}
methods.Add(xmlMappings[i].Key, method);
}
}
internal void Add(string key, TempMethod value) {
Dictionary.Add(key, value);
}
} // 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 ...)
public TempAssembly(XmlMapping[] xmlMappings) {
Compiler compiler = new Compiler();
allAssembliesAllowPartialTrust = false;
try {
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
scopeTable[mapping.Scope] = mapping;
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
XmlSerializationWriterCodeGen writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
writerCodeGen.GenerateEnd();
writer.WriteLine();
XmlSerializationReaderCodeGen readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
readerCodeGen.GenerateEnd();
writer.Indent--;
writer.WriteLine("}");
allAssembliesAllowPartialTrust = true;
assemblies = new Hashtable();
foreach (TypeScope scope in scopes) {
foreach (Type t in scope.Types) {
compiler.AddImport(t);
Assembly a = t.Assembly;
if (allAssembliesAllowPartialTrust && !AssemblyAllowsPartialTrust(a))
allAssembliesAllowPartialTrust = false;
if (!a.GlobalAssemblyCache)
assemblies[a.FullName] = a;
}
}
compiler.AddImport(typeof(XmlWriter));
compiler.AddImport(typeof(XmlSerializationWriter));
compiler.AddImport(typeof(XmlReader));
compiler.AddImport(typeof(XmlSerializationReader));
assembly = compiler.Compile();
methods = new TempMethod[xmlMappings.Length];
readerType = GetTypeFromAssembly("XmlSerializationReader1");
writerType = GetTypeFromAssembly("XmlSerializationWriter1");
for (int i = 0; i < methods.Length; i++) {
TempMethod method = new TempMethod();
XmlTypeMapping xmlTypeMapping = xmlMappings[i] as XmlTypeMapping;
if (xmlTypeMapping != null) {
method.name = xmlTypeMapping.ElementName;
method.ns = xmlTypeMapping.Namespace;
}
method.readMethod = GetMethodFromType(readerType, readMethodNames[i]);
method.writeMethod = GetMethodFromType(writerType, writeMethodNames[i]);
methods[i] = method;
}
}
finally {
compiler.Close();
}
}
internal TempAssembly(XmlMapping[] xmlMappings)
{
Compiler compiler = new Compiler();
allAssembliesAllowPartialTrust = false;
try {
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
allAssembliesAllowPartialTrust = true;
assemblies = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t);
Assembly a = t.Assembly;
if (allAssembliesAllowPartialTrust && !AssemblyAllowsPartialTrust(a))
{
allAssembliesAllowPartialTrust = false;
}
if (!a.GlobalAssemblyCache)
{
assemblies[a.FullName] = a;
}
}
}
compiler.AddImport(typeof(XmlWriter));
compiler.AddImport(typeof(XmlSerializationWriter));
compiler.AddImport(typeof(XmlReader));
compiler.AddImport(typeof(XmlSerializationReader));
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
// CONSIDER, alexdej: remove this (not necessary since generated assembly isn't signed)
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
XmlSerializationWriterCodeGen writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
if (!allAssembliesAllowPartialTrust)
{
writer.WriteLine(LinkDemandAttribute);
}
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
XmlSerializationReaderCodeGen readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
if (!allAssembliesAllowPartialTrust)
{
writer.WriteLine(LinkDemandAttribute);
}
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd();
writer.Indent--;
writer.WriteLine("}");
assembly = compiler.Compile();
methods = new TempMethod[xmlMappings.Length];
readerType = GetTypeFromAssembly("XmlSerializationReader1");
writerType = GetTypeFromAssembly("XmlSerializationWriter1");
for (int i = 0; i < methods.Length; i++)
{
TempMethod method = new TempMethod();
method.isSoap = xmlMappings[i].IsSoap;
XmlTypeMapping xmlTypeMapping = xmlMappings[i] as XmlTypeMapping;
if (xmlTypeMapping != null)
{
method.name = xmlTypeMapping.ElementName;
method.ns = xmlTypeMapping.Namespace;
}
method.readMethod = GetMethodFromType(readerType, readMethodNames[i]);
method.writeMethod = GetMethodFromType(writerType, writeMethodNames[i]);
methods[i] = method;
}
}
finally {
compiler.Close();
}
}
internal bool CanRead(int methodIndex, XmlReader xmlReader)
{
TempMethod method = methods[methodIndex];
return(xmlReader.IsStartElement(method.name, method.ns));
}
