linq執行sql語句
❶ linq to sql語句和sql語句一樣嗎
並不一樣，SQL 語句是遵照T-SQL語法的，linq to sql 是使用Linq的，雖然看上去很類似，但關鍵字，查詢方式都完全不一樣，建議你按照MSDN上的教程分別學習。
❷ 如何直接執行SQL語句
1、ExecuteQuery方法
看命名，我們很容易聯想到ADO.NET里熟悉的Command的ExecuteNonQuery方法，但是VS的智能提示告訴我們這個方法返回的是一個泛型集合，應該「所思非所得」。下面通過一個簡單方法，驗證我們的猜想（資料庫設計可以參考這一篇）：
/// <summary>
/// 直接執行sql語句，獲取總人數
/// </summary>
/// <returns></returns>
publicint GetTotalCount()
{
string strSql = "SELECT COUNT(0) FROM Person(NOLOCK)";
var query = dataContext.ExecuteQuery<int>(strSql);
int result = query.First<int>();
Console.WriteLine();
Console.WriteLine("total count:{0}", result);
return result;
}
調試的時候，通過IntelliTrace跟蹤到：
毫無疑問，上面的圖片說明最初的想法是不正確的,」ADO.NET:執行Reader…」雲雲，讓我們更加堅信它實際執行的應該是ExecuteReader方法。當然最簡單的方法是直接查看它的方法說明：
// 摘要:
// 直接對資料庫執行 SQL 查詢並返回對象。
//
// 參數:
// query:
// 要執行的 SQL 查詢。
//
// parameters:
// 要傳遞給命令的參數數組。注意下面的行為：如果數組中的對象的數目小於命令字元串中已標識的最大數，
則會引發異常。如果數組包含未在命令字元串中引用的對象，則不會引發異常。如果某參數為
// null，則該參數會轉換為 DBNull.Value。
//
// 類型參數:
// TResult:
// 返回的集合中的元素的類型。
//
// 返回結果:
// 由查詢返回的對象的集合。
public IEnumerable<TResult> ExecuteQuery<TResult>(string query, paramsobject[] parameters);
ExecuteQuery方法還有一個非泛型方法：
//
// 摘要:
// 直接對資料庫執行 SQL 查詢。
//
// 參數:
// elementType:
//
要返回的 System.Collections.Generic.IEnumerable<T>
的類型。使查詢結果中的列與對象中的欄位或屬性相匹配的演算法如下所示：如果欄位或屬性映射到特定列名稱，則結果集中應包含該列名稱。如果未映射欄位或屬性，則結果集中應包含其名稱與該欄位或屬性相同的列。通過先查找區分大小寫的匹配來執行比較。如果未找到匹配項，則會繼續搜索不區分大小寫的匹配項。如果同時滿足下列所有條件，則該查詢應當返回（除延遲載入的對象外的）對象的所有跟蹤的欄位和屬性：T
// 是由 System.Data.Linq.DataContext 顯式跟蹤的實體。
System.Data.Linq.DataContext.ObjectTrackingEnabled
// 為 true。實體具有主鍵。否則會引發異常。
//
// query:
// 要執行的 SQL 查詢。
//
// parameters:
// 要傳遞給命令的參數數組。注意下面的行為：如果數組中的對象的數目小於命令字元串中已標識的最大數，
則會引發異常。如果數組包含未在命令字元串中引用的對象，則不會引發異常。如果某參數為
// null，則該參數會轉換為 DBNull.Value。
//
// 返回結果:
// 由查詢返回的對象的 System.Collections.Generic.IEnumerable<T> 集合。
public IEnumerable ExecuteQuery(Type elementType, string query, paramsobject[] parameters);
看它的參數需要多傳遞一個elementType，明顯不如泛型方法簡潔。
2、ExecuteCommand方法
同樣道理，這個方法立刻讓我們聯想到（世界沒有聯想，生活將會怎樣？），聯想到，等等，不知聯想到什麼。然後我們看一下方法使用說明：
//
// 摘要:
// 直接對資料庫執行 SQL 命令。
//
// 參數:
// command:
// 要執行的 SQL 命令。
//
// parameters:
// 要傳遞給命令的參數數組。注意下面的行為：如果數組中的對象的數目小於命令字元串中已標識的最大數，
則會引發異常。如果數組包含未在命令字元串中引用的對象，則不會引發異常。如果任一參數為
// null，則該參數會轉換為 DBNull.Value。
//
// 返回結果:
// 一個 int，表示所執行命令修改的行數。
publicint ExecuteCommand(string command, paramsobject[] parameters);
到這里，看它的返回類型為int，表示執行命令修改的行數，這次很容易想到ExecuteNonQuery方法。對不對呢？通過下面的代碼證明我們的設想：
/// <summary>
/// 直接執行sql語句 根據用戶Id更新體重
/// </summary>
/// <param name="id">用戶Id</param>
/// <param name="destWeight">更新後的體重</param>
/// <returns></returns>
publicint ModifyWeightById(int id, double destWeight)
{
string strSql = string.Format("UPDATE Person SET Weight={0} WHERE Id={1}", destWeight, id);
int result = dataContext.ExecuteCommand(strSql);
Console.WriteLine();
Console.WriteLine("affect num:{0}", result);
return result;
}
調試過程中，通過IntelliTrace可以很清楚地捕獲：「ADO.NET:執行NonQuery…」基本可以斷言我們的設想是正確的。
3、防止sql注入
1和2中，執行sql語句的兩個方法都有一個params 類型的參數，我們又會想到ADO.NET非常重要的sql語句的參數化防止sql注入問題。下面通過一個方法，看看linq2sql可不可以防止sql注入。
（1）、直接執行拼接的sql語句（有風險）
/// <summary>
/// 直接執行sql語句 根據用戶Id更新FirstName
/// </summary>
/// <param name="id">用戶Id</param>
/// <param name="destName">更新後的FirstName</param>
/// <returns></returns>
publicint ModifyNameById(int id, string destName)
{
string strSql = string.Format("UPDATE Person SET FirstName='{0}' WHERE Id={1}", destName, id);
//這么拼接有風險
int result = dataContext.ExecuteCommand(strSql);
Console.WriteLine();
Console.WriteLine("affect num:{0}", result);
return result;
}
然後，在客戶端這樣調用這個方法：
int result = ServiceFactory.CreatePersonService().ModifyNameById(10, "'Anders'");
//更新id為10的人的FirstName
❸ 如何查看LINQ執行的SQL語句
如何查看某個用戶執行過的sql語句
--SYS窗口
SQL> select sql_text from v$sql where parsing_schema_name='SCOTT'
2 order by last_load_time desc;
no rows selected
SQL> /
SQL_TEXT
-------------------------------------------------------------------------------
select * from dept
SQL>
--SCOTT窗口
SQL> show user
USER is "SCOTT"
SQL> select * from dept;
DEPTNO DNAME LOC
❹ linq to sql 通用查詢語法 return db.Set<T>().Where<T>(wherelambda).AsQueryable();
Linq是延遲查詢的。
測試（以下查詢，查詢分析器中跟蹤是帶where條件的）：
privatevoidButton_Click(objectsender,RoutedEventArgse)
{
List<v_plancase>list=GetData(p=>p.xh==1).ToList();
}
///<summary>
///查詢
///</summary>
///<paramname="ExpWhere">查詢條件</param>
///<returns></returns>
staticIQueryable<v_plancase>GetData(Expression<Func<v_plancase,bool>>ExpWhere)
{
TESTEntitiesdb=newTESTEntities();
returndb.v_plancase.Where(ExpWhere).AsQueryable();
}
詳細介紹：
在用戶創建 LINQ 查詢後，該查詢將轉換為一個命令目錄樹。 命令目錄樹是與實體框架兼容的查詢表示形式。 然後，針對數據源執行該命令目錄樹。 在執行查詢時，將計算所有查詢表達式（即查詢的所有組成部分），包括在結果具體化中使用的那些表達式。
執行查詢表達式的時間點可能會有所不同。 LINQ 查詢始終在循環訪問查詢變數時執行，而不是在創建查詢變數時執行。 這稱為「延遲執行」。 您也可以強制立即執行查詢，這對於緩存查詢結果很有用。
當執行 LINQ to Entities 查詢時，查詢中的有些表達式可能在伺服器上執行，而有些部分可能在客戶端上本地執行。 表達式的客戶端計算發生於在伺服器上執行查詢之前。 如果在客戶端上計算表達式，則該計算的結果將替換查詢中的表達式，然後在伺服器上執行查詢。 因為是對數據源執行查詢，所以數據源配置將重寫客戶端中指定的行為。 例如，null 值處理和數值精度取決於伺服器設置。 在查詢執行期間在伺服器上引發的任何異常都將直接向上傳遞到客戶端。
參考MSDN文檔：http://msdn.microsoft.com/zh-cn/library/vstudio/bb738633(v=vs.100).aspx
❺ SQL語句轉化為Linq語句
分少點！回頭幫我的團隊打工償還吧！O(∩_∩)O哈哈~
-------------
我的表是Table_1s和Table_2s
linq 查詢如下：
from t in Table_1s
join f in Table_2s on t.B equals f.Key into FD
from f in FD.Where(b=>b.RowName=="B").DefaultIfEmpty()
join s in Table_2s on t.C equals s.Key into FDS
from s in FDS.Where(b=>b.RowName=="C").DefaultIfEmpty()
select new
{
A=t.A,
B=f.Value,
C=s.Value
}
---
對應sql如下：
-- Region Parameters
DECLARE @p0 NVarChar(1) SET @p0 = 'B'
DECLARE @p1 NVarChar(1) SET @p1 = 'C'
-- EndRegion
SELECT [t0].[A], [t1].[value] AS [B], [t2].[value] AS [C]
FROM [Table_1] AS [t0]
LEFT OUTER JOIN [Table_2] AS [t1] ON ([t1].[RowName] = @p0) AND ([t0].[B] = [t1].[key])
LEFT OUTER JOIN [Table_2] AS [t2] ON ([t2].[RowName] = @p1) AND ([t0].[C] = [t2].[key])
---
應該滿足你的要求！
❻ ASP.NET中的Linq怎麼用
21.1.1 准備數據源
既然LINQ可以查詢多種數據源和對象，這些對象可能是數組，可能是數據集，也可能是資料庫，那麼在使用LINQ進行數據查詢時首先需要准備數據源。
1．數組
數組中的數據可以被LINQ查詢語句查詢，這樣就省去了復雜的數組遍歷。數組數據源示例代碼如下所示。
string[] str = { "學習", "學習LINQ", "好好學習", "生活很美好" };
int[] inter = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
數組可以看成是一個集合，雖然數組沒有集合的一些特性，但是從另一個角度上來說可以看成是一個集合。在傳統的開發過程中，如果要篩選其中包含「學習」欄位的某個字元串，則需要遍歷整個數組。
2．SQL Server
在資料庫操作中，同樣可以使用LINQ進行資料庫查詢。LINQ以其優雅的語法和面向對象的思想能夠方便的進行資料庫操作，為了使用LINQ進行SQL Server資料庫查詢，可以創建兩個表，這兩個表的結構如下所示。Student（學生表）：
S_ID：學生ID。
S_NAME：學生姓名。
S_CLASS：學生班級。
C_ID：所在班級的ID。
上述結構描述了一個學生表，可以使用SQL語句創建學生表，示例代碼如下所示。
USE [student]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Student](
[S_ID] [int] IDENTITY(1,1) NOT NULL,
[S_NAME] [nvarchar](50) COLLATE Chinese_PRC_CI_AS NULL,
[S_CLASS] [nvarchar](50) COLLATE Chinese_PRC_CI_AS NULL,
[C_ID] [int] NULL,
CONSTRAINT [PK_Student] PRIMARY KEY CLUSTERED
(
[S_ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,
ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
為了更加詳細的描述一個學生所有的基本信息，就需要創建另一個表對該學生所在的班級進行描述，班級表結構如下所示。Class（班級表）：
C_ID：班級ID。
C_GREAD：班級所在的年級。
C_INFOR：班級專業。
上述代碼描述了一個班級的基本信息，同樣可以使用SQL語句創建班級表，示例代碼如下所示。
USE [student]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Class](
[C_ID] [int] IDENTITY(1,1) NOT NULL,
[C_GREAD] [nvarchar](50) COLLATE Chinese_PRC_CI_AS NULL,
[C_INFOR] [nvarchar](50) COLLATE Chinese_PRC_CI_AS NULL,
CONSTRAINT [PK_Class] PRIMARY KEY CLUSTERED
(
[C_ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF,
ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
上述代碼在Student資料庫中創建了一個班級表，開發人員能夠向資料庫中添加相應的信息以准備數據源。
3．數據集
LINQ能夠通過查詢數據集進行數據的訪問和整合；通過訪問數據集，LINQ能夠返回一個集合變數；通過遍歷集合變數可以進行其中數據的訪問和篩選。在第9章中講到了數據集的概念，開發人員能夠將資料庫中的內容填充到數據集中，也可以自行創建數據集。
數據集是一個存在於內存的對象，該對象能夠模擬資料庫的一些基本功能，可以模擬小型的資料庫系統，開發人員能夠使用數據集對象在內存中創建表，以及模擬表與表之間的關系。在數據集的數據檢索過程中，往往需要大量的if、else等判斷才能檢索相應的數據。
使用LINQ進行數據集中數據的整理和檢索可以減少代碼量並優化檢索操作。數據集可以是開發人員自己創建的數據集也可以是現有資料庫填充的數據集，這里使用上述SQL Server創建的資料庫中的數據進行數據集的填充。
21.1.2 使用LINQ
在傳統對象查詢中，往往需要很多的if、else語句進行數組或對象的遍歷，例如在數組中尋找相應的欄位，實現起來往往比較復雜，而使用LINQ就簡化了對象的查詢。由於前面已經准備好了數據源，那麼就能夠分別使用LINQ語句進行數據源查詢。
1．數組
在前面的章節中，已經創建了一個數組作為數據源，數組示例代碼如下所示。
int[] inter = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
上述代碼是一個數組數據源，如果開發人員需要從其中的元素中搜索大於5的數字，傳統的方法應該遍歷整個數組並判斷該數字是否大於5，如果大於5則輸出，否則不輸出，示例代碼如下所示。
using System;
using System.Collections.Generic;
using System.Linq; //使用必要的命名空間
using System.Text;
namespace _21_1
{
class Program
{
static void Main(string[] args)
{
string[] str = { "學習", "學習LINQ", "好好學習", "生活很美好" }; //定義數組
int[] inter = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
for (int i = 0; i < inter.Length; i++) //遍歷數組
{
if (inter[i] > 5) //判斷數組元素的值是否大於5
{
Console.WriteLine(inter[i].ToString()); //輸出對象
}
}
Console.ReadKey();
}
}
}
上述代碼非常簡單，將數組從頭開始遍歷，遍歷中將數組中的的值與5相比較，如果大於5就會輸出該值，如果小於5就不會輸出該值。雖然上述代碼實現了功能的要求，但是這樣編寫的代碼繁冗復雜，也不具有擴展性。如果使用LINQ查詢語句進行查詢就非常簡單，示例代碼如下所示。
class Program
{
static void Main(string[] args)
{
string[] str = { "學習", "學習LINQ", "好好學習", "生活很美好" }; //定義數組
int[] inter = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //定義數組
var st = from s in inter where s > 5 select s; //執行LINQ查詢語句
foreach (var t in st) //遍歷集合元素
{
Console.WriteLine(t.ToString()); //輸出數組
}
Console.ReadKey();
}
}
使用LINQ進行查詢之後會返回一個IEnumerable的集合。在上一章講過，IEnumerable是.NET框架中最基本的集合訪問器，可以使用foreach語句遍歷集合元素。使用LINQ查詢數組更加容易被閱讀，LINQ查詢語句的結構和SQL語法十分類似，LINQ不僅能夠查詢數組，還可以通過.NET提供的編程語言進行篩選。例如str數組變數，如果要查詢其中包含「學習」的字元串，對於傳統的編程方法是非常冗餘和繁瑣的。由於LINQ是.NET編程語言中的一部分，開發人員就能通過編程語言進行篩選，LINQ查詢語句示例代碼如下所示。
var st = from s in str where s.Contains("學習") select s;
2．使用SQL Server
在傳統的資料庫開發中，如果需要篩選某個資料庫中的數據，可以通過SQL語句進行篩選。在ADO.NET中，首先需要從資料庫中查詢數據，查詢後就必須將數據填充到數據集中，然後在數據集中進行數據遍歷，示例代碼如下所示。
try
{
SqlConnection
con = new SqlConnection("server='(local)';database='student';uid='sa';pwd='sa'"); //創建連接
con.Open(); //打開連接
string strsql = "select * from student,class where student.c_id=class.c_id"; //SQL語句
SqlDataAdapter da = new SqlDataAdapter(strsql, con); //創建適配器
DataSet ds = new DataSet(); //創建數據集
int j = da.Fill(ds, "mytable"); //填充數據集
for (int i = 0; i < j; i++) //遍歷集合
{
Console.WriteLine(ds.Tables["mytable"].Rows[i]["S_NAME"].ToString()); //輸出對象
}
}
catch
{
Console.WriteLine("資料庫連接錯誤"); //拋出異常
}
上述代碼進行資料庫的訪問和查詢。在上述代碼中，首先需要創建一個連接對象進行資料庫連接，然後再打開連接，打開連接之後就要編寫SELECT語句進行資料庫查詢並填充到DataSet數據集中，並在DataSet數據集中遍歷相應的表和列進行數據篩選。如果要查詢C_ID為1的學生的所有姓名，有三個辦法，這三個辦法分別是：
修改SQL語句。
在循環內進行判斷。
使用LINQ進行查詢。
修改SQL語句是最方便的方法，直接在SELECT語句中添加查詢條件WHERE C-ID=1就能夠實現，但是這個方法擴展性非常的低，如果有其他需求則就需要修改SQL語句，也有可能造成其餘代碼填充數據集後數據集內容不同步。
在循環內進行判斷也是一種方法，但是這個方法當循環增加時會造成額外的性能消耗，並且當需要擴展時，還需要修改循環代碼。最方便的就是使用LINQ進行查詢，在Visual Studio 2008中提供了LINQ to SQL類文件用於將現有的數據抽象成對象，這樣就符合了面向對象的原則，同時也能夠減少代碼，提升擴展性。創建一個LINQ to SQL類文件，直接將服務資源管理器中的相應表拖放到LINQ to SQL類文件可視化窗口中即可，如圖21-1所示。
圖21-1 創建LINQ to SQL文件
創建了LINQ to SQL類文件後，就可以直接使用LINQ to SQL類文件提供的類進行查詢，示例代碼如下所示。
linqtosqlDataContext lq = new linqtosqlDataContext();
var mylq = from l in lq.Student from cl in lq.Class where l.C_ID==cl.C_ID select l; //執行查詢
foreach (var result in mylq) //遍歷集合
{
Console.WriteLine(result.S_NAME.ToString()); //輸出對象
}
上述代碼只用了很短的代碼就能夠實現資料庫中數據的查詢和遍歷，並且從可讀性上來說也很容易理解，因為LINQ查詢語句的語法基本與SQL語法相同，只要有一定的SQL語句基礎就能夠非常容易的編寫LINQ查詢語句。
3．數據集
LINQ同樣對數據集支持查詢和篩選操作。其實數據集也是集合的表現形式，數據集除了能夠填充資料庫中的內容以外，開發人員還能夠通過對數據集的操作向數據集中添加數據和修改數據。前面的章節中已經講到，數據集可以看作是內存中的資料庫。數據集能夠模擬基本的資料庫，包括表、關系等。這里就將SQL Server中的數據填充到數據集即可，示例代碼如下所示。
try
{
SqlConnection
con = new SqlConnection("server='(local)';database='student';uid='sa';pwd='sa'"); //創建連接
con.Open(); //打開連接
string strsql = "select * from student,class where student.c_id=class.c_id"; //執行SQL
SqlDataAdapter da = new SqlDataAdapter(strsql, con); //創建適配器
DataSet ds = new DataSet(); //創建數據集
da.Fill(ds, "mytable"); //填充數據集
DataTable tables = ds.Tables["mytable"]; //創建表
var dslq = from d in tables.AsEnumerable() select d; //執行LINQ語句
foreach (var res in dslq)
{
Console.WriteLine(res.Field<string>("S_NAME").ToString()); //輸出對象
}
}
catch
{
Console.WriteLine("資料庫連接錯誤");
}
上述代碼使用LINQ針對數據集中的數據進行篩選和整理，同樣能夠以一種面向對象的思想進行數據集中數據的篩選。在使用LINQ進行數據集操作時，LINQ不能直接從數據集對象中查詢，因為數據集對象不支持LINQ查詢，所以需要使用AsEnumerable方法返回一個泛型的對象以支持LINQ的查詢操作，示例代碼如下所示。
var dslq = from d in tables.AsEnumerable() select d; //使用AsEnumerable
上述代碼使用AsEnumerable方法就可以讓數據集中的表對象能夠支持LINQ查詢。
21.1.3 執行LINQ查詢
從上一節可以看出LINQ在編程過程中極大的方便了開發人員對於業務邏輯的處理代碼的編寫，在傳統的編程方法中復雜、冗餘、難以實現的方法在LINQ中都能很好的解決。LINQ不僅能夠像SQL語句一樣編寫查詢表達式，LINQ最大的優點也包括LINQ作為編程語言的一部分，可以使用編程語言提供的特性進行LINQ條件語句的編寫，這就彌補了SQL語句中的一些不足。在前面的章節中將一些復雜的查詢和判斷的代碼簡化成LINQ應用後，就能夠執行應用程序判斷LINQ是否查詢和篩選出了所需要的值。
1．數組
在數組數據源中，開發人員希望能夠篩選出大於5的元素。開發人員將傳統的代碼修改成LINQ代碼並通過LINQ查詢語句進行篩選，示例代碼如下所示。
var st = from s in inter where s > 5 select s; //執行LINQ查詢
上述代碼將查詢在inter數組中的所有元素並返回其中元素的值大於5的元素的集合，運行後如圖21-2所示。
圖21-2 遍歷數組
LINQ執行了條件語句並返回了元素的值大於5的元素。LINQ語句能夠方便的擴展，當有不同的需求時，可以修改條件語句進行邏輯判斷，例如可以篩選一個平方數為偶數的數組元素，直接修改條件即可，LINQ查詢語句如下所示。
var st = from s in inter where (s*s)%2==0 select s; //執行LINQ查詢
上述代碼通過條件(s*s)%2==0將數組元素進行篩選，選擇平方數為偶數的數組元素的集合，運行後如圖21-3所示。
圖21-3 更改篩選條件
2．使用SQL Server
在LINQ to SQL類文件中，LINQ to SQL類文件已經將資料庫的模型封裝成一個對象，開發人員能夠通過面向對象的思想訪問和整合資料庫。LINQ to SQL也對SQL做了補充，使用LINQ to SQL類文件能夠執行更強大的篩選，LINQ查詢語句代碼如下所示。
var mylq = from l in lq.Student from cl in lq.Class where l.C_ID==cl.C_ID select l; //執行LINQ查詢
上述代碼從Student表和Class表中篩選了C_ID相等的學生信息，這很容易在SQL語句中實現。LINQ作為編程語言的一部分，可以使用更多的編程方法實現不同的篩選需求，例如篩選名稱中包含「郭」字的學生的名稱在傳統的SQL語句中就很難通過一條語句實現，而在LINQ中就能夠實現，示例代碼如下所示。
var mylq = from l in lq.Student from cl in lq.Class where l.C_ID==cl.C_ID where
l.S_NAME.Contains("郭") select l; //執行LINQ條件查詢
上述代碼使用了Contains方法判斷一個字元串中是否包含某個字元或字元串，這樣不僅方便閱讀，也簡化了查詢操作，運行後如圖21-4和圖21-5所示。
圖21-4 簡單查詢 圖21-5 條件查詢
LINQ返回了符合條件的元素的集合，並實現了篩選操作。LINQ不僅作為編程語言的一部分，簡化了開發人員的開發操作，從另一方面講，LINQ也補充了在SQL中難以通過幾條語句實現的功能的實現。從上面的LINQ查詢代碼可以看出，就算是不同的對象、不同的數據源，其LINQ基本的查詢語法都非常相似，並且LINQ還能夠支持編程語言具有的特性從而彌補SQL語句的不足。在數據集的查詢中，其查詢語句也可以直接使用而無需大面積修改代碼，這樣代碼就具有了更高的維護性和可讀性。
❼ 哪位高手知道vs2010中的linq怎麼查看生成的sql語句
linq使用對象的方式來操作資料庫。最後根本的還是生成原始的sql。但是對象的方式掩蓋了很多原本的sql面貌可能會是我們不明白對應的sql是什麼。還好linq可以輸出sql語句
DataClassesDataContext dc = new DataClassesDataContext();
這個對象提供的日誌功能。就是輸出對應的sql語句。在控制台應用程序下。使用dc.console（有誤）可以直接輸出顯示對應的sql語句。
在windonw和web程序下面可以建立一個txt文件日誌。把生成的sql記錄下來。代碼比較簡單了
DataClassesDataContext dc = new DataClassesDataContext();
StreamWriter sw = new StreamWriter(Server.MapPath("sqlLog.txt"), true); // Append
dc.Log = sw;
//然後是linq的相關數據操作
sw.Flush();
sw.Close();
就這樣對應的sql語句就記錄到sqlLog.txt文件中了。
我們可能會發現生成的sql在我們意料之外。呵呵。我的感覺是這樣
❽ LINQ比一般的SQL語句效率更高嗎
Linq是一個范圍比較大的概念，它其中不單單只有linq to sql，還有相應的linq to xml等等。所以拿linq 與SQL語句相比，沒有可比性的。
但如果拿linq to sql相比的話，與SQL還是有很大的可比性的。一般情況下，你必須要明白你所指的效率是哪一方面？是資料庫執行效率？還是整體成品軟體運行效率？還是開發效率？
開發效率上linq to sql顯然要比SQL的效率要高很多，我們使用linq to sql 可以很容易實現編程，其中的代碼量也大大減少。所以如果從開發方面linq to sql的效率是毫無疑問要高於直接的SQL與資料庫連接。
如果從編方譯考慮，這個一般情況下，linq to sql是引入的新的技術，效率肯定是不如SQL的。好在這個編譯的部分不需要開發人員或是任何用戶的參與，所以即是效率差一點，對軟體來說沒有任何的影響。
最後一部分你可以比較感興趣，誰對資料庫的連接更快，執行效率更好？答案是linq to sql而不是直接的語句。一般我們使用直接的語句要求的是即是的執行，但事實上很多時間我們根本不需要那麼多，linq to sql其實說明了就是會自動生成與表結構同樣的一些對象。而這些對象在聯系資料庫時也是直接編譯好的語句，直接聯系時，兩者效率是相同的。
但是，如果我們對數據進行處理時，你就會發現，linq to sql的效率為什麼會更高了！因為他在讀取時不但會讀取當前表來填充生成的對象，同時還是延時讀其相關表，為你使用有關系的表提供了極大的方便。那麼你的相關表的讀取效率要快了！
但不管怎麼樣，他們都是在站立在了ado.net的基礎之上的，只不過有些自動生成了，根本不需要你再去做而已。唯一效果比較差的是，linq to sql讀出的數據在系統中被轉化了，同時它效率雖然變差一些，但是卻帶來了另一個好處，就是我們常說的SQL注入問題不再出現，你所輸入的任何東西都會變成了字元串了。
其實ADO.net的方案中我們使用了datareader方案的效高是比較高的，但是對於更新卻是極差的。而使用數據適配器的方案效率較底一些，更對於數據的更新是相當好的，而對於linq to sql其實它是使用數據緩存方案，也就是說linq to sql其實將資料庫中的數據緩存到了對象中，如果對象發生了更改，有必須過行返饋時，它是可以進行反饋的，而是這種反饋是可控制的，事務性的。從各方面給我們帶來了好處。
我們可以在更新了很多內容之後再去提交更改，那麼這種效率論從理解上還是效率上都優化你的原來的語句的！所以linq to sql並非在性能上的降低，而是一種提高。
嚴格說來，linq to sql並不是節省了代碼，相反它增加了很多代碼，便幸運的是，這些代碼都是由linq to sql框架自動生成的。若是換作人工，容易出錯的。但在使用時，由於框架完成了大部分的代碼，我們再使用linq to sql加上lambad表達式或查詢表達式，我們的代碼就變得極少且極簡潔了！而如果使用lambad表達式或查詢表達式時，它的效率顯然不如直接SQL來的直接。讀取效率會變得差一些的！
這是因為lambda表達式或查詢表達式是一個動態編譯的效果，而不是直接編譯好的，他要對語句進行編譯與優化以何證效率，但性能上因為多了一重處理，效率沒有SQL來的直接。但一般情況下，使用linq to sql配合查詢表達式或lambad表達式時，效率雖然稍差，但是帶來的卻是代碼的簡潔與易理解性，如果不配合查詢表達式與lambad表達式，linq to sql的優劣還不利用體現。所以關非linq to sql的效率差，而是我們使用了查詢表達式的動態編譯導致了效率較差。就linq to sql本身上來就，效率並不差的！
❾ 這兩段sql語句用linq語句怎麼寫
你的語句好像錯了，ON (OD.OrderID=OD.OrderID)這個應該是 ON (O.OrderID=OD.OrderID)
對於問題一，請參考這：
using (var db = new DataClasses1DataContext())
{
var list = from c in db.Customers
join o in db.Orders on c.CustomerID equals o.CustomerID
join od in db.Order_Details on o.OrderID equals od.OrderID
select new{c.Country,od};
var result = from d in list
group d by d.Country into g
orderby g.Sum(c => (c.od.UnitPrice * c.od.Quantity) * (1 - (decimal)c.od.Discount)) descending
select g.Key;
//result 即為最終想要的數據
}
對於問題二，請參考這：
using (var db = new DataClasses1DataContext())
{
foreach(var item in db.Order_Details.Where(c=>c.Procts.Categories.CategoryName=="Seafood"))
{
db.Order_Details.DeleteOnSubmit(item);
}
db.SubmitChanges();
}
❿ .net4.0中怎麼使用LINQ與SQL結合。
使用linq的這個方法 ExecuteCommand()
//
// 摘要:
// 直接對資料庫執行 SQL 命令。
//
// 參數:
// command:
// 要執行的 SQL 命令。
//
// parameters:
// 要傳遞給命令的參數數組。注意下面的行為：如果數組中的對象的數目小於命令字元串中已標識的最大數，
則會引發異常。如果數組包含未在命令字元串中引用的對象，則不會引發異常。如果任一參數為
// null，則該參數會轉換為 DBNull.Value。
//
// 返回結果:
// 一個 int，表示所執行命令修改的行數。
public int ExecuteCommand(string command, params object[] parameters)