Sunny Ahuwanya's Blog

Mostly notes on .NET and C#

Exploring C# 6

C# 6, the latest version of the C# programming language, is here and is (almost) feature complete.
In this post, we'll explore the new language features interactively. Let's start with the most fun feature.

Using Static

using static System.Console;
using static System.Tuple;

WriteLine(Create("C#", 6));

//Hit Go to run this code


Using static lets you import static members of types directly into scope.
In the above example, WriteLine is imported from the System.Console type and Create is imported from the System.Tuple type.
This feature is useful if you frequently use a group of static methods.

Using static also lets you import static members of non static types, including structs and enums.

using static System.String;
using static System.DateTime;
using static System.DayOfWeek;

Concat("Is today a ", Monday, " or a ", Tuesday, " ? : ", Now.DayOfWeek == Monday || Now.DayOfWeek == Tuesday)


In the example above, Concat is imported from the non-static System.String class, Monday and Tuesday are imported from the System.DayOfWeek enum and Now is imported from System.DateTime.

When you import a namespace, you bring into scope all visible types and all extension methods in the namespace.
With using static, you can now import extension methods from a single class.

using static System.Xml.Linq.XDocument;
using static System.Xml.Linq.Extensions;

var cities = Parse(
@"<Root>
    <State name='California'>
        <City name='Los Angeles' />
        <City name='San Francisco' />
    </State>
    <State name='New York'>
        <City name='New York City' />    
    </State>
</Root>").Descendants("City");

cities.AncestorsAndSelf()


In the example above, Parse is imported from the XDocument class and AncestorsAndSelf is imported from the System.Linq.Extensions class.
This code is able to use the extension methods in the System.Linq.Extensions class without bringing all types in the System.Xml.Linq namespace into scope.

 

nameof expressions

Occasionally, you need to supply the name of a variable, type, type member or other symbol in your code. A common example is when throwing an ArgumentNullException and the invalid parameter needs to be identified.

In the past, you would have to use reflection to find the name, which is a bit tedious, or hardcode the name, which is error prone.
nameof expressions validate and extract the name of the symbol as a string literal at compile time.

void MyMethod(string input)
{
    Console.WriteLine(nameof(input));    
    if (input == null) throw new ArgumentNullException(nameof(input));
}

MyMethod(null);


In the above example we're able to throw an ArgumentNullException specifying the name of the erring parameter without hardcoding its name.
If the parameter name is changed in the future via a refactoring operation, the new name will be reflected in the thrown exception.

nameof expressions work on different kinds of code symbols.

string s  = "a string";

//On an instance variable of a type
Console.WriteLine( nameof(s) );
//On a dotted member of the instance
Console.WriteLine( nameof(s.Length.ToString) );
//On a dotted member of a type
Console.WriteLine( nameof(Console.Write) );

In each case in the example above, the name of the last identifier in the expression is extracted.

 

Null-conditional operators

Null-conditional operators let you evaluate members only if a null resolution was not reached in the evaluation chain.

string s = null;

int? length = s?.Length;
Console.WriteLine(length == null);

//In an indexer/element access
char? firstChar = s?[0];
Console.WriteLine(firstChar == null);


As seen in the example above, this eliminates the need to write code that checks for null on each member access.
Null-conditional operators can be chained.

string GetFirstItemInLowerCase(IEnumerable<string> collection)
{
    return collection?.FirstOrDefault()?.ToLower();
    
    /*
    //Pre C# 6 code:
    if(collection == null || collection.FirstOrDefault() == null) return null;
    return collection.First().ToLower();
    */    
}

GetFirstItemInLowerCase(new string[0])


The method above returns the first item in a collection of strings in lower case.
It returns null if the collection is null or the collection is empty or the first item in the collection is null.

Null-conditional operators make the code more succinct than the pre-C# 6 code.

The null-conditional operators work with the null coalescing operator ( ?? ) to provide a default result when the expression evaluates to null.

string[] arr = null; //new string[]{"paper","pen"};
int length = arr?[0]?.Length ?? -1;

length


In the example above, length is -1 because the null-coalescing operator provides a default value.
Replace arr = null; with arr = new string[]{"paper","pen"} to get the length of the first element.

 

String Interpolation

String interpolation lets you format strings in an easier and safer manner.

var now = DateTime.Now;

var msg = $"Have a happy {now.DayOfWeek}! Today is day {now.DayOfYear} of {now.Year}";
/* //Same as:
var msg = String.Format("Have a happy {0}! Today is day {1} of {2}", now.DayOfWeek, now.DayOfYear, now.Year);
*/

msg


In the example above, the now.DayOfWeek, now.DayOfYear and now.Year expressions are placed exactly where they will appear.
You can now safely modify the string without worrying if the arguments at the end line up properly as is the case when String.Format is used.

To insert braces in an interpolated string, specify two opening braces ( {{ ) for an opening brace or two closing braces ( }} ) for a closing brace.
Interpolated strings can span multiple lines if the $ symbol is followed by an @ symbol, keeping in style with regular C# multiline string literals.

var val1 = "interpolated";
var val2 = "multiple";

var str = $@"

This is an {val1} string
spanning {val2} lines.

Braces can be escaped like {{this}}.

";

str


Expressions in interpolated holes can be complex. Alignment and format specifiers can also be specified, just as with String.Format, as shown in the following example.

//Standard currency numeric format
var amount = $"{-123.456:C2}";

//Guid, left aligned
var guid1 = $"|{Guid.NewGuid(),-50}|";

//Guid, right aligned with format specifier
var guid2 = $"|{Guid.NewGuid(),50:N}|";

//Custom DateTime format
var str = $"Yesterday was {DateTime.Now - TimeSpan.FromDays(1):dddd, d-MMM-yyyy.}";

Console.WriteLine(amount);
Console.WriteLine(guid1);
Console.WriteLine(guid2);
Console.WriteLine(str);


Interpolated strings are formatted using the current culture.
In a later release, interpolated strings will implement the IFormattable interface (but will be implicitly convertible to a string). This will allow interpolated strings to be formatted in other cultures.

var invariant = string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:C}", 20);

