Consulta LINQ en una DataTable

Estoy tratando de realizar una consulta LINQ en un objeto DataTable y extrañamente encuentro que realizar tales consultas en DataTables no es sencillo. Por ejemplo:

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

Esto no esta permitido. ¿Cómo hago para que algo así funcione?

¡Estoy sorprendido de que las consultas LINQ no estén permitidas en DataTables!

No puede consultar la colección de filas deDataTable 's , ya que no se implementa . Necesita usar la extensión para . Al igual que:DataRowCollectionIEnumerable<T>AsEnumerable()DataTable

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

Y como dice @Keith , deberá agregar una referencia a System.Data.DataSetExtensions

AsEnumerable()vuelve IEnumerable<DataRow>. Si necesita convertir IEnumerable<DataRow>a a DataTable, use la CopyToDataTable()extensión.

A continuación se muestra la consulta con la expresión Lambda,

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

No es que no se les haya permitido deliberadamente en DataTables, es solo que DataTables es anterior a las construcciones IQueryable y genéricas IEnumerable en las que se pueden realizar consultas Linq.

Ambas interfaces requieren algún tipo de validación de seguridad de tipo. Las tablas de datos no están fuertemente tipadas. Esta es la misma razón por la cual las personas no pueden consultar contra una ArrayList, por ejemplo.

Para que Linq funcione, necesita mapear sus resultados con objetos seguros para escribir y consultar en su lugar.

Como @ ch00k dijo:

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

También debe agregar una referencia de proyecto a 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")                         
                    };

los campos de nombre y edad ahora son parte del objeto de consulta y se puede acceder de esta manera: Console.WriteLine (query.name);

Me doy cuenta de que esto ha sido respondido varias veces, pero solo para ofrecer otro enfoque:

Me gusta usar el .Cast<T>()método, me ayuda a mantener la cordura al ver el tipo explícito definido y en el fondo creo que lo .AsEnumerable()llama de todos modos:

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

o

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

Como se señaló en los comentarios, no se necesitan otros ensamblajes ya que es parte de Linq ( Referencia )

Usando LINQ para manipular datos en 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();
 // 

Pruebe esta simple línea de consulta:

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

Puede usar LINQ para objetos en la colección Filas, de esta manera:

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

Esta es una manera simple que funciona para mí y utiliza expresiones lambda:

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

Entonces, si quieres un valor particular:

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

Prueba esto

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

Lo más probable es que las clases para DataSet, DataTable y DataRow ya estén definidas en la solución. Si ese es el caso, no necesitará la referencia DataSetExtensions.

Ex. Nombre de clase DataSet-> CustomSet, nombre de clase DataRow-> CustomTableRow (con columnas definidas: RowNo, ...)

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

O (como prefiero)

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;

En mi aplicación, descubrí que usar LINQ to Datasets con la extensión AsEnumerable () para DataTable, como se sugiere en la respuesta, era extremadamente lento. Si está interesado en optimizar la velocidad, use la biblioteca Json.Net de 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);

Para VB.NET El código se verá así:

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() ;

Ejemplo sobre cómo lograr esto se proporciona a continuación:

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();

Prueba esto...

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 );
}

Puede hacerlo funcionar elegante a través de linq de esta manera:

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

O como dynamic linq this (AsDynamic se llama directamente en DataSet):

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

Prefiero el último enfoque, mientras que es el más flexible. PD: no olvides conectar la System.Data.DataSetExtensions.dllreferencia

puede intentar esto, pero debe estar seguro del tipo de valores para cada columna

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"),    
});

Propongo la siguiente solución:

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

Mirando la documentación de DataView , lo primero que podemos ver es esto:

Representa una vista personalizada de datos enlazables de una tabla de datos para ordenar, filtrar, buscar, editar y navegar.

Lo que obtengo de esto es que DataTable está destinado a almacenar solo datos y DataView está allí nos permite "consultar" contra DataTable.

Así es como funciona esto en este caso particular:

Intenta implementar la instrucción SQL

SELECT *
FROM myDataTable
WHERE RowNo = 1

en "lenguaje DataTable". En C # lo leeríamos así:

FROM myDataTable
WHERE RowNo = 1
SELECT *

que se ve en C # así:

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});