public static void GenerateMIDICode(ICodeGenerator generator, MidiSequence sequence, string midiName, TextWriter writer)
{
CodeNamespace e = new CodeNamespace("AutoGenerated");
CodeTypeDeclaration declaration = new CodeTypeDeclaration(midiName);
declaration.Members.Add(CreateSequenceMethod(sequence));
for (int i = 0; i < sequence.NumberOfTracks; i++)
{
int num2 = i + 1;
declaration.Members.Add(CreateTrackMethod("CreateTrack" + num2.ToString(), sequence[i]));
}
e.Types.Add(declaration);
generator.GenerateCodeFromNamespace(e, writer, new CodeGeneratorOptions());
}
/// <summary>Creates code from a MIDI sequence.</summary>
/// <param name="generator">Generator used to generate the actual code.</param>
/// <param name="sequence">The sequence to translate.</param>
/// <param name="midiName">The name of the MIDI sequence to be used as the class name.</param>
/// <param name="writer">The writer to which the text is written.</param>
public static void GenerateMIDICode(
ICodeGenerator generator, MidiSequence sequence,
string midiName, TextWriter writer)
{
// Create a new namespace
CodeNamespace ns = new CodeNamespace("AutoGenerated");
// Create the new class
CodeTypeDeclaration midiType = new CodeTypeDeclaration(midiName);
// Add a method to it to create the sequence
midiType.Members.Add(CreateSequenceMethod(sequence));
for(int i=0; i<sequence.NumberOfTracks; i++)
{
midiType.Members.Add(CreateTrackMethod("CreateTrack" + (i+1).ToString(), sequence[i]));
}
// Add the class to the namespace
ns.Types.Add(midiType);
// Generate the code
generator.GenerateCodeFromNamespace(ns, writer, new CodeGeneratorOptions());
}
private static void PopulateNamespace(ICodeGenerator itfCG, TextWriter w)
{
// Add a code comment.
CodeCommentStatement c = new CodeCommentStatement("This is the wicked cool Hello class");
itfCG.GenerateCodeFromStatement(c, w, null);
// Build root namespace.
CodeNamespace cnamespace = new CodeNamespace("SimpleCodeDOMHelloClass");
// Reference other namespaces.
cnamespace.Imports.Add(new CodeNamespaceImport ("System") );
cnamespace.Imports.Add(new CodeNamespaceImport ("System.Windows.Forms") );
// Insert the HelloClass.
CodeTypeDeclaration co = new CodeTypeDeclaration ("HelloClass");
co.IsClass = true;
cnamespace.Types.Add(co);
co.BaseTypes.Add (typeof (System.Object) );
co.TypeAttributes = TypeAttributes.Public;
// Make a custom construcor.
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
ctor.Parameters.Add(new CodeParameterDeclarationExpression
(new CodeTypeReference(typeof(string)), "msg"));
ctor.Statements.Add((new CodeAssignStatement(new CodeArgumentReferenceExpression("mMsg"),
new CodeArgumentReferenceExpression("msg"))));
co.Members.Add(ctor);
// Add the default construcor.
ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
co.Members.Add(ctor);
// Insert a String field (mMsg).
CodeMemberField cf = new CodeMemberField("System.String", "mMsg");
cf.Comments.Add(new CodeCommentStatement("The state data..."));
cf.Attributes = MemberAttributes.Private;
co.Members.Add(cf);
// Add the Message property.
CodeMemberProperty cp = new CodeMemberProperty();
cp.Name = "Message";
cp.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cp.Type = new CodeTypeReference("System.String");
cp.Comments.Add(new CodeCommentStatement("The Message property"));
// Getter.
cp.GetStatements.Add(new CodeMethodReturnStatement
(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "mMsg")));
// Setter.
cp.SetStatements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("mMsg"),
new CodeArgumentReferenceExpression("value")));
co.Members.Add (cp);
// Add the Display() message.
CodeMemberMethod cm = new CodeMemberMethod();
cm.Name = "Display";
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Comments.Add(new CodeCommentStatement("Show 'em what we got!"));
cm.Statements.Add (new CodeMethodInvokeExpression
(new CodeTypeReferenceExpression("MessageBox"), "Show",
new CodeExpression []
{new CodeArgumentReferenceExpression ("mMsg")}));
co.Members.Add(cm);
// Generate the code!
itfCG.GenerateCodeFromNamespace (cnamespace, w, null);
}
} //Main()
public static void SpitList (TextWriter w, string typeName, ICodeGenerator baseCompiler, string ns)
{
CodeCommentStatement c = new CodeCommentStatement (string.Format ("List of {0}", typeName));
baseCompiler.GenerateCodeFromStatement (c, w, null);
CodeNamespace cnamespace = new CodeNamespace("Microsoft.Samples");
cnamespace.Imports.Add (new CodeNamespaceImport ("System") );
cnamespace.Imports.Add (new CodeNamespaceImport ("System.Collections") );
if (ns != null && ns != "") cnamespace.Imports.Add (new CodeNamespaceImport (ns) );
CodeTypeDeclaration co = new CodeTypeDeclaration (typeName +"List");
co.IsClass = true;
cnamespace.Types.Add (co);
co.BaseTypes.Add (typeof (CollectionBase) );
co.TypeAttributes = TypeAttributes.Public;
//Generates: public <TYPE> this[int index] {
// get {
// return ((<TYPE>)List[index]);
// }
// set {
// List[index] = value;
// }
// }
CodeMemberProperty cp = new CodeMemberProperty ();
cp.Name = "Item";
cp.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cp.Type = new CodeTypeReference(typeName);
cp.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeof(int)), "index"));
cp.GetStatements.Add (new CodeMethodReturnStatement (new CodeCastExpression (typeName, new CodeIndexerExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(), "List"), new CodeArgumentReferenceExpression ("index")))));
cp.SetStatements.Add (new CodeAssignStatement (new CodeIndexerExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), new CodeArgumentReferenceExpression ("index")), new CodeArgumentReferenceExpression ("value")));
co.Members.Add (cp);
//Gen: public int Add(<TYPE> value) {
// return List.Add(value);
// }
CodeMemberMethod cm = new CodeMemberMethod ();
cm.Name = "Add";
cm.ReturnType = new CodeTypeReference(typeof(int));
cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value"));
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Add",
new CodeArgumentReferenceExpression ("value"))));
co.Members.Add (cm);
//Gen: public void Insert(int index, <TYPE> value)
// {
// List.Insert(index, info);
// }
cm = new CodeMemberMethod ();
cm.Name = "Insert";
cm.ReturnType = new CodeTypeReference(typeof(void));
cm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeof(int)), "index"));
cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value"));
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Statements.Add (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Insert",
new CodeArgumentReferenceExpression ("index"), new CodeArgumentReferenceExpression ("value")));
co.Members.Add (cm);
//Gen: public int IndexOf(<TYPE> value)
// {
// return List.IndexOf(value);
// }
cm = new CodeMemberMethod ();
cm.Name = "IndexOf";
cm.ReturnType = new CodeTypeReference(typeof(int));
cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value"));
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "IndexOf", new CodeExpression []
{new CodeArgumentReferenceExpression ("value")})));
co.Members.Add (cm);
//Gen: public bool Contains(<TYPE> value)
// {
// return List.Contains(value);
// }
cm = new CodeMemberMethod ();
cm.Name = "Contains";
cm.ReturnType = new CodeTypeReference(typeof(bool));
cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value"));
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Statements.Add (new CodeMethodReturnStatement (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Contains", new CodeExpression []
{new CodeArgumentReferenceExpression ("value")})));
co.Members.Add (cm);
//Gen: public void Remove(<TYPE> value)
// {
// List.Remove(value);
// }
cm = new CodeMemberMethod ();
cm.Name = "Remove";
cm.Parameters.Add (new CodeParameterDeclarationExpression (typeName, "value"));
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Statements.Add (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "Remove", new CodeExpression []
{new CodeArgumentReferenceExpression ("value")}));
co.Members.Add (cm);
//Gen: public void CopyTo(<Type>[] array, int index)
// {
// List.CopyTo(array, index);
// }
cm = new CodeMemberMethod ();
cm.Name = "CopyTo";
cm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeName, 1), "array"));
cm.Parameters.Add (new CodeParameterDeclarationExpression (new CodeTypeReference(typeof(int)), "index"));
cm.Attributes = MemberAttributes.Public | MemberAttributes.Final ;
cm.Statements.Add (new CodeMethodInvokeExpression (new CodeFieldReferenceExpression (new CodeThisReferenceExpression(),"List"), "CopyTo", new CodeExpression []
{new CodeArgumentReferenceExpression ("array"), new CodeArgumentReferenceExpression ("index")}));
co.Members.Add (cm);
baseCompiler.GenerateCodeFromNamespace (cnamespace, w, null);
} //SpitList()
/// <summary>
/// ���ɴ���
/// </summary>
/// <param name="CodeGenerator"></param>
/// <param name="CurrentNameSpace"></param>
/// <returns></returns>
private static string GenerateCode(ICodeGenerator CodeGenerator,
CodeNamespace CurrentNameSpace)
{
// CodeGeneratorOptions��������ָ�����ֹ�����������
// ʹ�õĸ�ʽ��ѡ��
CodeGeneratorOptions cop = new CodeGeneratorOptions();
// ָ����ʽ�������ŵ�λ��
cop.BracingStyle = "C";
// ָ����ʽ��������������ʽ
cop.IndentString = " ";
StringBuilder sbCode = new StringBuilder();
StringWriter sw = new StringWriter(sbCode);
CodeGenerator.GenerateCodeFromNamespace(CurrentNameSpace, sw, cop);
return sbCode.ToString();
}
private string CreationClassePersistable(ICodeGenerator codeGenerator, Langage langageChoice)
{
// namespace DB + nom de la base de données
CodeNamespace monNamespace = new CodeNamespace("DB_" + (trvSqlServerSchema.SelectedNode.Parent.Tag as SQLDMO._Database).Name);
// ajout des imports de namespace
monNamespace.Imports.Add(new CodeNamespaceImport("System"));
monNamespace.Imports.Add(new CodeNamespaceImport("System.Data"));
monNamespace.Imports.Add(new CodeNamespaceImport("SableFin.SfinX.SimplePersistance"));
// creation de la classe
SQLDMO._Table tab=trvSqlServerSchema.SelectedNode.Tag as SQLDMO._Table;
CodeTypeDeclaration maClasse = new CodeTypeDeclaration(tab.Name);
//maClasse.BaseTypes.Add(tab.Name);
maClasse.Attributes = MemberAttributes.Public;
maClasse.IsClass = true;
maClasse.Comments.Add(new CodeCommentStatement("Persistable classes for the " + tab.Name + " table.", false));
// creation de l'attribut [PersistConnectionString]
CodeAttributeDeclaration attr=new CodeAttributeDeclaration();
attr.Name="PersistConnectionString";
maClasse.CustomAttributes.Add(attr);
if ((ConnectionStringIn)cboCnxStrIn.SelectedItem==ConnectionStringIn.ApplicationSettings)
attr.Arguments.Add(new CodeAttributeArgument("AppSettingsName",new CodePrimitiveExpression("cnxstr")));
else attr.Arguments.Add(new CodeAttributeArgument("SessionVariable",new CodePrimitiveExpression("cnxstr")));
if ((DatasourceType)cboPDSA.SelectedItem==DatasourceType.SQLServerStoredProc)
{
// creation de l'attribut [PersistStoredProc]
attr=new CodeAttributeDeclaration();
attr.Name="PersistStoredProc";
attr.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression("spS_" + tab.Name)));
attr.Arguments.Add(new CodeAttributeArgument("INSERTStoredProc",new CodePrimitiveExpression("spI_" + tab.Name)));
attr.Arguments.Add(new CodeAttributeArgument("DELETEStoredProc",new CodePrimitiveExpression("spD_" + tab.Name)));
attr.Arguments.Add(new CodeAttributeArgument("UPDATEStoredProc",new CodePrimitiveExpression("spU_" + tab.Name)));
attr.Arguments.Add(new CodeAttributeArgument("TableName",new CodePrimitiveExpression(tab.Name)));
}
else if ((DatasourceType)cboPDSA.SelectedItem==DatasourceType.DynamicSQL)
{
// creation de l'attribut [PersistDynamicSQL]
attr=new CodeAttributeDeclaration();
attr.Name="PersistDynamicSQL";
attr.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(tab.Name)));
}
maClasse.CustomAttributes.Add(attr);
monNamespace.Types.Add(maClasse); // ajout de la classe dans le namespace
for(int n=1;n<=tab.Columns.Count;n++)
{
SQLDMO._Column col=tab.Columns.Item(n);
Type dotNetType=GetDotNetType(col.PhysicalDatatype);
// private string
CodeMemberField priv_var = new CodeMemberField(dotNetType, "p_" + col.Name);
maClasse.Members.Add(priv_var );
// private bool si Nullable col
CodeMemberField null_var=null;
if (col.AllowNulls)
{
null_var=new CodeMemberField(typeof(bool),col.Name + "ISNULL");
null_var.Attributes=MemberAttributes.Public | MemberAttributes.Final;
null_var.InitExpression=new CodePrimitiveExpression(true);
maClasse.Members.Add(null_var);
}
// definition d'une reference a une variable
CodeFieldReferenceExpression ref_var = null;
ref_var = new CodeFieldReferenceExpression();
ref_var.TargetObject = new CodeThisReferenceExpression();
ref_var.FieldName = priv_var.Name;
CodeFieldReferenceExpression ref_null_var=null;
if (col.AllowNulls)
{
ref_null_var = new CodeFieldReferenceExpression();
ref_null_var.TargetObject = new CodeThisReferenceExpression();
ref_null_var.FieldName = null_var.Name;
}
CodeMemberProperty champDB = new CodeMemberProperty();
champDB.Attributes = MemberAttributes.Public | MemberAttributes.Final;
champDB.Type = new CodeTypeReference(dotNetType);
champDB.Name = col.Name;
champDB.HasGet = true;
champDB.HasSet = true;
CodeMethodReturnStatement returnRefThis = new CodeMethodReturnStatement(ref_var);
champDB.GetStatements.Add(returnRefThis);
CodeAssignStatement setField=new CodeAssignStatement(ref_var,new CodePropertySetValueReferenceExpression());
champDB.SetStatements.Add(setField);
if (col.AllowNulls)
{
CodeAssignStatement setFieldIsNullToFalse=new CodeAssignStatement(ref_null_var,new CodePrimitiveExpression(false));
champDB.SetStatements.Add(setFieldIsNullToFalse);
}
// création de l'attribut pour la propriété en cours
attr=new CodeAttributeDeclaration();
attr.Name="DBField";
attr.Arguments.Add(new CodeAttributeArgument(new CodePrimitiveExpression(col.Name)));
if (col.InPrimaryKey)
{
attr.Arguments.Add(new CodeAttributeArgument("PrimaryKey", new CodePrimitiveExpression(true)));
}
if (col.Identity)
{
attr.Arguments.Add(new CodeAttributeArgument("Identity", new CodePrimitiveExpression(true)));
}
if (col.AllowNulls)
{
attr.Arguments.Add(new CodeAttributeArgument("IsNullable", new CodePrimitiveExpression(true)));
//attr.Arguments.Add(new CodeAttributeArgument("NullValue", new CodePrimitiveExpression(GetDefaultValueForNull(col.PhysicalDatatype))));
}
champDB.CustomAttributes.Add(attr); // ajout de l'attribut sur la prop
maClasse.Members.Add(champDB); // ajout de la propriété dans la classe
}
// On génère finalement le code
System.Text.StringBuilder stringBuilder = new System.Text.StringBuilder();
TextWriter textWriter = new StringWriter(stringBuilder);
try
{
codeGenerator.GenerateCodeFromNamespace(monNamespace, textWriter, null);
}
catch (Exception exception)
{
return(exception.ToString());
}
finally
{
textWriter.Close();
}
return(stringBuilder.ToString());
}
/// <summary>
/// Main driving routine for building a class
/// </summary>
public static void BuildClass(string expression)
{
// need a string to put the code into
_source = new StringBuilder();
StringWriter sw = new StringWriter(_source);
//Declare your provider and generator
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator generator = codeProvider.CreateGenerator(sw);
CodeGeneratorOptions codeOpts = new CodeGeneratorOptions();
CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
myNamespace.Imports.Add(new CodeNamespaceImport("ArdupilotMega"));
//Build the class declaration and member variables
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration();
classDeclaration.IsClass = true;
classDeclaration.Name = "Calculator";
classDeclaration.Attributes = MemberAttributes.Public;
classDeclaration.Members.Add(FieldVariable("answer", typeof(object), MemberAttributes.Private));
//default constructor
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true));
defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor"));
classDeclaration.Members.Add(defaultConstructor);
//property
classDeclaration.Members.Add(MakeProperty("Answer", "answer", typeof(object)));
//Our Calculate Method
/*
* CodeMemberMethod myMethod = new CodeMemberMethod();
* myMethod.Name = "Calculate";
* myMethod.ReturnType = new CodeTypeReference(typeof(object));
* myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true));
* myMethod.Attributes = MemberAttributes.Public;
* myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Object obj"), new CodeSnippetExpression(expression)));
* //myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression("obj.ToString()")));
* myMethod.Statements.Add(
* new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer")));
* classDeclaration.Members.Add(myMethod);
*/
classDeclaration.Members.Add(FieldVariable("customforusenumber", typeof(double), MemberAttributes.Public));
classDeclaration.Members.Add(FieldVariable("customforuseobject", typeof(object), MemberAttributes.Public));
CodeSnippetTypeMember myMethod = new CodeSnippetTypeMember();
myMethod.Text = expression;
classDeclaration.Members.Add(myMethod);
//write code
myNamespace.Types.Add(classDeclaration);
generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts);
sw.Flush();
sw.Close();
Console.Write(sw.ToString());
}
/// <summary>
/// Main driving routine for building a class
/// </summary>
public void BuildFunctionClass(string expression, string strReturnType, string dllName)
{
//if( expression == "29487*[AREA]" )
//{
//}
_dllName = dllName;
bool bCalculate = true;
m_bCalculate = bCalculate;
m_expression = expression;
// expression = RefineEvaluationString(expression);
// expression = expression.ToUpper();
// need a string to put the code into
_source = new StringBuilder();
StringWriter sw = new StringWriter(_source);
//Declare your provider and generator
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator generator = codeProvider.CreateGenerator(sw);
CodeGeneratorOptions codeOpts = new CodeGeneratorOptions();
CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
//Build the class declaration and member variables
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration();
classDeclaration.IsClass = true;
classDeclaration.Name = "Calculator";
classDeclaration.Attributes = MemberAttributes.Public;
switch (strReturnType)
{
case "String":
classDeclaration.Members.Add(FieldVariable("answer", typeof(String), MemberAttributes.Private));
break;
case "double":
classDeclaration.Members.Add(FieldVariable("answer", typeof(double), MemberAttributes.Private));
break;
case "Boolean":
classDeclaration.Members.Add(FieldVariable("answer", typeof(Boolean), MemberAttributes.Private));
break;
default:
return;
//break;
}
//default constructor
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true));
// defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor"));
classDeclaration.Members.Add(defaultConstructor);
switch (strReturnType)
{
case "String":
classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(String)));
break;
case "double":
classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(double)));
break;
case "Boolean":
classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(Boolean)));
break;
default:
return;
//break;
}
//Our Calculate Method
CodeMemberMethod myMethod = new CodeMemberMethod();
myMethod.Name = "Calculate";
switch (strReturnType)
{
case "String":
myMethod.ReturnType = new CodeTypeReference(typeof(String));
break;
case "double":
myMethod.ReturnType = new CodeTypeReference(typeof(double));
break;
case "Boolean":
myMethod.ReturnType = new CodeTypeReference(typeof(Boolean));
break;
default:
return;
//break;
}
myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true));
myMethod.Attributes = MemberAttributes.Public;
myMethod.Parameters.AddRange(GetParametersFromBracketedItems(expression));
int nLastSemiColon = expression.LastIndexOf(";");
if (nLastSemiColon > 0)
{
expression = expression.Substring(0, nLastSemiColon);
}
expression = expression.Replace("[", "");
expression = expression.Replace("@", "");
expression = expression.Replace("]", "");
myMethod.Statements.Add(new CodeSnippetExpression(expression));
classDeclaration.Members.Add(myMethod);
//write code
myNamespace.Types.Add(classDeclaration);
generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts);
sw.Flush();
sw.Close();
}
public void BuildClass(string expression, bool bCalculate, string dllName)
{
_originalInput = expression.Replace("[$", "[").Replace("[@", "[");;
_dllName = dllName;
m_bCalculate = bCalculate;
m_expression = expression;
expression = RefineEvaluationString(expression);
Regex expressionWhiteSpaceMechanic = new Regex(@"\s");
if (!bCalculate) //Calculating equations only use numbers. No need for any manipulation. The expression is already to be compiled.
{
//This can't happen because it ToUpper() the string literals
//expression = expression.ToUpper();
expression = expression.Replace("||", "OR");
expression = expression.Replace("!=", "<>");
expression = expression.Replace("==", "=");
expression = expression.Replace("|", "'");
expression = expression.Replace(">=", ">>"); //This is so we can replace = with double ==
expression = expression.Replace("<=", "<<"); //This is so we can replace = with double ==
//we keep missing non-space whitespace...
expression = expressionWhiteSpaceMechanic.Replace(expression, " ");
expression = expression.Replace(" AND ", " && ");
expression = expression.Replace(" OR ", " || ");
expression = expression.Replace("=", "==");
expression = expression.Replace("<>", "!=");
expression = expression.Replace("<<", "<=");
expression = expression.Replace(">>", ">=");
int nOpen = -1;
bool bStringVariable = false;
bool bDateVariable = false;
for (int i = 0; i < expression.Length; i++)
{
if (expression.Substring(i, 1) == "[")
{
if (expression.Substring(i + 1, 1) == "@")
{
bStringVariable = true;
bDateVariable = false;
}
else if (expression.Substring(i + 1, 1) == "$")
{
bStringVariable = false;
bDateVariable = true;
}
else
{
bStringVariable = false;
bDateVariable = false;
}
}
if (expression.Substring(i, 1) == "'" && nOpen < 0)
{
nOpen = i;
continue;
}
if (expression.Substring(i, 1) == "'" && nOpen > -1)
{
//Get the value between open and (i)
//
String strValueWithQuotes = expression.Substring(nOpen, i - nOpen + 1);
String strValue = expression.Substring(nOpen + 1, i - nOpen - 1);
if (bStringVariable)
{
strValue = strValueWithQuotes.Replace("'", "\"");
}
else if (bDateVariable)
{
strValue = strValueWithQuotes.Replace("'", "\"");
strValue = " Convert.ToDateTime(" + strValue + ") ";
}
else
{
try
{
float fValue = float.Parse(strValue);
}
catch
{
strValue = strValueWithQuotes.Replace("'", "\"");
}
}
//expression = expression.Replace(strValueWithQuotes, strValue);
expression = expression.Remove(nOpen, i - nOpen + 1).Insert(nOpen, strValue);
nOpen = -1;
i = 0;
}
}
}
// need a string to put the code into
_source = new StringBuilder();
StringWriter sw = new StringWriter(_source);
//Declare your provider and generator
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator generator = codeProvider.CreateGenerator(sw);
CodeGeneratorOptions codeOpts = new CodeGeneratorOptions();
CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
//Build the class declaration and member variables
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration();
classDeclaration.IsClass = true;
if (bCalculate)
{
classDeclaration.Name = "Calculator";
}
else
{
classDeclaration.Name = "Evaluator";
}
classDeclaration.Attributes = MemberAttributes.Public;
if (bCalculate)
{
classDeclaration.Members.Add(FieldVariable("answer", typeof(double), MemberAttributes.Private));
}
else
{
classDeclaration.Members.Add(FieldVariable("answer", typeof(bool), MemberAttributes.Private));
}
//default constructor
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true));
defaultConstructor.Statements.Add(new CodeSnippetStatement("//TODO: implement default constructor"));
classDeclaration.Members.Add(defaultConstructor);
//property
if (bCalculate)
{
classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(double)));
}
else
{
classDeclaration.Members.Add(this.MakeProperty("Answer", "answer", typeof(bool)));
}
//Our Calculate Method
CodeMemberMethod myMethod = new CodeMemberMethod();
if (bCalculate)
{
myMethod.Name = "Calculate";
myMethod.ReturnType = new CodeTypeReference(typeof(double));
myMethod.Comments.Add(new CodeCommentStatement("Calculate an expression", true));
myMethod.Attributes = MemberAttributes.Public;
myMethod.Parameters.AddRange(GetParametersFromBracketedItems(expression));
myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("Answer"), new CodeSnippetExpression(System.Text.RegularExpressions.Regex.Replace(expression, "[[\\]]", ""))));
// myMethod.Statements.Add(new CodeSnippetExpression("MessageBox.Show(String.Format(\"Answer = {0}\", Answer))"));
myMethod.Statements.Add(
new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer")));
classDeclaration.Members.Add(myMethod);
}
else
{
myMethod.Name = "Evaluate";
myMethod.ReturnType = new CodeTypeReference(typeof(bool));
myMethod.Comments.Add(new CodeCommentStatement("Evaluate an expression", true));
myMethod.Attributes = MemberAttributes.Public;
myMethod.Parameters.AddRange(GetParametersFromBracketedItems(expression));
expression = expression.Replace("@", "").Replace("$", "");
myMethod.Statements.Add(new CodeConditionStatement(new CodeVariableReferenceExpression(System.Text.RegularExpressions.Regex.Replace(expression, "[[\\]]", "")), new CodeStatement[] { new CodeSnippetStatement("this.Answer = true;") }, new CodeStatement[] { new CodeSnippetStatement("this.Answer = false;") }));
myMethod.Statements.Add(
new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Answer")));
classDeclaration.Members.Add(myMethod);
}
//write code
myNamespace.Types.Add(classDeclaration);
generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts);
sw.Flush();
sw.Close();
}
public override void GenerateCodeFromNamespace(CodeNamespace e, TextWriter w, CodeGeneratorOptions o)
{
generator.GenerateCodeFromNamespace(e, w, o);
}
/// <summary>
/// Builds the assembly from WSDL.
/// </summary>
/// <param name="strWsdl">STR WSDL.</param>
/// <returns></returns>
private Assembly BuildAssemblyFromWsdl(string strWsdl)
{
// Use an XmlTextReader to get the Web Service description
StringReader wsdlStringReader = new StringReader(strWsdl);
XmlTextReader tr = new XmlTextReader(wsdlStringReader);
ServiceDescription.Read(tr);
tr.Close();
// WSDL service description importer
CodeNamespace cns = new CodeNamespace(CodeConstants.CODENAMESPACE);
sdi = new ServiceDescriptionImporter();
//sdi.AddServiceDescription(sd, null, null);
// check for optional imports in the root WSDL
CheckForImports(wsdl);
sdi.ProtocolName = protocolName;
sdi.Import(cns, null);
// change the base class
// get all available Service classes - not only the default one
ArrayList newCtr = new ArrayList();
foreach (CodeTypeDeclaration ctDecl in cns.Types)
{
if (ctDecl.BaseTypes.Count > 0)
{
if (ctDecl.BaseTypes[0].BaseType == CodeConstants.DEFAULTBASETYPE)
{
newCtr.Add(ctDecl);
}
}
}
foreach (CodeTypeDeclaration ctDecl in newCtr)
{
cns.Types.Remove(ctDecl);
ctDecl.BaseTypes[0] = new CodeTypeReference(CodeConstants.CUSTOMBASETYPE);
cns.Types.Add(ctDecl);
}
// source code generation
CSharpCodeProvider cscp = new CSharpCodeProvider();
ICodeGenerator icg = cscp.CreateGenerator();
StringBuilder srcStringBuilder = new StringBuilder();
StringWriter sw = new StringWriter(srcStringBuilder, CultureInfo.CurrentCulture);
if (schemas != null)
{
foreach (XmlSchema xsd in schemas)
{
if (XmlSchemas.IsDataSet(xsd))
{
MemoryStream mem = new MemoryStream();
mem.Position = 0;
xsd.Write(mem);
mem.Position = 0;
DataSet dataSet1 = new DataSet();
dataSet1.Locale = CultureInfo.InvariantCulture;
dataSet1.ReadXmlSchema(mem);
TypedDataSetGenerator.Generate(dataSet1, cns, icg);
}
}
}
icg.GenerateCodeFromNamespace(cns, sw, null);
proxySource = srcStringBuilder.ToString();
sw.Close();
// assembly compilation
string location = "";
if (HttpContext.Current != null)
{
location = HttpContext.Current.Server.MapPath(".");
location += @"\bin\";
}
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Xml.dll");
cp.ReferencedAssemblies.Add("System.Web.Services.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add(Assembly.GetExecutingAssembly().Location);
cp.ReferencedAssemblies.Add(location + "Thinktecture.Tools.Web.Services.Extensions.Messages.dll");
cp.GenerateExecutable = false;
cp.GenerateInMemory = false;
cp.IncludeDebugInformation = false;
cp.TempFiles = new TempFileCollection(CompiledAssemblyCache.GetLibTempPath());
ICodeCompiler icc = cscp.CreateCompiler();
CompilerResults cr = icc.CompileAssemblyFromSource(cp, proxySource);
if (cr.Errors.Count > 0)
{
throw new DynamicCompilationException(string.Format(CultureInfo.CurrentCulture, @"Building dynamic assembly failed: {0} errors", cr.Errors.Count));
}
Assembly compiledAssembly = cr.CompiledAssembly;
//rename temporary assembly in order to cache it for later use
CompiledAssemblyCache.RenameTempAssembly(cr.PathToAssembly, wsdl);
return(compiledAssembly);
}
/// <summary>
/// Main driving routine for building a class
/// </summary>
void BuildClass(string expression, Dictionary <string, double> vars, bool bSimpleAssign, bool bRetArray, int arrayLen)
{
// need a string to put the code into
_source = new StringBuilder();
StringWriter sw = new StringWriter(_source);
//Declare provider and generator
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
ICodeGenerator generator = codeProvider.CreateGenerator(sw);
CodeGeneratorOptions codeOpts = new CodeGeneratorOptions();
CodeNamespace myNamespace = new CodeNamespace("ExpressionEvaluator");
myNamespace.Imports.Add(new CodeNamespaceImport("System"));
//myNamespace.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
//Build the class declaration and member variables
CodeTypeDeclaration classDeclaration = new CodeTypeDeclaration();
classDeclaration.IsClass = true;
classDeclaration.Name = "Calculator";
classDeclaration.Attributes = MemberAttributes.Public;
classDeclaration.Members.Add(FieldVariable("ans", typeof(double), MemberAttributes.Private));
classDeclaration.Members.Add(FieldVariable("arrAns", typeof(double[]), MemberAttributes.Private));
foreach (KeyValuePair <string, double> k in vars)
{
classDeclaration.Members.Add(FieldVariable(k.Key, typeof(double), MemberAttributes.Private));
}
//default constructor
CodeConstructor defaultConstructor = new CodeConstructor();
defaultConstructor.Attributes = MemberAttributes.Public;
defaultConstructor.Comments.Add(new CodeCommentStatement("Default Constructor for class", true));
classDeclaration.Members.Add(defaultConstructor);
CodeTypeDelegate dg = new CodeTypeDelegate("FN1");
dg.ReturnType = new CodeTypeReference(typeof(double));
dg.Parameters.Add(new CodeParameterDeclarationExpression(typeof(double), "p0"));
classDeclaration.Members.Add(dg);
dg = new CodeTypeDelegate("FN2");
dg.ReturnType = new CodeTypeReference(typeof(double));
dg.Parameters.Add(new CodeParameterDeclarationExpression(typeof(double), "p0"));
dg.Parameters.Add(new CodeParameterDeclarationExpression(typeof(double), "p1"));
classDeclaration.Members.Add(dg);
dg = new CodeTypeDelegate("FN3");
dg.ReturnType = new CodeTypeReference(typeof(double));
dg.Parameters.Add(new CodeParameterDeclarationExpression(typeof(double), "p0"));
dg.Parameters.Add(new CodeParameterDeclarationExpression(typeof(double), "p1"));
dg.Parameters.Add(new CodeParameterDeclarationExpression(typeof(double), "p2"));
classDeclaration.Members.Add(dg);
//property
classDeclaration.Members.Add(this.MakeProperty("Ans", "ans", typeof(double)));
classDeclaration.Members.Add(this.MakeProperty("ArrAns", "arrAns", typeof(double[])));
//Our Calculate Method
CodeMemberMethod myMethod = new CodeMemberMethod();
myMethod.Name = "Calculate";
myMethod.Attributes = MemberAttributes.Public;
if (bRetArray)
{
myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("arrAns"), new CodeSnippetExpression("new double[" + arrayLen.ToString(CultureInfo.InvariantCulture) + "]")));
myMethod.ReturnType = new CodeTypeReference(typeof(double[]));
}
else
{
myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression("ans"), new CodeSnippetExpression("0.0")));
myMethod.ReturnType = new CodeTypeReference(typeof(double));
}
foreach (KeyValuePair <string, double> k in vars)
{
myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression(k.Key), new CodeSnippetExpression(k.Value.ToString(CultureInfo.InvariantCulture))));
}
if (bSimpleAssign) //require a full statement?
{
myMethod.Statements.Add(new CodeAssignStatement(new CodeSnippetExpression(bRetArray?"arrAns":"ans"), new CodeSnippetExpression(expression)));
}
else
{
myMethod.Statements.Add(new CodeSnippetExpression(expression));
}
if (bRetArray)
{
myMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "arrAns")));
}
else
{
myMethod.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "Ans")));
}
classDeclaration.Members.Add(myMethod);
//write code
myNamespace.Types.Add(classDeclaration);
generator.GenerateCodeFromNamespace(myNamespace, sw, codeOpts);
sw.Flush();
sw.Close();
}
