C# 3.0 新特性

最新推荐文章于 2024-08-10 19:25:52 发布

dag_mo

最新推荐文章于 2024-08-10 19:25:52 发布

阅读量484

点赞数

分类专栏： .Net C#语言文章标签： c# 扩展 lambda 编译器 string linq

本文链接：https://blog.csdn.net/dag_mo/article/details/3413210

版权

.Net C#语言专栏收录该内容

4 篇文章 0 订阅

订阅专栏

隐式类型变量：

对于一些无法确定的类型使用隐式类型变量是非常有用的。如LINQ里：

 
 static void Main(string[] args)
 {
    int[] numbers = {1,2,3,4,5,6,7,8,9};
       //使用LINQ查询语法查询数组中的偶数 
    var querySet = from i in numbers where i%2 == 0 select i;
    Console.WriteLine("查询结果为：");
       //遍历查询结果，并在屏幕上输出 
    foreach(var i in querySet)
    {
        Console.Write("{0},",i);
    }
 }
 

在声明隐式类型变量时必须指定一个初始值，以便编译器进行类型推断，一个var不能同时声明多个隐式变量。

 
  var strVar = "这是隐式类型变量";  //编译器根据指定的值推断出变量类型为String类型 
var intVar = 0;  //编译器根据指定的值推断出变量类型为int类型 
var a = 1,b = 2; //产生编译时错误

隐式类型变量只限于局部变量，如果将隐式类型变量声时于类变量、参数或返回值将产生错误。

自动属性:

自动属性特性简化了编写属性代码的复杂性，由编译器来代替人的这种重复性工作。

 
 public class book
{
    //一个简单的属性示例 
    private string _bookname = string.Empty;
    public string BookName
    {
          get{ return _bookName; }
          set{ _bookName = value;} 
     }
}
public class book 
{
    //使用自动属性 
    public string BookName{ get;set;}
}
 

以上两个类实现的属性功能是一样的。

对象初始化器:

使用对象初始化器可以在创建对象时直接向对象赋值，无需显式地调用对象的构造函数。

 
 //一个简单的书籍类 
public class Book
{
    //书名属性 
    public string BookName{get;set;}
    //书ISBN属性 
    public string ISBN{get;set;}
    //书的价钱属性 
    public double price{get;set;}
}
//不使用对象初始化器来初始化对象 
class Program
{
    strtic void Main(string[] args)
    {
        Book book = new Book();
        book.BookName = "程序设计";
        book.ISBN = "0000000000";
        book.Price = 99.9;
    }
}
//使用对象初始化器初始化对象的代码如下： 
Book book = new Book()
{
    BookName = "程序设计",
    ISBN = "0000000000",
    Price = 99.9
};
 

使用对象初始化器时类的构造函数可以正常使用。

如果集合的成员本身需要初始化，可以使用内部类型的初始化语法来对其初始化，假如有一个泛型Book类,可以使用如下代码来初始化集合:

 
  List<Book> books = new List<Book>
{
    new Book("编程书籍")
    {
        bookName = "程序设计",
        ISBN = "0000000000",
        Price = 99.9
    },
    new Book("小说")
    {
        bookName = "金瓶梅",
        ISBN = "111111111",
        Price = 99.9
    },
    new Book("编程书籍")
    {
        bookName = "c#程序设计",
        ISBN = "2222222222",
        Price = 99.9
    }
  
};
 
 

扩展方法:

如果想给任何已编译好的类添加新的工能，扩展方法解决了必须更改源代码或者从该类中派生的问题。开发人员可以在一个单独的类中对已存在的类进行扩展，为其添加附加的方法。

定义扩展方法：

扩展方法必须在一个静态类中，扩展方法自身必须是一个静态方法。

扩展方法中首个参数必须是this,最后紧跟扩展的类的名称。

扩展方法可以正确的对象实例调用，也可以使用静态类名进行静态的调用。

以下示例演示如何给Object对像类型添加SayHello方法:

 
  //定义一个静态类 
public static class ExtensionMethods
{
    //定义一个静态方法，该方法扩展Object对象 
    public static void SayHello(this Object obj)
    {
         Console.WriteLine("Hello I'm ExtensionMethods!");
     }
}
//承继于这个类的子类都包含这个方法
 
 

扩展方法使用范围：

扩展方法不能与要扩展的类有相同名称

不能在扩展方法中直接访问扩展方法扩展的类的成员变量。要访问时应该如：扩展类.变量

如果扩展方法与被扩展类有不同的命名空间,需要在调用扩展方法时引用定义扩展方法的命名空间。

