Generic Benutzerdefinierte Join Erweiterung Methode

Question

Nehmen wir an, wir haben 2 Tabellen, TableA und TableB mit einer PK-FK-Beziehung unter ihnen, ich habe eine extension method bis join diese 2 Tabellen geschrieben und holen Sie die Daten. Diese Erweiterungsmethode ist ziemlich spezifisch und erledigt die Arbeit für diese 2 Tabellen.

Was muss getan werden, um eine GENERIC-Erweiterungsmethode zu erstellen, um zwei beliebige Tabellen zu verbinden und die Daten zu projizieren?

Mein Code:

Schema von TableA:

CREATE TABLE [dbo].[TableA](
    [Id_1] [int] IDENTITY(1,1) NOT NULL, 
    [Name] [nvarchar](max) NULL, 
    [Address] [nvarchar](max) NULL, 
PRIMARY KEY CLUSTERED 
(
    [Id_1] ASC 
) 

Schema von TableB:

CREATE TABLE [dbo].[TableB](
    [Id_2] [int] IDENTITY(1,1) NOT NULL, 
    [Name2] [nvarchar](max) NULL, 
    [Address2] [nvarchar](max) NULL, 
    [FK_Id] [int] NULL, 
PRIMARY KEY CLUSTERED 
(
    [Id_2] ASC 
) 
ALTER TABLE [dbo].[TableB] WITH CHECK ADD FOREIGN KEY([FK_Id]) 
REFERENCES [dbo].[TableA] ([Id_1]) 

C# -Code:

public class ABDTO 
    { 
     public TableA A { get; set; } 
     public TableB B { get; set; } 
    } 

public static class Helper 
    { 
     public static IEnumerable<ABDTO> Join(this IEnumerable<TableA> tableA,IEnumerable<TableB> tableB) 
     { 
      return tableA.Join(tableB,x => x.Id_1,y => y.FK_Id, 
            (x, y) =>new ABDTO 
             { 
              A = x, 
               B = y 
              }); 
       } 

public class Program 
    { 
     static void Main(string[] args) 
     { 
      Operation1(); 
      Console.ReadLine(); 
     } 

     public static void Operation1() 
     { 
      using (var db = new SampleEntities()) 
      { 
       var result = db.TableAs.Join(db.TableBs); 

       foreach(var item in result) 
       { 
        Console.WriteLine("{0}; {1} ||| {2} ; {3}", item.A.Id_1, item.A.Name, item.B.Id_2, item.B.Name2); 
       } 
      } 
     } 
    } 

So, Join() ist ein extension method, der TableA und TableB aufnimmt, sie auf die PK-FK-Beziehung zugreift und die Selektoren herausprojiziert.

Wie kann ich etwas generic als schreiben:

public static IEnumerable<T> Join(this IEnumerable<T> Ta, IEnumerable<T> Tb) 
     { 
      return Ta.Join(Tb, x => Ta.SomeColumn1, y => Tb.SomeColumn2, 
           (x, y) => Projection of columns); 
     } 

Ich bin nicht sehr gut in LINQ und Extension methods, bitte helfen Sie. Alle Zeiger sind auch hilfreich.

Answer 1

Ich habe einige R & D und war in der Lage, die Lösung abzuleiten.

public class ABDTO<T,U> 
    { 
     public T A { get; set; } 
     public U B { get; set; } 
    } 
    public static class Helper 
    { 
     public static IQueryable<ABDTO<T,U>> JoinEx<T,U,Key>(this IQueryable<T> tableA,IQueryable<U> tableB, Expression<Func<T, Key>> column1, Expression<Func<U, Key>> column2) 
     { 
      return tableA.Join(tableB, column1, column2, (y, z) => new ABDTO<T,U> {A= y, B=z }); 
     } 
    } 

JoinEx<>() sind ein generisches extension Verfahren, das in 2 Tabellen der Typen nimmt T und U, kommt sie auf der Grundlage von zwei Spalten und in einer gemeinsamen DTO das Ergebnis herausragen. vielleicht Leistungsbeschränkungen, dass es, und diese Art von Operationen muß in den database als stored procedure durchgeführt werden, aber es ist eine Voraussetzung für diese Art von generischen Sachen

using (var db = new SampleEntities()) 
      { 
       var result=db.TableAs.JoinEx<TableA, TableB, int>(db.TableBs, x => x.Id_1, y => y.FK_Id); 
       foreach(var item in result) 
       {    
         Console.WriteLine("{0} \t {1}",item.A.Name,item.B.Name2);          
       } 
      } 

Ich verstehe:

Es ist wie unten genannt.

Danke