2013/08/24 C# WPF 学习笔记

变量

C#语言定义了7中不同类别的变量：

静态变量、实例变量、数组元素、值参数、引用参数、输出参数、局部变量。

[ref参数]

变量在可以作为ref参数在函数成员调用中传递之前，必须已明确赋值的。

在函数成员内部，ref参数被视为初始已赋值的。

[out参数]

变量在可以作为输出参数在函数成员调用中传递之前不一定要明确赋值。

在函数成员内部，out参数被视为初始未赋值的。

在函数成员的每个输出参数在该函数成员正常返回前必须是已明确赋值的。

一旦变量被声明之后，该变量可能是初始已赋值的(具有有初始值)，也可能是初始未赋值的(不具有初始值)。

以下7类中的变量属于初始已赋值的变量。

·静态变量

·类实例的实例变量

·初始已赋值结构变量的实例变量

·数组元素

·值参数

·引用参数

·在catch子句或foreach语句中声明的变量

以下3类中的变量属于初始未赋值的变量

·初始未赋值结构变量的实例变量

·输出参数

·局部变量，在catch子句或foreach语句中声明的那些除外

隐式转换是指不需要添加强制转换的类型的转换。

常用的隐式转换包括以下几种：

·标识转换：在同一类型内进行转换，它能够使已具有所需类型的实体可被认为是可转换的。

·隐式数值转换：如从int类型转换为long类型等。

·隐式枚举转换：将数值转换为枚举类型。

·隐式引用转换：如引用类型转换为object类型等。

·装箱转换：如值类型转换为object类型等。

·隐式常量表达式转换：如将int类型转换为uint类型等。

用户定义隐式转换，包括以下3个步骤

1）一个标准的隐式转换

2）执行用户定义的隐式转换运算符

3）另一个标准的隐式转换

显式转换是指需要添加强制转换的类型的转换。

常用的显式转换包括以下几种：

·显式数值转换：如long类型转换为int类型等。

·显式枚举转换：如int类型转换为枚举类型等。

·显式引用转换：如object类型转换为引用类型等。

·显式接口转换：如object类型转换为接口类型等。

·拆箱转换：如object类型转换为值类型等。

用户定义显式转换，包括以下3个步骤。

1）一个标准的显式转换

2）执行用户定义的隐式或显式转换运算符

3）另一个标准的显式转换

as

[在显式转换中，除了添加强制转换的类型方式之外，还可以使用as运算符实现显式转换。]

[与强制转换表达式相比，as运算符从不引发异常。如果指定的转换不可能实施，则运算结果为null。]

[as运算符必须用于引用类型或可以为null的类型。与上一条呼应。]

表达式|运算符

this关键字可以用来引用类的当前实例，还可以用作扩展方法的第一个参数的修饰符。

this关键字攒在以下3中常用用法。

·限定名称相同的成员 在某一个类中，如果某一个成员的名称和其他对象(如参数等)的名称相同，那么可以通过this关键字限定该成员。

public class Test1
{
private int integer;
public Test1(int integer)
{
this.integer = integer;//应用
}
}

·将对象本身作为参数 是指在当前类中调用方法时，将当前对象本身作为方法的参数，并传递到该方法中。

public class Test1
    {
        private int integer;

        public Test1(int integer)
        {
            this.integer = integer;
        }

        public Test1(int integer, out int i)
        {
            this.integer = integ
4000
er;
            i = GetInteger(this);//应用
        }

        public int GetInteger(Test1 t)
        {
            return t.integer + 100;
        }
    }

·声明索引器 索引器是一种带有参数的属性。在声明索引器是，需要使用this关键字。

索引器：其实是一种含有参数的属性，又称为含参属性。它提供索引的方式来访问对象，即与数组的访问方式相同。

