C#中一些关键字和罕见类

1、@

在处理字符串时，那些个字符串转义字符我们可以使用这个，那@就是为解决这个而诞生的，直接让字符串原样输出有木有？什么sql字符串了，还有路径啥了的，统统搞定

string sql = @"select * from student where id = '001'";
//实际sql输出select * from student where id = '001'
string path = @"C:\MDocu\student.xml";
//实际path输出C:\MDocu\student.xml，注意这里可不是\\哦

如果字符串里边包含双引号时，要稍微处理一下，那就是在双引号的外边再加双引号即可

string s = @"He said,""yes""";
//s输出He said,"yes"

2、is

目的就一个，检查变量是不是给定的类型，是就返回true，不是就false

int i = ;
bool check = i is int;//check = true

3、as

用于在兼容的引用类型之间执行转换。例如

tring s = someObject as string;
if (s != null)
{
    // someObject is a string.
}

as运算符类似于强制转换操作；但是，如果转换不可行，as会返回null而不是引发异常。更严格地说，这种形式的表达式 等效于

expression is type ? (type)expression : (type) null

as 运算符只执行引用转换和装箱转换。as运算符无法执行其他转换，如用户定义的转换，这类转换应使用cast表达式来执行。

B[] bb = new B[] { new B(), new B(), new B(), new B() };
string[] query = bb.Cast<string>().ToArray();

IEnumerable<Employee> query = listBox.Items.Cast<Employee>();
int count = listBox.Items.Cast<Employee>().Count();
bool b = listBox.Items.Cast<Employee>().Any(e => e.FirstName == "Bob");

4、sizeof

用于获取非托管类型的大小（以字节为单位）

int intSize = sizeof（int）;//intSize = 4

5、typeof

返回Type对象，该对象保存类型信息

Type myType = typeof（int）;
console.writeline("Type:{}",myType);
//输出Type：System.Int32

6、checked

检测操作的溢出情况

short a =,b=;
short myShort = checked((short)(a+b));
//error

7、unchecked

忽略溢出关键字，接受结果而不管溢出情况，默认是不检查溢出的

short a =,b=;
short myShort = unchecked((short)(a+b));
//忽略error

8、Guid

全局唯一标示符，是一个128位的字符串，在任何要以唯一方式来表示某个事物时就可以用该标示符。

uniquecode = Guid.NewGuid ();
console.WriteLine("myCode:{}",uniquecode.ToString());
//输出：myCode：cabfe0ba-fa72-4c5c-969f-e76821949ff1

9、?

可空类型

public class student
{
     private string name;
     private int? age=null;
     public string Name
     {
         get { return name; }
         set { name = value; }
     }
     public int? Age
     {
         get { return age; }
         set { age = value; }
     }
}
student s = new student();
s.Age = null;//是允许的

10、??

null接合操作符，也可以说是双问号操作符，意思是取所赋值??左边的，如果左边为null，取所赋值??右边的

DateTime? createDate = null;
DateTime? defaultDate= null;
DateTime secondDate = DateTime.Now;
createDate = createDate ??defaultDate??secondDate;

// 如果createDate 为空，则对defaultDate求值，如果defaultDate不为空，则将defaultDate赋值给createDate 。否则继续计算secondDate，是不是null都赋值给createDate ，因为是最后一个表达式

11、::

这个东东比较少见，你可以叫它双冒号运算符，这个在给命名空间起别名的时候能用到

在此示例中，命名空间 System 用于包括类 TestClass，因此必须使用 global::System.Console 来引用 System.Console 类，该类被 System 命名空间隐藏。 而且，别名 colAlias 用于引用命名空间 System.Collections；因此，将使用此别名而不是命名空间来创建 System.Collections.Hashtable 的实例。

using colAlias = System.Collections;
namespace System
{
    class TestClass
    {
        static void Main()
        {
            // Searching the alias:
            colAlias::Hashtable test = new colAlias::Hashtable();

            // Add items to the table.
            test.Add("A", "");
            test.Add("B", "");
            test.Add("C", "");

            foreach (string name in test.Keys)
            {
                // Searching the global namespace:
                global::System.Console.WriteLine(name + " " + test[name]);
            }
        }
    }
}

12、=>

Lambda表达式的运算符是=>，运算符左边列举出了需要的参数，右边定义了赋予Lambda变量的方法的实现代码

List<User> user = new List<User>{ new User{Id=,Name="LiSi",Age=},  new User{Id=,Name="ZhangSan",Age=} };
//获取特定人时所用的过滤条件，p参数属于User类型
var results = user.Where(p => p.Name == "LiSi").ToList();
//用User对象的Age值计算平均年龄
var average = user.Average(p => p.Age);

