Lowering in C#: What really happens with your code?, from NDC Oslo 2019

@davidwengier
Lowering in C#
What’s really going on in your code?
David Wengier
Microsoft
NDC { Oslo }
2019

@davidwengier
foreach (int item in listOfInts)
{
// do something with item
}
for (int i = 0; i < listOfInts.Count; i++)
{
int item = listOfInts[i];
}
int i = 0;
while (i < listOfInts.Count)
{
i++;
}
int i = 0;
again:
i++;
if (i < listOfInts.Count)
{
goto again;
}
IL_0024: ldloc.0
IL_0025: ldloc.1
IL_0026: callvirt instance !0 class
[mscorlib]List`1<int32>::get_Item(int32)
IL_002b: pop
IL_002c: ldloc.1
IL_002d: ldc.i4.1
IL_002e: add
IL_002f: stloc.1
IL_0030: ldloc.1
IL_0031: ldloc.0
IL_0032: callvirt instance int32 class
[mscorlib]List`1<int32>::get_Count()
IL_0037: blt.s IL_0024
What is lowering?
IL
foreach
for
while
gotogoto
while
for
foreach

@davidwengier
What is lowering?
“A common technique … is to have the compiler
“lower” from high-level language features to low-level
language features in the same language.”
Eric Lippert
https://ericlippert.com/2014/04/28/lowering-in-language-design-part-one/

@davidwengier
LINQ
from c in customers
where c.Country == “AU”
select c;

@davidwengier
LINQ
customers.Where(c => c.Country == “AU”)
.Select(c => c);

@davidwengier
LINQ
Enumerable.Select(
Enumerable.Where(customers,
c => c.Country == “AU”),
c => c);

@davidwengier
LINQ
Enumerable.Select(
Enumerable.Where(customers, FilterCustomers),
SelectCustomer);
bool FilterCustomers(Customer c)
{
return c.Country == “AU”;
}
Customer SelectCustomer(Customer c)
{
return c;
}

@davidwengier
var message = "NDC Oslo";
decimal message = 5M;
string message = "NDC " + "Oslo";
string message = part1 + part2;

@davidwengier
Why do I want to know?
string message = "You have " + count + " items";
string message = $"You have {count} items";
string message = string.Format("You have {0} items",
count);

@davidwengier
foreach
foreach (int m in values)
{
Console.WriteLine(m);
}

@davidwengier
IEnumerable
interface IEnumerable
{
IEnumerator GetEnumerator();
}
interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
}
interface IEnumerable<T> : IEnumerable
{
new IEnumerator<T> GetEnumerator();
}
interface IEnumerator<T> : IEnumerator, IDisposable
{
new T Current { get; }
}

@davidwengier
foreach
{
var e = values.GetEnumerator();
try
{
int m;
while (e.MoveNext())
{
m = (int)(int)e.Current;
}
}
finally
{
if (e != null && e is IDisposable)
{
((IDisposable)e).Dispose();
}
}
}
object[] v = new [] { 1, 2 };
Write(v);
void Write(object[] arr)
{
foreach (int s in arr)
{
Console.WriteLine(s);
}
}
Person[] v = new [] { Empl(),..};
Write(v);
void Write(Person[] arr)
{
foreach (Customer c in arr)
{
Handle(c);
}
}

