精华内容
下载资源
问答
  • C#中using关键字的使用介绍

    千次阅读 2008-07-07 22:00:00
    对于using关键字,可能大家比较熟悉的是引入包的功能如代码:using System;还有一种方法和上面的使用方法较类似,只是我们可以指定一个别名,代码如:using INet = System.Net;最后一种用法则主要用于释放对象占用的...

    对于using关键字,可能大家比较熟悉的是引入包的功能如代码:

    using System;

    还有一种方法和上面的使用方法较类似,只是我们可以指定一个别名,代码如:

    using INet = System.Net;

    最后一种用法则主要用于释放对象占用的资源的,代码如下:

    using (ClassC c = new ClassC())

    {

    c.Print();

    }

    上面代码保证程序在退出using块时会执行对象c的Dispose方法,即使在using块中return退出函数或是抛出异常。

    在这里ClassC必须实现接口IDisposable,不然会报出下面的编译出错代码:

    'UsingTest.ClassA': type used in a using statement must be implicitly convertible to 'System.IDisposable'

    从上面的代码看出,其实using语句试图将对象c隐式的转换成IDisposable接口。

    综上所述,对c对象的using语句块相当于以下的程序块:

    {

    ClassC c = new ClassC();

    try

    {

    c.Print();

    }

    finally

    {

    ((IDisposable)c).Dispose();

    }

    }

    注意这里最外面的大括号也是必须的,因为这对大括号限定了对象c的活动空间,这样上面的程序与使用using语句的程序就完成了完全相同的功能,这里唯一不一样的是在使用using关键字时编译器在编译时会进行一个类型检查,而上面的代码只在运行时执行一个类型检查。

     

    展开全文
  • C#中using关键字的作用及其用法

    千次阅读 2013-10-09 17:09:46
    C#中using关键字的作用及其用法 转自:http://wenku.baidu.com/view/d33471c34028915f804dc215.html using的用途和使用技巧。  using关键字微软MSDN上解释总共有三种用途: 1、引用命名空间。 2、为命名...
    C#中using关键字的作用及其用法
    转自:http://wenku.baidu.com/view/d33471c34028915f804dc215.html

    using的用途和使用技巧。


        using关键字微软MSDN上解释总共有三种用途:
    1、引用命名空间。
    2、为命名空间或类型创建别名。
    3、使用using语句。


        1、引用命名空间,这样就可以直接在程序中引用命名空间的类型而不必指定详细的命名空间。


            这个就不用说了吧,比如大家最常用的:using System.Text;


        2、为命名空间或类型创建别名:


            当同一个cs引用了不同的命名空间,但这些命名控件都包括了一个相同名字的类型的时候,可以使用using关键字来创建别名,这样会使代码更简洁。注意:并不是说两个名字重复,给其中一个用了别名,另外一个就不需要用别名了,如果两个都要使用,则两个都需要用using来定义别名的。


            using System;


            using aClass = NameSpace1.MyClass;


            using bClass = NameSpace2.MyClass;


            ......


            //使用方式


            aClass my1 = new aClass();            


            Console.WriteLine(my1);


            bClass my2 = new bClass();


            Console.WriteLine(my2);


        3、使用using语句,定义一个范围,在范围结束时处理对象。(不过该对象必须实现了IDisposable接口)。其功能和try ,catch,Finally完全相同。


            比如:


            using (SqlConnection cn = new SqlConnection(SqlConnectionString)){......}//数据库连接


            using (SqlDataReader dr = db.GetDataReader(sql)){......}//DataReader


            PS:这里SqlConnection和SqlDataReader对象都默认实现了IDisposable接口,如果是自己写的类,那就要自己手动来实现IDisposable接口。比如:


            using (Employee emp = new Employee(userCode))


            {


                ......


            }


            Emlpoyee.cs类:


             public class Employee:IDisposable


    {


           实现IDisposable接口#region 实现IDisposable接口


            /** <summary>


           /// 通过实现IDisposable接口释放资源


            /// </summary>


            public void Dispose()


            {


                Dispose(true);


                GC.SuppressFinalize(this);


            }


            /** <summary>


            /// 释放资源实现


             /// </summary>


            /// <param name="disposing"></param>


            protected virtual void Dispose(bool disposing)


            {


                if (!m_disposed)


                {


                    if (disposing)


                    {


                        // Release managed resources


                        if(db!=null)


                            this.db.Dispose();


                        if(dt!=null)


                            this.dt.Dispose();


                        this._CurrentPosition = null;


                        this._Department = null;


                        this._EmployeeCode = null;


                       


                    }


                    // Release unmanaged resources


                    m_disposed = true;


                }


            }


            /** <summary>


            /// 析构函数


             /// </summary>


            ~Employee()


            {


                Dispose(false);


            }


            private bool m_disposed;


            #endregion


    }       


            使用using语句需要注意的几点:


            3.1、对象必须实现IDisposeable接口,这个已经说过,如果没有实现编译器会报错误。


                如:  


                using( string strMsg = "My Test" )


                {           


                    Debug.WriteLine( strMsg );//Can't be compiled


                }


            3.2、第二个using对象检查是静态类型检查,并不支持运行时类型检查,因此如下形式也会出现编译错误。    


             SqlConnection sqlConn = new SqlConnection( yourConnectionString );


             object objConn = sqlConn;


             using ( objConn )


             {


                Debug.WriteLine( objConn.ToString() );//Can't be compiled


             }


    不过对于后者,可以通过“as”来进行类型转换方式来改进。


            SqlConnection sqlConn = new SqlConnection( yourConnectionString );


            object objConn = sqlConn;


            using ( objConn as IDisposable )


           {


             Debug.WriteLine( objConn.ToString() );


           }


            3.3、当同时需要释放多个资源时候,并且对象类型不同,可以这样写:


            using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) )


            using( SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn ) )


            {


                sqlConn.Open();//Open connection


               /Operate DB here using "sqlConn"  


                sqlConn.Close();//Close connection


            }


            如果对象类型相同,可以写到一起:


            using (Font MyFont = new Font("Arial", 10.0f), MyFont2 = new Font("Arial", 10.0f))


           {


                // use MyFont and MyFont2


            }   // compiler will call Dispose on MyFont and MyFont2


            3.4、using关键字只是针对C#语句,对于VB等其他语言还没有对应的功能。


            关于.Net资源释放问题,也就是对于非内存的资源,最好使用IDisposable接口提供的Dispose来释放。
           很明显,Dispose方法是一个外部方法,系统并不会帮你调用。为了尽早释放对象所占用的资源,所以需要保证Dispose方法能尽早被执行。那么在.Net中提供了一个比较简便的方法,就是对于实现了IDisposable接口的类型对象提供了using语句。




    就操作一个数据库这个例子来说,使用using语句可以如下:




        using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) )


        {


            sqlConn.Open(); //Open connection   


            //Operate DB here using "sqlConn"


            sqlConn.Close(); //Close connection


        }




    但是有时候当多个对象需要释放的候,例如:




        SqlConnection sqlConn = new SqlConnection( yourConnectionString );


        SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn );


        using(sqlConn as IDisposable)


        using(sqlComm as IDisposable)


        {


            sqlConn.Open(); //Open connection   


            sqlComm.ExecuteNonQuery(); //Operate DB here


        }




           这时候要特别注意,需要确保在发生异常的情况下,所有对象都能正常释放。显然,这段程序块,当构造“sqlComm”对象发生异常,会造成 “sqlConn”对象无法及时被释放。虽说构造函数内部很少发生异常,或者说编写程序的时候要尽量避免从构造函数内向外散发异常。不过这里所说的意思是,要尽量把需要释放的对象放到using或者try-catch程序块,并作局部的异常处理,避免异常造成有些对象没有被释放。那么改进的方法,例如可以如下。


        using( SqlConnection sqlConn = new SqlConnection( yourConnectionString ) )


        using( SqlCommand sqlComm = new SqlCommand( yourQueryString, sqlConn ) )


        {


            try


            {


                sqlConn.Open(); //Open connection


                sqlComm.ExecuteNonQuery(); //Operate DB here


            }


            catch( SqlException err )


            {


                MessageBox.Show( err.Message );


            }


            catch( Exception err )


            {


                MessageBox.Show( err.Message );


            }


        }




    (如上,即使在构造“sqlComm”出现异常,也会释放“sqlConn”对象。同时在这里多谢 lmtz 网友对文章提出的异议,从而使我重新审查此文,并进行修正。)




    但是对于using程序块来说,它有两个限制。


           第一个就是using所对应的对象必须继承IDisposable,如果此对象没有继承IDisposable接口的话,系统会提示编译错误。


    例如:


        using( string strMsg = "My Test" )


            Debug.WriteLine( strMsg ); //Can't be compiled




    第二个using对象检查是静态类型检查,并不支持运行时类型检查,因此如下形式也会出现编译错误。


        SqlConnection sqlConn = new SqlConnection( yourConnectionString );


        object objConn = sqlConn;


        using ( objConn )


        {


            Debug.WriteLine( objConn.ToString() ); //Can't be compiled


        }




    不过对于后者,可以通过“as”来进行类型转换方式来改进。


        SqlConnection sqlConn = new SqlConnection( yourConnectionString );


        object objConn = sqlConn;


        using ( objConn as IDisposable )


        {


            Debug.WriteLine( objConn.ToString() );


        }




           对于Dispose函数的调用来说,使用using程序块来完成只是最常用的方法,除此外,还可以用try-finally来完成,例如:


        SqlConnection sqlConn = new SqlConnection( yourConnectionString );


        try


        {


            sqlConn.Open();       


            //Operate DB here using "sqlConn"


        }


        finally


        {


            if( sqlConn != null )


                sqlConn.Dispose();


        }




           为了及早释放对象所占用的非托管资源,因此要保证Dispose方法能在使用完对象后被调用,.Net提供了using程序块和try-finally程序块两个方法,两者并没有太大的区别,可能使用using能使程序看得比较简明,但是为了防止异常,需要在using中加入try-catch,这样反而不如try-finally看得舒服,不过这也只是我个人的看法。总的来说,只要把方法合理整合到应用程序当中才是最重要的。






    public   DataSet   GetRoleList()  
      {  
                using(DataSet   roles=RunProcedure("sp_Accounts_GetAllRoles",new    
                                                                                                                IDataParameter[]   {},"Roles"))  
       
            {  
              return   roles;  
            }  
      }  
      using   的作用我记得是这样的。using后面的括号表示这里面有重要的资源产生,  
                                                          using下面的   {}表示在这段代码运行完后释放掉那个   
    展开全文
  • c#using关键字的作用

    2019-06-10 13:28:48
    using关键字的三种作用: 1. 引用命名空间; 2. 为命名空间或者类型创建别名; 3. 使用using语句。 (1)引用命名空间 类似于c和c++的#include<>, python的import,都是在程序引入命名空间的类型,而...

    using关键字的三种作用:

    1. 引用命名空间;

    2. 为命名空间或者类型创建别名;

    3. 使用using语句。

    (1)引用命名空间

            类似于c和c++的#include<>, python的import,都是在程序中引入命名空间的类型,而不必制定类型详细的命名空间。

            使用方法为:using + 命名空间名称;

    (2)为命名空间或者类型创建别名

            使用方法为:using + 别名 = 包括详细命名空间信息的具体的类型;s 

    using System;    //引用命名空间
    using aClass = test1.MyClass; //创建别名
    using bClass = test2.MyClass; //创建别名
    
    namespace test1 
    {
        public class MyClass 
    
        {
    
            public override string ToString() 
            {
                return "You are in test1.MyClass";
            }
        }
    }
     
    namespace test2 
    {
        class MyClass 
        {
            public override string ToString() 
            {
                return "You are in test2.MyClass";
            }
        }
    } 

    (3)使用using语句

            使用方法:

    //首先test和test2类必须实现IDisposable接口
    
    //using关键字的使用方法
    using (test t = new test())
    {
        ........
    }
    
    //多个using关键字的使用方法
    using (new test()) using (new test2())
    {
        .........
    }

        using关键字要求小括号内的对象必须实现IDisposable接口或者其基类实现了IDisposable接口,如果没有实现此接口,那么在编译时就会出现错误。在using关键字下面的代码块执行完毕后,会自动将test对象隐式转换为IDisposable接口类型,并调用接口方法dispose释放对象资源。

        using的实质: 在程序编译阶段,编译器会自动将using语句生成为try-finally语句,并在finally块中调用对象的Dispose方法,来清理资源。所以,using语句等效于try-finally语句。

    展开全文
  • 读者可以尝试预言一下这段代码输出: #include <iostream> using namespace std; class Complex { private: double real; double imag;... // 默认构造器无explicity关键字 ... C...

    读者可以尝试预言一下这段代码的输出:

    #include <iostream>
    using namespace std;
    class Complex
    {
        private:
            double real;
            double imag;
        public:
            // 默认构造器无explicity关键字
            Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
          
            // 比较操作符==,接受一个Complex的参数
            bool operator == (Complex rhs) {
               return (real == rhs.real && imag == rhs.imag)? true : false;
            }
    };
    int main()
    {
        // a Complex object
        Complex com1(3.0, 0.0);
        if (com1 == 3.0)//将Complex与double类型比较
           cout << "Same";
        else
           cout << "Not Same";
         return 0;
    } 

    输出:

    Same

    上面Complex的==操作符接受的是一个Complex参数。当程序运行到com1 == 3.0时,程序会自动调用Complex的构造器并且传入参数3.0,然后得到一个新的Complex对象,再将这个新对象传给com1的==操作符。所以程序表面上看起来是Complex和double在进行比较,但实际上程序做了隐式的转化(将double转成了Complex),依然是两个Complex在比较。

     

    在C++中如果一个类有能够被单参数所调用的构造器,那么这个构造器就被称为转化构造器——转化构造器允许从单参数到类构造的转化。C++中能够接受单参数的构造器默认都是转化构造器。

     

    那么如何避免这种隐式的转化呢?可以使用explicity关键字。使用了explicity关键字的构造器就不允许上面的隐式转化,要转化的话,只能强制转化。

    我们修改后的程序如下:

    #include <iostream>
    using namespace std;
    class Complex
    {
        private:
            double real;
            double imag;
        public:
            // 在构造器上加入explicity关键字
            explicit Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
          
            // 比较操作符==,接受一个Complex的参数
            bool operator== (Complex rhs) {
               return (real == rhs.real && imag == rhs.imag)? true : false;
            }
    };
    int main()
    {
        // a Complex object
        Complex com1(3.0, 0.0);
    
        //if (com1 == 3.0)//编译错误
        if (com1 == (Complex)3.0) //Complex的构造器使用了explicity关键字,就只能进行强制转化了。
           cout << "Same";
        else
           cout << "Not Same";
         return 0;
    } 

    在案例中,我们可以将double转化为Complex,但是必需强制转化。

     

    下面是一个赋值的案例(Complex的构造器上无 explicity 关键字):

        Complex com1(3.0, 0.0);
        Complex com2 = 3.0;//将一个3.0赋值给Complex对象

    第一个语句是传入参数构造器Complex对象,这没有什么可讨论的。第二个语句将3.0赋值给了Complex对象,其实原理和上面是一样的,首先传入参数3.0到Complex的构造器构造一个临时Complex对象,然后再将临时Complex对象传给com2对象。

    如果给Complex构造器加上explicity关键字,那么就变成如下的形式了:

    Complex com2 = (Complex)3.0;

     


    原文链接:

    https://www.geeksforgeeks.org/g-fact-93/


    转载于:https://www.cnblogs.com/HDK2016/p/11013922.html

    展开全文
  • C语言中的typedef关键字允许您定义新类型。 Starting from the built-in C types, we can create our own types, using this syntax: 从内置的C类型开始 ,我们可以使用以下语法创建自己类型:...
  • 不知道大家有没有奇怪过,在开始始学习C sharp的时候(我用的Visual Studio编译器),然乎偶无意中使用了Sinle关键字,我发现这个关键字的颜色竟然是绿色的,通常C sharp关键字是蓝色的,所以float与single,double...
  • C++class关键字

    2015-03-10 08:54:23
    在C++ 语言class是定义类的关键字,C++也可以使用struct定义类。两者区别是,用class定义类,如果数据成员或成员函数没有说明则默认为private(私有),而用struct定义,默认为public(公共)。 示例 ...
  • <p>However the array-binder loop produces different results than using other methods that should do the exact same thing. <p>My table contains 1 column and 3 rows : "a b c", "b c", "1 2 3". <pre>...
  • auto关键字

    2021-01-31 17:07:12
    在早期C/C++auto含义是:使用auto修饰变量,是具有自动存储器局部变量 在C++11,auto具有全新含义:auto不再是一个存储类型指示符,而是作为一个新类型指示符来指示编译器,auto声明变量必须由...
  • static关键字

    2012-08-12 21:36:41
    C/C++中的static有两种用法:面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类问题。 A.面向过程程序设计中的static关键字 1)静态全局变量 在全局变量前,...
  • 使用extern修饰非static全局变量和函数; 修饰变量 #include &lt;iostream&gt; #include&lt;string&gt; using namespace std; void printInfo(); int main(int argc, char** argv) { //...
  • const关键字与指针

    2018-07-30 22:42:18
    const是C/C++定义常量的关键字,有利提高代码鲁棒性和可读性。const经常与指针一起使用,有指针指向内容为常量和指针本身为常量两种,容易引起混淆。 指针指向内容不变 #include &lt;iostream&...
  • C# using三种使用方式

    2017-10-03 20:22:49
    本文转自:...using + 命名空间名字,这样可以在程序直接用命令空间中的类型,而不必指定类型详细命名空间,类似于Javaimport,这个功能也是最常用,几乎每个c
  • C++进阶(三)static 关键字在作用域上,限定其作用范围在内存方面,存储在静态存储区类中的静态成员函数和成员变量 在作用域上,限定其作用范围   对于全局变量和函数来说,使用 static 修饰,使得其仅在当前文件...
  • 值类型 引用类型 ...使用了Ref和Out效果就几乎和C中使用了指针变量一样。它能够让你直接对原数进行操作,而不是对那个原数Copy进行操作。举个小例子: using System;namespace ConsoleApplication4{
  • auto自动类型推断,用于从初始化表达式推断出变量数据类型。通过auto自动类型推断,可以大大简化我们编程工作。下面是一些使用auto例子。 #include <vector> #include <map> using ...
  • C/C++,变量、函数和类都是大量存在的,这些变量、函数和类的名称都将存在于全局作用域,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的...
  • C#using”小提示

    2010-04-09 13:20:00
    原文地址:http://www.dingos.cn/index.php?topic=2008.0using关键字可以用于创建别名,因此他更容易定义类或命名空间别名标识。例如,我们使用System命名空间中的Console类WriteLine方法将信息输出到控制台。...
  • C++typedef和using

    2020-03-10 15:22:10
    typedef是C/C++语言保留的关键字,用来定义一种数据类型别名。 ypedef定义类型作用域只在该语句作用域之内 typedef经常使用的场景包括以下几种: 指定一个简单别名,避免了书写过长类型名称 实现...
  • 委托与C++、C中的函数指针类似,差别不大。 一、 委托声明需要使用delegate关键字,与函数声明非常类似,委托声明指定了一个返回类型和一个参数列表。 在定义了委托类型参数之后就可以使用这个变量调用...
  • using强制资源清理

    2012-10-26 11:38:45
    using强制资源清理 用途:清理非托管资源,不受GC控制的资源。Using结束后会隐式的调用...但是当对象使用using关键字的时候,必须实现IDisposable接口。其实using的使用和try-catch-finaly,在finaly代码域调
  •      在C/C++98,为一个变量或是函数定义别名,首先想到是typedef关键字,它并非定义了一种新类型,仅仅是为其定义了一个别名而已。经常在结构体、共用体、联合体中使用typedef,比如: typedef struct A{...
  • 31.C#中使用internal修饰符修饰类成员对于同一包中应用程序或库是透明,而在包.net之外是... 32.C#中使用名字空间时using后没有namespace关键字,而在C++需要使用using namespace 33.C#类静态(static)
  • static 及const在c/c++是非常重要的两个关键字,在函数及参数中都有广泛的使用。 2.【代码举例】 ps:请直接看代码是1 、2、3、4的说明即可。 #include <iostream> using namespace std; class tTest;...
  • using C# 参考 using关键字有两个主要用途 1作为指令用于为命名空间创建别名或导入其他命名空间定义的类型 using指令有两个用途允许在命名空间使用类型这样就不必在该命名空间 限定某个类型的使用为命名空间或...
  • 试卷总分:20 得分:201.PHP如果要实现网站常见翻页功能,mysql中的哪个子句是必不...A.usingB.left joinC.right joinD.inner join答案:C3.mysql 中的 group by 语句功能是A.模糊查询B.排序C.批量导入D.分组答案:D4...
  • c# 静态变量与非静态变量Inside a function, you can initialize a static ... 在函数内部,可以使用static关键字初始化静态变量 。 I said “inside a function”, because global variables are static by defaul...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 184
精华内容 73
热门标签
关键字:

c中using关键字的使用