Linq to DataSet

最新推荐文章于 2022-05-29 15:27:16 发布
最新推荐文章于 2022-05-29 15:27:16 发布
阅读量141 收藏
点赞数
文章标签： c# 数据库
[索引页]

我想我的blogs现在也有些常客,要谢谢你们的来访,我会尽力写好出好的文章.也努力像园子里的兄弟们学习.
我将会在大概4天内就会将linq搞定.所以要快,要更快!加油!

一 Linq概念

    (1)来先看这里:Language-Integrated Query (LINQ) 直接译就是整合了查询的语言,再看LINQ makes a query a first-class language construct in C# and Visual Basic.是以类为主的语言,传统的query是retrieved from a data source,而且是在C#,VB.NET中的,
    (2) You write queries against strongly typed collections of objects by using language keywords and familiar operators.可以使用熟悉的操作符号和关键字,是强类型的!
    (3)in C# with full type checking and IntelliSense support.支持类型检测和IntelliSense.
    (4)you can write LINQ queries in Visual Basic or C# with SQL Server databases, XML documents, ADO.NET Datasets, and any collection of objects that supports IEnumerable or the generic IEnumerable(T) interface.
       你能在Visual Basic or C#中写LINQ查询SQL Server databases, XML documents, ADO.NET Datasets(DataSet,SQL)和支持IEnumerable 或generic IEnumerable(T) interface 的任何集合对象.
上面整理之后.就比你看MSDN中文版好理解多拉.
    (5)还有一句值得关注:a query that returns a sequence of values,在查询返回值, the query variable itself never holds the query results and only stores the query commands.(这个var query=...变量从来就不会持有查询结果,只是存储查询命令) Execution of the query is deferred until the query variable is iterated over in a foreach or For Each loop. This is called deferred execution;执行查询回延迟到在你的变量被foreach 或For Each loop语句使用时,它才会执行.

(6)如何创建一个LINQ工程.
   这里详细介绍
   第一个LINQ程序
using  System;
 using  System.Linq;

 class  LinqDemo
 {
  static void Main(  )
  {
    string[] names = { "Tom", "Dick", "Harry" };


    IEnumerable<string> filteredNames = names.Where (n => n.Length >= 4);
    foreach (string name in filteredNames) Console.Write (name + "|");
  }
}
    (7)LINQ有些关键字.如from,where,select,group,into,orderby,join.let大家都很熟悉,再这里Join我以后单独写,现在谈let
    You can do this with the let keyword, which creates a new range variable and initializes it with the result of the expression you supply该关键字可以创建一个新的范围变量，并且用您提供的表达式的结果初始化该变量.
   