var current = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0:C}", 20);

var interpolated = $"{20:C}";

Console.WriteLine(invariant);
Console.WriteLine(current);
Console.WriteLine(interpolated);

/* 
//NOTE: Will work in a future update.
//Formats interpolated string in Japanese culture

public string InJapaneseCulture(IFormattable formattable)
{
    return formattable.ToString(null, new System.Globalization.CultureInfo("ja-JP"));
}

InJapaneseCulture($"{20:C}") //Displays "¥20"
*/

 

Parameterless constructors in structs

Structs can now have parameterless constructors.

struct Point
{
    public int X {get; set;}
    public int Y {get; set;}
    public int Z {get; set;}
    
    public Point()
    {
        X = -1;
        Y = -2;
        Z = -3;
    }
}

new Point()


This feature is useful if you need to create a new instance of a struct with a parameterless constructor that initializes fields to values that are not the default type value.

Consider a generic method that returns a list of a generic type.

public List<T> CreateList<T>(int count) where T:new()
{
    List<T> list = new List<T>();
    for(int i = 0; i < count; i++)
    {
        list.Add(new T());
    }
    
    return list;
}

struct Point
{
    public int X {get; set;}
    public int Y {get; set;}
    public int Z {get; set;}
    
    public Point()
    {
        X = -1; Y = -2; Z = -3;
    }
}

CreateList<Point>(3)


Calling CreateList<Point>(50) in older versions of C# will return a list of 50 Point objects, however, each point will be invalid since the X,Y and Z properties will default to zero.
With C# 6, all points in the list will have the desired initial values for X, Y and Z.

There is a bug in this feature and it doesn't currently work quite as expected.

 

Expression bodied methods and properties

This feature lets methods and properties have bodies that are expressions instead of statement blocks.

public string Hexify(int i) => i.ToString("X");

/* //Same as:
public string Hexify(int i)
{
    return i.ToString("X");
}

*/

Hexify(7012)


The body of the Hexify method above is expressed as an expression, like a lambda expression, and is equivalent to the commented out regular style body.
Bodies of getter-only properties and indexers can also be expressed as expressions.

class Order
{
    private Guid _id = Guid.NewGuid();
    
    public string Id => _id.ToString();
    
    /* //Same as:
    public string Id
    {
        get
        {
            return _id.ToString();
        }
    } */
}

new Order().Id

Auto-Property Initializers