Lambda表达式是c#3.0的新内容，例如，我定义一个委托：

delegate int Method(int a,int b);
//再定义一个方法：
int Add(int a,int b)
{
  return a+b;
}
//我可能需要这样通过委托调用方法：
Method m+=Add;
Console.WriteLine(m(,));
//但如果用Lambda表达式：
Method m+=(a,b)=>a+b;
Console.WriteLine(m(,));
//可以省去方法的定义；实际上，Lambda表达式只是简化了匿名方法的语法而已。

附c#2.0的匿名方法语法：

Method m+=delegate(inta,int b){return a+b;};
Console.WriteLine(m(,));

13、ref

ref 关键字使参数按引用传递，也就是说它能够让你直接对原数进行操作，而不是对那个原数的Copy进行操作。若要使用 ref参数，则方法定义和调用方法都必须显式使用 ref 关键字，而且传递到 ref 参数的参数必须最先初始化，例如：

class RefExample
{
static void Method(ref int i)
{
i = ;
}
static void Main()
{
int val = ;
Method(ref val); // val is now 44
}
}

14、out

out是传出参数，与ref有点像，但偏重于输出，而且不用初始化，通过执行使用out参数的方法逻辑，out后面的数接受并返回这个值，比如你写一个方法返回dataset，同时你还想返回页数，怎么办？方法一般不能返回多个值啊，这个时候out就可以返回多个值，是不是很爽，你需要多个值得时候别忘了out这厮啊

public DataSet getData(out int count)
{
    dataset ds=bll.getdata(,);
    //获取第11条到第20条数据,但是不可能只显示共有10条记录吧,那么我们就可以用out了
    int rcount=bll.GetCount();//比方说这个是取总记录数的
    count=rcount;
    return ds;
} 

//显示的时候
public void showdata()
{
    int count=;
    gridview1.datasource=getData(out count);
    gridview1.databind();
   label1.text="共有"+count.tostring()+"条记录";
} 

15、params

params主要的用处是在给函数传参数的时候用，就是当函数的参数不固定的时候。在方法声明中的 params 关键字之后不允许任何其他参数，并且在方法声明中只允许一个 params 关键字！

注意事项：

（1）若形参表中含一个参数数组，则该参数数组必须位于形参列表的最后；

（2）参数数组必须是一维数组；

（3）不允许将params修饰符与ref和out修饰符组合起来使用；

（4）与参数数组对应的实参可以是同一类型的数组名，也可以是任意多个与该数组的元素属于同一类型的变量；

（5）若实参是数组则按引用传递，若实参是变量或表达式则按值传递。

（6）用法：可变的方法参数，也称数组型参数，适合于方法的参数个数不知的情况，用于传递大量的数组集合参数；当使用数组参数时，可通过使用params关键字在形参表中指定多种方法参数，并在方法的参数表中指定一个数组，形式为：方法修饰符　返回类型　方法名（params　类型［］　变量名）

如带有参数的SQL 语句，不同的表的字段数量也不同，当你更新修改的时候就可以用params

例如：

params using System;
public class MyClass;
{
    public static void UseParams(params int[] list)
   {
       for (int i =  ; i < list.Length; i++)
      { Console.WriteLine(list[i]); }
      Console.WriteLine();
   }
   public static void UseParams2(params object[] list)
   {
       for (int i =  ; i < list.Length; i++)
      { Console.WriteLine(list[i]); }
      Console.WriteLine();
   }
   static void Main()
   {
　　　　UseParams(, , );
　　　　UseParams2(, 'a', "test");
　　　　 // An array of objects can also be passed, as long as
　　　　// the array type matches the method being called.
　　　　int[] myarray = new int[] {,,};
　　　　UseParams(myarray);
　　}
}

16、using

这个再也熟悉不过了，常见三种用法

（1）引用命名空间，例如：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

（2）创建别名（类或者命名空间的别名）

using MyControle=System.Console;
class UsingEx
{
   public static void Main()
   {
    MyConsole.WriteLine("应用了类的别名");
    }
}

（3）自动清理资源

using (SqlConnection conn = new SqlConnection(_connstr))
//这样你就不用手工清理连接资源了

17、this

用法一  this代表当前类的实例对象

namespace Demo
{
    public class Test
    {
        private string scope = "全局变量";
        public string getResult()
        {
            string scope = "局部变量";
　　　　　　　// this代表Test的实例对象
　　　　　　　// 所以this.scope对应的是全局变量
　　　　　　  // scope对应的是getResult方法内的局部变量
            return this.scope + "-" + scope;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Test test = new Test();
                Console.WriteLine(test.getResult());
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            finally
            {
                Console.ReadLine();
            }

        }
    }
}

