The document summarizes new features that have been added to C# programming language over different versions of Visual Studio. It discusses features such as generics, lambda expressions, LINQ, tuples, pattern matching, exception filters, auto-property initializers, expression-bodied members and more. It also provides code examples to illustrate some of these features like tuples, deconstruction, pattern matching with case statements, async Main method and others.

1. Алексей Соммер
New C# features

2. C# 1.0 Visual Studio 2002
Retrospective
C# 2.0 Visual Studio 2005 - Generics, Anonymous methods, iterators/yield, static classes
C# 3.0 Visual Studio 2008 - LINQ, Lambda Expressions, Implicit typing, Extension methods
C# 6.0 Visual Studio 2015 - Null-conditional operators, String Interpolation
C# 5.0 Visual Studio 2012 - async/await, Caller Information, some breaking changes
C# 4.0 Visual Studio 2010 - dynamic, Optional parameters and named arguments
C# 7.0 Visual Studio 2017 - Tuples, Pattern matching, Local functions
C# 1.1 Visual Studio 2003 - #line, pragma, xml doc comments

3. public event PropertyChangedEventHandler PropertyChanged;
public void OnPropertyChanged([CallerMemberName] string prop = "")
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(prop));
}
OnPropertyChanged(); OnPropertyChanged("Price");

4. From F# to C#
Tuples
LINQ
Immutability
Pattern matching
Exception filters
Auto-property initializers
Expression-bodied function members

5. try
{
SomeMethod(param);
}
catch (Exception e) when (param != null)
{
}
Exception filters

6. public string AppUrl { get; set; } = "http://lalala.com";
public string AppUrl { get; set; } = InitializeProperty();
public static string InitializeProperty()
{
return "http://lalala.com ";
}
Auto-property initializers

7. public int Sum(int x, int y)
{
return x+y;
}
public string ServerIP { get { return "65.23.135.201"; } }
public int Sum(int x, int y) => x+y;
public string ServerIP => "65.23.135.201";
Expression-bodied function members

8. C# 7 Work List of Features
bit.ly/1E1nrJZ
Language Feature Status
bit.ly/1TKZAHc

9. Tuples
There no need anymore to create new class if you want to
send or get multiple parameters!
var unnamed = (35, "What is your age?");
unnamed.Item1 == named.Answer
var named = (Answer: 35, Question: "What’s your age again?");

10. (int, string) GetXY()
{
int x = 1;
string y = "One";
return (x, y);
}
Simplest example
var xy = GetXY();

11. Deconstruction
(int, List<string>) GetListWithId()
{
int x = 1;
List<string> y = new List<string>();
return (x, y);
}
(int x, List<string> y) = GetListWithId();
var (x, y) = GetXY();

12. public class Coordinates
{
public int X { get; }
public int Y { get; }
public Coordinates(int x, int y)
{
X = x;
Y = y;
}
public void Deconstruct(out int x, out int y)
{
x = X;
y = Y;
}
}
Coordinates xy =
new Coordinates(5, 7);
(int x, int y) = xy;
User defined types

13. Pattern Matching
if (someObject is Customer)
{
var c = (Customer)someObject;
c.Balance = c.Balance + 1000;
}
if (someObject is Customer c) c.Balance = c.Balance + 1000;

14. switch (userRole)
{
case Manager m:
return m.Salary;
case Partner p:
return p.Income;
}
Case

15. switch (userRole)
{
case Manager m with Salary<1500:
return m.Salary*1.2;
case Manager m:
return m.Salary;
case Partner p:
return p.Income;
}
Case …. with

16. C# 7.1 features
Async Main
default literal
Infer tuple names
Pattern-matching with generics
Reference assemblies

17. static void Main(string[] args)
{
DoWork().GetAwaiter().GetResult();
}
static void Main(string[] args)
{
DoWork().Wait();
}
static async Task DoWork() { }
any exception
AggregateException
Boilerplate code
async Main

18. default
int i = default;
Instead of
int i = default(int);

19. Infer Tuple Names
explicit names
var tuple = (a: x.a, y: x.y);
inferred names
var tuple = (x.a, y);

20. Infer tuple names
int x=1;
Action y = () => SomeMethod();
var tuple = (a: x, y);
tuple.y();
Aaa! It’s breaking back compatibility!
// previously
public static class ExtClass
{
public static void y(this (int, Action) z)
{
}
}
// now
void SomeMethod() { }

21. Pattern-matching with generics
class Manager : Person { }
class Employee : Person { }
……………
Employee m = new Employee();
IncreaseSalary<Employee>(m);
……………
public void IncreaseSalary<T>(T person) where T : Person
{
if (person is Manager m) person.Salary++;
}

22. Readonly ref
static Employee CreateCopy(ref Position p)
{
// don’t change p value!
return new Position() { Lat = p.Lat, Long = p.Long };
}
static Employee CreateCopy(ref readonly Position p)
{
p.Lat = 54.32654;
SomeMethod(ref p.Lat);
return new Position() { Lat = p.Lat , Long = p.Long };
}

23. Non-trailing named arguments
int SomeMethod(int x, int y)
{
return (x - y) * (x + y);
}
SomeMethod(11, 27)
SomeMethod(y:17, x:21)
SomeMethod(11, y:27)
SomeMethod(x:12, 11)
Why?

24. int SomeMethod(int y, int x) { return 1; }
int SomeMethod<T>(int x, T y) { return 2; }
SomeMethod(x: 17, y: 21); // calls first SomeMethod
SomeMethod(11, y: 27); // calls second SomeMethod
Drawbacks

25. blittable
blittable struct BlittableOrNot
{
public byte a;
public bool b;
public int c;
}
blittable struct BlittableOrNot
{
public byte a;
public double b;
public int c;
}

26. Default Interface Methods
1. Currently if you want to change interface then you should change
all implementations
2. What if class will try to implement two interfaces having a default
method with the same signature?
3. Interfaces are still different from abstract classes

27. > Спасибо за внимание!
> Алексей Соммер
> asommer@yandex.ru
> skype: alexejsommer