Auto properties can now be initialized with an initial value.

class Order
{
    public string Instructions {get; set;} = "None";
    
    public string Id {get;} = Guid.NewGuid().ToString();
}

new Order()


A new instance of the Order class above will have the Instructions property set to "None" and the Id property set to a new Guid string.
It's important to note that the default values are initialized once on the underlying backing field. This means each call to the Id property will return the value on the backing field and not a brand new Guid.

Getter-only auto-properties can also be assigned an initial value in the type's constructor.

class Order
{
    public string Instructions {get; set;} // Okay in C# 5
    public string Id {get;} // Only okay in C# 5 if class is abstract or extern
    
    public Order()
    {
        Instructions = "None"; // Okay in C# 5
        Id =  Guid.NewGuid().ToString(); // New in C# 6
    }
}

new Order()

 

Index Initializers

This feature lets you initialize the indices of a newly created object as part of the object initializer.

var birthdays = new Dictionary<string, DateTime> {
    ["Turing"] = new DateTime(1912, 6, 23),
    ["Lovelace"] = new DateTime(1815, 12, 10),
    ["Neumann"] = new DateTime(1903, 12, 28)
};

birthdays


This feature makes it easy to compose hierarchical objects, suitable for JSON serialization.

var locations = new Dictionary<string, object>
{
    ["Canada"] = null,
    ["Mexico"] = "Distrito Federal",
    ["United States"] = new Dictionary<string, object>
    {
        ["Illinois"] = null,
        ["New York"] = "New York City",
        ["California"] = new string[]{"Los Angeles", "San Jose"}
    }
};

locations


The object above is easier to read and compose than having to assign values to indices in separate statements after each new dictionary is created.

 

Exception filters

This feature allows a catch block to execute only when some criteria is met.

int state = 3;
try
{
    throw new InvalidOperationException();
}
catch (InvalidOperationException) when (state == 2)
{
    Console.WriteLine("Exception thrown! State = 2");
}
catch (InvalidOperationException) when (state == 3)
{
    Console.WriteLine("Exception thrown! State = 3");
}
catch
{
    Console.WriteLine("Exception thrown!");
}


In the example above, the first catch block is not executed because state isn't 2, even though that catch block handles the InvalidOperationException.
The exception processing logic then moves to the next catch block which is executed because it handles the exception type and the filter evaluates to true.

This is cleaner than having a big catch block that checks the criteria within the block. An added benefit of using exception filters instead of catching and rethrowing exceptions is that it doesn't change the stack -- useful when debugging the source of an exception.

 

Conclusion

C# 6 is a nice improvement that addresses many of the annoyances C# developers face daily.
I applaud the direction in which the C# team is taking the language. I really like using static, nameof expressions, null conditional operators and string interpolation.
These features will undoubtedly make life easier for many developers.

C# Brain teasers Part II

I’ve compiled a few C# brain teasers that you can explore interactively.
They are a tougher than the ones I posted previously but are only limited to the C# 2.0 feature set, to keep things simple.

Try to guess the answer to each question and then hit Go to evaluate the code.
The explanations for the answers are at the bottom of this post.

1)

//Can you guess what the output is?

for(int i = 0; i < 10; i++)
{
    Console.Write(i + ' '); 
}

Explanation

2)

//Class declarations

class Base
{
}

class A : Base
{
    public int Field;
}

class B : Base
{
    public int Field = 0;
    public static implicit operator A(B source)
    {
        return new A { Field = source.Field };
    }
}

// Is there anything wrong with the assignment below?

A obj = new B();

// Do any of these four statements compile?

/* 1. */ object[] oArr = new string[5];
/* 2. */ A[] aArr = new B[5];
/* 3. */ object[] oArr2 = new int[5];
/* 4. */ long[] dArr = new int[5];

Explanation

3)

//Can you guess what the output is?

struct Counter
{
    int counter;
    public override string ToString()
    {
        return counter++.ToString();
    }
}

Counter c = new Counter();
Console.WriteLine(c);
Object o = c;
Object r = o;
Console.WriteLine(c);
Console.WriteLine(r);
Console.WriteLine(o);
Console.WriteLine(o);
Console.WriteLine(r);

Explanation

4)

//What is wrong with this code?

class Outer
{
    static int sField = 0;