@davidwengier
foreach (C# 5+)
{
try
{
{
int m;
m = (int)(int)e.Current;
}
}
finally
{
if (e != null && e is IDisposable)
{
((IDisposable)e).Dispose();
}
}
}

@davidwengier
Lambdas
public class C
{
public void M()
{
Action<string> act = x => Console.WriteLine(x);
act(“hello”);
}
}

@davidwengier
Lambdas
public class C
{
public void M()
{
Action<string> act = _act;
act(“hello”);
}
private void _act(string x)
{
Console.WriteLine(x);
}
}

@davidwengier
Lambdas
public class C
{
public void M()
{
ActHelper c = new ActHelper();
Action<string> act = c.act;
act(“hello”);
}
private class ActHelper
{
internal void act(string x)
{
}
}
}

@davidwengier
Lambdas
public class C
{
public void M()
{
if (ActHelper.Instance._act == null)
{
ActHelper.Instance._act = new Action<string>(ActHelper.Instance.act);
}
Action<string> act = ActHelper.Instance._act;
act(“hello”);
}
private sealed class ActHelper
{
public static readonly ActHelper Instance = new ActHelper();
public static Action<string> _act;
{
}
}
}

@davidwengier
public class C
{
public void M()
{
Action<string> act = x => Console.WriteLine(x);
act(“Hello”);
}
}
public class C
{
public void M()
{
act(“Hello”);
}
{
{
}
}
}

@davidwengier
public class C
{
public void M()
{
string y = “ World”;
Action<string> act = x => Console.WriteLine(x + y);
act(“Hello”);
}
}
public class C
{
public void M()
{
act(“Hello”);
}
{
{
Console.WriteLine(x + y);
}
}
}
public class C
{
public void M()
{
act(“Hello”);
}
{
public string y;
{
}
}
}
public class C
{
public void M()
{
c.y = “ World”;
act(“Hello”);
}
{
public string y;
{
}
}
}

@davidwengier
public class C
{
public void M()
{
y = “ Fish”;
act(“Hello”);
}
}
public class C
{
public void M()
{
c.y = “ World”;
act(“Hello”);
}
{
public string y;
{
}
}
}

@davidwengier
public class C
{
public void M()
{
y = “ Fish”;
act(“Hello”);
}
}
public class C
{
public void M()
{
c.y = “ World”;
c.y = “ Fish”;
act(“Hello”);
}
{
public string y;
{
}
}
}

@davidwengier
Foreach and lambdas
List<Action> things = new List<Action>();
foreach (int m in values)
{
things.Add(() => Console.WriteLine(m));
}

@davidwengier
Foreach and lambdas
{
try
{
{
c.m = (int)(int)e.Current;
things.Add(new Action(c.act));
}
}
finally
{
if (e != null && e is IDisposable) ((IDisposable)e).Dispose();
}
}

@davidwengier
Foreach and lambdas (C# 5+)
{
try
{
{
c.m = (int)(int)e.Current;
things.Add(new Action(c.act));
}
}
finally
{
if (e != null && e is IDisposable) ((IDisposable)e).Dispose();
}
}

@davidwengier
public class C
{
private int z;
public void M()
{
Action<string> act = x => Console.Write(x + y + z);
act(“Hello”);
}
}
public class C
{
private int z;
public void M()
{
c.y = “ World”;
c._this = this;
c.act(“Hello”);
}
{
public C _this;
public string y;
{
Console.Write(x + y + _this.z);
}
}
}

@davidwengier
yield
foreach (int x in GetInts())
{
}
public IEnumerable<int> GetInts()
{
yield return 1;
yield return 2;
yield return 3;
yield return 4;
yield return 5;
}

@davidwengier
yield
using (IEnumerator<int> enumerator = this.GetInts().GetEnumerator())
{
while (enumerator.MoveNext())
{
Console.WriteLine(enumerator.Current);
}
}
{
return new GetIntsHelper(-2);
}

@davidwengier
yield
private class GetIntsHelper : IEnumerable<int>, IEnumerable, IEnumerator<int>, IDisposable, IEnumerator
{
private int _state;
private int _current;
private int _initialThreadId;
int IEnumerator<int>.Current { get { return this._current; } }
object IEnumerator.Current { get { return this._current; } }
public GetIntsHelper(int initialState)
{
this._state = initialState;
this._initialThreadId = Environment.CurrentManagedThreadId;
}
void IDisposable.Dispose()
{
}

@davidwengier
yield
IEnumerator<int> IEnumerable<int>.GetEnumerator()
{
GetIntsHelper result;
if (this._state == -2 && this._initialThreadId == Environment.CurrentManagedThreadId)
{
this._state = 0;
result = this;
}
else
{
result = new GetIntsHelper(0);
}
return result;
}

@davidwengier
yield
bool IEnumerator.MoveNext()
{
switch (this._state)
{
case 0:
this._state = -1;
this._current = 1;
this._state = 1;
return true;
case 1:
this._state = -1;
this._current = 2;
this._state = 2;
return true;
case 2:
this._state = -1;
this._current = 3;
this._state = 3;
return true;
case 3:
this._state = -1;
this._current = 4;
this._state = 4;
return true;
case 4:
this._state = -1;
this._current = 5;
this._state = 5;
return true;
case 5:
this._state = -1;
return false;
default:
return false;

@davidwengier
Yield states
-2 : GetEnumerator() hasn’t been called
-1 : Running – Getting the next value
0 : Before – MoveNext() hasn’t been called
1- 4 : Suspended – Waiting for a MoveNext() call
5 : After – Finished.

@davidwengier
yield
{
foreach (int x in Enumerable.Range(1, 10))
{
yield return x;
}
}

@davidwengier
yield
private IEnumerator<int> _wrap;
void IDisposable.Dispose()
{
if (this._state == -3 || this._state == 1)
{
this._Finally();
}
}
private void _Finally()
{
this._state = -1;
if (this._wrap != null)
{
this._wrap.Dispose();
}
}

@davidwengier
yield
bool IEnumerator.MoveNext()
{
try
{
// ... Next slide
}
catch
{
this.Dispose();
throw;
}
}

@davidwengier
yield
if (this._state == 0)
{
this._state = -1;
this._wrap = Enumerable.Range(1, 10).GetEnumerator();
this._state = -3;
}
else
{
if (this._state != 1) return false;
this._state = -3;
}
if (this._wrap.MoveNext())
{
this._current = (int)this._wrap.Current;
this._state = 1;
return true;
}
else
{
this._Finally();
this._wrap = null;
return false;
}

@davidwengier
Yield states
-3 : Running – Getting the next value
-2 : GetEnumerator() hasn’t been called
-1 : Running – Getting the range enumerator
0 : Before – MoveNext() hasn’t been called
1 : Suspended (and After) – Waiting for a MoveNext() call

@davidwengier
Captain planet
private int _min;
public void M()
{
int max = 5;
foreach (int x in GetInts(max))
{
}
}
public IEnumerable<int> GetInts(int max)
{
yield return 1;
foreach (int x in Enumerable.Range(this._min, max).OrderBy(i => i * this._min + max))
{
yield return x;
}
}
???

@davidwengier
Want to know more?
• Roslyn source code
• Your favourite decompiler
• http://sharplab.io

@davidwengier
Thank you!
Questions?
Comments?
Quemments?
@davidwengier

Lowering in C#: What really happens with your code?, from NDC Oslo 2019

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Lowering in C#: What really happens with your code?, from NDC Oslo 2019

Similar to Lowering in C#: What really happens with your code?, from NDC Oslo 2019 (20)

Recently uploaded

Recently uploaded (20)

Lowering in C#: What really happens with your code?, from NDC Oslo 2019

Editor's Notes