用法二  用this串联构造函数

namespace Demo
{
    public class Test
    {
        public Test()
        {
            Console.WriteLine("无参构造函数");
        }
        // this()对应无参构造方法Test()
　　　　 // 先执行Test()，后执行Test(string text)
        public Test(string text) : this()
        {
            Console.WriteLine(text);
            Console.WriteLine("有参构造函数");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Test test = new Test("张三");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            finally
            {
                Console.ReadLine();
            }
        }
    }
}

用法三 为原始类型扩展方法

特点：1、静态类 2、静态方法 3、第一个参数前加this

例如：public static List<T> ToList<T>(this string Json)，就是为this对应的string类型扩展类ToList()方法，调用方式 strJson.ToList();

详细扩展

namespace Demo
{
    public static class Extends
    {
　　　　 // string类型扩展ToJson方法
        public static object ToJson(this string Json)
        {
            return Json == null ? null : JsonConvert.DeserializeObject(Json);
        }
        // object类型扩展ToJson方法
        public static string ToJson(this object obj)
        {
            var timeConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm:ss" };
            return JsonConvert.SerializeObject(obj, timeConverter);
        }
        public static string ToJson(this object obj, string datetimeformats)
        {
            var timeConverter = new IsoDateTimeConverter { DateTimeFormat = datetimeformats };
            return JsonConvert.SerializeObject(obj, timeConverter);
        }
        public static T ToObject<T>(this string Json)
        {
            return Json == null ? default(T) : JsonConvert.DeserializeObject<T>(Json);
        }
        public static List<T> ToList<T>(this string Json)
        {
            return Json == null ? null : JsonConvert.DeserializeObject<List<T>>(Json);
        }
        public static DataTable ToTable(this string Json)
        {
            return Json == null ? null : JsonConvert.DeserializeObject<DataTable>(Json);
        }
        public static JObject ToJObject(this string Json)
        {
            return Json == null ? JObject.Parse("{}") : JObject.Parse(Json.Replace("&nbsp;", ""));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                List<User> users = new List<User>{
                    new User{ID="",Code="zs",Name="张三"},
                    new User{ID="",Code="ls",Name="李四"}
                };

                // list转化json字符串
                string json = users.ToJson();
　　　　　　　　　 // string转化List
                users = json.ToList<User>();

                // string转化DataTable
                DataTable dt = json.ToTable();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
            finally
            {
                Console.ReadLine();
            }
        }
    }

    public class User
    {
        public string ID { get; set; }
        public string Code { get; set; }
        public string Name { get; set; }
    }
}

用法四  索引器（基于索引器封装EPList，用于优化大数据下频发的Linq查询引发的程序性能问题，通过索引从list集合中查询数据）

18、partial  局部类型

局部类型适用于以下情况：

(1) 类型特别大，不宜放在一个文件中实现。
(2) 一个类型中的一部分代码为自动化工具生成的代码，不宜与我们自己编写的代码混合在一起。
(3) 需要多人合作编写一个类。

局部类型是一个纯语言层的编译处理，不影响任何执行机制——事实上C#编译器在编译的时候仍会将各个部分的局部类型合并成一个完整的类。

public partial class Program
   {
     static void Main(string[] args)
     {
     }
   }

2. 局部类型的限制

(1) 局部类型只适用于类、接口、结构，不支持委托和枚举。
(2) 同一个类型的各个部分必须都有修饰符 partial。
(3) 使用局部类型时，一个类型的各个部分必须位于相同的命名空间中。
(4) 一个类型的各个部分必须被同时编译。

3. 局部类型的注意点

(1) 关键字partial是一个上下文关键字，只有和 class、struct、interface 放在一起时才有关键字的含义。因此partial的引入不会影响现有代码中名称为partial的变量。
(2) 局部类型的各个部分一般是分开放在几个不同的.cs文件中，但C#编译器允许我们将他们放在同一文件中。

4. 局部类型的应用特性

在局部类型上的特性具有“累加”效应。

[Attribute1, Attribute2("Hello")]
partial class Class1{}

[Attribute3, Attribute2("Exit")]
partial class Class1{}

//相当于
[Attribute1, Attribute2("Hello"), Attribute3, Attribute2("Exit")]
class Class1 {}

//注：Attribute2属性允许在类上多次使用。

5. 局部类型上的修饰符