    public class Nested
    {
        public virtual int GetFieldValue()
        {
            return sField;
        }
    }
}

class SubClass : Outer.Nested
{
    public override int GetFieldValue()
    {
        return sField + 5;
    }
}

Explanation

5)

//What is the length of the strings?

string s1 = "\U0010FADE";
string s2 = "\U0000FADE";
Console.WriteLine(s1.Length);
Console.WriteLine(s2.Length);

Explanation

6)

//What is the output? i.e. the lengths of the arrays?

int[] singleDimension = {1,2,3,4};
int[,] multiDimension = {{1,2},{3,4}};
int[][] jagged = { new int[] { 1, 2 }, new int[] { 3, 4 } };

Console.WriteLine(singleDimension.Length);
Console.WriteLine(multiDimension.Length);
Console.WriteLine(jagged.Length);

Explanation

7)

//Class declarations

class Base
{
    protected class C
    {
        public C()
        {
            Console.WriteLine("Base.C()");
        }
    }
}

class A : Base
{
    public A()
    {
        Base.C inheritedC = new Base.C();
        C myC = new C();
    }

    new class C
    {
        public C()
        {
            Console.WriteLine("A.C()");
        }
    }
}

class B : A
{
    public B()
    {
        C implicitC = new C();
        Base.C baseC = new Base.C();
    }
}

//What is outputted when a new B object is created?

B b = new B();

Explanation

8)

// What is wrong with this code?

class B
{
    private static void M() { Console.WriteLine("B.M"); }
    public static void M(int i) { Console.WriteLine("B.M(int)"); }
}

class E
{
    static void M() { Console.WriteLine("E.M"); }
    static void M(int i) { Console.WriteLine("E.M(int)"); }

    class C : B
    {
        public static void Main()
        {
            M();
        }
    }
}

Explanation

9)

//Which field initializer statement(s) in the class will not compile?

class A
{
    bool a = false;
    object b = new A();
    bool c = a;
    object d = this; 
    int j = i + 1;
    static int i = 4;   
}

Explanation

10)

//What is wrong with this code?

class Generator
{
    readonly Random rnd;

    public Generator(ref Random RandomGenerator)
    {
        GetRandomGenerator(out rnd);
        RandomGenerator = rnd;
    }

    public void Reset(ref Random RandomGenerator)
    {
        GetRandomGenerator(out rnd);
        RandomGenerator = rnd;
    }

    private void GetRandomGenerator(out Random RandomGenerator)
    {
        RandomGenerator = new Random();
    }
}

Explanation

11)

// Why won't the code below compile?

class A
{
    private int i;

    public int P
    {
        get
        {
            return i;
        }
        set
        {
            i = value;
        }
    }

    public int get_P()
    {
        return i;
    }

    public void set_P(int i)
    {
        this.i = i;
    }
}

Explanation

12)

//Why won't the code below compile?

class A
{
    int Item = 0;

    public int this[params int[] arr]
    {
        get
        {
            return Item;
        }
    }
}

Explanation

13)

//What is the output?

float number = 23, zero = 0;

try
{
    Console.WriteLine(number / zero);
}
catch (DivideByZeroException)
{
    Console.WriteLine("Division By Zero");
}

Explanation

14)

//What is the output?

//Checked context
float fMax = float.MaxValue;
int iMax = int.MaxValue;
decimal decMax = decimal.MaxValue;
checked
{
    try
    {
        Console.WriteLine(fMax += 10);
    }
    catch { Console.WriteLine("Float Overflow"); }
    try
    {
        Console.WriteLine(iMax += 10);
    }
    catch { Console.WriteLine("Integer Overflow"); }
    try
    {
        Console.WriteLine(decMax += 10);
    }
    catch { Console.WriteLine("Decimal Overflow"); }
}

//Unchecked context
fMax = float.MaxValue;
iMax = int.MaxValue;
decMax = decimal.MaxValue;
unchecked
{
    try
    {
        Console.WriteLine(fMax += 10);
    }
    catch { Console.WriteLine("Float Overflow"); }
    try
    {
        Console.WriteLine(iMax += 10);
    }
    catch { Console.WriteLine("Integer Overflow"); }
    try
    {
        Console.WriteLine(decMax += 10);
    }
    catch { Console.WriteLine("Decimal Overflow"); }
}

