Linq 记录

-- 感觉使用Linq来实现最基本的 增删修查[简单查询：如按ID,按编码等] 即可，其他还是使用原始的 sql 比较好 --

-- 与对象的映射问题：1 用Linq查询出来的已经是对象了    --

 

-- 使用原始的 sql 有时会查出一些 DataRow集， 但这个似乎也不常用

-- DataRow -> Object 即 实体类 obj = new 实体类(DataRow drOne) --

 Guid _UserId = db.T_User.Single(c=>c.F_ID==new Guid("00000000-0000-0000-0000-000000000001")).F_ID;
 Guid _UserId = db.T_User.Where(c => c.F_ID == new Guid("00000000-0000-0000-0000-000000000001")).Select(c => c.F_ID).Single();

 

GetUserInfoDataContext cxt = new GetUserInfoDataContext(System.Configuration.ConfigurationManager.ConnectionStrings["TestConnectionString"].ToString());
    //插入操作
    protected void Button1_Click(object sender, EventArgs e)
    {
        UserInfo userinfo = new UserInfo();
        userinfo.username = TextBox1.Text;
        userinfo.password = TextBox2.Text;
        cxt.UserInfos.InsertOnSubmit(userinfo);
        cxt.SubmitChanges();
    }
    //删除操作
    protected void Button2_Click(object sender, EventArgs e)
    {
        UserInfo userinfo = cxt.UserInfos.Single(b => b.id == int.Parse(txt_id.Text));
        cxt.UserInfos.DeleteOnSubmit(userinfo);
        cxt.SubmitChanges();
    }
    //更新操作
    protected void Button3_Click(object sender, EventArgs e)
    {
        UserInfo userinfo = cxt.UserInfos.Single(b => b.id == int.Parse(txt_update_id.Text));
        userinfo.username = txt_update_username.Text;
        userinfo.password = txt_update_password.Text;
        // cxt.UserInfos.
        cxt.SubmitChanges();
    }

 

Northwnd db = new Northwnd(@"c:\Northwnd.mdf");

var cust =
    (from c in db.Customers
     where c.CustomerID == "ALFKI"
     select c).First();
cust.ContactName = "New Contact";

Order ord = new Order { OrderDate = DateTime.Now };
cust.Orders.Add(ord);
Order ord0 = cust.Orders[0];

 

------------------------------------------------------------------------------------------------

在 LINQ 查询中，最先使用 from 子句的目的是引入数据源 (customers) 和范围变量 (cust)。

//queryAllCustomers is an IEnumerable<Customer>
var queryAllCustomers = from cust in customers
select cust;

只返回那些地址位于伦敦的 customers。

var queryLondonCustomers = from cust in customers
where cust.City == "London"
select cust;

 

若要返回位于伦敦或巴黎的客户，您应编写下面的代码：

where cust.City == "London" || cust.City == "Paris"

 

 

排序

通常可以很方便地将返回的数据进行排序。orderby 子句将使返回的序列中的元素按照被排序的类型的默认比较器进行排序。例如，下面的查询可以扩展为按 Name 属性对结果进行排序。因为 Name 是一个字符串，所以默认比较器执行从 A 到 Z 的字母排序。

var queryLondonCustomers3 = 
 from cust in customers
 where cust.City == "London"
 orderby cust.Name ascending
 select cust;

 

若要按相反顺序（从 Z 到 A）对结果进行排序，请使用 orderby…descending 子句。

分组

使用 group 子句，您可以按指定的键分组结果。例如，您可以指定结果应按 City 分组，以便位于伦敦或巴黎的所有客户位于各自组中。在本例中，cust.City 是键。

