Comment faire une jointure LINQ qui se comporte exactement comme une jointure interne de base de données physique?

Précédemment Soution ...

public static DataTable JoinDataTables2(DataTable dt1, DataTable dt2, string table1KeyField, string table2KeyField)
{
    DataTable joinTable = new DataTable();
    foreach (DataColumn dt1Column in dt1.Columns)
    {
        joinTable.Columns.Add(dt1Column.ColumnName, dt1Column.DataType);
    }

    var col2 = dt2.Columns[table2KeyField];
    joinTable.Columns.Add(col2.ColumnName,typeof(string));

    var result = (from dataRows1 in dt1.AsEnumerable()
                  join dataRows2 in dt2.AsEnumerable()
                      on dataRows1.Field<string>(table1KeyField) equals dataRows2.Field<string>(table2KeyField)
                  select new
                  {
                      Col1 = dataRows1,
                      Col2 = dataRows2.Field<string>(table2KeyField)
                  });
    foreach (var row in result)
    {
        DataRow dr = joinTable.NewRow();
        foreach (DataColumn dt1Column in dt1.Columns)
        {
            dr[dt1Column.ColumnName] = row.Col1[dt1Column.ColumnName];
        }

        dr[table2KeyField] = row.Col2;
        joinTable.Rows.Add(dr);
    }
    joinTable.AcceptChanges();
    return joinTable.AsEnumerable().Distinct().CopyToDataTable();
}

Vous pouvez lister toutes les colonnes de table1 dans la requête de sélection. La requête suivante a un DataTable par définition avec toutes les colonnes de table1 et uniquement la colonne clé de table2. Cela peut vous aider.

public static DataTable JoinDataTables2(DataTable dt1, DataTable dt2, string table1KeyField, string table2KeyField) {
   DataTable result = ( from dataRows1 in dt1.AsEnumerable()
                            join dataRows2 in dt2.AsEnumerable()
                            on dataRows1.Field<string>(table1KeyField) equals dataRows2.Field<string>(table2KeyField) 
                            select new {Col1= datarows1Field<string>(table1FieldName), Col2= datarows2.Field<string>(table2FieldName)}).Distinct().CopyToDataTable();
   return result;
}

[Mise à jour n ° 3]

1. Je ne sais pas si l'ensemble de résultats que je récupère est correct en fonction du comportement INNER JOIN.

Un ensemble de résultats renvoyé par une requête linq représente exactement ce que vous avez écrit dans une requête.

2. La liste de sélection n'inclut pas la "colonne de jointure" pour la deuxième table de données (dans> cet exemple particulier, qui serait "ModelID"), et je en a besoin.

La réponse est très simple: votre requête ne renvoie les données que du premier datatable (BTW: vous l'avez déjà mentionné dans la description du problème).

Une fois cela fait, je peux confirmer que les valeurs CMODEL correspond aux valeurs ModelID et confirme ainsi que j'ai une jointure valide. (Ce n'est qu'un scénario, ce sera différent, donc aucun nom de colonne ne peut être codé en dur dans la fonction.)

Vous pouvez être sûr qu'une requête Linq2DataSet renvoie les bons ID. Ils doivent correspondre pour pouvoir les rejoindre. S'il n'y a pas de correspondance, un ensemble de résultats sera vide! Il semble que vous deviez améliorer vos connaissances sur les jointures. Veuillez lire cet excellent article: Représentation visuelle des jointures SQL a>

Une version courte de l'article connexe:

jointure à gauche

DataTable resultDt = OleDbJoin("FullFileName1", "FullFileName2", "F1", "F2");

jointure interne

public static DataTable OleDbJoin(string csv1, string csv2, string key1, string key2)
{
    DataTable dt = new DataTable();

    string sConn = string.Format(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source={0}\;Extended Properties='text;HDR=No;FMT=CSVDelimited()';", Path.GetDirectoryName(csv1));
    string sSql = string.Format(@"SELECT T.*
        FROM (
            SELECT * FROM [{0}] AS t1
            INNER JOIN (SELECT * FROM [{1}]) AS t2
                ON t1.[{2}] = t2.[{3}]) AS T;",
            Path.GetFileName(csv1), Path.GetFileName(csv2), key1, key2);

    try
    {
        using (OleDbConnection oConn = new OleDbConnection(sConn))
        {
            using (OleDbCommand oComm = new OleDbCommand(sSql, oConn))
            {
                oConn.Open();
                OleDbDataReader oRdr = oComm.ExecuteReader();
                dt.Load(oRdr);
                oComm.Dispose();
                oRdr.Dispose();
                oConn.Close();
                oConn.Dispose();
            }
        }
    }
    catch(OleDbException ex)
    {
        Console.WriteLine(ex.Message);
    }
    catch(Exception ex)
    {
        Console.WriteLine(ex.Message);
    }

    return dt;
}

jointure droite

select new {datarows1, datarows2}

jointure croisée

cross join returns the cartesian product of the sets

3. Comment DISTINCTER le jeu de résultats?

Il existe un Méthode distincte .

Mais je ne suis pas sûr, vous en avez vraiment besoin; (

Remarque générale:

Il y a quelques façons de lire délimité files (* .csv):

1) en utilisant les méthodes de lecture de fichier texte "standard" et en divisant le texte en parties dans une ou plusieurs boucles [for]

Voir: Un lecteur CSV rapide

2) en utilisant les méthodes linq, c'est-à-dire: Select()

Remarque: La plupart des programmeurs savent bien que Les méthodes linq seront beaucoup plus lentes que la boucle [for] lorsque vous travaillez sur de grands ensembles de données.
Pour pouvoir projeter des champs à partir de tables jointes, vous devez utiliser:

Set1 = [1, 2, 3, 5]
Set2 = [2, 4, 5]
Resultset = [2,4,5] // gets [2] from right (set2), [4,5] are common (set1 and set2)

Si vous souhaitez créer des colonnes dynamiques à l'aide de Linq, consultez: Interroger une table de données avec des noms de colonnes dynamiques à l'aide de LINQ

Voici un code complet pour joindre deux tables de données en une seule Datatable : dotnetfiddle

3) avec OleDb: OleDbConnection , OleDbCommand