Explanation

15)

// Class declaration

class B
{
    public B()
    {
        M1();
    }
    public virtual void M1()
    {
        Console.WriteLine("B.M1");
    }
}

class C : B
{
    int f;

    public C()
    {
        f = 7;
    }
    public override void M1()
    {
        Console.Write("C.M2 : " + f);
    }
}

// What is outputted when a new C object is created?

new C();

Explanation

16)

// Type declarations

class MyClass
{   
    private int PrivA;
    public int PubB;
    
    public MyClass(int a, int b)
    {
        this.PrivA = a;
        this.PubB = b;
    }
}

struct MyStruct
{    
    private int PrivA;
    public int PubB;
    
    public MyStruct(int a, int b)
    {
        this.PrivA = a;
        this.PubB = b;
    }
}

// What is outputted?

MyClass c1 = new MyClass(50, 99);
MyClass c2 = new MyClass(70, 99);
MyClass c3 = new MyClass(50, 99);

MyStruct s1 = new MyStruct(50, 99);
MyStruct s2 = new MyStruct(70, 99);
MyStruct s3 = new MyStruct(50, 99);

Console.WriteLine(c1.Equals(c2));
Console.WriteLine(c1.Equals(c3));

Console.WriteLine(s1.Equals(s2));
Console.WriteLine(s1.Equals(s3));

Explanation

 

Explanations:

A1.
The output is 32333435363738394041.
A char is a numeric value that is expressed as a character so 1 + ' ' is really 1 + 32.

 

A2.
The A obj = new B() assignment is legal since an implicit conversion exists between classes A and B.

The first statement will compile because the String class derives from the Object class and so qualifies as an implicit reference conversion.
The second statement will not compile because even though there is a user defined implicit conversion, only standard implicit reference conversions are considered for arrays.
The third statement will not compile because even though Int32 derives from the Object class, it is a value type and cannot partake in an implicit reference conversion.
The fourth statement will not compile because even though the Int32 type is implicitly convertible to the Int64 (long) type, they are both value types and arrays can only convert from reference types that qualify for an implicit reference conversion.

 

A3. 
The output is:

0
0
0
1
2
3

How’s that? This is a case of boxing and unboxing turned on its head.
When the ToString() method override is called, struct c is automatically boxed to an object type to facilitate the call. This stores a copy of c on the heap and calls ToString() on that copy.
Therefore the counter field on the actual struct c never changes. The counter field for struct c will always be 0, regardless of how many times ToString() is called.

Object o is a boxed copy of struct c and object r references the same boxed copy. When ToString() is called on either o or r, the boxed copy is accessed directly and the counter is incremented.
Thus calls to o.ToString() and r.ToString() increment the same referenced counter structure.
This shows that contrary to popular opinion, it is possible, even trivial, to modify a boxed value.

 

A4.
The static Outer.sField private field is accessible to class Nested but not accessible to class SubClass because the scope of a static member includes nested classes, but it excludes subclasses of the nested class.

A5.
The output is:
2
1

The \Udddddddd escape code is used for encoding UTF-16 unicode characters (also referred to as codepoints).
System.Char structures store 16 bit values (0x0000 through 0xFFFF) and so a single System.Char is unable to store unicode characters that fall within the 0x10000 and 0x10FFFF range.
To accommodate these characters, multiple System.Char structures are used.
This is the case for string s1, where two chars are used to store the unicode character.
In string s2, only one char stores the unicode character.

String.Length returns the number of System.Char structures in the string, not the number of unicode characters.

 

A6.
The output is:
4
4

 
The Length property of arrays returns the total number of elements in single and multi-dimensional arrays.
However, it returns only the number of elements in the first dimension of a jagged array.

 

A7. 
The output is:
Base.C()
A.C()
Base.C()
Base.C()

Nested class Base.C is marked with a protected modifier and so will be inherited by classes that derive from Base. This is similar to the way protected fields are inherited, except in this case it is the access to Base.C that is being inherited.
Class A is derived from Base and so inherits access to Base.C , but also defines a nested class called C, which hides Base.C.
Base.C is still accessible from within class A but must be referred to explicitly by Base.C.
Classes that derive from class A will have access to both Base.C and A.C. However, it's important to note that external access to A.C points to the inherited Base.C because the new class A.C is implicitly private and is only visible and accessible to code within class A.
Class B is derived from class A. It inherits access to Base.C and the externally visible A.C (which is actually Base.C), so variables implicitC and baseC refer to objects constructed from the same class.