(1) 一个类型的各个部分上的访问修饰符必须维持一致性。
(2) 如果一个部分类使用了abstract修饰符，那么整个类都将被视为抽象类。
(3) 如果一个部分类使用了 sealed 修饰符，那么整个类都将被视为密封类。
(4) 一个类的各个部分不能使用相互矛盾的修饰符，比如不能在一个部分上使用abstract，又在另一个部分上使用sealed。
(5)如果一个部分类使用了 static修饰符，那么整个类都将被视为静态类。

6. 局部类型的基类和接口

(1) 一个类型的各个部分上指定的基类必须一致。某个部分可以不指定基类，但如果指定，则必须相同。
(2) 局部类型上的接口具有“累加”效应。

partial class Class2: Iinterface1, Iinterface2 {}
partial class Class2: Iinterface3 {}
partial class Class2: Iinterface2 {}

//相当于
class Class2: Iinterface1, Iinterface2, Iinterface3 {}

16、using

base其实最大的使用地方在面相对性开发的多态性上，base可以完成创建派生类实例时调用其基类构造函数或者调用基类上已被其他方法重写的方法。
例如：

2.1关于base调用基类构造函数

public class A
{
        public A()
        {
                Console.WriteLine("Build A");
        }
}
public class B:A
{
        public B():base()
        {
                Console.WriteLine("Build B");
        }
        static void Main()
        {
                B b = new B();
                Console.ReadLine();
        }
}

创建一个B的实例对象，获得结果是同时打印Build A和Build B．

2.2关于base在派生类中调用基类的方法。

public class A
{
        public virtual void Hello()
        {
                Console.WiriteLine("Hello");
        }
}
public class B : A
{
        public override void Hello()
        {
                base.Hello();//调用基类的方法,显示Hello
                Console.WiriteLine("World");
        }
}

这样如果程序调用B.Hello()获得的效果将会使Hello World.

最后补充下，根据MSDN Library介绍来看这两个关键字都是属于[访问关键字]类型

 

+++++++++++++++++++++++++++++ 无敌分割线 +++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++ 文章二 +++++++++++++++++++++++++++++

 

关于base

base 关键字用于从派生类中访问基类的成员：
调用基类上已被其他方法重写的方法。
指定创建派生类实例时应调用的基类构造函数。
基类访问只能在构造函数、实例方法或实例属性访问器中进行。

示例：
1. 在派生类中调用基类方法。

using System;
public class BaseClass
{
    protected string _className = "BaseClass";
    public virtual void PrintName()
    {
        Console.WriteLine("Class Name: {0}", _className);
    }
}
class DerivedClass : BaseClass
{
    public string _className = "DerivedClass";
    public override void PrintName()
    {
        Console.Write("The BaseClass Name is {0}");
        //调用基类方法
        base.PrintName();
        Console.WriteLine("This DerivedClass is {0}", _className);
    }
}
class TestApp
{
    public static void Main()
    {
        DerivedClass dc = new DerivedClass();
        dc.PrintName();
    }
}

2. 在派生类中调用基类构造函数。

注意：
从静态方法中使用 base 关键字是错误的。
base 主要用于面向对象开发的对态这方面，在示例2中有体现。

 

关于this

this 关键字引用类的当前实例。
以下是 this 的常用用途：
限定被相似的名称隐藏的成员
将对象作为参数传递到其他方法
声明索引器

示例：

// this 关键字
// keywords_this.cs
using System;
class Employee
{
    private string _name;
    private int _age;
    private string[] _arr = new string[];
    public Employee(string name, int age)
    {
        // 使用this限定字段，name与age
        this._name = name;
        this._age = age;
    }
    public string Name
    {
        get { return this._name; }
    }
    public int Age
    {
        get { return this._age; }
    }
    // 打印雇员资料
    public void PrintEmployee()
    {
        // 将Employee对象作为参数传递到DoPrint方法
        Print.DoPrint(this);
    }
    // 声明索引器
    public string this[int param]
    {
        get { return _arr[param]; }
        set { _arr[param] = value; }
    }
}
class Print
{
    public static void DoPrint(Employee e)
    {
        Console.WriteLine("Name: {0}\nAge: {1}", e.Name, e.Age);
    }
}
class TestApp
{
    static void Main()
    {
        Employee E = new Employee("Hunts", );
        E[] = "Scott";
        E[] = "Leigh";
        E[] = "Kiwis";
        E.PrintEmployee();
        for (int i = ; i < ; i++)
        {
            Console.WriteLine("Friends Name: {0}", E[i]);
        }
        Console.ReadLine();
    }
}