Shulou(Shulou.com)06/02 Report--

This article introduces the knowledge of "what are the five improvements of C# 3.0". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

1. Implicit local variable

C # 3.0 introduces a new keyword called "var". This keyword allows developers to create a variable, but it is not necessary to specify its type. For example, use var to describe a string, like this:

VarmyData = "This is my data"

Note that there is no mention here that the myData variable is a string, which is required by C # 2.0.

Although var allows you to create implicit types, it does not reduce the strong type characteristics of C #. The var keyword is only useful when creating variables, and once you create a variable and determine its type, you can no longer use var to change the type of a variable.

For example, this code does not work:

VarmyDate = DateTime.Now;myDate = "Hello."

Using the var keyword also produces an interesting result, which can help developers reduce the code input when creating variables. For example, to create a Customer object in C # 2.0, you need to enter the following code:

Customer myCustomer = new Customer ()

With the new var keyword, simply enter:

VarmyCustomer = new Customer ()

Another feature of the var keyword is that it is used to avoid changing a method call that returns an object of a certain type. For example, in C # 2.0, if you need to call a method that returns a Customer object, you should write the following code:

Customer myCustomer = GetByName ("Zach")

If at some point the GetByName method returns an object that is not Customer, this code cannot be compiled. However, if you apply the var keyword, you don't have to worry about the object types returned by GetByName.

VarmyData = GetByName ("Zach")

Now, because of the var keyword, the GetByName method can be changed to return a Person object, and the method call is still valid.

2.extension method

In C #, you cannot inherit and extend types marked "encapsulated" with access identifiers. But in C # 3.0, the extension method allows you to extend any class, even a class marked as encapsulated. For example, if you want to add a NoSpaces () method to a string class, we want to define an extension method similar to the one in listing A.

NamespaceMyExtensionMethods {public static class Extension {public static void NoSpaces (this string data) {return data.Replace ("", ");}

When the extension method is imported into a class, the developer can call the NoSapces () method on any string contained in the class.

The * * parameters of the extension method determine the valid type of the extension method. In this case, "this string data" (this string data) indicates that the extension method applies to the string class; if the extension method takes "this object data" (this object data) as a parameter, the method is valid for each object.

To indicate that you want to import extension methods, simply include a using directive in their namespace. For example, to apply the method described above, you need to include a using MyExtensionMethods instruction in the class file:

UsingMyExtensionMethods;namespace MyNamespace {public class MyClass {public MyClass () {string data = "thisismydata"; / / nospaces will contain "thisismydata". String nospaces = data.NoSpaces ();}

Note that the extension method has a lower priority than the instance method. Therefore, if the instance method and the extension method have the same signature, the instance method should be executed.

3. Object initializer

In C # 2.0, developers believe that a number of constructors are built to set a property value as the object initialization process. Here is an example: the class accesses the Customer method:

Customer myCustomer = new Customer ("Zach", "Smith")

Customer class constructor:

Public Customer (string firstName, string lastName): this () {this.FirstName = firstName; this.LastName = lastName;} public Customer () {}

C # 3.0 introduces a new way to initialize an object, which allows you to set any property value when initializing the object. For example, in C # 3.0, the above block of code can be written as:

Class to access the Customer method:

Customer myCustomer = new Customer {FirstName = "Zach", LastName = "Smith"}

Customer class constructor:

Public Customer () {}

In the C # 3.0 code, there is no constructor corresponding to the initialization object. In this way, developers do not have to create different constructors for each set of properties that need to be set.

Another effect of this is that the code becomes easier to read. For example, although we know clearly that the following code initializes a Car object, we do not know the role of the variables in it:

Car car = new Car (18,10,550)

At first glance, the following line of code is easier to read, although we have to enter more code:

Car car = new Car {WheelDiameter = 18, WheelWidth = 10, Horsepower = 550}

4. Anonymous type

C# 2.0 introduces anonymous methods, and C# 3.0 introduces anonymous types. Anonymous types are similar to anonymous methods in that they are built embedded and do not have a formal name. Before creating an anonymous type, you must combine the above concepts of object initializers and implicit local variables. Here is an example of an anonymous type:

VarmyType = new {Length = 79, Width = 30}

The scope of an anonymous type is the same as that of any other variable. For example, the cobra instance in the following code block is valid only in the Speed function block:

Private void Speed () {var cobra = new {Horsepower = 550, Torque = 570};}

If one anonymous type is initialized and another anonymous type is in the scope domain and their signatures are the same, the second type will occupy * types of its own. For example, in the following code, cobra and mustang are both anonymous types and can be set to each other.

Private void Speed () {var cobra = new {Horsepower = 570}; var mustang = new {Horsepower = 300, Torque = 300}; mustang = cobra; / / or you could say cobra = mustang}

5.LINQ

In previous versions of C #, developers used many different query languages to access different data sources. For example, to query a XML file, the developer will use XPath, and to query a SQL database, the developer will use SQL. This method was very effective in the past and is still the main way to access all kinds of data. However, this approach has some disadvantages. A significant disadvantage is that developers have to write query code in a different language than the one they currently use (such as SQL or XPath). Another disadvantage is that when executing certain query languages, such as SQL, developers must write mapping code to convert the query results into available C# business objects.

Clipping 3.0 introduces a new approach called language Integrated query (LINQ). With LINQ, developers can write code that can search any IEnumerable data source. So in addition to using TSQL to access MS SQL database and XPath to access XML files, they can also apply LINQ.

The following code is an example of a LINQ query that returns all customers whose OrderCount is greater than 10:

Using System;using System.Query;using System.Collections.Generic;public class SampleClass {static void Main () {Listcustomers = GetCustomers (); / / Write our query to retrieve customers who have more than// 10 orders.IEnumerablequeryResult = from customer in customerswhere customer.OrderCount > 10orderbycustomer.IDselect customer;}}

Unlike SQL or XPath, LINQ queries are written in caching, not in a third-party language. In this way, there will be no type problems with the query, and there is no need for developers to write mapping code to convert the data returned by the query into C # objects, and LINQ API will automatically handle the mapping.

That's all for "what are the five improvements in C# 3.0"? thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.