class  LetSample1
 {
    static void Main()
    {
        string[] strings =
        {
            "A penny saved is a penny earned.",
            "The early bird catches the worm.",
            "The pen is mightier than the sword."
        };

        // Split the sentence into an array of words
        // and select those whose first letter is a vowel.
        var earlyBirdQuery =
            from sentence in strings
            let words = sentence.Split(' ')
            from word in words
            let w = word.ToLower()
            where w[0] == 'a' || w[0] == 'e'
                || w[0] == 'i' || w[0] == 'o'
                || w[0] == 'u'
            select word;

        // Execute the query.
        foreach (var v in earlyBirdQuery)
        {
            Console.WriteLine("\"{0}\" starts with a vowel", v);
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

   
二 LINQ to DataSet Overview

    首先你要到这个地址不知道大家发现没 http://msdn2.microsoft.com/en-us/library/bb399365.aspx,
    LINQ to ADO.NET分为LINQ to DataSet,LINQ to SQL.使用这个的目的是因为我们以前都常常处理a high-level language和query language之间的一些问题,如我们的SQL是写在C#语言中的用" "包裹着("select * from products"),编译器不会编译它,不能检测错误,而且是不能检测类型,没有IntelliSens;而LINQ是without having to use a separate query language.不需要使用独立的查询语言,能debug等优势；LINQ to DataSet就是利用LINQ来优化和丰富DataSet,而LINQ to SQL着允许你查询SQL Server database.
    这里我们只先讨论LINQ to DataSet;LINQ to DataSet就是让我们更容易,更快的查询在缓存中的DataSet对象.
 


   
    看过这两个就会很清楚里.再看向下
   
   
   
三 回顾DataSet

    DataSet,简单说就是一个在内存中数据缓存.an in-memory cache of data.它是由DataTable对象集合组成,你还可以在DataSet中建立表关系或数据的关系,如外键等,而DataTable又是由DataTableCollection组成,通过DataRelationCollection 来连接他们的关系;其实DataSet可以读取/写XML.还是看图:





    这里为什么要谈DataSet,因为DataSet是ADO.NET里主要的组件,ADO中常用的命名空间是System.Data,而我们还要谈到System.Data中的DataTableExtensions和DataRowExtensions类,他们是分别为DataTable类和DataRow类定义一组扩展方法(extension methods ).他们的Assembly是在System.Data.DataSetExtensions.dll中,他们都是静态类.

    我们先看DataTableExtensions Class,
    public static class DataTableExtensions:
    有三个方法:
  (1)AsDataView:
允许LINQ创建和返回一个DataView对象
 通常使用方式;与 GridView结合
   
DataTable orders  =  dataSet.Tables[ " SalesOrderDetail " ];
    DataView view  =  orders.AsDataView();
    bindingSource1.DataSource  =  view;
    dataGridView1.AutoResizeColumns();

// DataTableExtensions class
                 // Usage DataTableExtensions.AsDataView Method
                Console.WriteLine( " -------------------DataTableExtensions.AsDataView() " );
                DataTable myProducts  =  ds.Tables[ " Products " ];
                DataView view  =  myProducts.AsDataView();
                 // Query
                IEnumerable < DataRow >  viewQuery  =  from myView  in  view.Table.AsEnumerable() select myView;
                 foreach  (DataRow myDataRow  in  viewQuery)
                 {
                    Console.WriteLine(myDataRow.Field<String>("ProductName"));
                }
                Console.ReadLine();

(2)DataTableExtensions.AsEnumerable方法


    返回IEnumerable(T) objcet,这里的泛性参数T为DataRow.这个对象能被LINQ表达式或查询方法使用.
这个方法常常使用，就不列代码拉。

    (3)DataTableExtensions.CopyToDataTable(T) Generic Method

    返回一个DataTable,里面包括DataRow对象.
   
public   static  DataTable CopyToDataTable < T > (
         this  IEnumerable < T >  source
    )  where  T : DataRow 

// Usage CopyToDataTable(T)
                 // Use   DataTable myProducts = ds.Tables["Products"];
                 //
                 Console.WriteLine( " -------------------CopyToDataTable(T) " );
                IEnumerable < DataRow >  myProductsQuery  =  from myProduct  in  myProducts.AsEnumerable()
                                                        where
                                                           myProduct.Field < int > ( " ProductID " )  >   30
                                                       select myProduct;
                DataTable boundTables  =  myProductsQuery.CopyToDataTable < DataRow > ();
                Console.WriteLine( " ---------------------boundTables " );
                IEnumerable < DataRow >  newProductsQuery  =  from boundTable  in  boundTables.AsEnumerable()
                                                        select boundTable;
                 foreach  (DataRow myDataRow  in  newProductsQuery)
                 {
                    Console.WriteLine(myDataRow.Field<int>("ProductID"));
                    Console.WriteLine(myDataRow.Field<string>("ProductName"));
                }
                Console.ReadLine();

    再来看DataRowExtensions Class
    (1)Field(T)

    提供一个强类访问指定row的中所有的column的值.
    (2)SetField(T)

    为在DataRow中指定的column设置一个新值.
    
// DataRowExtensions Class
                 // Use   DataTable myProducts = ds.Tables["Products"];
                Console.WriteLine( " ---------------------------------------DataRowExtensions Class " );
                
                IEnumerable < DataRow >  boundFieldQuery  =  from myProduct  in  myProducts.AsEnumerable()
                                                        where  myProduct.Field < int > ( " ProductID " )  <=   30 &&
                                                             myProduct.Field < Decimal > ( " UnitPrice " ) == 10
                                                       select myProduct;
                 foreach  (DataRow myDataRow  in  boundFieldQuery)
                 {
             
                    Console.WriteLine(myDataRow.Field<string>("ProductName"));
                    myDataRow.SetField<string>(2,"worksguo");
                    Console.WriteLine(myDataRow.Field<string>("ProductName"));
                }
                Console.ReadLine();
四  实践:


    这里我们分为五个部分:
    (1)首先先熟悉LINQ:

int [] integers  =   { 1, 6, 2, 27, 10, 33, 12, 8, 14, 5 } ;
IEnumerable < int >  twoDigits  =
from numbers  in  integers
 where  numbers  >=   10
select numbers;
Console.WriteLine( " Integers > 10: " );
 foreach  (var number  in  twoDigits)
 {
Console.WriteLine(number);
}
   
(2)简单的查询

// Usage generally LINQ Query
                DataTable products  =   ds.Tables[ " Products " ];

                Console.WriteLine( " Mapping  Name of Table{0} " , ds.Tables[ " Products " ].TableName.ToString());
                IEnumerable < DataRow >  query  =  from product  in  products.AsEnumerable() select product;

                Console.WriteLine( " Product Names " );

                 foreach  (DataRow p  in  query)
                 {
                    Console.WriteLine(p.Field<string>("ProductName"));
                }

                Console.ReadLine();
(3)基于Lambda Expressions表达式的查询


  // Usage Method-Based Query Syntax
                 // Use DataSet ds = new DataSet();
                var queryInfo  =  products.AsEnumerable().Select(product  =>   new
                 {
                    ProductName = product.Field<string>("ProductName"),
                    ProductNumber = product.Field<int>("ProductID")
                } );
                Console.WriteLine( " Product Info: " );
                 foreach  (var productInfo  in  queryInfo)
                 {
                    Console.WriteLine("Product name: {0} Product number: {1} ",
                        productInfo.ProductName, productInfo.ProductNumber);
                }
                Console.ReadLine();
(4)组合式查询


// Usage Composing Queries
                 // Use DataSet ds = new DataSet();
                IEnumerable < DataRow >  productsQuery  =  from product  in  products.AsEnumerable() select product;

                IEnumerable < DataRow >  largeProducts  =  productsQuery.Where(p  =>  p.Field < string > ( " ProductName " )  ==   " Chai " );

                Console.WriteLine( " ProductName =='Chai' " );

                 foreach  (DataRow product  in  largeProducts)
                 {
                    Console.WriteLine(product.Field<int>("ProductID"));
                }
                Console.ReadLine();
   
(5)最后就是使用ToList(TSource), ToArray(TSource),ToDictionary(TSource, TKey)
        ToList(TSource), ToArray(TSource)就是分别从IEnumerable(T)中创建一个List,Array,因为我们使用LINQ插叙回来的数据都是基于IEnumerable(T)泛性接口,返回值的类型为T的指定类型.
        而ToDictionary(TSource, TKey)是从IEnumerable(T)中创建一个字典.

// toList(TSource),ToArray(TSource),ToLookup,
                 //  Use DataSet ds = new DataSet();but we use newly Table as name is  Suppliers  
                DataTable Suppliers  =  ds.Tables[ " Suppliers " ];

                IEnumerable < DataRow >  SuppliersQuery  =  from Supplier  in  Suppliers.AsEnumerable()
                                                      orderby
                                                          Supplier.Field < string > ( " City " ) descending
                                                      select Supplier;

                IEnumerable < DataRow >  SuppliersArray  =  SuppliersQuery.ToArray();
                IEnumerable < DataRow >  SupplierstoList  =  SuppliersQuery.ToList();
                 foreach  (DataRow SuppArray  in  SuppliersArray)
                 {
                    Console.WriteLine(SuppArray.Field<String>("City"));
                }

                 foreach  (DataRow supplist  in  SupplierstoList)
                 {
                    Console.WriteLine(supplist.Field<String>("City"));
                }

最后是所有代码：

表的的结构是Northwind中的Products和Suppliers这两张表,Products表中使用拉ProductName,ProductID,UnitPrice字段,而Suppliers中使用
SupplierID,CompanyName,City字段.

完整代码：
Code
class LinqToADOApp1
    {
        public static void Main(String[] args)
        {
        
            try {
                //Query Expression Syntax
                //As mentioned earlier in this topic, the query variable itself 
                //only stores the query commands when the query is designed to return 
                //a sequence of values. If the query does not contain a method that
               // will cause immediate execution, the actual execution of the query is 
               // deferred until you iterate over the query variable in a foreach or For Each loop
                // Deferred execution enables multiple queries to be combined or a query to be extended. 
                //
                DataSet ds = new DataSet(); 
                LinqToADOApp1 ltaa = new LinqToADOApp1();  
                ds=ltaa.FillDataSet();
                ds.Locale = CultureInfo.InstalledUICulture;

                //DataTableExtensions class
                //Usage DataTableExtensions.AsDataView Method
                Console.WriteLine("-------------------DataTableExtensions.AsDataView()");
                DataTable myProducts = ds.Tables["Products"];
                DataView view = myProducts.AsDataView();
                //Query
                IEnumerable<DataRow> viewQuery = from myView in view.Table.AsEnumerable() select myView;
                foreach (DataRow myDataRow in viewQuery)
                {
                    Console.WriteLine(myDataRow.Field<String>("ProductName"));
                }
                Console.ReadLine();

                //Usage CopyToDataTable(T)
                //Use   DataTable myProducts = ds.Tables["Products"];
                //
                Console.WriteLine("-------------------CopyToDataTable(T)");
                IEnumerable<DataRow> myProductsQuery = from myProduct in myProducts.AsEnumerable()
                                                       where
                                                           myProduct.Field<int>("ProductID") > 30
                                                       select myProduct;
                DataTable boundTables = myProductsQuery.CopyToDataTable<DataRow>();
                Console.WriteLine("---------------------boundTables");
                IEnumerable<DataRow> newProductsQuery = from boundTable in boundTables.AsEnumerable()
                                                        select boundTable;
                foreach (DataRow myDataRow in newProductsQuery)
                {
                    Console.WriteLine(myDataRow.Field<int>("ProductID"));
                    Console.WriteLine(myDataRow.Field<string>("ProductName"));
                }
                Console.ReadLine();

                //DataRowExtensions Class
                //Use   DataTable myProducts = ds.Tables["Products"];
                Console.WriteLine("---------------------------------------DataRowExtensions Class");
                
                IEnumerable<DataRow> boundFieldQuery = from myProduct in myProducts.AsEnumerable()
                                                       where myProduct.Field<int>("ProductID") <= 30&&
                                                             myProduct.Field<Decimal>("UnitPrice")==10
                                                       select myProduct;
                foreach (DataRow myDataRow in boundFieldQuery)
                {
             
                    Console.WriteLine(myDataRow.Field<string>("ProductName"));
                    myDataRow.SetField<string>(2,"worksguo");
                    Console.WriteLine(myDataRow.Field<string>("ProductName"));
                }
                Console.ReadLine();

                //Usage generally LINQ Query
                DataTable products =  ds.Tables["Products"];

                Console.WriteLine("Mapping  Name of Table{0}", ds.Tables["Products"].TableName.ToString());
                IEnumerable<DataRow> query = from product in products.AsEnumerable() select product;

                Console.WriteLine("Product Names");

                foreach (DataRow p in query)
                {
                    Console.WriteLine(p.Field<string>("ProductName"));
                }

                Console.ReadLine();

                //UsageMethod-Based Query Syntax
                //Use DataSet ds = new DataSet();
                var queryInfo = products.AsEnumerable().Select(product => new
                {
                    ProductName = product.Field<string>("ProductName"),
                    ProductNumber = product.Field<int>("ProductID")
                });
                Console.WriteLine("Product Info:");
                foreach (var productInfo in queryInfo)
                {
                    Console.WriteLine("Product name: {0} Product number: {1} ",
                        productInfo.ProductName, productInfo.ProductNumber);
                }
                Console.ReadLine();

                //Usage Composing Queries
                //Use DataSet ds = new DataSet();
                IEnumerable<DataRow> productsQuery = from product in products.AsEnumerable() select product;

                IEnumerable<DataRow> largeProducts = productsQuery.Where(p => p.Field<string>("ProductName") == "Chai");

                Console.WriteLine("ProductName =='Chai'");

                foreach (DataRow product in largeProducts)
                {
                    Console.WriteLine(product.Field<int>("ProductID"));
                }
                Console.ReadLine();

                //toList(TSource),ToArray(TSource),ToLookup,
                // Use DataSet ds = new DataSet();but we use newly Table as name is  Suppliers  
                DataTable Suppliers = ds.Tables["Suppliers"];

                IEnumerable<DataRow> SuppliersQuery = from Supplier in Suppliers.AsEnumerable()
                                                      orderby
                                                          Supplier.Field<string>("City") descending
                                                      select Supplier;

                IEnumerable<DataRow> SuppliersArray = SuppliersQuery.ToArray();
                IEnumerable<DataRow> SupplierstoList = SuppliersQuery.ToList();
                foreach (DataRow SuppArray in SuppliersArray)
                {
                    Console.WriteLine(SuppArray.Field<String>("City"));
                }

                foreach (DataRow supplist in SupplierstoList)
                {
                    Console.WriteLine(supplist.Field<String>("City"));
                }
               
                





            }
            catch (Exception ex)
            {
                Console.WriteLine("SQL exception occurred: " + ex.Message);
                Console.ReadLine();
            }

        }
        public DataSet FillDataSet()
        {
         
                  string connectionString = "Data Source=localhost;Initial Catalog=Northwind;"
                                                + "Integrated Security=true;";

                  SqlConnection connection = new SqlConnection(connectionString);

                  //Create a SqlDataAdapter for the Suppliers table.
                  SqlDataAdapter adapter = new SqlDataAdapter();

                  // A table mapping names the DataTable.
                  adapter.TableMappings.Add("Table", "Suppliers");

                  // Open the connection.
                  connection.Open();
                  Console.WriteLine("The SqlConnection is open.");

                  // Create a SqlCommand to retrieve Suppliers data.
                  SqlCommand command = new SqlCommand(
                      "SELECT SupplierID, CompanyName,City FROM dbo.Suppliers;",
                      connection);
                  command.CommandType = CommandType.Text;

                  // Set the SqlDataAdapter's SelectCommand.
                  adapter.SelectCommand = command;

                  // Fill the DataSet.
                  DataSet dataSet = new DataSet("Suppliers");
                  adapter.Fill(dataSet);

                  // Create a second Adapter and Command to get
                  // the Products table, a child table of Suppliers. 
                  SqlDataAdapter productsAdapter = new SqlDataAdapter();
                  productsAdapter.TableMappings.Add("Table", "Products");

                  SqlCommand productsCommand = new SqlCommand(
                      "SELECT ProductID, SupplierID,ProductName,UnitPrice FROM dbo.Products;",
                      connection);
                  productsAdapter.SelectCommand = productsCommand;

                  // Fill the DataSet.
                  productsAdapter.Fill(dataSet);

                  // Close the connection.
                  connection.Close();
                  Console.WriteLine("The SqlConnection is closed.");

                  // Create a DataRelation to link the two tables
                  // based on the SupplierID.
                  DataColumn parentColumn =
                      dataSet.Tables["Suppliers"].Columns["SupplierID"];
                  DataColumn childColumn =
                      dataSet.Tables["Products"].Columns["SupplierID"];
                  DataRelation relation =
                      new System.Data.DataRelation("SuppliersProducts",
                      parentColumn, childColumn);
                  dataSet.Relations.Add(relation);
                  Console.WriteLine(
                      "The {0} DataRelation has been created.",
                      relation.RelationName);

                  return dataSet;       
          
      
        }

        //static private string GetConnectionString()
        //{
        //    return "Data Source=(local);Initial Catalog=Northwind;"
        //        + "Integrated Security=SSPI";
        //}
    }

worksguo

weixin_34216036
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linq to DataSet 学习笔记一
jvbss的专栏
03-31 658
Linq to DataSet Linq to  DataSet将Linq与ADO.NET集成，通过ADO.NET获取数据，然后通过Linq进行查询，从而实现对数据的复杂查询，Linq to DataSet可以理解为通过Linq对DataSet中保存的数据进行查询，一般den为以下几个步骤： 1.获取DataSet或DataTable数据源，Linq to DataSet通过Linq查询Dat
第三十六讲 LINQ to DataSet
wljhk2006的专栏
04-24 606
回顾     1. 前三节以LINQ TO OBJECT 作为依托，对LINQ的基础，语法，技巧做了详细的讨论和演示          2. LINQ查询适用于实例IEnumerable接口或IQueryable接口的数据源          3. LINT TO OBJECT表示一种新的处理集合的方法         1. 它们更简明，更易读，尤其在筛选多个条件时。       
LinQ To DataSet
weixin_30455023的博客
10-09 217
LINQ to DataSet 是LINQ to ADO.NET 的一个独立技术。使用LINQ to DataSet能够更 快更容易的查询DataSet对象中的数据。 LINQ to DataSet 功能主要通过DataRowExtensions和DataTableExtensions静态类 中的扩展方法来实现。LINQ to DataSet 不但能够对DataSet 对象中的单个表进行查询，而且...
LINQ（LINQ to DataSet）
weixin_34090643的博客
08-21 126
       DataTable.Select（）方法使用和 SQL 相似的过滤语法从 DataTable 中提取你关心的记录，虽然 Select（）可以很好的工作，但它还是有一些明显的限制。首先，它是基于字符串的，也就是说可能的错误不能在编译的时候发现。其次，它的过滤功能也很有限，它没有提供 LINQ 操作符能够提供的其他特性，如排序、分组以及投影。        使用 LINQ to Dat...
LINQ to DataSet的使用步骤
xtaimafanle的博客
05-21 450
LINQ to DataSet 使用的四个步骤 1）获取DataSet/DataTable数据源 2）将DataTable使用AsEnumerable()方法转换成IEnumerable类型 3）使用LINQ语法编写查询 4）使用查询结果 Attention：查询结果为EnumerableRowCollection类型，按照列名操作的语法为：**Field（）**示例： var rowCollection = dataTable.AsEnumerable(); var query = from b
Linq技术实例 Linq To Sql Linq To DataSet
02-22
**Linq技术实例：Linq To Sql与Linq To DataSet** **一、Linq简介** Linq（Language Integrated Query，语言集成查询）是.NET Framework 3.5引入的一项创新技术，它将查询操作直接整合到C#和VB.NET等编程语言中，...
LINQ自定义实体及LINQtoDATASET
12-02
本文档详细介绍了LINQ TO DATASET以以及LINQ TO SQL创建实体类的例子，本人亲自测试通过。可以做参考，源代码，注释很清楚
LINQ to Dataset
12-04
LINQ 技术是当前最流行的数据库访问技术，这本书是网上唯一一本LINQ中文 版
vs2008语言集成查询（LINQ）之LINQ TO DataSet
08-12
**正文** ...如果你想要深入理解并实践LINQ to DataSet，可以参考《跟我一起学Visual Studio 2008系列课程(5)：语言集成查询(LINQ)之LINQ to DataSet》这份资源，它将带你逐步探索这一强大的工具。
Linq 大全 Linq To Sql Linq To DataSet Linq To Object Linq to Xml
05-28
Linq 大全 Linq To Sql Linq To DataSet Linq To Object Linq to Xml
linq to datasets，通过linq访问强类型数据集
09-05
linq to datasets，通过linq访问强类型数据集
LINQ to DataSet/ LINQ to DataTable
lzm204442535的博客
05-29 491
一个DataSet通常包含一个或多个DataTable，同时也包括它们之间的关系集合等，实际上可以把它看成是一个缩影的数据库。LINQ to DataSet也是对一个或多个DataTable进行查询，这些DataTable可以来自单个DataSet，也可以是来自多个DataSet。 LINQ to DataSet的使用通常包含以下步骤： （1）获取DataSet/DataTable数据源 （2）将DataTable转换成IEnumerable类型。LINQ只能在IEnumerable或IQueryable接
从LINQ开始之LINQ to Objects（上）
weixin_30266829的博客
05-23 114
LINQ概述 　　LINQ，语言集成查询(Language Integrated Query)，它允许使用C#或VB代码以查询数据库相同的方式来操作不同的数据源。 LINQ体系结构 从上图可以看出，LINQ总共包括五个部分：LINQ to Objects、LINQ to DataSets、LINQ to SQL、LINQ to Entities、LINQ to XML。 LINQ to Obj...
linq入门（一）
qq_44866632的博客
06-04 158
1.linq的提出是为了提供一种跨越各种数据源的统一查询方式，它主要包括四个组件：linq to Objects、linq to XML、linq to DataSet和linq to SQL。 1）linq to SQL：可以查询基于关系数据库的数据。微软实现了SQL Sever的查询等操作。其他的第三方也实现了很多。 2）linq to DataSet：查询 DataSet中的数据，并能对数据...
linq学习 Linq to DataSet
byebyegov5qq
04-22 181
Linq to DataSet Linq to DataSet将Linq与ADO.NET集成，通过ADO.NET获取数据，然后通过Linq进行查询，从而实现对数据的复杂查询，Linq to DataSet可以理解为通过Linq对DataSet中保存的数据进行查询，一般den为以下几个步骤： 1.获取DataSet或DataTable数据源，Linq to DataSet通过Linq查...
Linq to DataSet查询
人和代码有一个能跑
02-27 926
笔者项目中遇到从DataSet中按某条件查询单个数据问题，DataSet后是Sql语句从数据库中查询取得一个集合。查询语句就不写了。其中表结构如下： CREATE TABLE [dbo].[tb_report]( [time] [datetime] NOT NULL, [ID] [int] IDENTITY(1,1) NOT NULL, [GSM] [varchar](50) NOT NU
Linq to DataSet的Distinct用法
绿龙术士的专栏
02-23 1344
做项目时个人空间访客列表中，显示最近来访的客户头像，于是建了张客户个人空间日志表 表结构如下： id 主键id user_id 访客id visit_id 被访问用户id add_time 创建日期 state 状态 之后需要用到用户名和头像，与用户表(users)连接，创建视图v_space_log 视图如下： //最近来访 DataSet ds = _...
LINQ to DataSet
weixin_30834019的博客
08-27 83
Linq to DataSet-查询ADO.NET数据集 Linq查询适用于实现了IEnumerable<T>接口或IQueryable<T>接口的数据源，而DataTable类没有实现其中的任一接口，因此必须调用AsEnumerable方法将DataTable作为LINQ查询from子句的源。 AsEnumerable方法将DataTable对象转换为Enumerab...
LINQ（C#）入门
12-26
此外，还有一些其他的LINQ提供者，如LINQ to Entities、LINQ to DataSet等，用于支持不同类型的数据源。 总的来说，LINQ是.NET Framework中一种强大的查询工具，它简化了数据查询的过程，提高了代码的可读性和可...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值