C# Reference

• Call a method on the base class that has been overridden by another method.
• Specify which base-class constructor should be called when creating instances of the derived class.

A base class access is permitted only in a constructor, an instance method, or an instance property accessor.

It is an error to use the base keyword from within a static method.

The base class that is accessed is the base class specified in the class declaration. For example, if you specify class ClassB : ClassA, the members of ClassA are accessed from ClassB, regardless of the base class of ClassA.

• The switch statement: Specifies the default label.
• Generic code: Specifies the default value of the type parameter. This will be null for reference types and zero for value types.

public class Publisher

{

// Declare the delegate (if using non-generic pattern).

public delegate void SampleEventHandler(object sender, SampleEventArgs e);

// Declare the event.

public event SampleEventHandler SampleEvent;

// Wrap the event in a protected virtual method

// to enable derived classes to raise the event.

protected virtual void RaiseSampleEvent()

{

// Raise the event by using the () operator.

if (SampleEvent != null)

SampleEvent(this, new SampleEventArgs(“Hello”));

}

}

Events are a special kind of multicast delegate that can only be invoked from within the class or struct where they are declared (the publisher class). If other classes or structs subscribe to the event, their event handler methods will be called when the publisher class raises the event.

Events can be marked as public, private, protected, internal, or protectedinternal. These access modifiers define how users of the class can access the event.

This conversion operator can be invoked like this:

Fahrenheit f = new Fahrenheit(100.0f);

Console.Write(“{0} fahrenheit”, f.Degrees);

Celsius c = (Celsius)f;

The conversion operator converts from a source type to a target type. The source type provides the conversion operator. Unlike implicit conversion, explicit conversion operators must be invoked by means of a cast. If a conversion operation can cause exceptions or lose information, you should mark it explicit. This prevents the compiler from silently invoking the conversion operation with possibly unforeseen consequences.

• false Operator : Returns the bool value true to indicate that an operand is false and returns false otherwise. Prior to C# 2.0, the true and false operators were used to create user-defined nullable value types that were compatible with types such as SqlBool. However, the language now provides built-in support for nullable value types, and whenever possible you should use those instead of overloading the true and false operators. For more information, see Nullable Types (C# Programming Guide).
• false Literal : Represents the boolean value false.

Point pt = new Point();

// Using fixed allows the address of pt members to be

// taken, and “pins” pt so it isn’t relocated.

fixed (int* p = &pt.x)

{

*p = 1;

}

}

// User-defined conversion from Digit to double

public static implicit operator double(Digit d)

{

return d.val;

}

// User-defined conversion from double to Digit

public static implicit operator Digit(double d)

{

return new Digit(d);

}

}

Digit dig = new Digit(7);

//This call invokes the implicit “double” operator

double num = dig;

//This call invokes the implicit “Digit” operator

Digit dig2 = 12;

• Methods
• Properties
• Indexers
• Events

An interface can inherit from one or more base interfaces.

When a base type list contains a base class and interfaces, the base class must come first in the list.

A class that implements an interface can explicitly implement members of that interface. An explicitly implemented member cannot be accessed through a class instance, but only through an instance of the interface.