If the new class A.C's access modifier is changed to protected i.e. protected new class C , the code will output
Base.C()
A.C()
A.C()
Base.C()
because B will now inherit access to the true class A.C. In fact, since class A.C is closer to class B than class Base.C in the inheritance hierarchy, A.C can be implicitly referred to as C, and so the variable implicitC now maps to an object constructed from class A.C whereas variable baseC will refer to an object constructed from class Base.C.

 

A8.

The call to M() in the Main method is not allowed. Even though there is an accessible static M() method in the enclosing class E, the call refers to the inaccessible B.M() method because inherited members of C are preferred over members of enclosing classes.
There is an accessible inherited method M(int i), so all calls to methods named M (of any signature) from class C will be mapped to the M methods in the base class B.

It's not possible to call an overload of a method in the base class and call another overload in the enclosing class.
The compiler will choose to call either all overloads in the base class (preferably) or all overloads in the enclosing class.
If you comment out the B.M(int i) method overload, then the static M method in the enclosing class is called.

 

A9.

These two statements will not compile:

bool c = a; //CS0236 A field initializer cannot reference the nonstatic field, method, or property 'field'
object d = this; //CS0027 Keyword this is not available in the current context

Outside a method, instance fields cannot be used to initialize other instance fields.
The this keyword is unavailable outside a method, property or constructor.
Interestingly, the field A.b that initializes a brand new object A is allowed.

 

A10.

The following line will not compile:

GetRandomGenerator(out rnd); //CS0192 A readonly field cannot be passed ref or out (except in a constructor)

A readonly field cannot be passed as a ref or out parameter (except in a constructor).
Constructors can accept ref and out parameters.

 

A11.

Properties are compiled into get_{Property_Name} and set_{Property_Name} methods.
The methods get_P and set_P will conflict with the generated property methods.

 

A12.

Indexers are compiled into a property named Item and methods named get_Item and set_Item.
The field Item conflicts with the generated property name.
It’s okay to have a params modifier in an indexer.

 

A13.

The output is:
Infinity

Only integral (int, long, short, byte, uint, ulong, ushort, sbyte, char) and the decimal types throw a DivisionByZero exception when divided by zero.
Float and Double types will return special IEEE754 values such as Infinity or NaN.

 

A14.

The output is:

3.402823E+38
Integer Overflow
Decimal Overflow
3.402823E+38
-2147483639
Decimal Overflow

Overflows in integral (int, long, short, byte, uint, ulong, ushort, sbyte, char) types wrap around in an unchecked context. In a checked context they throw an overflow exception.
Overflows in floating point (float and double) types always wrap around and never throw an overflow exception in any context. They can also produce special IEEE754 values such as Infinity or NaN as results.
Overflows in the decimal type always throw an overflow exception in any context.

 

A15.

The output is:
C.M2 : 0

When C's constructor is called, It implicitly calls the base constructor before the field f assignment.
B's constructor calls the M1 method, a virtual-instance method, which resolves to method C.M1.
At the point when C.M1 is called from B's constructor, the value of field f has not been assigned yet and is the default value of zero. 

 

A16.

The output is:

False
False
False
True

By default the Equals method compares references in reference types. i.e returns true if both variables refer to the same object.
In value types, it will compare the types of the variables. If they are not the same, it returns false.
If they are the same type, it will compare the value of each field (including private ones).

Introducing C# Pad

I’m excited to present C# Pad, an interactive web based C# REPL.

Have you ever wanted to quickly evaluate an expression or test some code, like say try out different DateTime string formats or test a method or clear up some confusion (like what’s the difference between Uri.EscapeDataString and Uri.EscapeUriString or what new Random().Next(0) returns), or decode some string in Base64 or some other format?

C# Pad lets you easily do all those things and a whole lot more.

Interactive REPL

Do you see the embedded code pad below? Go ahead and hit the Go button.

var greeting = "こんにちは世界";
Console.WriteLine("{0} in Japanese is {1}", "Hello World", greeting);

