C Sharp 2.0
The
C# 2.0 Features
Partial class
file1.cs:
public partial class MyClass
{
public void MyMethod1()
{
// Manually written code
}
}
file2.cs:
public partial class MyClass
{
public void MyMethod2()
{
// Automatically generated code
}
}
Generics
Static classes
Static classes are classes that cannot be instantiated or inherited from, and that only allow static members. Their purpose is similar to that of
Generator functionality
The .NET 2.0 Framework allowed C# to introduce an
With ayield return
, the function automatically keeps its state during the iteration.
// Method that takes an iterable input (possibly an array)
// and returns all even numbers.
public static IEnumerable<int> GetEven(IEnumerable<int> numbers)
{
foreach (int i in numbers)
{
if (i % 2 == 0)
yield return i;
}
}
There is also a yield break
statement, in which control is unconditionally returned to the caller of the iterator. There is an implicit yield break
at the end of each generator method.
Anonymous delegates
As a precursor to the
out
and ref
parameters. For example:-
int SumOfArrayElements(int[] array)
{
int sum = 0;
Array.ForEach(array,
delegate(int x)
{
sum += x;
}
);
return sum;
}
Unlike some closure implementations, each anonymous delegate instance has access to the same relative memory location for each bound variable, rather than to the actual values at each creation. See a
Delegate covariance and contravariance
Conversions from method groups to delegate types are covariant and contravariant in return and parameter types, respectively.[4]
The accessibility of property accessors can be set independently
Example:
string status = string.Empty;
public string Status
{
get { return status; } // anyone can get value of this property,
protected set { status = value; } // but only derived classes can change it
}
Nullable value types
int? i = null;
) which add null
to the set of allowed values for any value type. This provides improved interaction with SQL databases, which can have nullable columns of types corresponding to C# primitive types: an SQL INTEGER NULL
column type directly translates to the C# int?
.
Nullable value types received an improvement at the end of August 2005, shortly before the official launch, to improve their boxing characteristics: a nullable variable which is assigned null is not actually a null reference, but rather an instance of struct Nullable<T>
with property HasValue
equal to false
. When boxed, the Nullable
instance itself is boxed, and not the value stored in it, so the resulting reference would always be non-null, even for null values. The following code illustrates the corrected flaw:
int? i = null;
object o = i;
if (o == null)
System.Console.WriteLine("Correct behaviour - runtime version from September 2005 or later");
else
System.Console.WriteLine("Incorrect behaviour - pre-release runtime (from before September 2005)");
When copied into objects, the official release boxes values from Nullable
instances, so null values and null references are considered equal. The late nature of this fix caused some controversy[5]
, since it required core-CLR changes affecting not only .NET2, but all dependent technologies (including C#, VB, SQL Server 2005 and Visual Studio 2005).
Null-coalescing operator
The ??
operator is called the null coalescing operator and is used to define a default value for nullable value types as well as reference types. It returns the left-hand operand if it is not null; otherwise it returns the right operand.[6]
object nullObj = null;
object obj = new Object();
return nullObj ?? obj; // returns obj
The primary use of this operator is to assign a nullable type to a non-nullable type with an easy syntax:
int? i = null;
int j = i ?? 0; // If i is not null, initialize j to i. Else (if i is null), initialize j to 0.
References
- ^ "An Introduction to C# Generics". Microsoft. January 2005. Retrieved June 18, 2009.
- ^ "yield". C# Language Reference. Microsoft. Retrieved 2009-04-26.
- ^ "Anonymous Methods (C#)". C# Programming Guide. Microsoft. Retrieved June 18, 2009.
- ^ "Covariance and Contravariance in Delegates (C#)". C# Programming Guide. Microsoft. Retrieved June 18, 2009.
- MSDN. Retrieved 2008-11-05.
- ^ "?? Operator". C# Reference. Microsoft. Retrieved 2008-11-23.