1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Art.-Nr.  Art.-name  Warengruppe
1    Artikelname1  Schuhe
2    Artikelname2  Schuhe          
3    Artikelname3  Jacken 
4    Artikelname4  Hosen 
5    Artikelname5  Schuhe 
6    Artikelname6  Jacken 
7    Artikelname7  Anzüge 
8    Artikelname8  Hüte 
9    Artikelname9  Hosen					

1:
2:
3:
4:
5:
6:

Art.-Nr.  Art.-name  Warengruppe
1    Artikelname1  Schuhe
2    Artikelname2  Schuhe          
4    Artikelname4  Hosen 
5    Artikelname5  Schuhe 
9    Artikelname9  Hosen					

1:
2:
3:
4:
5:
6:
7:
8:

HashSet<string> approvedGroups = new HashSet<string> { "Schuhe", "Hosen" };

bool IsApproved(string[] item)
{
  return approvedGroups.Contains(item[2]);
}

List<string[]> filtered = items.FindAll(IsApproved);					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

// Kann sich die Warengruppe auch ändern?
class MyItemComparer : IEqualityComparer<DataTable>
{
  public bool Equals(string[] item1, string[] item2)
  {
    return item1[0] == item2[0] && item1[1] == item2[1];
  }

  public int GetHashCode(string[] item)
  {
    return item[0].GetHashCode() ^ item[1].GetHashCode();
  }
}

List<string[]> diff = itemsToday.Except(itemsYesterday, new MyItemComparer()).ToList(); // Ba Da Bing!					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

//Holt alle Artikel in eine generische Auflistung die Bezeichnung Hose oder Schuhe beinhalten

            IEnumerable<DataRow> ArtikelInDerNeuenTabelle =
                from DataRow Artikel in NeueTabelle.Rows
                where
                        ((string)Artikel["Warengruppe"]).Contains("Hose") ||
                        ((string)Artikel["Warengruppe"]).Contains("Schuhe")
                select Artikel;

//Holt alle Spalten, die nicht in der alten Tabelle sind oder sich geändert haben.
//Der PrimaryKey von AlteTabelle muss dafür alle Spalten enthalten. Das kann man
//beliebig anpassen und z.B. nur bestimmte Spalten nach Änderung durchsuchen

            IEnumerable<DataRow> NeueArtikel =
                from DataRow Artikel in ArtikelInDerNeuenTabelle
                where !(AlteTabelle.Rows.Contains(Artikel.ItemArray))
                select Artikel;

//Befüllt eine neue Tabelle mit den geänderten Artikeln
            foreach (DataRow dr in NeueArtikel)
            {
                ResultierendeTabelle.ImportRow(dr);
            }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

        // Das übergebene DataTable wird mit den Schlüsselwörtern in dem 
        // ebenfalls übergebenen List Objekt gefiltert. Der Filter 
        // wirkt hierbei auf die übergebene Spalte. Das Rückgabe Objekt
        // ist eine DataTable die um all die unerwünschten Zeilen erleichtert 
        // wurde.
        private DataTable GetfilteredDataTable(DataTable dt, List<string> filter, int row)
        {
           IEnumerable<DataRow> ArtikelInDerNeuenTabelle =
                from DataRow Artikel in dt.Rows
                where ((string)Artikel[row]).Contains(filter[0].ToString()) || 
                      ((string)Artikel[row]).Contains(filter[1].ToString())
                select Artikel;
            DataTable boundnewdt = ArtikelInDerNeuenTabelle.CopyToDataTable<DataRow>();
            
            return boundnewdt;
        }					

1:

var artikelInDerNeuenTabelle = dt.Rows.Where(artikel => filter.Contains(artikel.Field<string>(row));					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

        private DataTable GetfilteredDataTable(DataTable dt, List<string> filter, int row)
        {
           IEnumerable<DataRow> ArtikelInDerNeuenTabelle =
                from DataRow Artikel in dt.Rows
                where Artikel[row] != System.DBNull && (
                      ((string)Artikel[row]).Contains(filter[0].ToString()) || 
                      ((string)Artikel[row]).Contains(filter[1].ToString()))
                select Artikel;
            DataTable boundnewdt = ArtikelInDerNeuenTabelle.CopyToDataTable<DataRow>();
            
            return boundnewdt;
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

       private DataTable GetfilteredDataTable(DataTable dt, List<string> filter, int row)
        {
           IEnumerable<DataRow> ArtikelInDerNeuenTabelle =
                from DataRow Artikel in dt.Rows
                where Artikel[row] is string && (
                      ((string)Artikel[row]).Contains(filter[0].ToString()) || 
                      ((string)Artikel[row]).Contains(filter[1].ToString()))
                select Artikel;
            DataTable boundnewdt = ArtikelInDerNeuenTabelle.CopyToDataTable<DataRow>();
            
            return boundnewdt;
        }					

1:

Artikel[row].GetType() == typeof(string)					

1:

!(Artikel[row] is System.DBNull)					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:

namesspace MyApp
{
    public static class AddOnMethods
    {
        /// <summary>
        /// Überprüft, ob der String einen der gesuchten Strings enthält
        /// </summary>
        /// <param name="item"></param>
        /// <param name="searchStrings">Die Strings, nach denen gesucht werden soll</param>
        /// <returns></returns>
        public static bool ContainsAny(this string item, string[] searchStrings)
        {
            bool res = false;
            foreach (string ss in searchStrings)
            {
                res |= item.Contains(ss);
            }

            return res;
        }
    }

    class DeineMainClass
    {
        private IEnumerable<string[]> GetfilteredDataTable(IEnumerable<string[]> dt, string[] filter, int row)
        {
            return
                    from string[] Artikel in dt
                    where Artikel[row].ContainsAny(filter)
                    select Artikel;      
        }
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

        // Das übergebene DataTable wird mit den Schlüsselwörtern in dem 
        // ebenfalls übergebenen List Objekt gefiltert. Der Filter 
        // wirkt hierbei auf die übergebene Spalte. Das Rückgabe Objekt
        // ist eine DataTable die um all die unerwünschten Zeilen erleichtert 
        // wurde.
        private DataTable GetfilteredDataTable(DataTable dt, List<string> filter, int col)
        {
            IEnumerable<DataRow> ArticleInNewDataTable =
                 from DataRow Article in dt.Rows
                 where Article[col] is string && (filter.Contains(Article.Field<string>(col)))
                 select Article;
            return ArticleInNewDataTable.CopyToDataTable<DataRow>();
        }					

1:

artikelInDerNeuenTabelle = dt.Rows.Where(artikel => filter.Contains(artikel.Field<string>(row));					

1:
2:
3:
4:
5:

     private DataTable GetfilteredDataTable(DataTable dt, List<string> filter, int col)
        {
            var ArticleInNewDataTable = dt.Rows.where(Article => filter.Contains(Article.Field<string>(col)));
            return ArticleInNewDataTable.CopyToDataTable<DataRow>();
        }