Consulta LINQ en un DataTable

No puedes consultar contra el DataTable's filas colección, desde DataRowCollection no implementa IEnumerable<T>. Necesitas usar el AsEnumerable() extensión para DataTable. Al igual que:

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

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

AsEnumerable() devoluciones IEnumerable<DataRow>. Si necesita convertir IEnumerable<DataRow> a una DataTable, utilizar el CopyToDataTable() extensión.

A continuación se muestra una consulta con Lambda Expression,

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 hayan permitido deliberadamente en DataTables, es solo que DataTables es anterior a las construcciones IQueryable y IEnumerable genéricas en las que se pueden realizar consultas de 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 que las personas no pueden consultar una ArrayList, por ejemplo.

Para que Linq funcione, debe mapear sus resultados con objetos de tipo seguro y consultarlos en su lugar.

Como dijo @ ch00k:

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 a ellos así: 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 .AsEnumerable() lo llama de todos modos:

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

or

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 sencilla línea de consulta:

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

Puede usar LINQ para objetos en la colección Rows, así:

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

Esta es una forma simple que funciona para mí y usa expresiones lambda:

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

Entonces, si quieres un valor en particular:

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

Prueba esta

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 de DataSet-> CustomSet, nombre de clase de 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, encontré 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);

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

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

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 hacer que funcione de manera 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 conectarte System.Data.DataSetExtensions.dll referencia

puede probar esto, pero debe asegurarse de que el 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);

En cuanto al Documentación de DataView, lo primero que podemos ver es esto:

Representa una vista personalizada y enlazable de datos 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 nos permite "consultar" contra el DataTable.

Así es como funciona esto en este caso particular:

Intentas implementar la declaració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});