New features of C# 7.1, plus what we could get in 7.2 and 8

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