{

// Skip if 2

if (number == 2) continue;

// Stop iteration if 5 if (number == 5)

break;

Console.Write(number + ", ");

}

// Prints: 1, 3, 4,

Live Demo on .NET Fiddle

Notice that the order of iteration is guaranteed only for certain collections such as arrays and List, but not guaranteed for many other collections.

While IEnumerable is typically used to indicate enumerable collections, foreach only requires that the collection expose publicly the object GetEnumerator() method, which should return an object that exposes the bool MoveNext() method and the object Current { get; } property.

Section 52.20: dynamic

The dynamic keyword is used with dynamically typed objects. Objects declared as dynamic forego compile-time static checks, and are instead evaluated at runtime.

using System;

using System.Dynamic;

dynamic info = new ExpandoObject(); info.Id = 123;

info.Another = 456;

Console.WriteLine(info.Another);

// 456

Console.WriteLine(info.DoesntExist);

// Throws RuntimeBinderException

The following example uses dynamic with Newtonsoft's library Json.NET, in order to easily read data from a deserialized JSON file.

try

{

string json = @"{ x : 10, y : ""ho""}";

dynamic deserializedJson = JsonConvert.DeserializeObject(json); int x = deserializedJson.x;

string y = deserializedJson.y;

// int z = deserializedJson.z; // throws RuntimeBinderException

}

catch (RuntimeBinderException e)

{

//This exception is thrown when a property

//that wasn't assigned to a dynamic variable is used

}

returning). For example:

try

{

connection.Open();

return connection.Get(query);

}

finally

{

connection.Close();

}

The statement connection.Close() will execute before the result of connection.Get(query) is returned.

Section 52.22: void

The reserved word "void" is an alias of System.Void type, and has two uses:

1. Declare a method that doesn't have a return value:

public void DoSomething()

{

// Do some work, don't return any value to the caller.

}

A method with a return type of void can still have the return keyword in its body. This is useful when you want to exit the method's execution and return the flow to the caller:

public void DoSomething()

{

// Do some work...

if (condition) return;

// Do some more work if the condition evaluated to false.

}

2. Declare a pointer to an unknown type in an unsafe context.

In an unsafe context, a type may be a pointer type, a value type, or a reference type. A pointer type declaration is usually type* identifier, where the type is a known type - i.e int* myInt, but can also be void* identifier, where the type is unknown.

Note that declaring a void pointer type is discouraged by Microsoft.

Section 52.23: namespace

The namespace keyword is an organization construct that helps us understand how a codebase is arranged. Namespaces in C# are virtual spaces rather than being in a physical folder.

namespace StackOverflow

{

namespace Documentation

{

namespace CSharp.Keywords

{

public class Program

{

public static void Main()

{

Console.WriteLine(typeof(Program).Namespace);

//StackOverflow.Documentation.CSharp.Keywords

}

}

}

}

}

Namespaces in C# can also be written in chained syntax. The following is equivalent to above:

namespace StackOverflow.Documentation.CSharp.Keywords

{

public class Program

{

public static void Main()

{

Console.WriteLine(typeof(Program).Namespace);

//StackOverflow.Documentation.CSharp.Keywords

}

}

}

Section 52.24: ref, out

The ref and out keywords cause an argument to be passed by reference, not by value. For value types, this means that the value of the variable can be changed by the callee.

int x = 5; ChangeX(ref x);

// The value of x could be different now

For reference types, the instance in the variable can not only be modified (as is the case without ref), but it can also be replaced altogether:

Address a = new Address();

ChangeFieldInAddress(a);

//a will be the same instance as before, even if it is modified

CreateANewInstance(ref a);

//a could be an entirely new instance now

The main di erence between the out and ref keyword is that ref requires the variable to be initialized by the caller, while out passes that responsibility to the callee.

To use an out parameter, both the method definition and the calling method must explicitly use the out keyword.

int number = 1;

Console.WriteLine("Before AddByRef: " + number); // number = 1 AddOneByRef(ref number);

Console.WriteLine("After AddByRef: " + number); // number = 2 SetByOut(out number);

Console.WriteLine("After SetByOut: " + number); // number = 34

void AddOneByRef(ref int value)

{