root/trunk/WhatIsLambda/IfIHadABoat/Part5/Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Xml;
using System.Collections;
using System.Reflection;

namespace IfIHadABoat.Part5
{
    interface ILocation
    {
        string Name { get; set; }
    }

    interface IPony : ILocation
    {
        IPony Ride(ILocation location);
    }

    interface IBoat : ILocation
    {
        IBoat GoOut(ILocation location);
    }

    class Program
    {
        static public void Example()
        {
            Expression<Action<IBoat, IPony, ILocation>> e3 =
                (boat, pony, place) => pony.Ride(boat == null ? place : boat.GoOut(place));

            Action<IBoat, IPony, ILocation> x3 = e3.Compile();

            var myPony = new Pony { Name = "my pony" };
            var myBoat = new Boat { Name = "my boat" };
            var theOcean = new Location { Name = "the ocean" };

            x3(myBoat, myPony, theOcean);
            // my boat go out on the ocean
            // my pony ride on my boat

            x3(null, new Pony(), new Location { Name = "through the desert" });
            // no name ride on through the desert

            ShowIt(e3);
            // big chunks of xml
        }

        static void ShowIt(Expression e)
        {
            XmlDocument doc = new XmlDocument();
            doc.AppendChild(doc.CreateElement("e"));
            Make(doc.DocumentElement, e, new Stack<object>());
            using (XmlTextWriter writer = new XmlTextWriter(Console.Out))
            {
                writer.Formatting = Formatting.Indented;
                writer.Indentation = 2;
                writer.IndentChar = ' ';
                doc.WriteTo(writer);
            }
        }

        static void Make(XmlElement elt, object obj, Stack<object> dontBeCyclical)
        {
            dontBeCyclical.Push(obj);
            try
            {
                Type type = obj.GetType();

                if (obj is Expression)
                {
                    elt.ParentNode.InsertBefore(elt.OwnerDocument.CreateComment(obj.ToString()), elt);
                }


                foreach (var propInfo in type.GetProperties())
                {
                    object value;
                    try
                    {
                        value = propInfo.GetValue(obj, null);
                    }
                    catch (Exception ex)
                    {
                        value = ex.Message;
                    }


                    if (value == null)
                        continue;

                    if (typeof(Type).IsAssignableFrom(type) && propInfo.Name != "Name")
                        continue;
                    if (typeof(MemberInfo).IsAssignableFrom(type) && propInfo.Name != "Name")
                        continue;

                    if (value.GetType().IsPrimitive || value is string || value is Enum)
                    {
                        elt.Attributes.Append(elt.OwnerDocument.CreateAttribute(propInfo.Name)).Value = Convert.ToString(value);
                        continue;
                    }
                    
                    XmlElement valueElt = elt.OwnerDocument.CreateElement(XmlConvert.EncodeName(value.GetType().Name + "-" + propInfo.Name));
                    elt.AppendChild(valueElt);
                    if (dontBeCyclical.Contains(value))
                    {
                        valueElt.AppendChild(elt.OwnerDocument.CreateTextNode("Cyclical object " + Convert.ToString(value)));
                    }
                    else if (value is IEnumerable)
                    {
                        elt.RemoveChild(valueElt);
                        valueElt = elt.OwnerDocument.CreateElement(propInfo.Name);
                        elt.AppendChild(valueElt);
                        foreach (var item in value as IEnumerable)
                        {
                            XmlElement itemElt = elt.OwnerDocument.CreateElement(item.GetType().Name);
                            valueElt.AppendChild(itemElt);
                            Make(itemElt, item, dontBeCyclical);
                        }
                    }
                    else
                    {
                        Make(valueElt, value, dontBeCyclical);
                    }

                    //elt.Attributes.Append(elt.OwnerDocument.CreateAttribute(propInfo.Name)).Value = Convert.ToString(value);
                }
            }
            finally
            {
                dontBeCyclical.Pop();
            }
        }
    }

    class Location : ILocation
    {
        public string Name { get; set; }
    }


    class Pony : IPony
    {
        public string Name { get; set; }

        public IPony Ride(ILocation location)
        {
            Console.WriteLine("{0} ride on {1}", this.Name ?? "no name", location.Name);
            return this;
        }
    }

    class Boat : IBoat
    {
        public string Name { get; set; }

        public IBoat GoOut(ILocation location)
        {
            Console.WriteLine("{0} go out on {1}", this.Name ?? "no name", location.Name);
            return this;
        }
    }

}