Question

I have code-first based context with following entities:

public class City : IEquatable<City>
{

    public City()
    {
        Posts = new List<Post>();
    }

    public City(string cityName) : this()
    {
        Name = cityName;
    }

    public virtual ICollection<Post> Posts { get; private set; }

    public int Id { get; set; }

    public string Name { get; private set; }

    protected string  LoweredName 
    {
        get { return Name.ToLower(CultureInfo.CurrentCulture); }
    }

    public override bool Equals(object obj)
    {
        bool equals = false;
        var city = obj as City;
        if (city != null)
            equals = Equals(city);
        return equals;
    }

    public override int GetHashCode()
    {
        int idHash = Id.GetHashCode();
        int nameHash = LoweredName.GetHashCode();

        var hashCode = idHash ^ nameHash;
        return hashCode;
    }

    public bool Equals(City other)
    {
        return Id == other.Id && LoweredName == other.Name.ToLower(CultureInfo.CurrentCulture);
    }
}
public class Post : IEquatable<Post>
{
    public Post()
    {
        Addresses = new List<PostalAddress>();
    }

    public virtual ICollection<PostalAddress> Addresses { get; private set; }
    public virtual City City { get; set; }

    public int Id { get; set; }

    public string ZipCode { get; set; }
    protected string LoweredZipCode { get { return ZipCode.ToLower(CultureInfo.CurrentCulture); } }

    public bool Equals(Post other)
    {

        return Id == other.Id && City.Equals(other.City) && LoweredZipCode == other.ZipCode.ToLower(CultureInfo.CurrentCulture);
    }
}

DbContext has defined those entities in method OnModelCreating:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
    modelBuilder.Configurations.Add(new CityMap());
    modelBuilder.Configurations.Add(new PostMap());
}

public class CityMap : EntityTypeConfiguration<City>
{
    public CityMap()
    {
        // Primary Key
        HasKey(t => t.Id);

        // Properties
        // Table & Column Mappings
        ToTable("City");
        Property(t => t.Id).HasColumnName("Id");
        Property(t => t.Name)
            .HasColumnName("Name")
            .HasMaxLength(450);
    }
}
public class PostMap : EntityTypeConfiguration<Post>
{
    public PostMap()
    {
        // Primary Key
        HasKey(t => t.Id);

        // Properties
        // Table & Column Mappings
        ToTable("Post");
        Property(t => t.Id)
            .HasColumnName("Id");
        Property(t => t.ZipCode)
            .HasColumnName("ZipCode")
            .HasMaxLength(450);

        // Relationships
        HasRequired(t => t.City)
            .WithMany(t => t.Posts)
            .Map(map => map.MapKey("CityId"));
    }
}

I’ve readed some data as POCO object and inserted them into List collection

public class PostImportObject : IEquatable<PostImportObject>
    {

        private string _city;
        private string _loweredCity;

        public string City
        {
            get { return _city; }
            set
            {
                _city = value.CapitalizeFirstLetter();
                _loweredCity = value.ToLower(CultureInfo.CurrentCulture);
            }
        }

        public string ZipCode
        {
            get { return _zipValue; }
            set { _zipValue = value.ToLower(CultureInfo.CurrentCulture); }
        }


        protected string LoweredCity
        {
            get { return _loweredCity; }
        }

        public override bool Equals(object obj)
        {
            bool equals = false;
            var postImport = obj as PostImportObject;
            if (postImport != null)
            {
                equals = Equals(postImport);
            }
            return equals;
        }

        public override int GetHashCode()
        {
            int ziphash = ZipCode.GetHashCode();
            int cityHash = LoweredCity.GetHashCode();

            var hashCode = ziphash ^ cityHash;
            return hashCode;
        }

        public bool Equals(PostImportObject other)
        {
            bool equals = _loweredCity == other.City.ToLower(CultureInfo.CurrentCulture) && ZipCode == other.ZipCode;
            return equals;
        }
    }

If I query data in import list and in database too, my following queries return the same Exception:

using(var db = new DbContext())
{
    var query1 = from post2 in db.Posts.Include("City")
                                    join mergedPost in mergedPosts on new PostImportObject() {City = post2.City.Name, ZipCode = post2.ZipCode} equals new PostImportObject() {City = mergedPost.City, ZipCode = mergedPost.ZipCode} into joinedPosts
                                    from joinedPost in joinedPosts.DefaultIfEmpty()
                                    where joinedPosts==null
                                    select post2;

            var query2= from city1 in db.Cities
                            join postImportObject in mergedPosts on city1.Name equals postImportObject.City
                            join post1 in db.Posts on city1 equals post1.City
                            select post1;
}

I’ll get following exception when querying Any() method of query1 or query2:
Index (zero based) must be greater than or equal to zero and less than the size of the argument list

I’m sorry that I created another topic with same subject, but I didn’t find solution for my problem in other topics.

Answer 1

Looking at the stack trace, I’m guessing there’s a problem with the translated version of the ELinq_UnsupportedConstant resource. The English version of this error message is: Unable to create a constant value of type ‘{0}’. Only primitive types (‘{1}’) are supported in this context.

I think you have two problems:

1. For a join, the composite key needs to be an anonymous type; you can’t use your PostImportObject as the join key in query1;

2. You can’t join a database table to a local list;

I think you’ll need to use .AsEnumerable() to pull the entire list into memory before you can join to the local list:

var query = from post in context.Posts.Include(p => p.City).AsEnumerable()
            join mergedPost in mergedPosts 
               on new { City = post.City.Name, post.ZipCode } 
               equals new { mergedPost.City, mergedPost.ZipCode } 
               into joinedPosts
           from joinedPost in joinedPosts.DefaultIfEmpty()
           where joinedPost == null
           select post;