// queryCustomersByCity is an IEnumerable<IGrouping<string, Customer>>
 var queryCustomersByCity =
 from cust in customers
 group cust by cust.City;

 // customerGroup is an IGrouping<string, Customer>
 foreach (var customerGroup in queryCustomersByCity)
 {
 　　Console.WriteLine(customerGroup.Key);
 　　foreach (Customer customer in customerGroup)
 　　{
 　　Console.WriteLine(" {0}", customer.Name);
 　　}
 }

 

如果您必须引用组操作的结果，可以使用 into 关键字来创建可进一步查询的标识符。下面的查询只返回那些包含两个以上的客户的组：

 

// custQuery is an IEnumerable<IGrouping<string, Customer>>
var custQuery =
 from cust in customers
 group cust by cust.City into custGroup
 where custGroup.Count() > 2
 orderby custGroup.Key
 select custGroup;

 

Join操作符

适用场景：在我们表关系中有一对一关系，一对多关系，多对多关系等。对各个表之间的关系，就用这些实现对多个表的操作。

说明：在Join操作中，分别为Join(Join查询), SelectMany(Select一对多选择)和GroupJoin(分组Join查询)。
该扩展方法对两个序列中键匹配的元素进行inner join操作

 

 

1.一对多关系(1 to Many)：

var q =
 from c in db.Customers
 from o in c.Orders
 where c.City == "London"
 select o;

语句描述：Customers与Orders是一对多关系。即Orders在Customers类中以EntitySet形式出现。所以第二个from是从c.Orders而不是db.Orders里进行筛选。这个例子在From子句中使用外键导航选择伦敦客户的所有订单。

var q =
 from p in db.Products
 where p.Supplier表.Country == "USA" && p.UnitsInStock == 0
 select p;

语句描述：这一句使用了p.Supplier.Country条件，间接关联了Supplier表。这个例子在Where子句中使用外键导航筛选其供应商在美国且缺货的产品。生成SQL语句为：

SELECT [t0].[ProductID], [t0].[ProductName], [t0].[SupplierID],
[t0].[CategoryID],[t0].[QuantityPerUnit],[t0].[UnitPrice], 
[t0].[UnitsInStock], [t0].[UnitsOnOrder],[t0].[ReorderLevel],
[t0].[Discontinued] FROM [dbo].[Products] AS [t0]
LEFT OUTER JOIN [dbo].[Suppliers] AS [t1] ON 
[t1].[SupplierID] = [t0].[SupplierID]
WHERE ([t1].[Country] = @p0) AND ([t0].[UnitsInStock] = @p1)
-- @p0: Input NVarChar (Size = 3; Prec = 0; Scale = 0) [USA]
-- @p1: Input Int (Size = 0; Prec = 0; Scale = 0) [0]

 

2.多对多关系(Many to Many)：

var q =
 from e in db.职员
 from et in e.职员_地域关系表
 where e.City == "Seattle"

 //下是要显示的属性
 select new
 {
 e.FirstName,
 e.LastName,
 et.地域.名称 };

说明：多对多关系一般会涉及三个表(如果有一个表是自关联的，那有可能只有2个表)。这一句语句涉及Employees, EmployeeTerritories, Territories三个表。它们的关系是1：M：1。Employees和Territories没有很明确的关系。

语句描述：这个例子在From子句中使用外键导航筛选在西雅图的雇员，同时列出其所在地区

 

3.自联接关系：

var q =
 from e1 in db.Employees
 from e2 in e1.Employees
 where e1.City == e2.City
 select new {
 FirstName1 = e1.FirstName, LastName1 = e1.LastName,
 FirstName2 = e2.FirstName, LastName2 = e2.LastName,
 e1.City
 };

 

 

------------------------- 

json Example

Product product = new Product();

product.Name = "Apple";

product.Expiry = new DateTime(2008, 12, 28);

product.Price = 3.99M;

product.Sizes = new string[] { "Small", "Medium", "Large" };

string json = JavaScriptConvert.SerializeObject(product);

Product deserializedProduct = JavaScriptConvert.DeserializeObject<Product>(json);

 

 -----------------------