public static void ConstructorTest()
{
FluentCodeCompileUnit compileUnit = new FluentCodeCompileUnit();
compileUnit.Namespace("TestNamespace")
.Class("AClass").Inherits("BaseClass")
.Constructor(MemberAttributes.Public)
.BaseArgs()
.EndConstructor
.Constructor(MemberAttributes.Public).Parameter(typeof(int), "IntArg")
.ThisArgs(Expr.Arg("IntArg"), Expr.Primitive("Hello"))
.EndConstructor
.Constructor(MemberAttributes.Public).Parameter(typeof(int), "IntArg").Parameter(typeof(string), "StringArg")
.BaseArgs(Expr.Arg("StringArg"))
.EndConstructor
.EndClass
.Class("BaseClass")
.Constructor(MemberAttributes.Public)
.EndConstructor
.Constructor(MemberAttributes.Public).Parameter(typeof(string), "TextToPrint")
.CallStatic(typeof(Console), "WriteLine", Expr.Arg("TextToPrint"))
.EndConstructor
.EndClass
.EndFluent();
Assembly assembly = TestGenerated(compileUnit.EndFluent());
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetConstructor(new Type[] { typeof(int)}).Invoke(instance, new object[] { 32 });
}
public static void UsingTest()
{
string executingAssemblyPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string path = System.IO.Path.GetDirectoryName(executingAssemblyPath) + "\\..\\..\\test.txt";
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace");
ns.Class("AClass")
.Method(MemberAttributes.Public, "UsingTest")
.Declare(typeof(System.IO.FileStream), "fs", Expr.CallStatic(typeof(System.IO.File), "OpenRead", Expr.Primitive(path)))
.UsingEmu(Expr.Var("fs"))
.UsingEmu(Expr.Declare(typeof(StreamReader), "sr", Expr.New(typeof(StreamReader), Expr.Var("fs"))))
.CallStatic(typeof(Console), "WriteLine", Expr.CallMember(Expr.Var("sr"), "ReadToEnd"))
.EndUsing
.EndUsing
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Assembly assembly = TestGenerated(compileUnit);
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetMethod("UsingTest").Invoke(instance, new object[] { });
}
public static void LinqTest()
{
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace");
ns.Class("AClass")
.Method(MemberAttributes.Public, "LinqTest").ReturnType(typeof(bool))
.Declare(typeof(int), "a", Expr.Primitive(5))
.Declare(typeof(int), "b", Expr.Primitive(6))
.If((int a, int b) => a > b)
.Declare(typeof(string), "text", Expr.Primitive("A is bigger than B"))
.Stmt((string text) => Console.WriteLine(text))
.Stmt(ExprLinq.Expr(() => Console.Read()))
.Else
.Declare(typeof(string), "text", Expr.Primitive("B is bigger or equal A"))
.Stmt((string text) => Console.WriteLine(text))
.EndIf
.Return((int a, int b) => a > b)
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Assembly assembly = TestGenerated(compileUnit);
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetMethod("LinqTest").Invoke(instance, new object[] { });
}
public static void ConstructorTest()
{
FluentCodeCompileUnit compileUnit = new FluentCodeCompileUnit();
compileUnit.Namespace("TestNamespace")
.Class("AClass").Inherits("BaseClass")
.Constructor(MemberAttributes.Public)
.BaseArgs()
.EndConstructor
.Constructor(MemberAttributes.Public).Parameter(typeof(int), "IntArg")
.ThisArgs(Expr.Arg("IntArg"), Expr.Primitive("Hello"))
.EndConstructor
.Constructor(MemberAttributes.Public).Parameter(typeof(int), "IntArg").Parameter(typeof(string), "StringArg")
.BaseArgs(Expr.Arg("StringArg"))
.EndConstructor
.EndClass
.Class("BaseClass")
.Constructor(MemberAttributes.Public)
.EndConstructor
.Constructor(MemberAttributes.Public).Parameter(typeof(string), "TextToPrint")
.CallStatic(typeof(Console), "WriteLine", Expr.Arg("TextToPrint"))
.EndConstructor
.EndClass
.EndFluent();
Assembly assembly = TestGenerated(compileUnit.EndFluent());
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetConstructor(new Type[] { typeof(int) }).Invoke(instance, new object[] { 32 });
}
static void Main(string[] args)
{
CodeCompileUnit compileUnit = new FluentCodeCompileUnit()
.Namespace("Sample4")
.Class("Program")
.Method("Test")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Test"))
.If(Expr.Op(Expr.Primitive(5), CodeBinaryOperatorType.GreaterThan, Expr.Primitive(3)))
.EndIf
.EndMethod
.Method(MemberAttributes.Public | MemberAttributes.Static, "Main").Parameter(typeof(string[]), "args")
.Stmt(ExprLinq.Expr(() => Console.WriteLine("Hello Linq2CodeDOM")))
.Declare(typeof(int), "random", ExprLinq.Expr(() => new Random().Next(10)))
.If((int random) => random <= 5)
.Stmt(ExprLinq.Expr(() => Console.WriteLine("Smaller or equal to 5.")))
.Else
.Stmt(ExprLinq.Expr(() => Console.WriteLine("Bigger than 5.")))
.EndIf
.EndMethod
.EndClass
.EndNamespace
.EndFluent();
Console.WriteLine(Helper.CodeDomHelper.GenerateCodeAsString(compileUnit, new CSharpCodeProvider()));
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
assembly.GetType("Sample4.Program").GetMethod("Main").Invoke(null, new object[] { null });
}
static void Main(string[] args)
{
CodeCompileUnit compileUnit = new FluentCodeCompileUnit()
.Namespace("Sample4")
.Class("Program")
.Method("Test")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Test"))
.If(Expr.Op(Expr.Primitive(5), CodeBinaryOperatorType.GreaterThan, Expr.Primitive(3)))
.EndIf
.EndMethod
.Method(MemberAttributes.Public | MemberAttributes.Static, "Main").Parameter(typeof(string[]), "args")
.Stmt(ExprLinq.Expr(() => Console.WriteLine("Hello Linq2CodeDOM")))
.Declare(typeof(int), "random", ExprLinq.Expr(() => new Random().Next(10)))
.If((int random) => random <= 5)
.Stmt(ExprLinq.Expr(() => Console.WriteLine("Smaller or equal to 5.")))
.Else
.Stmt(ExprLinq.Expr(() => Console.WriteLine("Bigger than 5.")))
.EndIf
.EndMethod
.EndClass
.EndNamespace
.EndFluent();
Console.WriteLine(Helper.CodeDomHelper.GenerateCodeAsString(compileUnit, new CSharpCodeProvider()));
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
assembly.GetType("Sample4.Program").GetMethod("Main").Invoke(null, new object[] { null });
}
public static void EnumTest()
{
FluentCodeCompileUnit compileUnit = new FluentCodeCompileUnit();
compileUnit.Namespace("TestNamespace")
.Enum("TestEnum").CustomAttribute(typeof(FlagsAttribute))
.Value("Value1", Expr.Primitive(1)).EndValue
.Value("Value2", Expr.Primitive(2)).EndValue
.Value("Value3", Expr.Primitive(4)).EndValue
.EndEnum
.EndFluent();
TestGenerated(compileUnit.EndFluent());
}
static void Main(string[] args)
{
CodeCompileUnit compileUnit = new FluentCodeCompileUnit()
.Namespace("Sample1")
.Class("Program")
.Method(MemberAttributes.Public | MemberAttributes.Static, "Main").Parameter(typeof(string[]), "args")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Hello Fluent CodeDom"))
.EndMethod
.EndClass
.EndNamespace
.EndFluent();
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
assembly.GetType("Sample1.Program").GetMethod("Main").Invoke(null, new object[] { null });
}
static void Main(string[] args)
{
var ns = new FluentCodeCompileUnit().Namespace("Sample5");
ns.Class(MemberAttributes.Public | MemberAttributes.Static, "Program")
.Method(MemberAttributes.Public | MemberAttributes.Static, "ForArrayTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForArrayTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForArray("i", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.ArrayIndex(Expr.Var("sArr"), Expr.Var("i")))
.EndFor
.EndMethod
.Method(MemberAttributes.Public | MemberAttributes.Static, "ForeachTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForeachTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForeachEmu(typeof(string), "s", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.Var("s"))
.EndForeach
.EndMethod
.Method(MemberAttributes.Public | MemberAttributes.Static, "WhileTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("WhileTest:"))
.Declare(typeof(int), "a", Expr.Primitive(1))
.WhileEmu(Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.LessThanOrEqual, Expr.Primitive(10)))
.CallStatic(typeof(Console), "WriteLine", Expr.CallStatic(typeof(string), "Format", Expr.Primitive("Value: {0}"), Expr.Var("a")))
.Set(Expr.Var("a"), Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.Add, Expr.Primitive(1)))
.EndWhile
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Console.WriteLine(Helper.CodeDomHelper.GenerateCodeAsString(compileUnit, new CSharpCodeProvider()));
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
assembly.GetType("Sample5.Program").GetMethod("ForArrayTest").Invoke(null, new object[] { });
assembly.GetType("Sample5.Program").GetMethod("ForeachTest").Invoke(null, new object[] { });
assembly.GetType("Sample5.Program").GetMethod("WhileTest").Invoke(null, new object[] { });
}
static void Main(string[] args)
{
CodeCompileUnit compileUnit = new FluentCodeCompileUnit()
.Namespace("Sample3")
.Class("Program")
.Method(MemberAttributes.Public | MemberAttributes.Static, "Main").Parameter(typeof(string[]), "args")
.ConsoleWriteLine(Expr.Primitive("Hello Fluent CodeDom")).UserData("Key", "Value")
.EndMethod
.EndClass
.EndNamespace
.EndFluent();
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
assembly.GetType("Sample3.Program").GetMethod("Main").Invoke(null, new object[] { null });
}
public static void LoopTest()
{
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace");
ns.Class("AClass")
.Method(MemberAttributes.Public, "ForArrayTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForArrayTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForArray("i", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.ArrayIndex(Expr.Var("sArr"), Expr.Var("i")))
.EndFor
.EndMethod
.Method(MemberAttributes.Public, "ForeachTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForeachTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForeachEmu(typeof(string), "s", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.Var("s"))
.EndForeach
.EndMethod
.Method(MemberAttributes.Public, "WhileTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("WhileTest:"))
.Declare(typeof(int), "a", Expr.Primitive(1))
.WhileEmu(Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.LessThanOrEqual, Expr.Primitive(10)))
.CallStatic(typeof(Console), "WriteLine", Expr.CallStatic(typeof(string), "Format", Expr.Primitive("Value: {0}"), Expr.Var("a")))
.Set(Expr.Var("a"), Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.Add, Expr.Primitive(1)))
.EndWhile
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Assembly assembly = TestGenerated(compileUnit);
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetMethod("ForArrayTest").Invoke(instance, new object[] { });
instance.GetType().GetMethod("ForeachTest").Invoke(instance, new object[] { });
instance.GetType().GetMethod("WhileTest").Invoke(instance, new object[] { });
}
static void Main(string[] args)
{
var ns = new FluentCodeCompileUnit().Namespace("Sample5");
ns.Class(MemberAttributes.Public | MemberAttributes.Static, "Program")
.Method(MemberAttributes.Public | MemberAttributes.Static, "ForArrayTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForArrayTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForArray("i", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.ArrayIndex(Expr.Var("sArr"), Expr.Var("i")))
.EndFor
.EndMethod
.Method(MemberAttributes.Public | MemberAttributes.Static, "ForeachTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForeachTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForeachEmu(typeof(string), "s", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.Var("s"))
.EndForeach
.EndMethod
.Method(MemberAttributes.Public | MemberAttributes.Static, "WhileTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("WhileTest:"))
.Declare(typeof(int), "a", Expr.Primitive(1))
.WhileEmu(Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.LessThanOrEqual, Expr.Primitive(10)))
.CallStatic(typeof(Console), "WriteLine", Expr.CallStatic(typeof(string), "Format", Expr.Primitive("Value: {0}"), Expr.Var("a")))
.Set(Expr.Var("a"), Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.Add, Expr.Primitive(1)))
.EndWhile
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Console.WriteLine(Helper.CodeDomHelper.GenerateCodeAsString(compileUnit, new CSharpCodeProvider()));
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
assembly.GetType("Sample5.Program").GetMethod("ForArrayTest").Invoke(null, new object[] { });
assembly.GetType("Sample5.Program").GetMethod("ForeachTest").Invoke(null, new object[] { });
assembly.GetType("Sample5.Program").GetMethod("WhileTest").Invoke(null, new object[] { });
}
private static TInterface ImplentInterface <TInterface>()
{
Type interfaceType = typeof(TInterface);
FluentCodeNamespace ns = new FluentCodeCompileUnit().Namespace("Sample2");
// public class <Interface>Test : <Interface>
string typeName = string.Format("{0}Test", interfaceType.Name);
var type = ns.Class(typeName).Inherits(interfaceType);
foreach (MethodInfo methodInfo in interfaceType.GetMethods())
{
// Console.WriteLine("<Method> called with Parameters:")
var method =
type.Method(MemberAttributes.Public, methodInfo.Name)
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive(string.Format("{0} called with parameters:", methodInfo.Name)));
foreach (ParameterInfo paramInfo in methodInfo.GetParameters())
{
method.Parameter(paramInfo.ParameterType, paramInfo.Name);
// Console.WriteLine("<ParamName>: <Value>")
method.CallStatic(typeof(Console), "WriteLine",
Expr.CallStatic(typeof(string), "Format",
Expr.Primitive(string.Format("{0}: {1}", paramInfo.Name, "{1}")),
Expr.CallMember(Expr.Arg(paramInfo.Name), "ToString")
)
);
}
}
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
// Display Code
string code = Helper.CodeDomHelper.GenerateCodeAsString(compileUnit, new CSharpCodeProvider());
Console.WriteLine(code);
Assembly assembly = Helper.CodeDomHelper.CompileInMemory(compileUnit);
return((TInterface)assembly.GetType(string.Format("Sample2.{0}", typeName))
.GetConstructor(Type.EmptyTypes)
.Invoke(new object[] { }));
}
public static void TryCatchTest()
{
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace")
.Import("System");
FluentCodeClass type = ns.Class(MemberAttributes.Public, "TryCatchClass");
type.Method(MemberAttributes.Public, "TryCatchMethod")
.Try
.Throw(Expr.New(typeof(Exception), Expr.Primitive("Evil Exception")))
.Catch(typeof(Exception), "ex")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Catch Block"))
.Finally
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Finally Block"))
.EndTry
.EndMethod.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
TestGenerated(compileUnit);
}
public static void EnumTest()
{
FluentCodeCompileUnit compileUnit = new FluentCodeCompileUnit();
compileUnit.Namespace("TestNamespace")
.Enum("TestEnum").CustomAttribute(typeof(FlagsAttribute))
.Value("Value1", Expr.Primitive(1)).EndValue
.Value("Value2", Expr.Primitive(2)).EndValue
.Value("Value3", Expr.Primitive(4)).EndValue
.EndEnum
.EndFluent();
TestGenerated(compileUnit.EndFluent());
}
public static void LinqTest()
{
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace");
ns.Class("AClass")
.Method(MemberAttributes.Public, "LinqTest").ReturnType(typeof(bool))
.Declare(typeof(int), "a", Expr.Primitive(5))
.Declare(typeof(int), "b", Expr.Primitive(6))
.If((int a, int b) => a > b)
.Declare(typeof(string), "text", Expr.Primitive("A is bigger than B"))
.Stmt((string text) => Console.WriteLine(text))
.Stmt(ExprLinq.Expr(() => Console.Read()))
.Else
.Declare(typeof(string), "text", Expr.Primitive("B is bigger or equal A"))
.Stmt((string text) => Console.WriteLine(text))
.EndIf
.Return((int a, int b) => a > b)
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Assembly assembly = TestGenerated(compileUnit);
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetMethod("LinqTest").Invoke(instance, new object[] { });
}
public static void LoopTest()
{
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace");
ns.Class("AClass")
.Method(MemberAttributes.Public, "ForArrayTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForArrayTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForArray("i", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.ArrayIndex(Expr.Var("sArr"), Expr.Var("i")))
.EndFor
.EndMethod
.Method(MemberAttributes.Public, "ForeachTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("ForeachTest:"))
.Declare(typeof(string[]), "sArr", Expr.NewArray(typeof(string), Expr.Primitive(2)))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(0)), Expr.Primitive("Hallo1"))
.Set(Expr.ArrayIndex(Expr.Var("sArr"), Expr.Primitive(1)), Expr.Primitive("Hallo2"))
.ForeachEmu(typeof(string), "s", Expr.Var("sArr"))
.CallStatic(typeof(Console), "WriteLine", Expr.Var("s"))
.EndForeach
.EndMethod
.Method(MemberAttributes.Public, "WhileTest")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("WhileTest:"))
.Declare(typeof(int), "a", Expr.Primitive(1))
.WhileEmu(Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.LessThanOrEqual, Expr.Primitive(10)))
.CallStatic(typeof(Console), "WriteLine", Expr.CallStatic(typeof(string), "Format", Expr.Primitive("Value: {0}"), Expr.Var("a")))
.Set(Expr.Var("a"), Expr.Op(Expr.Var("a"), CodeBinaryOperatorType.Add, Expr.Primitive(1)))
.EndWhile
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Assembly assembly = TestGenerated(compileUnit);
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetMethod("ForArrayTest").Invoke(instance, new object[] { });
instance.GetType().GetMethod("ForeachTest").Invoke(instance, new object[] { });
instance.GetType().GetMethod("WhileTest").Invoke(instance, new object[] { });
}
public static void TryCatchTest()
{
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace")
.Import("System");
FluentCodeClass type = ns.Class(MemberAttributes.Public, "TryCatchClass");
type.Method(MemberAttributes.Public, "TryCatchMethod")
.Try
.Throw(Expr.New(typeof(Exception), Expr.Primitive("Evil Exception")))
.Catch(typeof(Exception), "ex")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Catch Block"))
.Finally
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Finally Block"))
.EndTry
.EndMethod.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
TestGenerated(compileUnit);
}
public static void UsingTest()
{
string executingAssemblyPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string path = System.IO.Path.GetDirectoryName(executingAssemblyPath) + "\\..\\..\\test.txt";
var ns = new FluentCodeCompileUnit().Namespace("TestNamespace");
ns.Class("AClass")
.Method(MemberAttributes.Public, "UsingTest")
.Declare(typeof(System.IO.FileStream), "fs", Expr.CallStatic(typeof(System.IO.File), "OpenRead", Expr.Primitive(path)))
.UsingEmu(Expr.Var("fs"))
.UsingEmu(Expr.Declare(typeof(StreamReader), "sr", Expr.New(typeof(StreamReader), Expr.Var("fs"))))
.CallStatic(typeof(Console), "WriteLine", Expr.CallMember(Expr.Var("sr"), "ReadToEnd"))
.EndUsing
.EndUsing
.EndMethod
.EndFluent();
CodeCompileUnit compileUnit = ns.EndNamespace.EndFluent();
Assembly assembly = TestGenerated(compileUnit);
object instance = GetClassInstance("TestNamespace.AClass", assembly);
instance.GetType().GetMethod("UsingTest").Invoke(instance, new object[] { });
}
public static void DefintionTest()
{
var fluent = new FluentCodeCompileUnit();
CodeCompileUnit compileUnit = fluent
.Namespace("Test.FluentCodeDom.Test")
.Import("System")
.Import("System.Text")
.Class(MemberAttributes.Public, "StringModifier")
.Constructor()
.EndConstructor
.Field(typeof(int), "_fld").EndField
.Field(MemberAttributes.Private, typeof(int), "_field1").EndField
.Field(MemberAttributes.Private, typeof(DateTime), "_now").EndField
.Field(typeof(DateTime), "_now2").EndField
.Field(typeof(int), "_intValue").EndField
.Property(MemberAttributes.Public, typeof(int), "IntValue")
.Get
.Return(Expr.Var("_intValue"))
.EndGet
.Set
.Set(Expr.Var("_intValue"), Expr.Value())
.EndSet
.EndProperty
.Method(MemberAttributes.Public, "OutMethod").Parameter(typeof(int), "outParam")
.Set(Expr.Arg("outParam"), Expr.Primitive(55))
.EndMethod
.Method(MemberAttributes.Public, "HelloWorld")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Hallo Welt"))
.CallStatic(typeof(Console), "ReadLine")
.EndMethod
.Method("StringSplit").Parameter(typeof(string), "s").Parameter(typeof(char), "seperationChar").ReturnType(typeof(string))
.Declare(typeof(string[]), "stringArr", Expr.CallMember(Expr.Arg("s"), "Split", Expr.Arg("seperationChar")))
.If(Expr.Op(Expr.Primitive(5), CodeBinaryOperatorType.ValueEquality, Expr.Primitive(10)))
.Declare(typeof(int), "abc")
.Set(Expr.Var("abc"), Expr.Primitive(5))
.Else
.If(Expr.Primitive(false))
.Call("HelloWorld")
.EndIf
.Declare(typeof(int[]), "array", Expr.NewArray(typeof(int), Expr.Primitive(5)))
.ForArray("i", Expr.Var("array"))
.EndFor
.EndIf
.Return(Expr.ArrayIndex(Expr.Var("stringArr"), Expr.Primitive(0)))
.EndMethod
.EndClass
.Enum(MemberAttributes.Public, "SuperEnum")
.Value("Unit", 1).EndValue
.Value("Testing", 2).EndValue
.Value("Sucks").EndValue
.EndEnum
.EndNamespace
.EndFluent();
TestGenerated(compileUnit);
}
public static void DefintionTest()
{
var fluent = new FluentCodeCompileUnit();
CodeCompileUnit compileUnit = fluent
.Namespace("Test.FluentCodeDom.Test")
.Import("System")
.Import("System.Text")
.Class(MemberAttributes.Public, "StringModifier")
.Constructor()
.EndConstructor
.Field(typeof(int), "_fld").EndField
.Field(MemberAttributes.Private, typeof(int), "_field1").EndField
.Field(MemberAttributes.Private, typeof(DateTime), "_now").EndField
.Field(typeof(DateTime), "_now2").EndField
.Field(typeof(int), "_intValue").EndField
.Property(MemberAttributes.Public, typeof(int), "IntValue")
.Get
.Return(Expr.Var("_intValue"))
.EndGet
.Set
.Set(Expr.Var("_intValue"), Expr.Value())
.EndSet
.EndProperty
.Method(MemberAttributes.Public, "OutMethod").Parameter(typeof(int), "outParam")
.Set(Expr.Arg("outParam"), Expr.Primitive(55))
.EndMethod
.Method(MemberAttributes.Public, "HelloWorld")
.CallStatic(typeof(Console), "WriteLine", Expr.Primitive("Hallo Welt"))
.CallStatic(typeof(Console), "ReadLine")
.EndMethod
.Method("StringSplit").Parameter(typeof(string), "s").Parameter(typeof(char), "seperationChar").ReturnType(typeof(string))
.Declare(typeof(string[]), "stringArr", Expr.CallMember(Expr.Arg("s"), "Split", Expr.Arg("seperationChar")))
.If(Expr.Op(Expr.Primitive(5), CodeBinaryOperatorType.ValueEquality, Expr.Primitive(10)))
.Declare(typeof(int), "abc")
.Set(Expr.Var("abc"), Expr.Primitive(5))
.Else
.If(Expr.Primitive(false))
.Call("HelloWorld")
.EndIf
.Declare(typeof(int[]), "array", Expr.NewArray(typeof(int), Expr.Primitive(5) ))
.ForArray("i", Expr.Var("array"))
.EndFor
.EndIf
.Return(Expr.ArrayIndex(Expr.Var("stringArr"), Expr.Primitive(0)))
.EndMethod
.EndClass
.Enum(MemberAttributes.Public, "SuperEnum")
.Value("Unit", 1).EndValue
.Value("Testing", 2).EndValue
.Value("Sucks").EndValue
.EndEnum
.EndNamespace
.EndFluent();
TestGenerated(compileUnit);
}