class Test2
{
private string[] strList;

public Test2(int count)
{
this.strList = new string[count];
for (int i = 0; i < count; i++)
{
strList[i] = i.ToString();
}
}

public string this[int index]//应用
{
get
{
if (index > -1 && index < strList.Length) return strList[index];
else return string.Empty;
}
set { if (index > -1 && index < strList.Length) strList[index] = value; }
}
}
// 引用时效果为          Test2 t2 = new Test2(5); t2[2] = 1;

base关键字用于从派生类中访问基类的成员，主要存在以下两种用法。

·调用基类上已被其他方法重写的方法。

·指定创建派生实例时应调用的基类构造函数。

[base关键字之后一般跟着“·”标记和一个标识符或一个用方括号括起来的表达式列表。]

[基类访问只能在构造函数、实例方法或实例属性访问器中进行，而且base保留字只能在实例构造函数、实例方法或实例访问器的块中使用。]

class A1
{
private string strA;
public string StrA { get; set; }

public A1(string str)
{
this.strA = str;
}
}

class A2 : A1
{
private string strB;
public string StrB { get; set; }

public A2(string str1, string str2) : base(str1)
{
base.StrA = str1;
this.strB = str2;
}
}

new关键字

·new运算符 可以用来创建对象和调用构造函数、创建匿名类型的实例、调用值类型的默认构造函数等。

//========================1
object o = new object();
//========================2
class A
{
public string Name { get; set; }
public string Sex { get; set; }
}

List<A> list = new List<A>();  
for(int i = 0; i < 5; i++)
{
    list.Add(new A() { Name = i.ToString(), Sex = (i % 2).ToString() }
}

·new修饰符 可以用来显示隐藏从基类继承的成员。(继承派生时)

class A
{
public int x;
....
}

class B
{
new public int x;//
...
}
//应用中  B b = new B(); int i = b.x;  (b.x 表示 B类的实例b的x成员)

·new约束 用于在泛型声明中约束可能用作类型参数的参数的类型。new约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。

当泛型类创建类型的新实例时，将此约束应用与类型参数。

[

在使用new运算符创建值类型的实例时，是不会发生动态分配内存。

对于值类型的实例而言，一般不需要分配该实例表示的变量之外的内存(值类型的实例本身会占用一定的内存)

]
通常地，类型形参的类型可以指定为任何类型。然而，一些类型形参需要指定一定种类的类型，如结构、类等。

为了实现该功能，就需要限制类型形参的类型，这种限制被称为约束。

即在定义泛型类时，可以限制在实例化类时用于类型参数的类型种类。

如果尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。

类型形参的约束使用where上下文关键字指定，后跟一个类型形参和一个冒号，再跟着一个逗号分隔的列表。

列表项可以是类类型、接口类型甚至或类型形参(还可以是特殊引用类型、值类型和构造函数约束）。

下面列出了常用的6种类型的约束。

■T：结构， 类型参数必须是值类型，但不能是Nullable类型。

public class A<T> where T : struct
{
...
}

■T：类，类型参数必须是引用类型。

■T：new()，类型参数必须具有无参数的公共构造函数。如果该类型参数存在多个约束，则new()约束必须最后指定。

public class A<T> where T : class,new()//必须为引用类型或者具有无参数的公共构造函数的类型
{
...
}

■T：<基类名>，类型参数必须是指定的基类或者其派生类。

■T：<接口名称>，类型参数必须是指定的接口或实现指定的接口。

■T：U，T的类型参数必须是U提供的参数或派生自为U提供的参数。

public class A<T> where T : class,IComparable,IComparable<T> //必须为引用类型，且需要实现IComparable和IComparable<T>接口
{
...
}

左移，右移

[2008 >> 2] 小数点向左  502

2 = 0010   =>  0000 1000       20 / 2 / 2  = 5

8 = 1000   =>  0010                  8 / 2 / 2 = 2

[2008 << 2]小数点向左   8032

2 = 0010   =>  1000                  2 * 2 * 2  = 8

8 = 1000   =>   0010  0000     8 * 2 * 2 = 32