For more details and code examples on explicit interface implementation, see Explicit Interface Implementation (C# Programming Guide). Or read below

Explicit Interface :

If a class implements two interfaces that contain a member with the same signature, then implementing that member on the class will cause both interfaces to use that member as their implementation.

interface IControl

{

void Paint();

}

interface ISurface

{

void Paint();

}

class SampleClass : IControl, ISurface

{

// Both ISurface.Paint and IControl.Paint call this method.

public void Paint()

{

}

}

If the two interface members do not perform the same function, however, this can lead to an incorrect implementation of one or both of the interfaces. It is possible to implement an interface member explicitly—creating a class member that is only called through the interface, and is specific to that interface. This is accomplished by naming the class member with the name of the interface and a period.

public class SampleClass : IControl, ISurface

{

void IControl.Paint()

{

System.Console.WriteLine(“IControl.Paint”);

}

void ISurface.Paint()

{

System.Console.WriteLine(“ISurface.Paint”);

}

}

Explicit implementation is also used to resolve cases where two interfaces each declare different members of the same name such as a property and a method:

The lock keyword ensures that one thread does not enter a critical section of code while another thread is in the critical section. If another thread tries to enter a locked code, it will wait, block, until the object is released.

The lock keyword calls Enter at the start of the block and Exit at the end of the block.

In general, avoid locking on a public type, or instances beyond your code’s control. The common constructs lock (this), lock (typeof (MyType)), and lock (“myLock”) violate this guideline:

• lock (this) is a problem if the instance can be accessed publicly.
• lock (typeof (MyType)) is a problem if MyType is publicly accessible.
• lock(“myLock”) is a problem because any other code in the process using the same string, will share the same lock.

Best practice is to define a private object to lock on, or a private static object variable to protect data common to all instances.

• another namespace
• class
• interface
• struct
• enum
• delegate

Whether or not you explicitly declare a namespace in a C# source file, the compiler adds a default namespace. This unnamed namespace, sometimes referred to as the global namespace, is present in every file. Any identifier in the global namespace is available for use in a named namespace.

Namespaces implicitly have public access and this is not modifiable.

public class BaseC

{

public int x;

public void Invoke() { }

}

public class DerivedC : BaseC

{

new public void Invoke() { }

}

new Constraint

Used to restrict types that might be used as arguments for a type parameter in a generic declaration.

The new constraint specifies that any type argument in a generic class declaration must have a public parameterless constructor. To use the new constraint, the type cannot be abstract.

Apply the new constraint to a type parameter when your generic class creates new instances of the type, as shown in the following example:

class ItemFactory<T> where T : new()

{

public T GetNewItem()

{

return new T();

}

}

• parameter modifier in parameter lists : The out keyword causes arguments to be passed by reference. This is like the ref keyword, except that ref requires that the variable be initialized before it is passed. To use an out parameter, both the method definition and the calling method must explicitly use the out keyword.

generic type parameters in generic interfaces and delegates : For generic type parameters, the out keyword specifies that the type parameter is covariant. You can use the out keyword in generic interfaces and delegates.

Covariance enables you to use a more derived type than that specified by the generic parameter. This allows for implicit conversion of classes that implement variant interfaces and implicit conversion of delegate types. Covariance and contravariance are supported for reference types, but they are not supported for value types.

An interface that has a covariant type parameter enables its methods to return more derived types than those specified by the type parameter. For example, because in .NET Framework 4, in IEnumerable<T>, type T is covariant, you can assign an object of the IEnumerabe(Of String) type to an object of the IEnumerable(Of Object) type without using any special conversion methods.

A covariant delegate can be assigned another delegate of the same type, but with a more derived generic type parameter.

For more information, see Covariance and Contravariance (C# and Visual Basic).

// Covariant interface.

interface ICovariant<out R> { }

// Extending covariant interface.

interface IExtCovariant<out R> : ICovariant<R> { }

// Implementing covariant interface.

class Sample<R> : ICovariant<R> { }

ICovariant<Object> iobj = new Sample<Object>();

ICovariant<String> istr = new Sample<String>();

// You can assign istr to iobj because

// the ICovariant interface is covariant.

iobj = istr;

For more information about how to use the override keyword, see Versioning with the Override and New Keywords (C# Programming Guide) and Knowing when to use Override and New Keywords.

• Enum types
• Pointer types
• User-defined structs that do not contain any fields or properties that are reference types

Classes and static classes may have static constructors. Static constructors are called at some point between when the program starts and the class is instantiated.

public static int WordCount(this String str)

{

return str.Split(new char[] { ‘ ‘, ‘.’, ‘?’ }, StringSplitOptions.RemoveEmptyEntries).Length;

}

}

}

The following example shows an extension method defined for the System.String class.

int1 = unchecked(ConstantMax + 10);

• As a directive, when it is used to create an alias for a namespace or to import types defined in other namespaces. See using Directive.

As a statement, when it defines a scope at the end of which an object will be disposed. See using Statement : Provides a convenient syntax that ensures the correct use of IDisposable objects. File and Font are examples of managed types that access unmanaged resources (in this case file handles and device contexts). There are many other kinds of unmanaged resources and class library types that encapsulate them. All such types must implement the IDisposable interface.

As a rule, when you use an IDisposable object, you should declare and instantiate it in a using statement. The using statement calls the Dispose method on the object in the correct way, and (when you use it as shown earlier) it also causes the object itself to go out of scope as soon as Dispose is called. Within the using block, the object is read-only and cannot be modified or reassigned.

The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object. You can achieve the same result by putting the object inside a try block and then calling Dispose in a finally block; in fact, this is how the using statement is translated by the compiler.

When a virtual method is invoked, the run-time type of the object is checked for an overriding member. The overriding member in the most derived class is called, which might be the original member, if no derived class has overridden the member.

By default, methods are non-virtual. You cannot override a non-virtual method.

You cannot use the virtual modifier with the static, abstract, private, or override modifiers.

Virtual properties behave like abstract methods, except for the differences in declaration and invocation syntax.

• It is an error to use the virtual modifier on a static property.
• A virtual inherited property can be overridden in a derived class by including a property declaration that uses the override modifier.

• Reference types.
• Pointer types (in an unsafe context). Note that although the pointer itself can be volatile, the object that it points to cannot. In other words, you cannot declare a “pointer to volatile.”
• Types such as sbyte, byte, short, ushort, int, uint, char, float, and bool.
• An enum type with one of the following base types: byte, sbyte, short, ushort, int, or uint.
• Generic type parameters known to be reference types.
• IntPtr and UIntPtr.

The volatile keyword can only be applied to fields of a class or struct. Local variables cannot be declared volatile.

The following example demonstrates how an auxiliary or worker thread can be created and used to perform processing in parallel with that of the primary thread. For background information about multithreading, see Managed Threading and Threading (C# and Visual Basic).

using System;

using System.Threading;

public class Worker

{

// This method is called when the thread is started.

public void DoWork()

{

while (!_shouldStop)

{

Console.WriteLine(“Worker thread: working…”);

}

Console.WriteLine(“Worker thread: terminating gracefully.”);

}

public void RequestStop()

{

_shouldStop = true;

}

// Keyword volatile is used as a hint to the compiler that this data

// member is accessed by multiple threads.

private volatile bool _shouldStop;

}

public class WorkerThreadExample

{

static void Main()

{

// Create the worker thread object. This does not start the thread.

Worker workerObject = new Worker();

Thread workerThread = new Thread(workerObject.DoWork);

// Start the worker thread.

workerThread.Start();

Console.WriteLine(“Main thread: starting worker thread…”);

// Loop until the worker thread activates.

while (!workerThread.IsAlive) ;

// Put the main thread to sleep for 1 millisecond to

// allow the worker thread to do some work.

Thread.Sleep(1);

// Request that the worker thread stop itself.

workerObject.RequestStop();

// Use the Thread.Join method to block the current thread

// until the object’s thread terminates.

workerThread.Join();

Console.WriteLine(“Main thread: worker thread has terminated.”);

}

// Sample output:

// Main thread: starting worker thread…

// Worker thread: working…

// Worker thread: working…

// Worker thread: working…

// Worker thread: working…

// Worker thread: working…

// Worker thread: working…

// Worker thread: terminating gracefully.

// Main thread: worker thread has terminated.

}

add

{

lock (PreDrawEvent)

{

PreDrawEvent += value;

}

}

remove

{

lock (PreDrawEvent)

{

PreDrawEvent -= value;

}

}

}

}

