A. asp.net 中的 using 的用法
ASP.NET中using的用法1.
using指令。using
+
命名空间名字，这样可以在程序中直接用命令空间中的类型，而不必指定类型的详细命名空间，类似于Java的import，这个功能也是最常用的，几乎每个cs的程序都会用到。
例如：using
System;
using
System.Data;
ASP.NET中using的用法2.
using语句，定义一个范围，在范围结束时处理对象。
场景：
当在某个代码段中使用了类的实例，而希望无论因为什么原因，只要离开了这个代码段就自动调用这个类实例的Dispose。
要达到这样的目的，用try...catch来捕捉异常也是可以的，但用using也很方便。
例如：
public static DataTable GetTable(string sql, int executeTimeOut, string connStringName)
{
DataTable dtRet = new DataTable();
using (SqlConnection sc = new SqlConnection(connStringName))
{
using (SqlDataAdapter sqa = new SqlDataAdapter(sql, sc))
{
sqa.SelectCommand.CommandTimeout = executeTimeOut;
sqa.Fill(dtRet);
return dtRet;
}
}
}
ASP.NET中using的用法3.
using别名。using
+
别名
=
包括详细命名空间信息的具体的类型。
这种做法有个好处就是当同一个cs引用了两个不同的命名空间，但两个命名空间都包括了一个相同名字的类型的时候。当需要用到这个类型的时候，就每个地方都要用详细命名空间的办法来区分这些相同名字的类型。而用别名的方法会更简洁，用到哪个类就给哪个类做别名声明就可以了。注意：并不是说两个名字重复，给其中一个用了别名，另外一个就不需要用别名了，如果两个都要使用，则两个都需要用using来定义别名的。
例如：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using aClass = ConsoleApplication1.MyClass;
using bClass = ConsoleApplication2.MyClass;
namespace ConsoleApplication1
{
public class MyClass
{
public override string ToString()
{
return "You are in ConsoleApplication1.MyClass";
}
}
class TestUsing
{
}
}
namespace ConsoleApplication2
{
class MyClass
{
public override string ToString()
{
return "You are in ConsoleApplication2.MyClass";
}
}
}
namespace TestUsing
{
using ConsoleApplication1;
using ConsoleApplication2;
class ClassTestUsing
{
static void Main()
{
aClass my1 = new aClass();
Console.WriteLine(my1);
bClass my2 = new bClass();
Console.WriteLine(my2);
Console.WriteLine("ress any key");
Console.Read();
}
}
}
参考自：http://www.poluoluo.com/jzxy/201008/91919.html
B. mysql数据库中的using是干嘛的
using等价于join操作中的on，例如a和b根据id字段关联，那么以下等价
using(id)
on a.id=b.id
以下2个实例等价：
select a.name,b.age from test as a
join test2 as b
on a.id=b.id
select a.name,b.age from test as a
join test2 as b
using(id)
C. C# using用法范围
using
(对象a)
{
}
//超出这两个{}对象a就被释放
SqlDataAdapter在你那里是个局部变量，.net会自动回收
像上面的using是手动设置范围
你0分要问多少问题呐~~
D. sql server 有using语句吗
SQL sever是不支持using的用法，
SQL sever只能用复杂的写法，其实也大概理解为c++,和Python的区别，c++中各种声明和规则对初学者非常不友好，Python相对来说没有严格的定义规则，就简单点，
oracle和MySQL都是支持using的，就是为了简化join语句的优化，
E. using (SqlConnection connection = new SqlConnection(connectionString))
using专业名词叫作用域,顾名思义,就是using中声明的变量只在using中有效,这样可以避免有时忘了释放一些必须释放的资源所引起的异常.
F. SQL语句的using到底什么用法
SQL中是没有USING的，我想你指的是PL/SQL吧。
他是给bind变量传入值用的，比如：
for i2 in 1..1000 loop
execute immediate 'select * from tablex where id=:1' using i2;
end loop;
这个语句被执行1000次，每次查询条件不一样，但是该语句只被parse一次
G. SQL语句的using到底什么用法
SQL中是没有USING的，我想你指的是PL/SQL吧。
他是给bind变量传入值用的，比如：
for
i2
in
1..1000
loop
execute
immediate
'select
*
from
tablex
where
id=:1'
using
i2;
end
loop;
这个语句被执行1000次，每次查询条件不一样，但是该语句只被parse一次
H. c# 中using的用法
这里的using是一种特殊用记，主要是用来Disponse资源
在执行完using体完语句后会自已执行Disponse,相当于你在你在后面自动加了connection.Disponse();
I. .NET中using(SqlConnection conn = new SqlConnection(connectionStr))解释这种using用法什么意思
using是一种方便的简写形式。当某个类型实现了IDisposable接口时，在使用这样的类型时就可以用using。它等价于：
SqlConnection conn = new SqlConnection(connectionStr);
....
conn.Dispose();//这个Dispose就是从IDisposable接口实现的方法。这个方法一般做一些清理工作
J. SQL 中的各种联接的详细用法用途
连接表
一个连接表是根据特定的连接规则从两个其它表(真实表或生成表)中派生的表。我们支持内连接、外连接、交叉连接。
连接类型
交叉连接
T1 CROSS JOIN T2对每个来自 T1 和 T2 的行进行组合，生成的表将包含这样的行：所有 T1 里面的字段后面跟着所有 T2 里面的字段。如果两表分别有 N 和 M 行，连接成的表将有 N*M 行。
FROM T1 CROSS JOIN T2 等效于 FROM T1, T2 。它还等效于 FROM T1 INNER JOIN T2 ON TRUE (见下文)。
条件连接
T1 { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2 ON boolean_expression
T1 { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2 USING ( join column list )
T1 NATURAL { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2INNER 和 OUTER 对所有连接类型都是可选的。INNER 为缺省。LEFT, RIGHT, FULL 隐含外连接。
连接条件在 ON 或 USING 子句里声明，或者用关键字 NATURAL 隐含地声明。连接条件判断来自两个源表中的那些行是"匹配"的，这些我们将在下面详细解释。
ON 子句是最常见的连接条件的类型：它接收一个和 WHERE 子句相同的布尔表达式。如果两个分别来自 T1 和 T2 的行在 ON 表达式上运算的结果为真，那么它们就算是匹配的行。
USING 是个一个连接条件的缩写语法：它接收一个用逗号分隔的字段名列表，这些字段必须是连接表共有的并且其值必须相同。最后，JOIN USING 会将每一对相等的输入字段输出为一个字段，其后跟着所有其它字段。因此，USING (a, b, c) 等效于 ON (t1.a = t2.a AND t1.b = t2.b AND t1.c = t2.c) 只不过是如果使用了 ON ，那么在结果里 a, b, c 字段都会有两个，而用 USING 的时候就只会有一个。
最后，NATURAL 是 USING 的缩写形式：它自动形成一个由两个表中同名的字段组成的 USING 列表(同名字段只出现一次)。
条件连接可能的类型是：
INNER JOIN
内连接。对于 T1 中的每一行 R1 ，如果能在 T2 中找到一个或多个满足连接条件的行，那么这些满足条件的每一行都在连接表中生成一行。
LEFT OUTER JOIN
左外连接。首先执行一次内连接。然后为每一个 T1 中无法在 T2 中找到匹配的行生成一行，该行中对应 T2 的列用 NULL 补齐。因此，生成的连接表里无条件地包含来自 T1 里的每一行至少一个副本。
RIGHT OUTER JOIN
右外连接。首先执行一次内连接。然后为每一个 T2 中无法在 T1 中找到匹配的行生成一行，该行中对应 T1 的列用 NULL 补齐。因此，生成的连接表里无条件地包含来自 T2 里的每一行至少一个副本。
FULL OUTER JOIN
全连接。首先执行一次内连接。然后为每一个 T1 与 T2 中找不到匹配的行生成一行，该行中无法匹配的列用 NULL 补齐。因此，生成的连接表里无条件地包含 T1 和 T2 里的每一行至少一个副本。
如果 T1 和 T2 之一或全部是可以连接的表，那么所有类型的连接都可以串连或嵌套在一起。你可以在 JOIN 子句周围使用圆括号来控制连接顺序，如果没有圆括号，那么 JOIN 子句从左向右嵌套。
为了解释这些问题，假设我们有一个表 t1
num | name
-----+------
1 | a
2 | b
3 | c和 t2
num | value
-----+-------
1 | xxx
3 | yyy
5 | zzz然后我们用不同的连接方式可以获得各种结果：
=> SELECT * FROM t1 CROSS JOIN t2;
num | name | num | value
-----+------+-----+-------
1 | a | 1 | xxx
1 | a | 3 | yyy
1 | a | 5 | zzz
2 | b | 1 | xxx
2 | b | 3 | yyy
2 | b | 5 | zzz
3 | c | 1 | xxx
3 | c | 3 | yyy
3 | c | 5 | zzz
(9 rows)
=> SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num;
num | name | num | value
-----+------+-----+-------
1 | a | 1 | xxx
3 | c | 3 | yyy
(2 rows)
=> SELECT * FROM t1 INNER JOIN t2 USING (num);
num | name | value
-----+------+-------
1 | a | xxx
3 | c | yyy
(2 rows)
=> SELECT * FROM t1 NATURAL INNER JOIN t2;
num | name | value
-----+------+-------
1 | a | xxx
3 | c | yyy
(2 rows)
=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num;
num | name | num | value
-----+------+-----+-------
1 | a | 1 | xxx
2 | b | |
3 | c | 3 | yyy
(3 rows)
=> SELECT * FROM t1 LEFT JOIN t2 USING (num);
num | name | value
-----+------+-------
1 | a | xxx
2 | b |
3 | c | yyy
(3 rows)
=> SELECT * FROM t1 RIGHT JOIN t2 ON t1.num = t2.num;
num | name | num | value
-----+------+-----+-------
1 | a | 1 | xxx
3 | c | 3 | yyy
| | 5 | zzz
(3 rows)
=> SELECT * FROM t1 FULL JOIN t2 ON t1.num = t2.num;
num | name | num | value
-----+------+-----+-------
1 | a | 1 | xxx
2 | b | |
3 | c | 3 | yyy
| | 5 | zzz
(4 rows)用 ON 声明的连接条件也可以包含与连接不直接相关的条件。这种功能可能对某些查询很有用，但是需要我们仔细想清楚。比如：
=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num AND t2.value = 'xxx';
num | name | num | value
-----+------+-----+-------
1 | a | 1 | xxx
2 | b | |
3 | c | |
(3 rows)