LINQ ve Lambda ile Katılın / Nerede

LINQ ve Lambda yazılmış bir sorgu ile sorun yaşıyorum. Şimdiye kadar, benim hata burada bir sürü hata alıyorum:

int id = 1;
var query = database.Posts.Join(database.Post_Metas,
                                post => database.Posts.Where(x => x.ID == id),
                                meta => database.Post_Metas.Where(x => x.Post_ID == id),
                                (post, meta) => new { Post = post, Meta = meta });

LINQ kullanmak için yeniyim, bu yüzden bu sorgunun doğru olup olmadığından emin değilim.

SQL sözdizimine aşina iseniz, LINQ sorgu sözdizimini kullanmanın çok daha net, daha doğal olduğunu ve hataları tespit etmeyi kolaylaştırdığını görüyorum:

var id = 1;
var query =
   from post in database.Posts
   join meta in database.Post_Metas on post.ID equals meta.Post_ID
   where post.ID == id
   select new { Post = post, Meta = meta };

Eğer lambdas kullanmakta gerçekten sıkışıp kalırsanız, sözdiziminiz biraz kapalıdır. Aynı sorgu, LINQ uzantısı yöntemlerini kullanarak:

var id = 1;
var query = database.Posts    // your starting point - table in the "from" statement
   .Join(database.Post_Metas, // the source table of the inner join
      post => post.ID,        // Select the primary key (the first part of the "on" clause in an sql "join" statement)
      meta => meta.Post_ID,   // Select the foreign key (the second part of the "on" clause)
      (post, meta) => new { Post = post, Meta = meta }) // selection
   .Where(postAndMeta => postAndMeta.Post.ID == id);    // where statement

Bununla iki yoldan gidebilirsin. Kullanılması LINQPad ve bir kukla veritabanı, aşağıdaki sorguları inşa (Sen LINQ yeni eğer çok değerli):

Posts.Join(
    Post_metas,
    post => post.Post_id,
    meta => meta.Post_id,
    (post, meta) => new { Post = post, Meta = meta }
)

veya

from p in Posts
join pm in Post_metas on p.Post_id equals pm.Post_id
select new { Post = p, Meta = pm }

Bu özel durumda, ben LINQ sözdizimi daha temiz olduğunu düşünüyorum (Ben okumak için en kolay bağlı olarak ikisi arasında geçiş).

Ama işaret etmek istediğim, eğer veritabanınızda uygun yabancı anahtarlar varsa, (post ve post_meta arasında), çok sayıda kayıt yüklemeye çalışmadığınız sürece muhtemelen açık bir birleştirmeye ihtiyacınız yoktur. . Örneğin, tek bir gönderi ve meta verileri yüklemeye çalıştığınızı gösteriyor gibi görünüyor. Her bir gönderi için birçok post_meta kaydı olduğunu varsayarsak, aşağıdakileri yapabilirsiniz:

var post = Posts.Single(p => p.ID == 1);
var metas = post.Post_metas.ToList();

N + 1 probleminden kaçınmak istiyorsanız, açıkça LINQ'dan SQL'e ilgili öğelerin tümünü bir seferde yüklemesini söyleyebilirsiniz (bu, L2S'ye daha aşina olduğunuzda gelişmiş bir konu olabilir). Aşağıdaki örnekte "bir Yazı yüklediğinizde, onunla ilişkili tüm kayıtları 'Post_metas' özelliği tarafından temsil edilen yabancı anahtar aracılığıyla da yüklenir" yazıyor:

var dataLoadOptions = new DataLoadOptions();
dataLoadOptions.LoadWith<Post>(p => p.Post_metas);

var dataContext = new MyDataContext();
dataContext.LoadOptions = dataLoadOptions;

var post = Posts.Single(p => p.ID == 1); // Post_metas loaded automagically

Aynı türden veya birçok farklı türden LoadWitholuşan tek bir kümede birçok çağrı yapmak mümkündür DataLoadOptions. Bu lotları yine de yaparsanız, sadece önbelleğe almayı düşünebilirsiniz.

Daniel'in sözdizimi ilişkilerine ilişkin iyi bir açıklaması var, ancak anlamalarını biraz daha kolay hale getirmek için bu belgeyi ekibim için bir araya getirdim. Umarım bu birine yardımcı olur

Anahtar seçicileriniz yanlış. Söz konusu tablonun türünde bir nesne almalı ve birleşimde kullanmak için anahtarı döndürmelidirler. Bunu demek istediğini düşünüyorum:

var query = database.Posts.Join(database.Post_Metas,
                                post => post.ID,
                                meta => meta.Post_ID,
                                (post, meta) => new { Post = post, Meta = meta });

Daha sonra where yan tümcesini, anahtar seçicinin parçası olarak uygulayamazsınız.

LINQ + EntityFramework'a başladığımda bir günlüğüne bu örneklere baktım.

Eğer EntityFramework kullanıyorsanız ve adlandırılmış bir navigasyon özelliği varsa Metasenin üzerinde Postmodeli nesnesi kurmak, bu kir kolaydır. Varlığı kullanıyorsanız ve bu navigasyon özelliğine sahip değilseniz, ne bekliyorsunuz?

database
  .Posts
  .Where(post => post.ID == id)
  .Select(post => new { post, post.Meta });

Önce kod yapıyorsanız, mülkü bu şekilde kuracaksınız:

class Post {
  [Key]
  public int ID {get; set}
  public int MetaID { get; set; }
  public virtual Meta Meta {get; set;}
}

Ben böyle bir şey yaptım;

var certificationClass = _db.INDIVIDUALLICENSEs
    .Join(_db.INDLICENSECLAsses,
        IL => IL.LICENSE_CLASS,
        ILC => ILC.NAME,
        (IL, ILC) => new { INDIVIDUALLICENSE = IL, INDLICENSECLAsse = ILC })
    .Where(o => 
        o.INDIVIDUALLICENSE.GLOBALENTITYID == "ABC" &&
        o.INDIVIDUALLICENSE.LICENSE_TYPE == "ABC")
    .Select(t => new
        {
            value = t.PSP_INDLICENSECLAsse.ID,
            name = t.PSP_INDIVIDUALLICENSE.LICENSE_CLASS,                
        })
    .OrderBy(x => x.name);

Gibi bir şey olabilir

var myvar = from a in context.MyEntity
            join b in context.MyEntity2 on a.key equals b.key
            select new { prop1 = a.prop1, prop2= b.prop1};

1 eşittir 1 iki farklı masa birleşimi

var query = from post in database.Posts
            join meta in database.Post_Metas on 1 equals 1
            where post.ID == id
            select new { Post = post, Meta = meta };

Bu linq sorgusu sizin için çalışmalıdır. Post meta içeren tüm gönderileri alacaktır.

var query = database.Posts.Join(database.Post_Metas,
                                post => post.postId, // Primary Key
                                meta => meat.postId, // Foreign Key
                                (post, meta) => new { Post = post, Meta = meta });

Eşdeğer SQL Sorgusu

Select * FROM Posts P
INNER JOIN Post_Metas pm ON pm.postId=p.postId