You do not typically need to provide your own custom event accessors. The accessors that are automatically generated by the compiler when you declare an event are sufficient for most scenarios.

extern alias GridV2;

Each extern alias declaration introduces an additional root-level namespace that parallels (but does not lie within) the global namespace. Thus types from each assembly can be referred to without ambiguity by using their fully qualified name, rooted in the appropriate namespace-alias.

dynamic dyn = 1;

object obj = 1;

// Rest the mouse pointer over dyn and obj to see their

// types at compile time.

System.Console.WriteLine(dyn.GetType());

System.Console.WriteLine(obj.GetType());

}

}

The following example contrasts a variable of type dynamic to a variable of type object. To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statements. IntelliSense shows dynamic for dyn and object for obj.

• The data source on which the query or sub-query will be run.
• A local range variable that represents each element in the source sequence.

Both the range variable and the data source are strongly typed. The data source referenced in the from clause must have a type of IEnumerable, IEnumerable<T>, or a derived type such as IQueryable<T>.

If you want to perform additional query operations on each group, you can specify a temporary identifier by using the into contextual keyword. When you use into, you must continue with the query, and eventually end it with either a select statement or another group clause, as shown in the following excerpt:

// Group students by the first letter of their last name

// Query variable is an IEnumerable<IGrouping<char, Student>>

