The

Future
of C#

Ross Murray

  • BS in CS from Southeastern
  • Started using C# in 2011
  • Programming is pretty neat

This is about C# 7

  • New language features
  • Language design process
  • Direction of the language

Why?

  • New features often come from F# and other languages
  • They can introduce new patterns and ways of programming
  • Approaching problems in different ways leads to valuable insights and increased productivity
  • Use the right tool for the job.

Background Info

  • C# 6 just came out with VS 2015
  • A lot of .NET stuff is on github now
    • You can contribute to C# if you want
  • 7 is a long way away
  • Roslyn repo has C# language design meeting notes
  • Notes say not to infer future of C#
    • Let's do it anyway

How do they choose what to add?

  • There's a design team, they make the decisions
  • Ultimately the chief architect has the final say
  • The team picks vague themes to focus on for a new version
  • Anyone can propose new language features
    • make an issue on github with a proposal
    • these should be thorough and detailed

How do they choose what to add?

  • The team decides which proposals to explore
  • Chosen features are assigned to somebody to maintain a living proposal document
  • Proposals update over time with changes and comments
  • Practically, features are chosen by impact and cost

Some themes for C# 7

  • Working with data
  • Performance (interop)
  • Null
  • More syntax niceties

A focus on data

  • A common scenario today is sending around data between services, over the internet
  • Codebases with plain data models, and services with no state
  • OOP techniques aren't super effective in this scenario
    • coupling data and state, via encapsulation
    • a focus on object behavior rather than data
  • Functional programming is more effective in a data-focused scenario
    • composable functions that perform simple manipulations of immutable data

Let’s continue being inspired by functional languages, and in particular other languages – F#, Scala, Swift – that aim to mix functional and object-oriented concepts as smoothly as possible.

- MadsTorgersen (C# language PM)

What's the progress?

  • First big announcement in Jan 2015
  • Design review in April 2015
  • Several minor meetings between and since
  • Many features have detailed, accessible proposals
  • example (tuples)

Features

let me show you them

Real language support, not just System.Tuple

public (double meanAge, int oldest) GetAgeStats(IEnumerable<Person> people)
{
    var mean = people.Average(x => x.Age);
    var max = people.Max(x => x.Age);
    var result = (meanAge: mean, oldest: max);
    return result;
}

(var mean, var oldest) = GetAgeStats(people);

Non-nullable references

Dog - regular reference we have today

Dog! - a reference which cannot be null

Dog? - a reference which might be null

  • Compiler won't let you dereference anything from a Dog? unless you do a null check first. It's opting into safety.
  • Use Dog! everywhere you can, to preserve nullability information.

Deterministic disposal

  • Adds the notion of a destructible type.
  • Alternative to IDisposable or a finalizer.
  • Ensures an object's destructor is called exactly when the variable goes out of scope. No using() or waiting for GC.
  • Compiler enforces you can't make copies of the variable or stash them away.
public destructible struct ImageResource
{
    ...
    ~Cleanup() { ... }
}

Record types

  • Special class made with shorthand notation
  • Compiler generates a full class with private readonly backing fields and public properties that only have getters.
  • You can add more to your class declaration to override defaults, like adding setters.
public class Celsius(double Temperature);
public class Fahrenheit(double Temperature);

public class Cartesian(double X, double Y);
public class Polar(double r: Radius, double phi: Angle);

Record types

  • "is" operator now overridable.
public class Fahrenheit(double Temperature)
{
    public bool operator is(Celsius c) { ... }
}

var someTemp = new Fahrenheit(212.0);
if(someTemp is Celsius(100.0))
{
    //someTemp is boiling
}

Pattern matching

  • New ways to use "switch" and "is" keywords
var v = foo as Video;
if (v != null) {
    //code using v
}

becomes

if (foo is Video v) {
    //code using v
}
//v doesn't exist

Pattern matching

  • New ways to use "switch" and "is" keywords
abstract class Shape;
class Square(double Width, double Height) : Shape;
class Circle(double Radius) : Shape;

public double GetArea(Shape shape) {
  switch(shape) {
    case Square(1.0, 1.0): return 1.0;
    case Square s: return s.Width * s.Height;
    case Circle c: return Math.PI * c.Radius * c.Radius;
  }
}

Pattern matching

  • check it out
public record class Cartesian(double X, double Y);

public static class Polar
{
    public static bool operator is(Cartesian c, out double R,
        out double Theta)
    {
        R = Math.Sqrt(c.X*c.X + c.Y*c.Y);
        Theta = Math.Atan2(c.Y, c.X);
        return c.X != 0 || c.Y != 0;
    }
}

var c = Cartesian(3, 4);
if (c is Polar(var R, *)) Console.WriteLine(R);

Neat

  • Google to find all this info: C# 7 features
  • Much of this will change, but it gives an idea of the direction of the language.
  • Many C# features have similar origins in functional programming languages, such as generics, lambdas, LINQ, etc.
  • Tuples seem like a sure thing for C# 7
    • Probably Records and Pattern Matching, too.
    • The rest: /shrug

Neat

  • I recommend at least skimming the pattern matching proposal
    • It has a ton of little edge cases and uses
  • I love C#, and I think it keeps getting better.
  • Not afraid to push the boundaries a bit
  • If you don't feel the same, that's cool too.
  • Life is short, be kind and enjoy colors.

(sorry if you're colorblind)

Made with Slides.com