Consulta LINQ em um DataTable

Estou tentando executar uma consulta LINQ em um objeto DataTable e, estranhamente, estou descobrindo que executar essas consultas no DataTables não é simples. Por exemplo:

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

Isso não é permitido. Como obtenho algo assim funcionando?

Estou surpreso que as consultas LINQ não sejam permitidas no DataTables!

Você não pode consultar contra o DataTable's linhas coleção, desde DataRowCollectionnão implementa IEnumerable<T>. Você precisa usar a AsEnumerable()extensão para DataTable. Igual a:

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

E como @Keith diz, você precisará adicionar uma referência ao System.Data.DataSetExtensions

AsEnumerable()retorna IEnumerable<DataRow>. Se você precisar converter IEnumerable<DataRow>para a DataTable, use a CopyToDataTable()extensão

Abaixo está uma consulta com a expressão 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

Não é que eles não tenham sido deliberadamente permitidos no DataTables, apenas o DataTables é anterior às construções IQueryable e IEnumerable genéricas nas quais as consultas do Linq podem ser executadas.

Ambas as interfaces requerem alguma validação de segurança de tipo de classificação. DataTables não são fortemente tipadas. Esse é o mesmo motivo pelo qual as pessoas não podem consultar um ArrayList, por exemplo.

Para que o Linq funcione, você precisa mapear seus resultados em relação a objetos com segurança de tipo e, em vez disso, consultar esses itens.

Como @ ch00k disse:

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

Você também precisa adicionar uma referência de projeto ao 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")                         
                    };

os campos nome e idade agora fazem parte do objeto de consulta e podem ser acessados ​​da seguinte maneira: Console.WriteLine (query.name);

Sei que isso foi respondido algumas vezes, mas apenas para oferecer outra abordagem:

Eu gosto de usar o .Cast<T>()método, ele me ajuda a manter a sanidade ao ver o tipo explícito definido e, no fundo, acho que .AsEnumerable()chama assim mesmo:

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

ou

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

Conforme observado nos comentários, nenhum outro conjunto é necessário, pois faz parte do Linq ( Referência )

Usando o LINQ para manipular dados no 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();
 // 

Tente esta linha de consulta simples:

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

Você pode usar o LINQ para objetos na coleção Rows, da seguinte maneira:

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

Esta é uma maneira simples que funciona para mim e usa expressões lambda:

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

Então, se você deseja um valor específico:

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

Tente isto

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

Provavelmente, as classes para o DataSet, DataTable e DataRow já estão definidas na solução. Se for esse o caso, você não precisará da referência DataSetExtensions.

Ex. Nome da classe DataSet-> CustomSet, Nome da classe DataRow-> CustomTableRow (com colunas definidas: RowNo, ...)

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

Ou (como eu prefiro)

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;

No meu aplicativo, descobri que o uso de LINQ to Datasets com a extensão AsEnumerable () para DataTable, conforme sugerido na resposta, era extremamente lento. Se você estiver interessado em otimizar a velocidade, use a 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 O código será semelhante a este:

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

Exemplo de como conseguir isso fornecido abaixo:

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

Tente isso ...

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

Você pode fazê-lo funcionar de maneira elegante via linq assim:

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

Ou como o linq dinâmico, este (o AsDynamic é chamado diretamente no DataSet):

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

Prefiro a última abordagem, enquanto is é a mais flexível. PS: Não esqueça de conectar System.Data.DataSetExtensions.dllreferência

você pode tentar isso, mas deve ter certeza de que o tipo de valores para cada coluna

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

Proponho a seguinte solução:

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

Observando a documentação do DataView , a primeira coisa que podemos ver é:

Representa uma exibição personalizada e vinculável de um DataTable para classificação, filtragem, pesquisa, edição e navegação.

O que estou obtendo disso é que o DataTable se destina apenas a armazenar dados e o DataView nos permite "consultar" o DataTable.

Aqui está como isso funciona neste caso específico:

Você tenta implementar a instrução SQL

SELECT *
FROM myDataTable
WHERE RowNo = 1

no "idioma DataTable". Em C #, lemos assim:

FROM myDataTable
WHERE RowNo = 1
SELECT *

que fica em c # assim:

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