Voir:
Utilisation d'OleDb pour importer des fichiers texte onglet CSV personnalisé
Lire les colonnes spécifiques aux fichiers texte

Votre méthode d'extension pourrait ressembler à:

Set1 = [1, 2, 3, 5]
Set2 = [2, 4, 5]
Resultset = [2,5] //only common items (set1 and set2)

Appel:

Set1 = [1, 2, 3, 5]
Set2 = [2, 4, 5]
Resultset = [1,2,5] //get [1] from left (set1), [2,5] are common items (set1 and set2)

Conditions requises: em >
- les deux fichiers csv doivent être dans le même répertoire
- fichiers csv utilisant un séparateur standard pour les fichiers csv, ee: Fichier Schema.ini
- il n'y a pas d'en-tête dans les fichiers (pas de nom de colonne)

Il y a un peu d'ambiguïté, mais d'après ce que j'ai compris, vous devez Join deux tables et obtenir une ligne des deux (ou moins) après avoir appliqué un Distinct () sur les résultats de la Join . Tout cela, étant donné que les colonnes ne sont pas prédéfinies.

Voici ma solution:

Si chaque fichier CSV représente une table de votre base de données, envisagez de faire quelque chose de similaire au framework d'entité.

Au lieu de IQueryable<...> laissez vos DbSets code> implémenter IEnumerable<...>

Si vous avez seulement besoin de récupérer les données, ce sera assez facile. Si vous souhaitez également mettre à jour, vous devrez implémenter (ou réutiliser) un DbChangeTracker

Students.SaveChanges()
Teachers.SaveChanges();
Schools.SaveChanges();

Vous aurez également besoin d'un DbContext qui contient tous vos DbSets:

void SaveChanges()
{
    this.ChangeTracker.SaveChanges();
}

Vous pouvez améliorer les performances en vous rappelant les éléments déjà récupérés. Mettez-les dans un dédicace, utilisez la clé primaire comme clé diconique. Ajoutez également une fonction Find au DbSet:

class DbChangeTracker<T, TKey> : IEnumerable<T> where T : class
{
     public IEqualityComparer<T> ValueComparer {get; set;}
     ...
}

C'est plus simple si chaque élément de table a le même type de clé primaire:

