LINQ-Abfrage in einer DataTable

Ich versuche, eine LINQ-Abfrage für ein DataTable-Objekt durchzuführen, und stelle bizarrerweise fest, dass das Ausführen solcher Abfragen für DataTables nicht einfach ist. Zum Beispiel:

var results = from myRow in myDataTable
where results.Field("RowNo") == 1
select results;

Das ist nicht erlaubt. Wie bringe ich so etwas zum Laufen?

Ich bin erstaunt, dass LINQ-Abfragen in DataTables nicht zulässig sind!

Sie können nicht Abfrage der DataTable‚s Zeilen Sammlung, da DataRowCollectionnicht implementiert IEnumerable<T>. Sie müssen die AsEnumerable()Erweiterung für verwenden DataTable. Wie so:

var results = from myRow in myDataTable.AsEnumerable()
where myRow.Field<int>("RowNo") == 1
select myRow;

Und wie @Keith sagt, müssen Sie einen Verweis auf System.Data.DataSetExtensions hinzufügen

AsEnumerable()kehrt zurück IEnumerable<DataRow>. Wenn Sie konvertieren müssen , IEnumerable<DataRow>um ein DataTable, verwenden Sie die CopyToDataTable()Erweiterung.

Unten ist eine Abfrage mit Lambda-Ausdruck,

var result = myDataTable
    .AsEnumerable()
    .Where(myRow => myRow.Field<int>("RowNo") == 1);

var results = from DataRow myRow in myDataTable.Rows
    where (int)myRow["RowNo"] == 1
    select myRow

Es ist nicht so, dass sie absichtlich nicht in DataTables erlaubt waren, es ist nur so, dass DataTables die IQueryable- und generischen IEnumerable-Konstrukte vorab datiert, für die Linq-Abfragen ausgeführt werden können.

Beide Schnittstellen erfordern eine Sicherheitsüberprüfung des Sortiertyps. DataTables sind nicht stark typisiert. Dies ist der gleiche Grund, warum Benutzer beispielsweise keine Abfrage für eine ArrayList durchführen können.

Damit Linq funktioniert, müssen Sie Ihre Ergebnisse typsicheren Objekten zuordnen und stattdessen abfragen.

Wie @ ch00k sagte:

using System.Data; //needed for the extension methods to work

...

var results = 
    from myRow in myDataTable.Rows 
    where myRow.Field<int>("RowNo") == 1 
    select myRow; //select the thing you want, not the collection

Sie müssen auch einen Projektverweis hinzufügen System.Data.DataSetExtensions

var query = from p in dt.AsEnumerable()
                    where p.Field<string>("code") == this.txtCat.Text
                    select new
                    {
                        name = p.Field<string>("name"),
                        age= p.Field<int>("age")                         
                    };

Die Felder Name und Alter sind jetzt Teil des Abfrageobjekts und können wie folgt aufgerufen werden: Console.WriteLine (query.name);

Mir ist klar, dass dies einige Male beantwortet wurde, aber nur um einen anderen Ansatz anzubieten:

Ich benutze die .Cast<T>()Methode gerne , sie hilft mir dabei, den expliziten Typ zu definieren, der tief definiert ist, und ich denke, er .AsEnumerable()nennt ihn sowieso:

var results = from myRow in myDataTable.Rows.Cast<DataRow>() 
                  where myRow.Field<int>("RowNo") == 1 select myRow;

oder

var results = myDataTable.Rows.Cast<DataRow>()
                      .FirstOrDefault(x => x.Field<int>("RowNo") == 1);

Wie in den Kommentaren erwähnt, werden keine weiteren Baugruppen benötigt, da diese Teil von Linq ( Referenz ) sind.

Verwenden von LINQ zum Bearbeiten von Daten in DataSet / DataTable

var results = from myRow in tblCurrentStock.AsEnumerable()
              where myRow.Field<string>("item_name").ToUpper().StartsWith(tbSearchItem.Text.ToUpper())
              select myRow;
DataView view = results.AsDataView();

//Create DataTable 
DataTable dt= new DataTable();
dt.Columns.AddRange(new DataColumn[]
{
   new DataColumn("ID",typeof(System.Int32)),
   new DataColumn("Name",typeof(System.String))

});

//Fill with data

dt.Rows.Add(new Object[]{1,"Test1"});
dt.Rows.Add(new Object[]{2,"Test2"});

//Now  Query DataTable with linq
//To work with linq it should required our source implement IEnumerable interface.
//But DataTable not Implement IEnumerable interface
//So we call DataTable Extension method  i.e AsEnumerable() this will return EnumerableRowCollection<DataRow>


// Now Query DataTable to find Row whoes ID=1

DataRow drow = dt.AsEnumerable().Where(p=>p.Field<Int32>(0)==1).FirstOrDefault();
 // 

Versuchen Sie diese einfache Abfragezeile:

var result=myDataTable.AsEnumerable().Where(myRow => myRow.Field<int>("RowNo") == 1);

Sie können LINQ für Objekte in der Rows-Auflistung verwenden, z. B.:

var results = from myRow in myDataTable.Rows where myRow.Field("RowNo") == 1 select myRow;

Dies ist eine einfache Methode, die für mich funktioniert und Lambda-Ausdrücke verwendet:

var results = myDataTable.Select("").FirstOrDefault(x => (int)x["RowNo"] == 1)

Wenn Sie dann einen bestimmten Wert wünschen:

if(results != null) 
    var foo = results["ColName"].ToString()

Versuche dies

