1.对象初始化器
class Curry
{
public string MainIngredient{get;set;}
public string Style { get; set; }
public int Speciness { get; set; }
}
假如有如上一个类，当我们创建这个类的对象之后需要分别给每个属性赋值
Curry curry=new Curry();
curry.MainIngredient = "painr tikka";
curry.Style = "jal";
curry.Speciness = ;
这样显得非常麻烦，使用对象初始化器可以简化对象创建和初始化的过程。这段代码会调用默认的构造函数创建对象，对象创建之后在给对象属性赋值。也可以在new之后指定使用的构造函数
Curry test = new Curry { MainIngredient = "painr tikka", Style = "jal", Speciness = };
class Curry
{
public string MainIngredient{get;set;}
public string Style { get; set; }
public int Speciness { get; set; } public Curry()
{ } public Curry(int speciness)
{
Speciness = speciness;
}
}Curry test = new Curry() { MainIngredient = "painr tikka", Style = "jal"};
2.集合初始化器
List<int> primes = new List<int>() { , , , , };
集合初始化器会默认调用集合的Add方法来初始化集合，如果集合没有改方法将报错。
3.var关键字
C#3.0引入新的关键字var，允许使用var关键字定义需要编译器辅助确认类型的变量。它并不是创建没有类型或者类型可以变的变量。使用var需要注意：
1）使用var定义的变量声明和初始化必须一起，不能分开，比如var a ; a=0是错误的，正确的是var a =0;
2) var只能定义局部变量，不能定义全局变量；
3）变量初始化之后变量的类型就固定了，不能再用别的类型赋值。
可以使用var声明数组，比如var array =new []{4,5,6},但是数组初始化器的数据必须满足以下条件之一：
1）相同的类型；
2）相同的引用类型或null；
3）所有元素的类型都可以隐式的转换为一种类型。
4.匿名类型
为了显示数据，我们经常需要建一些简单的类，这些类只有简单的的几个属性，而且如果数据改变了又要更新这个类，最不爽的是这个类仅仅在某个地方用了一下下。比如如下一个类
class Curry
{
public string MainIngredient { get; set; }
public string Style { get; set; }
public int Spicinesss { get; set; }
}
不想建数据类型，匿名类型可以帮我们动态建立一个类型，它会根据我们初始化的数据建立类型。比如如下代码建立了一个匿名类型
var curry = new {
MainIngredient = "Lamb",
Style="Dhansak",
Spicinesss=
};
匿名类型的特征是new后面没有数据类型，这也是编译器确定匿名类型的方式。因为匿名类型没有类型名称，所以只能在当前代码块中使用创建的匿名类型
匿名类型与Equals、GetHashCode、==
class Curry
{
public string MainIngredient { get; set; }
public string Style { get; set; }
public int Spicinesss { get; set; }
}class Program
{ static void Main(string[] args)
{
try
{
var curries = new[]{
new {
MainIngredient = "Lamb",
Style="Dhansak",
Spicinesss=
},
new {
MainIngredient = "Lamb",
Style="Dhansak",
Spicinesss=
},
new {
MainIngredient = "Chicken",
Style="Dhansak",
Spicinesss=
}
}; Console.WriteLine(curries[].Equals(curries[]));
Console.WriteLine(curries[].Equals(curries[]));
Console.WriteLine(curries[].GetHashCode());
Console.WriteLine(curries[].GetHashCode());
Console.WriteLine(curries[].GetHashCode());
Console.WriteLine(curries[] == curries[]);
Console.WriteLine(curries[] == curries[]); }
catch (RuntimeBinderException ex)
{
Console.WriteLine(ex.Message);
} Console.ReadLine();
}
}
通过以上代码发现匿名类型使用Equals方法时比较的是它们的值是否相等，而不是比较引用；
GetHashCode因为curries[0]、curries[1]两个对象的值相同，所以它们的状态相同，返回的值也就相同。
==比较的是两个对象的引用curries[0]、curries[1]属于两个不同对象，引用不同。
5.动态查找
C#4.0引入了动态变量，动态变量顾名思义就算类型可变的变量。引入动态变量的目的在于使用C#处理另一种语言创建的对象，包括与旧及时今日交互，比如Component Object Model(Com)，以及处理JavaScript、ruby、python等动态语言。
比如代码从JavaScript中获取一个Add()方法，该方法把两个参数加在一起。如果没有动态查找功能就需要这样访问Add()方法
ScriptObject jsObj = SomeMethodGetTheObject();
int sum=Convert.ToInt32(jsObj.Invoke("Add", , ));
如果使用动态查找就可以直接调用方法
ScriptObject jsObj = SomeMethodGetTheObject();
int sum=Convert.ToInt32(jsObj.Add(, ));
动态查找方法可以根据变量的具体类型，动态的查找该类型是否有Add方法，如果没有该方法会引发一个RuntimeBinderException异常。
如下是一个使用动态查找的例子
namespace ConsoleApplication1
{
class Program
{ static void Main(string[] args)
{
try
{
dynamic firstResult = GetValue();
dynamic secondResult = GetValue(); Console.WriteLine("firstResult is :" + firstResult.ToString());
Console.WriteLine("secondResult is :" + secondResult.ToString());
Console.WriteLine("firstResult call :" + firstResult.Add(, ));
Console.WriteLine("secondResult call :" + secondResult.Add(, )); }
catch (RuntimeBinderException ex)
{
Console.WriteLine(ex.Message);
} Console.ReadLine();
} static int callCount = ;
static dynamic GetValue()
{
if (callCount++ == )
return new MyClass1();
return new MyClass2();
}
} class MyClass1
{
public int Add(int op1, int op2)
{
return op1 + op2;
}
} class MyClass2
{ }}
6.高级方法参数：可选参数和命名参数
可选参数
假如一个方法有大量的参数，有些参数并不是每次调用都需要传过去的，这意味着需要一种方式指定缺失的参数，否则在代码中会出现许多空值，比如
RmoteCall(var1,var2,null,null,null,null,null)
在理想情况下，这个RmoteCall方法应该有多个重载版本，其中一个有两个参数，但这样就需要维护更多的代码。
RmoteCall(var1,var2)
使用可选参数可以解决这个问题，可选参数的定义方式是在方法定义时，在参数后面赋默认值
public List<string>GetWords(string sentence,bool capitalizeWords=false)
{
//....
}
可选参数必须放在参数列表末尾，在所有必选参数后面
命名参数
假如有几个可选参数，我们只想给其中一个可选参数赋值，就可以用到命名参数，在调用方法时，指定参数的名和对应的值
public List<string>GetWords(string sentence,bool capitalizeWords=false, bool var1 =false)
{
//....
}//给最后一个可选参数赋值
GetWords("....",var1:true);
7.扩展方法
我们知道类型的操作是封装在数据类型里面的，使用扩展方法可以扩展类型的功能，而不修改类型本身。
创建一个扩展方法需要以下步骤：
1）创建一个非泛型静态类；
2）创建一个静态方法，该方法必须包含一个参数，该参数放在所有参数前面，用this关键字和类型符修饰，表示调用扩展方法的类型实例；
3）在使用扩展方法的地方用using语句导入包含扩展方法的类的名称空间；
4）通过扩展类型的一个实例调用方法，与调用该扩展类型的其他方法一样。
下面是给string类添加扩展方法的一个例子
namespace ConsoleApplication1
{
static class WordProgressor
{
public static List<string> GetWords(this string sentence, bool capitalizeWords = false, bool reverseOrder = false, bool reverseWords=false)//扩展方法
{
List<string> words = new List<string>(sentence.Split(' '));
if (capitalizeWords)
words = CapitalizeWords(words);
if (reverseOrder)
words = ReverseOrder(words);
if (reverseWords)
words = ReverseWords(words);
return words;
} public static List<string> CapitalizeWords(List<string> words)
{
List<string> capititalzieWords = new List<string>();
foreach (string word in words)
{
if (word.Length == )
capititalzieWords.Add(word[].ToString().ToUpper() );
else if(word.Length >)
capititalzieWords.Add(word[].ToString().ToUpper() + word.Substring());
} return capititalzieWords;
} public static List<string> ReverseOrder(List<string> words)
{
List<string> reverseOrder = new List<string>();
for (int i = words.Count - ; i >= ; i--)
{
reverseOrder.Add(words[i]);
} return reverseOrder;
} public static List<string> ReverseWords(List<string> words)
{
List<string> reverseWords = new List<string>();
foreach (string word in words)
{
reverseWords.Add(ReverseWord(word));
}
return reverseWords;
} public static string ReverseWord(string word)
{
StringBuilder sb = new StringBuilder();
for (int i = word.Length - ; i >= ; i--)
{
sb.Append(word[i]);
}
return sb.ToString();
} public static string ToStringReversed(this Object inputObject)//扩展方法
{
return ReverseWord(inputObject.ToString());
} public static string AsSentence(this List<string> words)//扩展方法，该方法扩展的类型是List<string>，所以只有该类型才能调用
{
StringBuilder sb = new StringBuilder();
for (int i = ; i < words.Count; i++)
{
sb.Append(words[i]);
if (i != words.Count - )
sb.Append(' ');
}
return sb.ToString();
}
} class Program
{ static void Main(string[] args)
{
string sourceString = "To go beyond is a wrong as to fall short."; Console.WriteLine(sourceString.ToStringReversed());
Console.WriteLine(sourceString.GetWords(capitalizeWords: true).AsSentence());
Console.ReadLine();
} }}
