public void CastExpression()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public, () => "foo",
Emit.declare(typeof(object), "d"),
Emit.assignVar("d", () => 10d),
Emit.declare("dr", (object d) => (decimal)d),
Emit.declare("dr2", (object d) => CodeDom.cast(typeof(decimal), d)),
Emit.stmt((object d) => CodeDom.cast <Var>("cls", d).Call("foo"))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void WorkingWithEvent()
{
var c = new CodeDomGenerator();
c.AddReference("System.Core.dll").AddNamespace("Samples").AddClass("cls")
.AddEvent(typeof(Action), MemberAttributes.Public, "ev")
.AddMethod(MemberAttributes.Public, () => "raise",
Emit.declare("cls2", "cc", () => CodeDom.@new("cls2")),
Emit.attachDelegate(CodeDom.@this, "ev", CodeDom.VarRef("cc"), "zoo"),
Emit.attachDelegate(CodeDom.@this, "ev", "cls2.foo"),
Emit.stmt(() => [email protected]("ev")()),
Emit.detachDelegate(CodeDom.@this, "ev", CodeDom.VarRef("cc"), "zoo")
)
.AddClass("cls2")
.AddMethod(MemberAttributes.Public, () => "zoo",
Emit.stmt(() => Console.WriteLine("ok"))
)
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.stmt(() => Console.WriteLine("ok"))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type cls = ass.GetType("Samples.cls");
Assert.IsNotNull(cls);
}
public void TestGetExpression()
{
CodeExpression exp = CodeDom.GetExpression(() => 1);
Assert.IsTrue(exp is CodePrimitiveExpression);
Assert.AreEqual(1, ((CodePrimitiveExpression)exp).Value);
CodeExpression exp2 = CodeDom.GetExpression((int g) => 1 + g);
Assert.IsTrue(exp2 is CodeBinaryOperatorExpression);
CodeExpression exp3 = CodeDom.GetExpression((int g) => [email protected] <int>("d") + g - 10);
Assert.IsTrue(exp3 is CodeBinaryOperatorExpression);
CodeExpression exp4 = CodeDom.GetExpression(() => CodeDom.Call(exp, "ToString")());
Assert.IsTrue(exp4 is CodeMethodInvokeExpression);
Assert.AreEqual(exp, ((CodeMethodInvokeExpression)exp4).Method.TargetObject);
CodeExpression exp5 = CodeDom.GetExpression(() => CodeDom.Call(exp3, "ToString")());
Assert.IsTrue(exp5 is CodeMethodInvokeExpression);
Assert.AreEqual(exp3, ((CodeMethodInvokeExpression)exp5).Method.TargetObject);
}
public void GenericObjectCreate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass(Define.Class("TestClass").Generic("T")
.AddFields(
Define.Field(MemberAttributes.Private, "T", "_s")
)
.AddProperty("T", MemberAttributes.Public, "S", "_s")
).AddClass(Define.Class("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, CodeDom.TypeRef("TestClass", "T"), () => "foo",
Emit.declare(CodeDom.TypeRef("TestClass", "T"), "cc",
() => CodeDom.@new(CodeDom.TypeRef("TestClass", "T"))),
Emit.@return((Var cc) => cc))
.Generic("T")
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass`1");
Assert.IsNotNull(TestClass);
}
public void TestLambdaVB()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, (bool f) => "foo",
Emit.declare("a", () => CodeDom.Lambda(() => 1)),
Emit.declare("c", () => CodeDom.Lambda((int aa) => aa + 10,
new LambdaParam(typeof(int), "aa"))),
Emit.stmt((int a) => CodeDom.CallDelegate(CodeDom.VarRef("c").Call("Compile"))(
CodeDom.CallDelegate(CodeDom.VarRef("a").Call("Compile"))
))
)
;
c.AddReference("System.Core.dll");
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void TestAnonymousMethod()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare("a", () => CodeDom.Lambda <Func <int, double> >(new [] { new LambdaParam("s") },
Emit.@return((double s) => s + 1)
))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
c.AddReference("System.Core.dll");
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
static void Main2()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, typeof(string), (int i) => "Print",
Emit.@if((int i) => i < 10,
Emit.@return(() => "i less than 10")
),
Emit.@return(() => "i greater than 10")
);
Console.WriteLine(c.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.CSharp));
var c2 = new CodeDomGenerator();
CodeMemberMethod method = Define.Method(MemberAttributes.Public, () => "foo");
c2.AddNamespace("TestNS").AddClass("Fibonacci")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, (int x) => "Calc",
Emit.@if((int x) => x <= 1,
Emit.@return(() => 1)),
Emit.@return((int x) =>
CodeDom.Call <int>("Calc")(x - 1) + CodeDom.Call <int>("Calc")(x - 2))
)
;
Console.WriteLine(c2.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.CSharp));
Console.WriteLine(c2.GenerateCode(LinqToCodedom.CodeDomGenerator.Language.VB));
}
public void TestAssignIndexer()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare("b", () => new int[10]),
Emit.assignExp((int[] b) => b[0], CodeDom.GetExpression(() => 1)),
Emit.declare("a", () => new List <int>()),
Emit.assignExp((List <int> a) => a[0], CodeDom.GetExpression(() => 1))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
ass = c.Compile();
Assert.IsNotNull(ass);
TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void Builder_Operator()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("ee")
.AddOperators(
Define.Operator(new CodeTypeReference(typeof(int)),
(DynType t) => CodeDom.TypedSeq(OperatorType.Implicit, t.SetType("ee")),
Emit.@return(() => 10)
)
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
}
public void TestDefaultProperty()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("ee", TypeAttributes.Public, true)
.AddMember(Define.GetProperty(new CodeTypeReference(typeof(string)), MemberAttributes.Family,
(int idx) => "prop", true,
Emit.@return((int idx) => idx.ToString())
))
.AddMember(Define.Property(new CodeTypeReference(typeof(string)), MemberAttributes.Family,
(int idx) => "prop2", false,
CodeDom.CombineStmts(Emit.@return((int idx) => idx.ToString())),
Emit.declare("i", (int idx) => idx)
))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
var ass = c.Compile(null, CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
}
static void Main(string[] args)
{
//Set Current Directory to EXE location
Assembly assembly = Assembly.GetExecutingAssembly();
FileInfo fileInfo = new FileInfo(assembly.Location);
Environment.CurrentDirectory = fileInfo.Directory.FullName;
//Download Schemas from VANTIV and use XSD to generate classes
Download.Prebuild();
// Remove unwanted attributes that was causing serialization issues
CodeDom.RemoveUnwantedDefaultValueAttributes(@"Transaction\express.cs");
CodeDom.RemoveUnwantedDefaultValueAttributes(@"Services\expressservices.cs");
CodeDom.RemoveUnwantedDefaultValueAttributes(@"Reporting\expressreporting.cs");
//Workaround missing classes due to XSD provided being invalid
List <string> elementsToSkip = new List <string>();
elementsToSkip.Add("TransactionSetup");
elementsToSkip.Add("BatchUpload");
CodeDom.FixMissingTransactionClasses(@"Transaction\express.xsd", @"Transaction\express-transaction-extensions.cs", "https://transaction.elementexpress.com", "VXEN.Models.Transaction", elementsToSkip);
elementsToSkip.Clear();
CodeDom.FixMissingTransactionClasses(@"Services\expressservices.xsd", @"Services\express-services-extensions.cs", @"https://services.elementexpress.com", "VXEN.Models.Services", elementsToSkip);
CodeDom.FixMissingTransactionClasses(@"Reporting\expressreporting.xsd", @"Reporting\express-reporting-extensions.cs", @"https://reporting.elementexpress.com", "VXEN.Models.Reporting", elementsToSkip);
}
public void Builder_AccessProperty()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls1")
.AddField(typeof(int), "_i", () => 10)
.AddProperty(typeof(int), MemberAttributes.Public, "I", "_i")
.AddClass("cls2")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, typeof(int), () => "foo",
Emit.declare("cls1", "cc", () => CodeDom.@new("cls1")),
Emit.@return((Var cc) => cc.Property <int>("I")))
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls2");
Assert.IsNotNull(TestClass);
int s = (int)TestClass.InvokeMember("foo",
BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod,
null, null, null);
Assert.AreEqual(10, s);
}
public void DefaultExpression()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "foo",
Emit.stmt(() => CodeDom.Call(CodeDom.TypeRef("cls"), "zoo")(default(int)))
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Private, (int i) => "zoo",
Emit.stmt((int i) => Console.WriteLine(i))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void Builder_MethodCall()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("TestClass")
.AddMethod(MemberAttributes.Public, typeof(int), (int a) => "Test", Emit.@return((int a) => a + 100))
.AddMethod(
Define.Method(MemberAttributes.Public, typeof(int), (int a) => "Test1", Emit.@return(() =>
CodeDom.VarRef <int>("a") +
[email protected] <int>("Test")(3)))
)
).AddClass(Define.Class("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare("TestClass", "cc"),
Emit.stmt(() => CodeDom.Call(CodeDom.VarRef("cc"), "Test1")(3))
)
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo2",
Emit.declare("TestClass", "cc", () => CodeDom.@new("TestClass")),
Emit.stmt((Var cc) => cc.Call("Test1")(3))
)
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, (int s) => "foo3",
Emit.declare("TestClass", "cc"),
Emit.declare(typeof(int), "i"),
Emit.stmt((int s) => CodeDom.Call(CodeDom.VarRef("cc"), "Test1")(CodeDom.VarRef <int>("i") + s))
)
.AddMethod(MemberAttributes.Public, () => "foo4",
Emit.@foreach("mi", () => [email protected] <Type>("GetType")().GetMethods(BindingFlags.NonPublic | BindingFlags.Static),
Emit.stmt(() => CodeDom.VarRef("mi").Call("GetParameters")),
Emit.@if((MethodInfo mi) => mi.Name == "dfdfd",
Emit.@return()
),
Emit.@return()
)
)
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass");
Assert.IsNotNull(TestClass);
object t = TestClass.InvokeMember(null, System.Reflection.BindingFlags.CreateInstance, null, null, null);
Assert.IsNotNull(t);
Assert.AreEqual(104, TestClass.InvokeMember("Test", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.InvokeMethod, null, t,
new object[] { 4 }));
Assert.AreEqual(104, TestClass.InvokeMember("Test1", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.InvokeMethod, null, t,
new object[] { 1 }));
}
public void Builder_Interface()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples")
.AddClass(Define.Class("TestClass", TypeAttributes.Public)
.Implements(typeof(IDisposable))
.AddMethod(MemberAttributes.Private, () => "Dispose",
Emit.@throw(() => new NotImplementedException())
).Implements(typeof(IDisposable))
).AddInterface(Define.Interface("Ixxx")
.AddMethod(MemberAttributes.Public, () => "First")
.AddMethod(MemberAttributes.Public, typeof(DateTime), () => "Second")
.AddProperty("TestClass", MemberAttributes.Public, "Third")
.AddGetProperty("TestClass", MemberAttributes.Public, "Fifth")
.AddEvent(typeof(EventHandler), MemberAttributes.Public, "Fourth")
).AddClass("xxx").Implements(new CodeTypeReference("Ixxx"))
.AddMethod(MemberAttributes.Private, () => "First",
Emit.@throw(() => new NotImplementedException())
).Implements(new CodeTypeReference("Ixxx"))
.AddMethod(MemberAttributes.Public, typeof(DateTime), () => "Second",
Emit.@throw(() => new NotImplementedException())
).Implements(new CodeTypeReference("Ixxx"))
.AddProperty("TestClass", MemberAttributes.Public, "Third",
CodeDom.CombineStmts(Emit.@throw(() => new NotImplementedException())),
Emit.@throw(() => new NotImplementedException())
).Implements("Ixxx")
.AddGetProperty("TestClass", MemberAttributes.Public, "Fifth",
Emit.@throw(() => new NotImplementedException())
).Implements(new CodeTypeReference("Ixxx"))
.AddEvent(typeof(EventHandler), MemberAttributes.Public, "Fourth"
).Implements("Ixxx")
.AddField(typeof(int), "_z", () => 100)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass");
Assert.IsNotNull(TestClass);
ass = c.Compile(CodeDomGenerator.Language.VB);
Assert.IsNotNull(ass);
TestClass = ass.GetType("Samples.xxx");
Assert.IsNotNull(TestClass);
}
public void Builder_Property()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("TestClass")
.AddFields(
Define.Field(MemberAttributes.Private, typeof(string), "_s")
)
.AddProperty(
Define.Property(typeof(string), MemberAttributes.Public, "Test",
CodeDom.CombineStmts(Emit.@return(() => [email protected] <string>("_s"))),
Emit.assignField("_s", (string value) => value)
)
)
.AddProperty(
Define.Property(typeof(string), MemberAttributes.Public, "Test2", "_s")
)
.AddProperty(typeof(string), MemberAttributes.Public, "Test3", "_s")
.AddProperty("TestClass", MemberAttributes.Public, "Test4",
CodeDom.CombineStmts(Emit.@return(() => CodeDom.@this)),
Emit.@throw(() => new NotImplementedException(
CodeDom.Property <string>(CodeDom.VarRef("value"), "Test")
))
)
.AddMethod(MemberAttributes.Public, typeof(string), (int a) => "Test1",
Emit.assignProperty("Test", () => Guid.NewGuid().ToString()),
Emit.@return((int a) =>
a.ToString() + [email protected] <string>("Test")))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass");
Assert.IsNotNull(TestClass);
object t = TestClass.InvokeMember(null, System.Reflection.BindingFlags.CreateInstance, null, null, null);
Assert.IsNotNull(t);
string s = TestClass.InvokeMember("Test1", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.InvokeMethod, null, t,
new object[] { 4 }) as string;
Assert.IsNotNull(s);
string TestProperty = s.Substring(1);
Assert.AreEqual(TestProperty, TestClass.InvokeMember("Test", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty, null, t, null));
}
private CodeExpression GetExpression(Expression exp)
{
try
{
object v = CodeDom.Eval(exp);
return(GetFromPrimitive(v));
}
catch (Exception)
{
return(_Visit(exp));
}
}
public void TestGetExpressionInject()
{
CodeExpression exp = CodeDom.GetExpression(() => 1);
Assert.IsTrue(exp is CodePrimitiveExpression);
Assert.AreEqual(1, ((CodePrimitiveExpression)exp).Value);
CodeExpression exp2 = CodeDom.GetExpression((int g) => CodeDom.InjectExp <int>(0) + g, exp);
Assert.IsTrue(exp2 is CodeBinaryOperatorExpression);
Assert.AreSame(exp, ((CodeBinaryOperatorExpression)exp2).Left);
Assert.IsTrue(((CodeBinaryOperatorExpression)exp2).Right is CodeVariableReferenceExpression);
}
private void btnBuild_Click(object sender, EventArgs e)
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Executables | *.exe";
if (sfd.ShowDialog() == DialogResult.OK)
{
string Source = Properties.Resources.Source;
string ClientSettings = Properties.Resources.ClientSettings;
Source = Source.Replace("[IP]", txtHost.Text);
Source = Source.Replace("[PORT]", txtPort.Text);
CodeDom.Compile(sfd.FileName, Source, ClientSettings);
MessageBox.Show("Compiled successfully at: " + sfd.FileName);
}
}
public static void Test()
{
var host = new HostApp();
host.Log("CodeDOM Tests...");
CodeDom.HelloTest_1();
CodeDom.HelloTest_2();
CodeDom.CalcTest_InterfaceInheritance(host);
CodeDom.CalcTest_InterfaceAlignment(host);
host.Log("Mono CompilerAsService Tests...");
CompilerAsService.HelloTest_1();
CompilerAsService.HelloTest_2();
CompilerAsService.CalcTest_InterfaceInheritance(host);
CompilerAsService.CalcTest_InterfaceAlignment(host);
}
public void TestPureClasses()
{
using (Stream stream = Resources.GetXmlDocumentStream("pure-classes"))
{
WXMLModel model = WXMLModel.LoadFromXml(XmlReader.Create(stream), new TestXmlUrlResolver());
Assert.IsNotNull(model);
var wxmlDocumentSet = model.GetWXMLDocumentSet(new WXMLModelWriterSettings());
Assert.IsNotNull(wxmlDocumentSet);
CodeDomGenerator c = new CodeDomGenerator();
c.AddNamespace("test")
.AddInterface(Define.Interface("MyInterface")
.AddProperty(typeof(int), MemberAttributes.Public, "ID")
.AddProperty(typeof(string), MemberAttributes.Public, "Name")
//.AddGetProperty(CodeDom.TypeRef(typeof(IQueryable<>), "MyInterface2"), MemberAttributes.Public, "e4s")
)
.AddInterface(Define.Interface("MyInterface2")
.AddProperty(typeof(int), MemberAttributes.Public, "ID")
.AddProperty(CodeDom.TypeRef(new CodeTypeReference("MyInterface")), MemberAttributes.Public, "prop1")
)
;
Assembly a = TestCSCodeInternal(model, new WXMLCodeDomGeneratorSettings(),
c.GetCompileUnit(CodeDomGenerator.Language.CSharp));
Assert.IsNotNull(a);
Type t = a.GetType("e3");
Assert.IsNotNull(t);
Assert.IsTrue(t.GetInterfaces().Any(i => i.Name == "MyInterface"));
a = TestVBCodeInternal(model, new WXMLCodeDomGeneratorSettings(),
c.GetCompileUnit(CodeDomGenerator.Language.VB));
Assert.IsNotNull(a);
t = a.GetType("e3");
Assert.IsNotNull(t);
Assert.IsTrue(t.GetInterfaces().Any(i => i.Name == "MyInterface"));
}
}
private void btnBuild_Click(object sender, EventArgs e)
{
/* This is the build feature. I'd like to give credits to xSilent for using his CodeDom class! */
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Executables | *.exe";
if (sfd.ShowDialog() == DialogResult.OK)
{
string Source = Properties.Resources.Source; /* The main source */
string ClientSettings = Properties.Resources.ClientSettings; /* ClientSettings wrapper */
/* Replacing variables */
Source = Source.Replace("[IP]", txtHost.Text);
Source = Source.Replace("[PORT]", txtPort.Text);
CodeDom.Compile(sfd.FileName, Source, ClientSettings);
MessageBox.Show("Compiled successfully at: " + sfd.FileName);
}
}
private void AddParam(CodeExpressionCollection @params, Expression par)
{
try
{
object v = CodeDom.Eval(par);
if (v == null && par != null)
{
@params.Add(_Visit(par));
}
else
{
@params.Add(GetFromPrimitive(v));
}
}
catch (Exception)
{
@params.Add(_Visit(par));
}
}
public void TypeOfExpression()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, typeof(string), (object o) => "foo",
Emit.ifelse((object o) => o.GetType() == typeof(int),
CodeDom.CombineStmts(Emit.@return(() => "int")),
Emit.@return(() => "other")))
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
public void Builder_Enum()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddEnum(Define.Enum("ee")
.AddFields(
Define.StructField("Xx"),
Define.StructField("Yy"),
Define.StructField("Zz", () => 100)
)
).AddEnum("rr").AddAttribute(typeof(FlagsAttribute))
.AddFields(
Define.StructField("Xx"),
Define.StructField("Yy"),
Define.StructField("Zz")
).AddClass("cls").AddMethod(MemberAttributes.Static | MemberAttributes.Public, () => "foo",
Emit.declare("rr", "e"),
Emit.assignVar("e", () => CodeDom.Field(new CodeTypeReference("rr"), "Xx"))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type eeClass = ass.GetType("Samples.ee");
Assert.IsNotNull(eeClass);
Type rrClass = ass.GetType("Samples.rr");
Assert.IsNotNull(rrClass);
}
public void ArrayComplexTypeCreate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, () => "foo",
Emit.declare("cls[]", "d"),
Emit.declare(CodeDom.TypeRef(typeof(List <>), "cls"), "d2"),
Emit.assignVar("d", (Var d2) => d2.Call("ToArray"))
)
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.cls");
Assert.IsNotNull(TestClass);
}
private void GenerateCS()
{
using (Microsoft.CSharp.CSharpCodeProvider provider = new Microsoft.CSharp.CSharpCodeProvider())
{
CodeGeneratorOptions opts = new CodeGeneratorOptions();
StringWriter sw = new StringWriter();
List <CodeTypeReference> implTypes = new List <CodeTypeReference>();
if (_property.ImplementationTypes != null)
{
var arr = new CodeTypeReference[_property.ImplementationTypes.Count];
_property.ImplementationTypes.CopyTo(arr, 0);
_property.ImplementationTypes.Clear();
_property.PrivateImplementationType = null;
implTypes.AddRange(arr);
}
provider.GenerateCodeFromMember(_property, sw, opts);
foreach (CodeTypeReference tr in implTypes)
{
_property.ImplementationTypes.Add(tr);
}
//StringReader sr = new StringReader(sw.GetStringBuilder().ToString());
//string line = sr.ReadLine();
//while (string.IsNullOrEmpty(line) || line.StartsWith("/") || line.StartsWith("["))
// line = sr.ReadLine();
StringBuilder sb = new StringBuilder();
if (InterfaceProperties != null)
{
foreach (CodeTypeReference tr in implTypes)
{
string prop;
if (InterfaceProperties.TryGetValue(tr, out prop))
{
var newProp = Define.Property(_property.Type, MemberAttributes.Private, prop).Implements(tr);
if (_property.HasGet)
{
newProp.GetStatements.Add(Emit.@return(() => [email protected](_property.Name)));
newProp.HasGet = true;
}
if (_property.HasSet)
{
newProp.SetStatements.Add(Emit.assignProperty(_property.Name, () => CodeDom.VarRef("value")));
newProp.HasSet = true;
}
StringWriter swNew = new StringWriter();
provider.GenerateCodeFromMember(CodeDomTreeProcessor.ProcessMember(newProp, CodeDomGenerator.Language.CSharp),
swNew, opts);
sb.Append(swNew.ToString());
}
}
if (sb.Length > 0)
{
sb.Insert(0, Environment.NewLine);
}
}
Text = sw.GetStringBuilder().ToString() + sb.ToString();
}
}
private static string CreateEscapedIdentifier(Parameter p)
{
return(CodeDom.CreateEscapedIdentifier(p.Name));
}
public void ObjectCreate()
{
var c = new CodeDomGenerator();
c.AddNamespace("Samples").AddClass(Define.Class("TestClass")
.AddFields(
Define.Field(MemberAttributes.Private, typeof(string), "_s"),
Define.Field(MemberAttributes.Private, typeof(int), "_i")
)
.AddCtor(
Define.Ctor((int i, string s) => MemberAttributes.Public,
Emit.assignField("_s", (string s) => s),
Emit.assignField("_i", (int i) => i)
)
)
.AddMethod(MemberAttributes.Static | MemberAttributes.Public, "TestClass", () => "Create", Emit.@return(() => CodeDom.@new("TestClass", 100, "yyy")))
);
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type TestClass = ass.GetType("Samples.TestClass");
Assert.IsNotNull(TestClass);
}
public void InstanceClassDelegate()
{
var c = new CodeDomGenerator();
c.AddReference("System.Core.dll").AddNamespace("Samples").AddClass("cls")
.AddMethod(MemberAttributes.Public, typeof(string), () => "foo", Emit.declare(typeof(Func <int, string>), "h2"), Emit.assignDelegate("h2", CodeDom.@this, "zoo"), Emit.@return((Func <int, string> h2) => h2(10)))
.AddMethod(MemberAttributes.Public, typeof(string), (int i) => "zoo", Emit.@return((int i) => i.ToString()))
.AddClass("cls2")
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, typeof(string), (DynType cc) => "foo" + cc.SetType("cls"), Emit.declare(typeof(Func <int, string>), "h2"), Emit.assignDelegate("h2", CodeDom.VarRef("cc"), "zoo"), Emit.@return((Func <int, string> h2) => h2(100)))
.AddMethod(MemberAttributes.Public | MemberAttributes.Static, typeof(string), (DynType cc, DynType c2) => "foo" + cc.SetType("cls") + c2.SetType(typeof(string)), Emit.declare(typeof(Func <int, string>), "h2"), Emit.assignDelegate("h2", CodeDom.VarRef("cc"), "zoo"), Emit.@return((Func <int, string> h2, string c2) => h2(100) + c2))
;
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.CSharp));
Console.WriteLine(c.GenerateCode(CodeDomGenerator.Language.VB));
var ass = c.Compile();
Assert.IsNotNull(ass);
Type cls = ass.GetType("Samples.cls");
Assert.IsNotNull(cls);
object t = cls.InvokeMember(null, System.Reflection.BindingFlags.CreateInstance, null, null, null);
Assert.IsNotNull(t);
string s = (string)cls.InvokeMember("foo",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Instance,
null, t, null);
Assert.AreEqual("10", s);
Type cls2 = ass.GetType("Samples.cls2");
Assert.IsNotNull(cls2);
object t2 = cls2.InvokeMember(null, System.Reflection.BindingFlags.CreateInstance, null, null, null);
Assert.IsNotNull(t2);
string s2 = (string)cls2.InvokeMember("foo",
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.Static,
null, t2, new object[] { t });
Assert.AreEqual("100", s2);
}
