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)