static string ToCode (Action<CSharpWriter> writer) { var @string = new StringWriter (); var csharp = new CSharpWriter (new TextFormatter (@string)); writer (csharp); return @string.ToString (); }
public void LanguageWriterTypeSourceTest() { ILanguageWriter writer = new CSharpWriter(); string s; Type type; type = typeof(double[][, ]); s = writer.TypeSource(CodeBuilder.Instance.TypeRef(type)); Assert.Equal("double[][,]", s); type = typeof(KeyValuePair <double[, ][], double[][, ]>[][, ]); s = writer.TypeSource(CodeBuilder.Instance.TypeRef(type)); Assert.Equal("KeyValuePair<double[,][],double[][,]>[][,]", s); }
public void InterfaceCheck() { var tmpProject = new ProjectInformation(); var tmpClass = Create.AddClass("IAttribute"); tmpClass.ModifierList.Add("public"); tmpClass.ModifierList.Add("interface"); tmpProject.ClassList.Add(tmpClass); new AnalyzerCore().LinkProjectInformation(tmpProject); var tmpObjectInformation = CSharpWriter.CreateClassesFromObjectInformation(tmpProject, new ConverterBase()).ToList(); Assert.AreEqual(1, tmpObjectInformation.Count); Assert.AreEqual(true, tmpObjectInformation[0].Content.Contains("public interface IAttribute")); }
public static void GenerateExterns(IEnumerable <Type> types, string className, string filePath) { CSharpWriter writer = new CSharpWriter(); writer.Write($"public static {className}"); using (new CSharpWriter.Scop(writer)) { foreach (var type in types) { GenerateContextExtern(type, writer); } } FileUtil.WriteFileWithCreateFolder(filePath, writer.ToString()); }
public override string ToCSharp(List <string> definedVariables, ConfigSettings settings) { using var writer = new StringWriter(); writer.Write("await "); switch (RequestParams) { case StandardRequestParams x: writer.Write("HttpRequestStandard(data, new StandardHttpRequestOptions { "); writer.Write("Content = " + CSharpWriter.FromSetting(x.Content) + ", "); writer.Write("ContentType = " + CSharpWriter.FromSetting(x.ContentType) + ", "); break; case RawRequestParams x: writer.Write("HttpRequestRaw(data, new RawHttpRequestOptions { "); writer.Write("Content = " + CSharpWriter.FromSetting(x.Content) + ", "); writer.Write("ContentType = " + CSharpWriter.FromSetting(x.ContentType) + ", "); break; case BasicAuthRequestParams x: writer.Write("HttpRequestBasicAuth(data, new BasicAuthHttpRequestOptions { "); writer.Write("Username = "******", "); writer.Write("Password = "******", "); break; case MultipartRequestParams x: writer.Write("HttpRequestMultipart(data, new MultipartHttpRequestOptions { "); writer.Write("Boundary = " + CSharpWriter.FromSetting(x.Boundary) + ", "); writer.Write("Contents = " + SerializeMultipart(x.Contents) + ", "); break; } writer.Write("Url = " + GetSettingValue("url") + ", "); writer.Write("Method = " + GetSettingValue("method") + ", "); writer.Write("AutoRedirect = " + GetSettingValue("autoRedirect") + ", "); writer.Write("MaxNumberOfRedirects = " + GetSettingValue("maxNumberOfRedirects") + ", "); writer.Write("UrlEncodeContent = " + GetSettingValue("urlEncodeContent") + ", "); writer.Write("AbsoluteUriInFirstLine = " + GetSettingValue("absoluteUriInFirstLine") + ", "); writer.Write("SecurityProtocol = " + GetSettingValue("securityProtocol") + ", "); writer.Write("CustomCookies = " + GetSettingValue("customCookies") + ", "); writer.Write("CustomHeaders = " + GetSettingValue("customHeaders") + ", "); writer.Write("TimeoutMilliseconds = " + GetSettingValue("timeoutMilliseconds") + ", "); writer.Write("HttpVersion = " + GetSettingValue("httpVersion") + ", "); writer.Write("UseCustomCipherSuites = " + GetSettingValue("useCustomCipherSuites") + ", "); writer.Write("CustomCipherSuites = " + GetSettingValue("customCipherSuites") + " "); writer.WriteLine("}).ConfigureAwait(false);"); return(writer.ToString()); }
private void GenRemoveSystem(Type type, CSharpWriter writer, string className) { writer.Write($"private readonly {className}Context context;").NewLine(); writer.Write($"public {className}({context.Name}Context context)"); using (new CSharpWriter.Scop(writer)) { writer.Write("this.context = context;"); } writer.Write($"public void OnCleanup()"); using (new CSharpWriter.Scop(writer)) { writer.Write($"context.RemoveAll<TComponent>();"); } }
private void BuildTree(string stem, string content) { Environment.CurrentDirectory = DirRef.ProjectDir().Dir("Grammar"); var grammarSource = FileRef.From($"./{stem}.Grammar"); var dests = FileRef.From(grammarSource.Directory + "/Out/" + grammarSource.BaseName).With(".Out"); var raw = Parser.Parse(grammarSource); if (raw != null) { var builder = new Build.GrammarBuilder(raw); var grammar = builder.Build(); new Dumper(grammar).Dump(dests); var ccOut = DirRef.ProjectDir().Dir("..").Dir("Lingu.CC").Dir("Gen"); var csharp = new CSharpWriter(grammar, grammarSource, ccOut); csharp.Write(); Debug.Assert(grammar.Eof != null); var dfaSet = new CompactDfaReader(new BinReader(new CompactDfaWriter(grammar).Write())).Read(); //var dfaSet = new DfaSet(grammar.Dfas.Select(dfa => dfa.Convert()).ToArray(), grammar.StateToDfa, grammar.SpacingDfa.Convert()); var context = new LinguContext( grammar.Symbols, grammar.Productions, grammar.ParseTable, dfaSet); Source source; if (File.Exists(content)) { source = Source.FromFile(content); } else { source = Source.FromString(content); } var tree = context.Try(source); new TreeDumper(dests.Add(".Tree")).Dump(tree); } }
internal void GenerateForClass(CSharpWriter stream, UmlAttributeNode attributeNode) { stream.WriteSummary(attributeNode.Documentation); var visibility = CSharpHelper.ConvertVisibility(attributeNode.Visibility, true, true); var attrType = CSharpHelper.ResolveType(attributeNode); if (attributeNode.IsReadOnly) { stream.WriteCodeLine($"{visibility} {attrType} {attributeNode.Name} {{ get; private set; }}"); } else { stream.WriteCodeLine($"{visibility} {attrType} {attributeNode.Name} {{ get; set; }}"); } }
public void CheckMitableValueEquals() { var tmpObjectInformation = ProjectInformationHelper.DoFullRun( ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader() { LoadDefaultData = true }, EqualsString); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList().Last(); Assert.AreEqual("MutableValue", tmpResult.FullName); Assert.AreEqual(true, tmpResult.Content.Contains(" return ((GetType() == inOther.GetType()) && this.equalsSameType(inOther));")); }
internal void GenerateForClass(CSharpWriter stream, UmlAssociationEndNode associationEndNode) { stream.WriteSummary(associationEndNode.Documentation); var visibility = CSharpHelper.ConvertVisibility(associationEndNode.Visibility, true, true); var opositeType = CSharpHelper.ResolveType(associationEndNode.OpositeEnd); if (associationEndNode.IsReadOnly) { stream.WriteCodeLine($"{visibility} IEnumerable<{opositeType}> {associationEndNode.Name} {{ get; private set; }}"); } else { stream.WriteCodeLine($"{visibility} IEnumerable<{opositeType}> {associationEndNode.Name} {{ get; set; }}"); } }
public void DoubleGenericClassReplace() { var tmpObjectInformation = ProjectInformationHelper.DoFullRun( ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader() { LoadDefaultData = true }, DoubleReplacement); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList().Last(); Assert.AreEqual("Bits", tmpResult.FullName); Assert.AreEqual(CSharpResultDouble, tmpResult.Content); }
public void IfWIthConstant() { var tmpIniData = DataHelper.LoadIni(""); var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> { JavaClass }, tmpIniData); new AnalyzerCore().LinkProjectInformation(tmpObjectInformation); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterJavaToCSharp()).ToList(); Assert.AreEqual(1, tmpResult.Count); Assert.AreEqual("Class1", tmpResult[0].FullName); Assert.AreEqual(CSharpResult1, tmpResult[0].Content); }
public void GenCode(CSharpWriter csw, string ns, string cls) { csw.Begin("namespace {0}", ns); foreach (var rule in Rules) { rule.GenClassDefs(csw); } csw.Begin("public partial class {0}", cls); foreach (var rule in Rules) { rule.GenParserMethods(csw); } csw.End(); csw.End(); }
public override void VisitTypeSpec(TypeSpec typeSpec, bool writeByRefModifier) { var stringWriter = new StringWriter(); var csharpWriter = new CSharpWriter(stringWriter); csharpWriter.VisitTypeSpec(typeSpec, writeByRefModifier); Writer.Write("<span class=\"typespec\" title=\""); Writer.WriteEscaped(stringWriter.ToString()); Writer.Write("\">"); base.VisitTypeSpec(typeSpec, writeByRefModifier); Writer.Write("</span>"); }
public void CheckMitableValueCompareTo() { var tmpObjectInformation = ProjectInformationHelper.DoFullRun( ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader() { LoadDefaultData = true }, CompareToString); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList().Last(); Assert.AreEqual("MutableValue", tmpResult.FullName); Assert.AreEqual(true, tmpResult.Content.Contains("Type c1 = this.GetType()")); Assert.AreEqual(true, tmpResult.Content.Contains(" - c2.GetHashCode()")); }
private static void WriteArgsDescription(XElement request, CSharpWriter w) { if (GenerateComments) { var args = request.Elements(ArgElement); foreach (var a in args) { var name = a.Attribute(NameAttrib)?.Value; var descr = a.Attribute(SummaryAttrib)?.Value; if (descr != null) { w.Line($"/// <param name=\"{name}\">{descr}</param>"); } } } }
public void Test() { var tmpClass = @" package java.lang; public class Collection<T>{ }"; var tmpObjectInformation = ProjectInformationHelper.DoFullRun(ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader() { LoadDefaultData = true }, tmpClass); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()).ToList(); ///Write to JSON to add additional Java Base Classes var b = ExportHelper.CreateJsonFromClassList(tmpObjectInformation.ClassList.Where(inItem => inItem.ClassType == CodeConverterCore.Enum.ClassTypeEnum.Normal).ToList()); }
private RegexCSharpCompiler(TextWriter writer, string pattern, RegexOptions options, CultureInfo culture, string @namespace, string className) { Pattern = pattern; Tree = RegexParser.Parse(pattern, options, culture); Code = RegexWriter.Write(Tree); Writer = new CSharpWriter(writer); Codes = Code.Codes; Operations = Operation.GenerateFromCodes(Codes); Strings = Code.Strings; FirstCharacterPrefix = Code.FCPrefix; BoyerMoorePrefix = Code.BMPrefix; Anchors = new Anchors(Code.Anchors); TrackCount = Code.TrackCount; Options = options; Namespace = @namespace; ClassName = className; }
public static void GenReactiveExecuteSystem(CSharpWriter writer, string className, string context, string componentName) { if (string.IsNullOrEmpty(componentName)) { componentName = $"I{context}Component"; } writer.Write($"using TComponent = {componentName};").NewLine(); writer.Write($"public class {className} : LiteECS.ReactiveExecuteSystem<{context}Entity, TComponent>"); using (new CSharpWriter.Scop(writer)) { writer.Write($" private {context}Context Context => context as {context}Context;").NewLine(); writer.Write($"public {className}({context}Context context):base(context)"); writer.EmptyScop(); writer.Write($"protected override void OnExecuteEntity({context}Entity entity, TComponent component)"); writer.EmptyScop(); } }
internal static string DeclarationToString(ITypeDeclaration declaration) { try { StringWriter sw = new StringWriter(); ILanguageWriter lw = new CSharpWriter() as ILanguageWriter; SourceNode sn = lw.GenerateSource(declaration); LanguageWriter.WriteSourceNode(sw, sn); sw.Close(); string s = sw.ToString(); return(s); } catch (Exception ex) { return("[ERROR WRITING DECLARATION: " + ex.Message + "]"); // +ist; } }
public void SimpleFor() { var tmpClass = @" package org; public class Class1 { public void forIInLength(int len){ for(int i=0;i<len;i++) { i--; } return false; } "; var tmpIniData = DataHelper.LoadIni(""); var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> { tmpClass }, tmpIniData); new AnalyzerCore().LinkProjectInformation(tmpObjectInformation); new NamingConvertionHelper(new ConverterLucene()).ConvertProject(tmpObjectInformation); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterJavaToCSharp()) .ToList() .Last(); var tmpExpectedResult = @" namespace org { public class Class1 { public void ForIInLength(int inLen) { for (int i = 0:(i < inLen):i++) { i--; } return false; } } } "; //Check Elvis Result Assert.AreEqual(tmpExpectedResult, tmpResult.Content); }
public void PropertyGet() { var tmpProject = new ProjectInformation(); var tmpClass = Create.AddClass("v1"); var tmpMethode = tmpClass.AddMethode("Name", new TypeContainer("string")); tmpMethode.IsProperty = true; tmpProject.FillClasses(new System.Collections.Generic.List <ClassContainer> { tmpClass }); var tmpObjectInformation = CSharpWriter.CreateClassesFromObjectInformation(tmpProject, new ConverterBase()).ToList(); Assert.AreEqual(1, tmpObjectInformation.Count); Assert.AreEqual(true, tmpObjectInformation[0].Content.Contains("string Name{")); Assert.AreEqual(false, tmpObjectInformation[0].Content.Contains("string Name()")); }
private static String DecompileMethod(String methodName) { MethodInfo netMethodInfo = typeof(MethodBodyTest).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static); if (netMethodInfo == null) { netMethodInfo = typeof(MethodBodyTest).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance); } IMethodReference methodReferece = AssemblyManager.FindMethod(netMethodInfo); CSharpWriter languageWriter = new CSharpWriter(); PlainTextWriter formattedCodeWriter = new PlainTextWriter(); languageWriter.WriteMethodDeclaration(methodReferece.Resolve(), formattedCodeWriter); return(formattedCodeWriter.ToString()); }
public void SimpleWhile() { var tmpClass = @" package org; public class Class1 { public void OneSmallerThanTwo(){ while(true){ return true; } } } "; var tmpIniData = DataHelper.LoadIni(""); var tmpObjectInformation = new JavaLoader().CreateObjectInformation(new List <string> { tmpClass }, tmpIniData); new AnalyzerCore().LinkProjectInformation(tmpObjectInformation); new NamingConvertionHelper(new ConverterLucene()).ConvertProject(tmpObjectInformation); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterJavaToCSharp()) .ToList() .Last(); var tmpExpectedResult = @" namespace org { public class Class1 { public void OneSmallerThanTwo() { while (true) { return true; } } } } "; //Check Elvis Result Assert.AreEqual(tmpExpectedResult, tmpResult.Content); }
public void PropertyInInterfaceWithDefaultValue() { var tmpAnalyerSettings = new AnalyzerSettings(); var tmpObjectInformation = ProjectInformationHelper.DoFullRun(ImportHelper.ImportMappingList(ClassRenameJson.SystemAliasJson), new ConverterLucene(), new JavaLoader() { LoadDefaultData = true }, JavaClass); var tmpResult = CSharpWriter.CreateClassesFromObjectInformation(tmpObjectInformation, new ConverterLucene()) .Where(inItem => inItem.FullName == "MutableValue") .ToList(); Assert.AreEqual(1, tmpResult.Count); Assert.AreEqual("MutableValue", tmpResult[0].FullName); Assert.AreEqual(CSharpResult1, tmpResult[0].Content); }
internal void WriteParserMembers(CSharpWriter csw, RuleCompiler cmp) { foreach (RuleItem item in Items) { item.WriteParserMembers(csw, cmp); } csw.Begin("public bool {0}({1} args)", ParseFuncName, cmp.Rule.ArgsClassName); csw.WriteLine("var beginMark = MarkPosition();"); foreach (RuleItem item in Items) { csw.Begin("if (!{0}(args))", item.ParseFuncName); csw.WriteLine("GoToMark(beginMark);"); csw.WriteLine("return false;"); csw.End(); } csw.WriteLine("return true;"); csw.End(); }
private static int Main(string[] args) { if (args.Length < 2 || (args.Length > 0 && (args[0] == "-h" || args[0] == "--help"))) { Console.WriteLine("usage: dotnet WaylandSharpGen.dll [protocol] [output]"); return(0); } if (args.Length == 0) { Console.WriteLine("No protocol path specified, using default path."); } var path = args[0]; Console.WriteLine($"Using protocol at '{path}'."); if (!File.Exists(path)) { Console.WriteLine("Protocol file not found. Exiting..."); return(1); } var fp = args[1]; var doc = XDocument.Load(path); var w = new CSharpWriter(); w.Line("// This file was generated from an xml Wayland protocol specification"); w.Line("// by WaylandSharpGen. https://github.com/Jjagg/OpenWindow/tree/master/generators/WaylandSharpGen"); w.Line(); w.Line("#pragma warning disable CS0649"); w.Line(); WriteProtocol(doc, w); var dirName = Path.GetDirectoryName(fp); if (!string.IsNullOrWhiteSpace(dirName)) { Directory.CreateDirectory(dirName); } File.WriteAllText(fp, w.ToString()); Console.WriteLine($"Wrote output to '{fp}'."); return(0); }
private void GenDestroySystem(Type type, CSharpWriter writer, string className) { writer.Write($"private readonly {context.Name}Context context;").NewLine(); writer.Write($"public {className}({context.Name}Context context)"); using (new CSharpWriter.Scop(writer)) { writer.Write($"this.context = context;"); } writer.Write($"public void OnCleanup()"); using (new CSharpWriter.Scop(writer)) { writer.Write("var group = context.CreatGroup<TComponent>();").NewLine(); writer.Write("while (group.MoveNext())"); using (new CSharpWriter.Scop(writer)) { writer.Write("group.Entity.Destroy();"); } } }
public static object ProcessQueryClass(InferenceEngine engine, Type type, MethodInfo singleQuery) { var typeDecl = RoslynDeclarationProvider.GetTypeDeclaration(type, false); var queryTransform = new QueryTransform(engine, singleQuery); var compiledQueries = queryTransform.Transform(typeDecl); bool showCode = false; if (showCode) { var sw = new StringWriter(); var lw = new CSharpWriter(); var sn = lw.GenerateSource(compiledQueries); LanguageWriter.WriteSourceNode(sw, sn); var sourceCode = sw.ToString(); } return(engine.Compiler.CompileWithoutParams <object>(new[] { compiledQueries }.ToList())); }
static void Main (string [] args) { var a = Expression.Parameter (typeof (int), "a"); var b = Expression.Parameter (typeof (int), "b"); var return_label = Expression.Label (typeof (int), "ret"); var c = Expression.Parameter (typeof (int), "c"); var d = Expression.Parameter (typeof (int), "d"); var left = Expression.Block ( new [] { c }, Expression.Assign (c, Expression.AddChecked (a, b)), Expression.AddAssignChecked (c, Expression.Constant (42)), c); var right = Expression.Block ( new [] { d }, Expression.Assign (d, Expression.SubtractChecked (a, b)), Expression.SubtractAssignChecked (d, Expression.Constant (42)), d); var conditional = Expression.Condition ( Expression.GreaterThan (a, b), left, right); var lambda = Expression.Lambda<Func<int, int, int>> (conditional, a, b); var add = lambda.Compile (); Console.WriteLine (add (2, 2)); Console.WriteLine ("--------------------"); var csharp = new CSharpWriter (new TextFormatter (Console.Out)); csharp.Write (lambda); Console.WriteLine ("--------------------"); Console.WriteLine (typeof (Expression).GetProperty ("DebugView", BindingFlags.NonPublic | BindingFlags.NonPublic | BindingFlags.Instance).GetValue (lambda, new object [0])); }
static void Main(string [] args) { var a = Expression.Parameter(typeof(int), "a"); var b = Expression.Parameter(typeof(int), "b"); var return_label = Expression.Label(typeof(int), "ret"); var c = Expression.Parameter(typeof(int), "c"); var d = Expression.Parameter(typeof(int), "d"); var left = Expression.Block( new [] { c }, Expression.Assign(c, Expression.AddChecked(a, b)), Expression.AddAssignChecked(c, Expression.Constant(42)), c); var right = Expression.Block( new [] { d }, Expression.Assign(d, Expression.SubtractChecked(a, b)), Expression.SubtractAssignChecked(d, Expression.Constant(42)), d); var conditional = Expression.Condition( Expression.GreaterThan(a, b), left, right); var lambda = Expression.Lambda <Func <int, int, int> > (conditional, a, b); var add = lambda.Compile(); Console.WriteLine(add(2, 2)); Console.WriteLine("--------------------"); var csharp = new CSharpWriter(new TextFormatter(Console.Out)); csharp.Write(lambda); Console.WriteLine("--------------------"); Console.WriteLine(typeof(Expression).GetProperty("DebugView", BindingFlags.NonPublic | BindingFlags.NonPublic | BindingFlags.Instance).GetValue(lambda, new object [0])); }
private static void WriteDescription(XElement e, CSharpWriter w) { if (GenerateComments) { var summary = e.Attribute(SummaryAttrib); var descr = e.Element(DescriptionElement); if (descr != null) { var descrStr = descr.Value; var summaryStr = summary == null ? string.Empty : summary.Value + "\n"; descrStr = $"{summaryStr}<p>" + descrStr + "</p>"; var lines = descrStr .Trim() .Split('\n') .SelectMany(l => string.IsNullOrEmpty(l) ? new [] { "</p>", "<p>" } : new [] { l }) .Select(s => s.Trim()); w.DocSummary(lines); } } }
static void Main (string [] args) { var a = Expression.Parameter (typeof (int), "a"); var b = Expression.Parameter (typeof (int), "b"); var scope = Expression.Parameter(typeof(object), "scope"); var instance = Expression.Constant(scope); var binder = Binder.GetMember( CSharpBinderFlags.None, "Text", typeof(object), new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) } ); var expArgs = new List<Expression>() { instance }; var binderM = Binder.InvokeMember( CSharpBinderFlags.None, "ToString", null, typeof(object), expArgs.Select(x => CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)) ); Expression resultm = Expression.Dynamic(binderM, typeof(object), expArgs); Expression result = Expression.Dynamic(binder, typeof(object), instance); var return_label = Expression.Label (typeof (int), "ret"); var c = Expression.Parameter (typeof (int), "c"); var d = Expression.Parameter (typeof (int), "d"); var left = Expression.Block ( new [] { c }, Expression.Assign (c, Expression.AddChecked (a, b)), Expression.AddAssignChecked (c, Expression.Constant (42)), c); var right = Expression.Block ( new [] { d }, Expression.Assign (d, Expression.SubtractChecked (a, b)), Expression.SubtractAssignChecked (d, Expression.Constant (42)), result, resultm, d); var conditional = Expression.Condition ( Expression.GreaterThan (a, b), left, right); var lambda = Expression.Lambda<Func<int, int, int>> (conditional, a, b); var add = lambda.Compile (); //Console.WriteLine (add (2, 2)); Console.WriteLine ("--------------------"); var csharp = new CSharpWriter (new TextFormatter (Console.Out)); csharp.Write (lambda); Console.WriteLine ("--------------------"); Console.WriteLine (typeof (Expression).GetProperty ("DebugView", BindingFlags.NonPublic | BindingFlags.NonPublic | BindingFlags.Instance).GetValue (lambda, new object [0])); }