匿名类型：

不具有名称的类型，开发人员只需要临时地使用一个类型表达一些信息，这个类只需要保存一些只读的信息，如状态信息等，并不需要关联任何方法、事件等，这时候开发人员可以不用显式地去定义一个类，可以考虑使用匿名类型。

 
  class Program
{
    static void Main(string[] args)
    {
        //初始化一个Book类的实例 
        Book book = new Book()
        book.BookName = "C# 啥啥啥！";
        book.ISBN = "000000000";
        book.Price = 9.9;
        //显示内容 
        Console.WriteLine("书名是：{0}，ISBN是：{1}，价格是：{2}",book.BookName,book.ISBN,book.Price);
    }
}
public class Book
{
    public string BookName{get;set;}
    public string ISBN{get;set;}
    public double Price{get;set}
}
//如果以后不重用Book类的话使用匿名类型形式代码会大大减少。 
//匿名类型： 
static void Main(string[] args)
{
    var book = new {BookName = "C# 啥啥啥！",ISBN = "0000000000",Price = 99.9};
    Console.WriteLine("书名是：{0}，ISBN是：{1}，价格是：{2}",book.BookName,book.ISBN,book.Price);
}
//注意： 匿名类型必须使用var进行隐式声明，匿名类型中只能包含公共的属性，不能包含方法或者是事件
 
 

局部类与局部方法:

局部类使开发人员将一个类的实现定义到多个代码文件中,只需要使用关键字Partial在多个文件中使用相同的类名即可,编译时编译器将生成一个完整的类.局部方法同样使用Partial关键字定义.

局部方法仅使用于局部类中.

局部方法的返回值必须是void.

局部方法可以是静态的或者是实例化的.

局部方法可以有参数,可以包含参数修饰符如this,ref或者Params,但不包括out修饰符.

局部方法隐式访问级别为private ,因此不能为虚方法.

 
  //book.cs  
namespace PartialMethod
{
    public partial class Book
    {
        public bool BuyBook(string BookName)
        {
            bool instock = false;
            //调用局部方法来判断所要购买的书是否有库存   
            BookInStock(BookName,ref instock);
            return instock;
         }
         //这是一个局部方法,在这里并没有提供任何方法的实现   
         partial void BookInStock(string BookName,ref bool instock);
    }
    
}
//BookInStock.cs  
namespace Partialmethod
{
    public partial class Book
    {
         //局部类中的局部方法,根据书名判断存货  
         partial void BookInStock(string BookName,ref bool instock)
         {
               if(BookName == "C# 啥啥啥书")
               { 
                     instock = true;
               }
               else
               {
                     instock = false;
               }
         }
    }
}
 
 

Lambda 表达式

“Lambda 表达式”是一个匿名函数．Lambda表达式格式为：

　　　　(参数列表) => 表达式或者语名块

 
    //可以有一个或多个参数，也可以无参数．参数类型可隐式或显式声明． 
(x,y) => x * y;                              //多个参数，隐式类型 => 表达式 
x => x * 10;                                   //单参数，　隐式类型 =>表达式 
x => { return x * 10;};                 //单参数，　隐式类型 => 语句块 
(int x) => x * 10;                          //单参数，显式类型 => 表达式 
(int x) => {return x * 10;};          //单参数，显式类型 => 语句块 
() => Console.WriteLine();          //无参数
 
   

C#的Lambda表达不具备即时调用的能力，必须用一个已知委托类型的变量接受它后,才能通过委托变量调用。

 
     //silverlight 中的timer调用中使用Lambda的例子 
System.Windows.Threading.DispatcherTimer dt = new System.Windows.Threading.DispatcherTimer();
 dt.Interval = new TimeSpan(0,0,0,1);
  dt.Tick += (Object sender, EventArgs e) => { this.label1.Text = DateTime.Now.ToString(); };
  dt.Start();
 
    

Lambda表达式与委托变量：必须有相同的参数个数，参数类型相同。返回类型相同。

 
         delegate string del(string str,string str1);
    protected void Button1_Click(object sender, EventArgs e)
    {
        del dd = (string a, string b) => { return a + b; };
        this.Label1.Text=dd(this.TextBox1.Text,this.TextBox2.Text);
    }
 
    

dag_mo

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C# 3.0 新特性

隐式类型变量：对于一些无法确定的类型使用隐式类型变量是非常有用的。如LINQ里：static void Main(string[] args) { int[] numbers = {1,2,3,4,5,6,7,8,9}; //使用LINQ查询语法查询数组中的偶数 var querySet = from i
复制链接

扫一扫

专栏目录