moissonneuse-batteuse se joignent à String.Contains dans LINQ requête

Question

j'ai la requête LINQ suivante qui créent une jointure gauche entre deux tables:

  var joinResultRows = from leftTable in dataSet.Tables[leftTableName].AsEnumerable() 
          join 
            rightTable in dataSet.Tables[rightTableName].AsEnumerable() 
            on leftTable.Field<string>(leftComparedColumnName) equals rightTable.Field<string>(rightComparedColumnName) 
             into leftJoinedResult 
          select new { leftTable, leftJoinedResult }; 

je veux obtenir les lignes qui répondent ceci: la valeur de chaîne dans la colonne de gauche contient la valeur de chaîne dans la colonne de droite.

i essayé ceci:

  var joinResultRows = from leftTable in dataSet.Tables[leftTableName].AsEnumerable() 
          join 
            rightTable in dataSet.Tables[rightTableName].AsEnumerable() 
            on leftTable.Field<string>(leftComparedColumnName).Contains(rightTable.Field<string>(rightComparedColumnName)) equals true 
             into leftJoinedResult 
          select new { leftTable, leftJoinedResult }; 

mais il ne fonctionne pas la cause RightTable n'est pas reconnu dans la partie gauche de la jointure.

Comment puis-je créer une jointure résultant de String.Contains, puis-je faire le contenu de la clause 'where' ou de la clause 'On'?

Answer 1

Je l'ai résolu en créant SelectMany (joindre) que la table de gauche détient tous les enregistrements et le droit détient null s'il n'y a pas de correspondance:

var joinResultRows = from leftDataRow in dataSet.Tables[leftTableName].AsEnumerable() 
          from rightDataRow in dataSet.Tables[rightTableName].AsEnumerable() 
          .Where(rightRow => 
           { 
            // Dont include "" string in the Contains, because "" is always contained 
            // in any string.           
            if (String.IsNullOrEmpty(rightRow.Field<string>(rightComparedColumnName))) 
             return false; 

            return leftDataRow.Field<string>(leftComparedColumnName).Contains(rightRow.Field<string>(rightComparedColumnName)); 

           }).DefaultIfEmpty() // Makes the right table nulls row or the match row 
           select new { leftDataRow, rightDataRow }; 

Merci pour l'astuce :)

Answer 2

Avez-vous essayé un SelectMany?

var result = 
from left in dataSet.Tables[leftTableName].AsEnumerable() 
from right in dataSet.Tables[rightTableName].AsEnumerable() 
where left.Field<string>(leftComparedColumnName).Contains(right.Field<string>(rightComparedColumnName)) 
select new { left, right }; 

Edit:

Les éléments suivants doivent avoir l'effet désiré:

class ContainsEqualityComparer: IEqualityComparer<string> 
{ 
    public bool Equals(string right, string left) { return left.Contains(right); } 
    public int GetHashCode(string obj) { return 0; } 
} 

var result = 
    dataSet.Tables[leftTableName].AsEnumerable().GroupJoin(
     dataSet.Tables[rightTableName].AsEnumerable(), 
     left => left, 
     right => right, 
     (left, leftJoinedResult) => new { left = left, leftJoinedResult = leftJoinedResult }, 
     new ContainsEqualityComparer()); 

La comparaison clé est exécutée par le IEqualityComparer personnalisé. Deux lignes ne seront jointes que si GetHashCode() de gauche et de droite sont identiques et Equals renvoie true.

Espérons que ça aide.