1. Static using(static using)
The static using declaration allows static methods to be called directly without using the class name.
The static using declaration allows invoking static methods without the class
name.
In C# 5
using System;
("Hello, World!");
In C# 6
using static ;
WriteLine("Hello, World");
2. Expression-Bodied Methods
Using expression methods, only one statement method can be written using lambda syntax.
With expression-bodied methods, a method that includes just one statement can
be written with the lambda syntax.
In C# 5
public bool IsSquare(Rectangle rect)
{
return == ;
}
In C# 6
public bool IsSquare(Rectangle rect) => == ;
3. Expression-Bodied Properties
Similar to expression methods, only a single-line attribute of a get accessor can be written using lambda syntax.
Similar to expression-bodied methods, one-line properties with only a get accessor
can be written with the lambda syntax
In C# 5
public string FullName
{
get
{
return FirstName +"" + LastName;
}
}
In C# 6
public string FullName => FirstName +"" + LastName;
4. Auto-Implemented Property Initializers
Automatic properties can be initialized using the property initializer.
Auto-implemented properties can be initialized with a property initializer.
In C# 5
public class Person
{
public Person()
{
Age = 24;
}
public int Age {get; set;}
}
In C# 6
public class Person
{
public int Age {get; set;} = 42;
}
5. Read-Only Auto Properties
C# 5 requires complete attribute syntax to implement read-only attributes, and C# 6 can use automatic attributes to implement them.
To implement read-only properties, C# 5 requires the full property syntax. With
C# 6, you can do this using auto-implemented properties.
In C# 5
private readonly int _bookId;
public BookId
{
get
{
return _bookId;
}
}
In C# 6
public BookId {get;}
6. Nameof Operator
The names of fields, properties, methods, and types can be accessed through nameof. Using nameof, you can easily refactor the name changes.
With the new nameof operator, names of fields, properties, methods, or types can
be accessed. With this, name changes are not missed with refactoring.
In C# 5
public void Method(object o)
{
if (o == null) throw new ArgumentNullException("o");
In C# 6
public void Method(object o)
{
if (o == null) throw new ArgumentNullException(nameof(o));
7. Null Propagation Operator
Null pass operators simplify null checking.
The null propagation operator simplifies null checks.
In C# 5
int? age = p == null ? null : ;
var handler = Event;
if (handler != null)
{
handler(source, e);
}
In C# 6
int? age = p?.Age;
handler?.Invoke(source, e);
8. String Interpolation
The string difference removes the call to the pair and uses an expression placeholder instead of the numeric format placeholder.
The string interpolation removes calls to . Instead of using
numbered format placeholders in the string, the placeholders can include
expressions.
In C# 5
public override ToString()
{
return ("{0}, {1}", Title, Publisher);
}
In C# 6
public override ToString() => $"{Title} {Publisher}";
9. Dictionary Initializers
Dictionaries can be initialized using a collection-like dictionary initializer.
Dictionaries can now be initialized with a dictionary initializer—similar to the
collection initializer.
In C# 5
var dict = new Dictionary<int, string>();
(3,"three");
(7,"seven");
In C# 6
var dict = new Dictionary<int, string>()
{
[3] ="three",
[7] ="seven"
};
10. Exception filters
Exception filters allow you to filter before catching exceptions.
Exception filters allow you to filter exceptions before catching them.
In C# 5
try
{
//etc.
} catch (MyException ex)
{
if ( != 405) throw;
// etc.
}
In C# 6
try
{
//etc.
} catch (MyException ex) when ( == 405)
{
// etc.
}
11. Use Await(Await in Catch) on Catch
await can be used directly in catch blocks, and needs to be used in C# 5.
await can now be used in the catch clause. C# 5 required a workaround.
In C# 5
bool hasError = false;
string errorMessage = null;
try
{
//etc.
} catch (MyException ex)
{
hasError = true;
errorMessage = ;
}
if (hasError)
{
await new MessageDialog().ShowAsync(errorMessage);
}
In C# 6
try
{
//etc.
} catch (MyException ex)
{
await new MessageDialog().ShowAsync();
}
The above is a summary of the new features of C# 6.0 introduced by the editor. I hope it will be helpful to you. If you have any questions, please leave me a message and the editor will reply to you in time. Thank you very much for your support for my website!