类型
C#是一种强类型语言，这种语言，必须声明每个要创建对象的类型，类型分为两类：内置类型和用户定义类型；也可以按存储方式分为值类型和引用类型。值类型将自身的值存储在栈中，而引用类型将自身的地址保存在栈中，但实际对象存储在堆中。
内置类型
C#语言提供了现代语言中通常应该提供的所有内置类型，每种类型都对应着.NET CLS（Common language specification)规范所支持的一种底层类型。
内置类型有sbyte,byte,char,bool,short,ushort,int,uint,long,ulong,float,double,decimal。
除此之外，还有两种值类型enum，struct。
内置类型的选择
对于内置类型的选择，考虑到内存的相对廉价，开发人员时间的宝贵，大多数情况整数可以把变量声明为int，小数float就足够了，注意编译器会默认带小数点的数为double,要赋值一个float 字面量，后面还要带上已给字母f：
float someFloat=56f;
内置类型的转换
一个类型的对象可以隐式或显式地转换为另一个类型。隐式转换是自动的进行，编译器自动转换；显示转换 需要我们明确地表示将值进行强制类型转化。
隐式转换是自动进行的，不会损失信息，例如可以隐式从short(2字节)转换为int(4字节)，无论short值为何，转换为int都不会有问题,
但是，如果反方向转换，肯定损失信息，这种情况下，编译器不会执行从int到shor的隐式转换：
这种情况下，就需要强行进行显式转换：
如果int中的值比32767大，将在转换中被截断：
变量与常量
创建变量是通过声明类型并给它取一个名字完成的，可以在声明类型时初始化，也可以在任何时候给变量赋值，改变原值，但在使用前必须初始化或者赋值。
常量就是恒定的变量，必须在声明时就初始化，并且初始化后不允许重新赋值，它有三种形式：字面值，符号常量，以及枚举。
在这个赋值语句中：
x=32;
32就是字面值，32的值永远是32，不能给32赋值其他新的值。
符号常量通常将一个名字指定为一个恒定值。可以使用const关键字和如下语法声明一个符号常量：
const 类型标识符 = 值；
如果取消最后一句的注释，即给符号常量重新赋值，则会抛出错误：
枚举
枚举的技术定义为：
[性质] [修饰符] enum 标识符 [:基类型]
{枚举列表}
其中[]表示可选。
每个枚举都有类型，可以是任何整数类型（integer,shor,long等），但char除外。基类型是枚举的底层类型，如果省略这个选项（经常如此），将默认为int。不能在枚举列表中对每个枚举值进行声明为不同类型的值，枚举列表注意用逗号分隔。要显示一个枚举常量的值，需要将常量转换为它的底层类型，否则不会返回其值；枚举列表中，如果不特别设置，枚举从0开始，每个后续值比前一个加1.
例子：
namespace EnumeratedConstants
{
class EnumeratedConstants
{
enum Tempratures
{
WickedCold=0,
FreezingPoint=32,
LightJacketWeather=60,
SwimmingWeather=72,
BoilingPoint=212,
}
enum SomeValue
{
First,
Second,
Third=20,
Fourth
}
enum test
{
test = 0,
test1 = 20
}
static void Main()
{
Console.WriteLine("Freezing point of water:{0}", (int)Tempratures.FreezingPoint);
Console.WriteLine("Boiling point of water:{0}", (int)Tempratures.BoilingPoint);
Console.WriteLine("enum SomeValue:{0},{1},{2},{3}", (int)SomeValue.First, (int)SomeValue.Second,
(int)SomeValue.Third, (int)SomeValue.Fourth);
Console.WriteLine("test and test1:{0},{1}", (int) test.test, (int) test.test1);
Console.WriteLine("test and test1:{0},{1}", test.test, test.test1); //测试不对枚举常量进行转换。
}
}
}
输出：
可见，不对枚举列表中的常量进行类型转换，显示不出其值。
字符串
string myString;
myString="Hello world!";
标识符
即变量的名字，必须以字母或下划线开头，Microsoft命名规范建议，变量名使用Camel记号法，方法名和其他标识符用Pascal记号法。
无条件分支语句
创建无条件分支有两种方法：一是通过方法调用，另一种是使用无条件分支关键字：goto,break,continue,return,throw。
条件分支语句
条件分支是通过条件语句创建的，条件语句用if,else,switch等关键字标识。条件分支只在条件表达式的值为true时才发生。
if-else
语法：
if (表达式)
语句1
[else
语句2]
[]表示可选。
例：
namespace ConditionStatement
{
class values
{
static void Main()
{
int valueOne = 10;
int valueTwo = 20;
if (valueOne > valueTwo)
{
Console.WriteLine("valueOne:{0} is larger than valueTwo:{1}", valueOne, valueTwo);
}
else
{
Console.WriteLine("valueTwo:{0} is larger than valueOne:{1}", valueTwo, valueOne);
}
valueOne = 30;
if (valueOne > valueTwo)
{
valueTwo = valueOne++; // valueOne自己增加1，将自增前的值赋予valueTwo
Console.WriteLine("
Setting valueTwo to valueOne Value.");
Console.WriteLine("and incrementing ValueOne.
");
Console.WriteLine("ValueOne:{0},ValueTwo:{1}", valueOne, valueTwo);
}
else
{
valueOne = valueTwo;
Console.WriteLine("Setting them equal.");
Console.WriteLine("ValueOne:{0},ValueTwo:{1}");
}
}
}
}
嵌套if
例：
namespace NestedIf
{
class NestedIf
{
static void Main()
{
int temp = 32;
if (temp <= 32)
{
Console.WriteLine("warning! Ice on road");
if (temp == 32)
{
Console.WriteLine("Temp exactly freezing,beware of water");
}
else
{
Console.WriteLine("Temp lower than 32,watch for black ice,temp:{0}", temp);
}
}
}
}
}
注意，C#要求if 语句只能接受布尔值，没有从数值到布尔值的转换，因此对于if (temp=32)将在编译过程中抛出错误。
switch 语句：嵌套if语句的替代方案
嵌套if语句可读性不太好，容易出错，而且难以调试。如果做出复杂选择判断，switch语句是一种强大的替代方案。switch的逻辑是选择一个匹配值，并作出相应操作。
其语法如下：
switch (表达式)
{
case 常量表达式：
语句
跳转语句
[default:语句]
}
例子：
namespace SwitchStatement
{
class SwitchStatement
{
static void Main()
{
const int Democrat = 0;
const int LiberalRepublication = 1;
const int Republican = 2;
const int Libertarian = 3;
const int NewLeft = 4;
const int Progressive = 5;
int myChoice = LiberalRepublication;
switch (myChoice)
{
case Democrat:
Console.WriteLine("You voted Democratic.
");
break;
case LiberalRepublication:
//此case下无语句，因此“向下执行”到下一条语句。如果语句没有内容，只能向下执行。
//Console.WriteLine("没有跳转语句，不能编译")；
case Republican:
Console.WriteLine("You voted republican.
");
break;
case NewLeft:
Console.WriteLine("Newleft is now Progreessive");
goto case Progressive;
case Progressive:
Console.WriteLine("You voted Progressive.
");
break;
case Libertarian:
Console.WriteLine("Libertaians are voting Republican");
goto case Republican;
default:
Console.WriteLine("You did not pick a valid choice.
");
break;
}
Console.WriteLine("Thank you for voting.");
}
}
}
在上例中，switch表达式是一个整数常量，C#还允许根据字符串跳转，因此可以写成:
case "Libertarian";
如果字符串匹配，进入case语句。
namespace SwitchStatement
{
class SwitchStatement
{
static void Main()
{
const string Democrat = "Democrat";
const string LiberalRepublication = "LiberalRepublication";
const string Republican = "Republican";
const string Libertarian = "Libertarian";
const string NewLeft = "NewLeft";
const string Progressive = "Progressive";
string myChoice = "LiberalRepublication";
switch (myChoice)
{
case Democrat:
Console.WriteLine("You voted Democratic.
");
break;
case LiberalRepublication:
//此case下无语句，因此“向下执行”到下一条语句。如果语句没有内容，只能向下执行。
//Console.WriteLine("没有跳转语句，不能编译")；
case Republican:
Console.WriteLine("You voted republican.
");
break;
case NewLeft:
Console.WriteLine("Newleft is now Progreessive");
goto case Progressive;
case Progressive:
Console.WriteLine("You voted Progressive.
");
break;
case Libertarian:
Console.WriteLine("Libertaians are voting Republican");
goto case Republican;
default:
Console.WriteLine("You did not pick a valid choice.
");
break;
}
Console.WriteLine("Thank you for voting.");
}
}
}
循环语句
goto语句
goto语句实际上应该尽量避免使用，它极易造成代码混乱，出于完整性的目的，学习一下goto用方法。
1.加一个行标，所谓行标就是后跟一个冒号的标识符。
2.goto到行标所指的行
namespace UsingGoTo
{
class UsingGoTo
{
static void Main()
{
int i = 0;
repeat: //行标
Console.WriteLine("i:{0}", i);
i++;
if (i < 10)
{
goto repeat; //尽量避免使用goto
}
return;
}
}
}
while语句
while循环的语义是”当条件为真时，进行操作“。
语法：
while (表达式) 语句
表达式的值为布尔值（true/false)，其中的语句也可以是语句块。
namespace WhileLoop
{
class WhileLoop
{
static void Main()
{
int i = 0;
while (i < 10)
{
Console.WriteLine("i:{0}", i);
i++;
}
//return;
}
}
}
do-while 语句
很多时候，while并不能满足需求，在一些场合，需要将”当为真时，运行“转换为”运行，当条件为真时“。即先进行操作，再检查条件。这就需要do-while循环。
do 语句 while 表达式
namespace DoWhile
{
class DoWhile
{
static int Main()
{
int i = 11;
do
{
Console.WriteLine("i:{0}", i);
i++;
}
while (i < 10);
return 0;
}
}
}
namespace DoWhile
{
class DoWhile
{
static int Main()
{
int i = 11;
do
{
Console.WriteLine("i:{0}", i);
i--;
}
while (i >6);
return 0;
}
}
}
for 循环
for （[初始化语句];[测试变量表达式];[变量递增]） 语句
namespace ForLoop
{
class ForLoop
{
static void Main()
{
for (int i = 0; i < 100; i++)
{
Console.Write("{0} ", i);
if (i % 10 == 0)
{
Console.Write(" {0}
", i); //相当于Console.WriteLine(" {0}",i};
}
}
}
}
}
continue 和break
continue是终止当次循环，进入下一循环，而break是终止循环。
操作符
增量和减量操作符
- 计算和重赋值操作符
特殊自赋值操作符，如-=, +=, *=, /=, %=,自增1，和自减1很常见，要自增1，用++，自减1，用--。
前缀和后缀操作符
firstValue=secondValue++;后缀
firstValue=++secondValue;前缀
后缀会先赋值，后自增（可这样帮助记忆：secondValue++，分别是先secondValue,然后++，因此是先赋值，然后自增）；
前缀是先自增，后赋值（可这样帮助记忆，++secondaValue，分别是先++，后secondValuee，即先自增，后赋值 ）
namespace PrefixPostfix
{
class PrefixPostfix
{
static void Main()
{
int valueOne = 10;
int valueTwo;
valueTwo = valueOne++;
Console.WriteLine("After postfix:{0},{1}", valueOne, valueTwo);
valueOne = 20;
valueTwo = ++valueOne;
Console.WriteLine("After prefix:{0},{1}", valueOne, valueTwo);
}
}
}
计算短路
对于
int x=8;
if ((x==8) || (y==12));
判断了x==8为true，则右边y==12将不被执行。
同理：
int y=5;
if ((y==4) && (a==9));
右边也将不再执行。
三元操作符
语法：
条件表达式? 表达式1：表达式2；
如果表达式为true，返回表达式1的结果，否则返回表达式2的结果。
例：
namespace TernaryOperator
{
class TernaryOperator
{
static void Main()
{
int valueOne = 10;
int valueTwo = 20;
int maxValue = (valueOne > valueTwo) ? valueOne : valueTwo;
Console.WriteLine("maxValue is {0}", maxValue);
}
}
}