After the submission is processed, you’ll see the result of the code evaluation.
Now, in the same code pad, type Console.WriteLine(greeting.Length) and hit Go.

As you can see, the greeting variable from the previous submission is accessible in the code editor.
That’s because C# Pad is a REPL. Objects in previous submissions are visible and accessible from the current one.
( Did you also notice the cool code completion? :) )

You don’t need to call Console.WriteLine to display results. Simply type the variable name (without a semicolon) in the last line of a code submission and the string representation of the variable’s value will be displayed. 
For example, type greeting in the same code pad and hit Go to see its value.

The following code pad contains a method that encodes an input string in Base64 format.

using System.IO;
using System.Text;

string Base64Encode(string input)
{
    if(input == null) throw new ArgumentNullException("input");
    
    var bytes = Encoding.UTF8.GetBytes(input);
    return Convert.ToBase64String(bytes);
}

Hit Go to submit the method and then type Base64Encode("My string") (do not include a semicolon) and hit Go.

You’ll observe the result is a string in Base64 format, encoded by the method that was defined in an earlier submission. Because the semicolon was left out, the result of the evaluation was displayed.

You can use C# Pad to write complex code, define classes and methods and evaluate all kinds of expressions ranging from simple mathematical expressions like 60 * 60 * 24 or Math.Sin((30 * Math.PI)/ 180) to LINQ expressions.

(from c in "The quick brown fox jumps over the lazy dog".ToLower()
group c by c into grp
select new { Letter = grp.Key, Count = grp.Count() }).ToArray()

C# Everywhere

You can embed interactive code pads in your blog, website or any site you can edit, just like I have in this blog post. You can even select a theme that matches your site.
Yes, this means you can now create a C# playground anywhere. Simply visit csharppad.com, compose the code you’d like to embed, click the embed button and follow the instructions.  

Here’s an example JSBin with an embedded code pad.

You can also load and save Github Gists.
To load a Gist, open csharppad.com/gist/_gist_owner_/_gist_id or simply csharppad.com/gist/_gist_id

As examples, the links below open up Gists in C# Pad.

http://csharppad.com/gist/9220821
http://csharppad.com/gist/octocat/1169852 ( Did you know The Octocat codes in C#? )

To open a single file in a Gist, append ?file_name at the end of the url, like so
http://csharppad.com/gist/9220821?random.cs

Numerical Analysis

The awesome Math.Net Numerics library is bundled with C# Pad, which makes working on complex math and statistics problems a breeze.

The following program integrates the function f(x) = exp(-x/5) (2 + sin(2 * x)) on a closed interval of [0, 100].

using MathNet.Numerics;
Integrate.OnClosedInterval(x => Math.Exp(-x / 5) * (2 + Math.Sin(2 * x)), 0, 100)


The following program generates ten samples of a Poisson distribution with a lambda parameter of 1.

using MathNet.Numerics.Distributions;
var poisson = new Poisson(1);
for(var i = 0; i < 10; i++)
{
    Console.WriteLine("{0:N05}", poisson.Sample());
}


The following program calculates the 75th percentile of an array of numbers.

using MathNet.Numerics;

var percentile = 75;
var array = new double[]{ 89.6, 33.5, 11.6, 44.3, 66.78, 34.78, 97.1, 68.0, 25.7, 48.7};

ExcelFunctions.Percentile(array, percentile / 100d)


The following program multiplies the transpose of a matrix with another matrix.

using MathNet.Numerics.LinearAlgebra.Double;

var matrixA = DenseMatrix.OfArray(new[,] { { 1.0, 2.0, 3.0 }, { 4.0, 5.0, 6.0 }, { 7.0, 8.0, 9.0 } 
});
var matrixB = DenseMatrix.OfArray(new[,] { { 1.0, 3.0, 5.0 }, { 2.0, 4.0, 6.0 }, { 3.0, 5.0, 7.0 } });

matrixA.Transpose() * matrixB

//Same as matrixA.TransposeThisAndMultiply(matrixB)

 

C# Pad is the first and only (as of this writing) web based interactive C# REPL, with code completion, diagnostics, themes, embeddability, timing information, Gist support and more features to come.

I hope you find C# Pad useful and delightful. Drop me a line or use the help link on the site to provide feedback on feature suggestions, bug reports and other kinds of feedback.

Have fun!