void SaveChanges()
{
    // your CsvFile database has functions to add / update / remove items
    foreach (var itemToAdd in itemsToAdd)
    {
        csvDatabase.Add(itemToAdd);
    }

    // update or remove fetched items with OriginalValue unequal to Value
    var itemsToUpdate = this.fetchedItems
        .Where(fetchedItem => !ValueComparer.Equals(fetchedItem.OriginalValue, fetchedItem.Value)
        .ToList();

    foreach (Entity<T> itemToUpdate in itemsToUpdate)
    {
        if (itemToUpdate.Value == null)
        {   // remove
            csvFile.Remove(itemToUpdate.OriginalValue);
        }
        else
        {   // update
            csvFile.Update(...);
        } 
    }
}

Sinon, vous devrez indiquer à votre DbSet le type de clé primaire:

public Entity<T> Find(TKey primaryKey)
{
    // is it already in the Dictionary (found before)?
    // if not: get it from the CsvDatabase and put it in the dictionary
    if (!fetchedItems.TryGetValue(primaryKey, out Entity<T> fetchedEntity))
    {
        // not fetched yet, fetch if from your Csv File
        T fetchedItem = ...
        // what to do if does not exist?
        // add to the dictionary:
        fetchedEntities.Add(new Entity<T>
        {
            value = fetchedItem,
            originalValue = (T)fetchedItem.Clone(),
            // so if value changes, original does not change
        });
    }
    return fetchedItem;
}

Si vous décidez de conserver vos éléments dans un dictionnaire, puis laissez votre GetEnumerator renvoyer d'abord les éléments déjà récupérés, avant de récupérer les nouvelles lignes de votre fichier CSV.

Ajouter / Mettre à jour / Supprimer des éléments

Pour cela, vous devez pouvoir ajouter / mettre à jour / supprimer des éléments de votre fichier CsV. Je suppose qu'il existe déjà des fonctions pour cela.

Pour faire la mise à jour efficacement, vous aurez besoin de quelque chose de similaire à DbContext.SaveChanges. Laissez chaque DbSet se souvenir des éléments à ajouter / supprimer / mettre à jour, en utilisant un ChangeTracker:

class Entity<T> where T : IPrimaryKey
{
    public T Value {get; set;}
    public T OriginalValue {get; set;}
}

class ChangeTracker<T, TKey> where T: ICloneable
{
    readonly Dictionary<int, Entity<T, TKey>> fetchedEntities = new Dictionary<int, Entity<T, TKey>>
    readonly List<T> itemsToAdd = new List<T>();

    public T Add(T item)
    {
        // TODO: check for not NULL, and Id == 0
        this.ItemsToAdd.Add(itemToAdd);
        return item;
    }
    public void Remove(T item)
    {
        // TODO: check not null, and primary key != 0
        Entity<T> entityToRemove = Find(item.Id);
        // TODO: decide what to do if there is no such item
        entityToRemove.Value = null;
        // null indicates it is about to be removed
    }

Vous aurez besoin d'un Find qui se souvient de la valeur d'origine:

class DbSet<T, TKey> : IEnumerable<T> where T : class
{
     private readonly Dictinary<TKey, T> fetchedItems = ...
}

Enfin vos SaveChanges ()

interface IPrimaryKey
{
     int Id {get;}
}

class DbSet<T> : IEnumerable<T> where T : IPrimaryKey {...}

Apparemment, si vous voulez pouvoir mettre à jour des éléments de votre base de données, vous devez être en mesure de vérifier si les éléments ont changé. Vous aurez besoin d'un IEqualityComparer qui vérifie par valeur

class DbSet<T> : IEnumerable<T>
{
    private readonly Dictionary<int, T> fetchedItems = new Dictionary<int, T>();

    public T Find(int id)
    {
        if (!fetchedItems.TryGetValue(id, out T fetchedItem))
        {
            // fetch elements using ReadCsvFile and put them in the Dictionary
            // until you found the item with the requested primary key
            // or until the end of your sequence
        }
        return fetchedItem;
    }
}

DbSet SaveChanges:

class DbContext
{
      public DbSet<School> Schools {get; } = new DbSet<School>{CsvFile = ...};
      public DbSet<Teacher> Teachers {get; } = new DbSet<Teacher> {CsvFile = ...};
      public DbSet<Student> Students {get; } = new DbSet<Student> {CsvFile = ...};
}

Modifications de sauvegarde DbContext:

public DbSet<T> : IEnumerable<T> where T: class
{
    public FileInfo CsvFile {get; set;}

    public IEnumerator<T> GetEnumerator()
    {
        return this.ReadCsvFile().GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }

    protected IEnumerable<T> ReadCsvFile()
    {
        // open the CsvFile, read the lines and convert to objects of type T
        // consider using Nuget package CsvHelper
        ...
        foreach (var csvLine in csvLines)
        {
            T item = Create<T>(csvLine); // TODO: write how to convert a line into T
            yield return T;
        }
    }
}