var row = (from result in dt.AsEnumerable().OrderBy( result => Guid.NewGuid()) select result).Take(3) ; 

Höchstwahrscheinlich sind die Klassen für DataSet, DataTable und DataRow bereits in der Lösung definiert. In diesem Fall benötigen Sie die DataSetExtensions-Referenz nicht.

Ex. DataSet-Klassenname-> CustomSet, DataRow-Klassenname-> CustomTableRow (mit definierten Spalten: RowNo, ...)

var result = from myRow in myDataTable.Rows.OfType<CustomSet.CustomTableRow>()
             where myRow.RowNo == 1
             select myRow;

Oder (wie ich es vorziehe)

var result = myDataTable.Rows.OfType<CustomSet.CustomTableRow>().Where(myRow => myRow.RowNo);

var results = from myRow in myDataTable
where results.Field<Int32>("RowNo") == 1
select results;

In meiner Anwendung stellte ich fest, dass die Verwendung von LINQ für Datensätze mit der Erweiterung AsEnumerable () für DataTable, wie in der Antwort vorgeschlagen, äußerst langsam war. Wenn Sie an einer Geschwindigkeitsoptimierung interessiert sind, verwenden Sie die Json.Net-Bibliothek von James Newtonking ( http://james.newtonking.com/json/help/index.html ).

// Serialize the DataTable to a json string
string serializedTable = JsonConvert.SerializeObject(myDataTable);    
Jarray dataRows = Jarray.Parse(serializedTable);

// Run the LINQ query
List<JToken> results = (from row in dataRows
                    where (int) row["ans_key"] == 42
                    select row).ToList();

// If you need the results to be in a DataTable
string jsonResults = JsonConvert.SerializeObject(results);
DataTable resultsTable = JsonConvert.DeserializeObject<DataTable>(jsonResults);

Für VB.NET Der Code sieht folgendermaßen aus:

Dim results = From myRow In myDataTable  
Where myRow.Field(Of Int32)("RowNo") = 1 Select myRow

IEnumerable<string> result = from myRow in dataTableResult.AsEnumerable()
                             select myRow["server"].ToString() ;

Ein Beispiel dafür, wie dies erreicht werden kann, finden Sie unten:

DataSet dataSet = new DataSet(); //Create a dataset
dataSet = _DataEntryDataLayer.ReadResults(); //Call to the dataLayer to return the data

//LINQ query on a DataTable
var dataList = dataSet.Tables["DataTable"]
              .AsEnumerable()
              .Select(i => new
              {
                 ID = i["ID"],
                 Name = i["Name"]
               }).ToList();

Versuche dies...

SqlCommand cmd = new SqlCommand( "Select * from Employee",con);
SqlDataReader dr = cmd.ExecuteReader( );
DataTable dt = new DataTable( "Employee" );
dt.Load( dr );
var Data = dt.AsEnumerable( );
var names = from emp in Data select emp.Field<String>( dt.Columns[1] );
foreach( var name in names )
{
    Console.WriteLine( name );
}

Sie können es elegant über linq wie folgt arbeiten lassen:

from prod in TenMostExpensiveProducts().Tables[0].AsEnumerable()
where prod.Field<decimal>("UnitPrice") > 62.500M
select prod

Oder wie bei Dynamic Linq (AsDynamic wird direkt in DataSet aufgerufen):

TenMostExpensiveProducts().AsDynamic().Where (x => x.UnitPrice > 62.500M)

Ich bevorzuge den letzten Ansatz, während er am flexibelsten ist. PS: Vergessen Sie nicht, die System.Data.DataSetExtensions.dllReferenz anzuschließen

Sie können dies versuchen, aber Sie müssen sicher sein, welche Art von Werten für jede Spalte gilt

List<MyClass> result = myDataTable.AsEnumerable().Select(x=> new MyClass(){
     Property1 = (string)x.Field<string>("ColumnName1"),
     Property2 = (int)x.Field<int>("ColumnName2"),
     Property3 = (bool)x.Field<bool>("ColumnName3"),    
});

Ich schlage folgende Lösung vor:

DataView view = new DataView(myDataTable); 
view.RowFilter = "RowNo = 1";
DataTable results = view.ToTable(true);

In der DataView-Dokumentation sehen wir zunächst Folgendes :

Stellt eine datenindigierbare, benutzerdefinierte Ansicht einer DataTable zum Sortieren, Filtern, Suchen, Bearbeiten und Navigieren dar.

Daraus ergibt sich, dass DataTable nur Daten speichern soll und DataView es uns ermöglicht, die DataTable abzufragen.

So funktioniert das in diesem speziellen Fall:

Sie versuchen, die SQL-Anweisung zu implementieren

SELECT *
FROM myDataTable
WHERE RowNo = 1

in "DataTable-Sprache". In C # würden wir es so lesen:

FROM myDataTable
WHERE RowNo = 1
SELECT *

was in C # so aussieht:

DataView view = new DataView(myDataTable);  //FROM myDataTable
view.RowFilter = "RowNo = 1";  //WHERE RowNo = 1
DataTable results = view.ToTable(true);  //SELECT *

                    //Json Formating code
                    //DT is DataTable
                    var filter = (from r1 in DT.AsEnumerable()

                                  //Grouping by multiple columns 
                                  group r1 by new
                                  {
                                      EMPID = r1.Field<string>("EMPID"),
                                      EMPNAME = r1.Field<string>("EMPNAME"),

                                  } into g
                                  //Selecting as new type
                                  select new
                                  {

                                      EMPID = g.Key.EMPID,
                                      MiddleName = g.Key.EMPNAME});