ToExpressionNode Extension method breaks in some cases about serialize.linq HOT 11 CLOSED

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel.Security;
using System.ServiceModel;
using System.IO;
using System.Diagnostics;
using System.Text;
using System.Globalization;

using Serialize.Linq;
using Serialize.Linq.Extensions;
using Serialize.Linq.Nodes;

using System.Linq.Expressions;

class Program
{
    public class MyType
    {
        public int Id { get; set; }
    }

    static void Main(string[] args)
    {
        var ids = new List<int> { 1, 2, 3, 4, 5, 6 };
        Expression<Func<MyType, bool>> expression1 = mt => mt.Id == 1 || mt.Id == 5 || mt.Id == 6;
        var node1 = expression1.ToExpressionNode();

        try
        {
            Expression<Func<MyType, bool>> expression2 = mt => ids.Contains(mt.Id);
            var node2 = expression2.ToExpressionNode();
        }
        catch
        {

        }
    }
}

System.ServiceModel.CommunicationException was unhandled
  Message=There was an error while trying to serialize parameter http://tempuri.org/:query. The InnerException message was 'Type 'System.Int32[]' with data contract name 'ArrayOfint:http://schemas.microsoft.com/2003/10/Serialization/Arrays' is not expected. Consider using a DataContractResolver or add any types not known statically to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding them to the list of known types passed to DataContractSerializer.'.  Please see InnerException for more details.
  Source=mscorlib

[DataContract]
public class Person
{
    [DataMember]
    public string FirstName { get; set; }

    [DataMember]
    public string LastName { get; set; }
}

[ServiceContract]
public interface IPersonService
{
    [OperationContract]
    Person[] GetAllPersons();

    [OperationContract]
    Person[] QueryPersons(ExpressionNode query);
}

public class PersonService : IPersonService
{
    private IList<Person> _persons = new List<Person>
    {
        new Person { FirstName="Bill", LastName="Gates" },
        new Person { FirstName="John", LastName="Doe" },
        new Person { FirstName="Jane", LastName="Smith" },
        new Person { FirstName="Fred", LastName="Gates" }
    };

    public Person[] GetAllPersons()
    {
        return _persons.ToArray();
    }

    public Person[] QueryPersons(ExpressionNode query)
    {
        var expression = query.ToExpression<Func<Person, bool>>();
        return _persons.Where(expression.Compile()).ToArray();
    }
}

static void Main(string[] args)
{
    ServiceHost personHost = null;

    try
    {
        personHost = new ServiceHost(typeof(PersonService));

        ServiceEndpoint productEndpoint = personHost.AddServiceEndpoint(typeof(IPersonService), new NetTcpBinding(), "net.tcp://localhost:9010/ProductService");
        personHost.Open();

        Console.WriteLine("The Product service is running and is listening on:");
        Console.WriteLine("{0} ({1})", productEndpoint.Address.ToString(), productEndpoint.Binding.Name);
        Console.WriteLine("\nPress any key to stop the service.");

        var myBinding = new NetTcpBinding();
        var myEndpoint = new EndpointAddress("net.tcp://localhost:9010/ProductService");
        var myChannelFactory = new ChannelFactory<IPersonService>(myBinding, myEndpoint);
        IPersonService client = null;
        try
        {
            client = myChannelFactory.CreateChannel();

            // This works fine.
            var persons = client.GetAllPersons();
            Console.WriteLine("{0} persons", persons.Count());

            Expression<Func<Person, bool>> expression1 = p => p.LastName == "Gates";
            // This works fine.
            var matches1 = client.QueryPersons(expression1.ToExpressionNode());
            Console.WriteLine("{0} persons", matches1.Count());

            var firstNames = new string[] { "Bill", "Jim", "Teddy", "Jane" };
            Expression<Func<Person, bool>> expression2 = p => firstNames.Contains(p.FirstName);
            // This will break.
            var matches2 = client.QueryPersons(expression2.ToExpressionNode());
            Console.WriteLine("{0} persons", matches2.Count());

            ((ICommunicationObject)client).Close();
        }
        catch
        {
            if (client != null)
            {
                ((ICommunicationObject)client).Abort();
            }
        }

        Console.ReadKey();
    }
    finally
    {
        if (personHost.State == CommunicationState.Faulted)
        {
            personHost.Abort();
        }
        else
        {
            personHost.Close();
        }
    }
}