面对着观念的快速更新，一片茫然，幸得cnblogs这块宝地，让我有跟上时代的机会。我也应该开始做一下记录了，记点有用的东西，希望多多支持.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Net30NewFeature1
{
public class ImplicitlyTypedLocalVariableTest
{
public static void Test()
{
Test4();
}
/**//// <summary>
/// 在.net 2.0 年代变量的声明是按预定的方式，就如同本函数
/// </summary>
public static void Test1()
{
int myInt = 0;
bool myBool = true;
string myString = "Time, marches on";
// Print out the underlying type.
Console.WriteLine("myInt is a: {0}", myInt.GetType().Name);
Console.WriteLine("myBool is a: {0}", myBool.GetType().Name);
Console.WriteLine("myString is a: {0}", myString.GetType().Name);
}
/**//// <summary>
/// 在.net 3.0 年代提供了一个 “var” 关键字，它可以用来替换一个特定的类型(such as int, bool, or string)，
/// 当你这样做时，编译器会根据“初始化的数据值”自动地推断出底层的数据类型。通过运行如下代码，你可以发现
/// 实际上在运行中的implicitly typed local variables，
/// 你也可以通过 Relfector 或 ildasm 来查看生成的assembly代码
/// </summary>
public static void Test2()
{
Console.WriteLine("***** Fun with Implicit Typing *****\n");
// Implicitly typed local variables.
var myInt = 0;
var myBool = true;
var myString = "Time, marches on";
// Print out the underlying type.
Console.WriteLine("myInt is a: {0}", myInt.GetType().Name);
Console.WriteLine("myBool is a: {0}", myBool.GetType().Name);
Console.WriteLine("myString is a: {0}", myString.GetType().Name);
}
/**//// <summary>
/// 你也需要了解，可以应用“隐式类型”的类型可以为 ： arrays, generics, and custom class types:
/// </summary>
public static void Test3()
{
var evenNumbers = new int[] { 2, 4, 6, 8 };
var myMinivans = new List<string>();
var myCar = new System.IO.FileInfo("");
}
/**//// <summary>
/// 可以在foreach循环的构造器中使用var关键字，编译器会自动识别正确的类型，
/// 对于识别正确的类型，你需要学些关于推断规则，好像是与编译原理有很大的关系，
/// 现在知道了形式语言的重要了。呵呵
/// </summary>
public static void Test4()
{
// Use 'var' in a standard for each loop.
var evenNumbers = new int[] { 2, 4, 6, 8 };
// Here, var is really a System.Int32.
foreach (var item in evenNumbers)
{
Console.WriteLine("Item value: {0}", item);
}
// Use 'var' to declare the array of data.
var evenNumbers1 = new int[] { 2, 4, 6, 8 };
// Use a strongly typed System.Int32 to iterate over contents.
foreach (int item in evenNumbers1)
{
Console.WriteLine("Item value: {0}", item);
}
}
/**//// <summary>
/// 特性： implicitly typed local variables，
/// 你要注意到它的限制，
/// 1。它仅仅可以应用到方法呀属性的scope下，用于返回值呀方法参数是不非法的。
/// </summary>
class ThisWillNeverCompile
{
//Error! var cannot be used as field data!
private var myInt = 10;
//Error! var cannot be used as return values or parameter types!
public var MyMethod(var x, var y) { }
}
/**//*
As well, local variables declared with the var keyword must be assigned an initial value at the
* 同时用var声明的局部变量也应该具有初使值，并且不可以赋为null 值(以便于进行类型的推断)。
// Error! Must assign a value!
var myData;
// Error! Must assign value at time of declaration!
var myInt;
myInt = 0;
// Error! Can't assign null!
var myObj = null;
It is permissible, however, to assign an inferred object local variable (已经被断定的变量)to null after its initial
assignment:
// OK!
var myCar = new SportsCar();
myCar = null;
//进一步这也是可以的，把隐式变量赋值缎带其它变量(包括隐式或预定的类型)
// Also OK!
var myInt = 0;
var anotherInt = myInt;
string myString = "Wake up!";
var myData = myString;
最后，我想要指出的是，过分的使用var 类型的变量，可以简代你的代码量，但是使代码的可读性降底了。
* 在这个时候，我们需要一定的软件构建知道帮我们进行
权衡。
*
* 然页，我们会在LINQ技术中利用查询表达式，来产生动态的结果集，这那些例子中，implicit typing 是很有用的，
* 我们不需要去确定我们需要的结果集的类型，通过编译器的推断，
* 我们可以省去很多的时间。
*
* 进一步的理解，local variables 类型推断并非与已有的脚本语言等同的技术，
* 如( (such as VBScript or Perl) or the COM Variant data type这些变量在程序的
* 生命周基中可以赋不同的类型，然而type inference 却是保持着c#强类型的特性，类型的确定是在编译时，而非运行时，
* // Error! The compiler knows myVar is a string, not an integer!
var s = "This variable can only hold string data!";
s = "This is fine";
s = 44; // This is not!
*/
}
}