var studentQuery2 =

from student in students

group student by student.Last[0] into g

orderby g.Key

select g;

• Inner join
• Group join : A group join produces a hierarchical result sequence, which associates elements in the left source sequence with one or more matching elements in the right side source sequence. A group join has no equivalent in relational terms; it is essentially a sequence of object arrays.
• Left outer join

var innerJoinQuery =

from category in categories

join prod in products on category.ID equals prod.CategoryID

select new { ProductName = prod.Name, Category = category.Name }; //produces flat sequence

};

// Split the sentence into an array of words

// and select those whose first letter is a vowel.

var earlyBirdQuery =

from sentence in strings

let words = sentence.Split(‘ ‘)

from word in words

let w = word.ToLower()

where w[0] == ‘a’ || w[0] == ‘e’

|| w[0] == ‘i’ || w[0] == ‘o’

|| w[0] == ‘u’

select word;

• Signatures in both parts of the partial type must match.
• The method must return void.
• No access modifiers or attributes are allowed. Partial methods are implicitly private.

where score > 80

select score;

// ordinary virtual property with backing field

private int num;

public virtual int Number

{

get { return num; }

set { num = value; }

}

}

class MyDerivedClass : MyBaseClass

{

private string name;

// Override auto-implemented property with ordinary property

// to provide specialized accessor behavior.

public override string Name

{

get

{

return name;

}

set

{

if (value != String.Empty)

{

name = value;

}

else

{

name = “Unknown”;

}

}

}

}

• Unsafe blocks are not allowed.
• Parameters to the method, operator, or accessor cannot be ref or out.
• A yield return statement cannot be located anywhere inside a try-catch block. It can be located in a try block if the try block is followed by a finally block.
• A yield break statement may be located in a try block or a catch block but not a finally block.

A yield statement cannot appear in an anonymous method. For more information, see Anonymous Methods (C# Programming Guide).

When used with expression, a yield return statement cannot appear in a catch block or in a try block that has one or more catch clauses. For more information, see Exception Handling Statements (C# Reference).

public class List

{

//using System.Collections;

public static IEnumerable Power(int number, int exponent)

{

int counter = 0;

int result = 1;

while (counter++ < exponent)

{

result = result * number;

yield return result;

}

}

static void Main()

{

// Display powers of 2 up to the exponent 8:

foreach (int i in Power(2, 8))

{

Console.Write(“{0} “, i);

}

}

}

/*

Output:

2 4 8 16 32 64 128 256

*/