Language Extensions In C# 2.0

List<int> mylist = new List<int>(); // Avoid boxing/unboxing and up-casting/down-casting
mylist.Add(99); // Compile-time error if you add any other type
// mylist.Add("Wrong type passed"); // Uncommenting this line will result in a compile-time error

// Similarly, you can define your custom generic class, for example:
public class MyList<T>
{
    T[] items;
    int counter;

    public void Add(T item)
    {
        // code here
    }

    public void Remove(T item)
    {
        // code here
    }
}

MyList<int> objList = new MyList<int>();
objList.Add(3); // This eliminates boxing/unboxing or casting operations

// The following line will result in a compile-time error
// objList.Add("This is a test message");

public class MyHash<TKey, TValue>
{
    // Rest of the code here
}

public class MyList<T>
{
    public void Add(T item)
    {
        T x; // Define your variable x
        if (Comparer<T>.Default.Compare(item, x) < 0)
        {
            // Code here
        }
    }
}

public class MyList<T> where T : IComparable
{
    public void Add(T item)
    {
        T x; // Define your variable x
        if (item.CompareTo(x) < 0)
        {
            // Code here
        }
    }
}

public interface IComparableList<T> : IComparable<T>, IList<T>
{
    // Additional members or methods if needed
}

public class MyList<T> where T : IComparableList<T>
{
    // Your code here
}

class List<T>
{
    // ...

    // This method adds items of type U to the list
    void Add<U>(List<U> items) where U : T
    {
        // Implementation of the Add method
    }
}

public class MyClass<T, U, V> where T : V
{
    // Rest of the class code here
}

class C<T>
{
    static int count = 0;

    public C()
    {
        count++;
    }

    public static int Count
    {
        get { return count; }
    }
}

class Application
{
    static void Main()
    {
        // Same closed constructed type because count is int type.
        C<int> x1 = new C<int>();
        Console.WriteLine(C<int>.Count); // Prints 1

        // Different closed constructed types
        C<double> x2 = new C<double>();
        Console.WriteLine(C<int>.Count); // Prints 1

        // Same closed constructed type because count is int type
        C<int> x3 = new C<int>();
        Console.WriteLine(C<int>.Count); // Prints 2
    }
}

public class MyList<T> where T : IComparable
{
    public void Add(T item)
    {
        T temp = default(T);
    }
}

An iterator may be used as the body of a function member as long as the return type of the function member is one of the enumerator interfaces or one of the enumerable interfaces.

• The enumerator interfaces are System.Collections.IEnumerator and types constructed from System.Collections.Generic.IEnumerator<T>.
• The enumerable interfaces are System.Collections.IEnumerable and types constructed from System.Collections.Generic.IEnumerable<T>.

It is important to understand that an iterator is not a kind of member but is a means of implementing a function member. A member implemented via an iterator may be overridden or overloaded by other members, which may or may not be implemented with iterators.

Look at the below example. This is a simple collection class that stores the days of the week as strings. For each iteration of a foreach loop, a different day of the week string is returned.

using System;
using System.Collections;
using System.Collections.Generic;

public class List
{
    public static IEnumerable<int> 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

In the above example, the yield keywords are used to return the value(s). When the yield return statement is reached, the current location is stored. Execution is restarted from this location the next time the iterator is called. The iterator block must be called multiple times (seven times in this example) before its own for loop finishes returning all its values. This is what the calling foreach does. Iterators are especially useful with collection classes, providing an easy way of iterating non-trivial data structures such as binary trees. Below are some of the important points to be kept in mind.

1. An iterator is a section of code that returns an ordered sequence of values.
2. An iterator can be used as the body of a method, an operator, or a get accessor.
3. The interactor code uses the yield return statement to return each element in turn.
4. Using iterators, it is no longer necessary to implement the interfaces System.Collections.IEnumerable and System.Collections.IEnumerator when creating a collection class that supports foreach. The compiler does this work for you.
5. The return type of an iterator must be System.Collections.IEnumerable, System.Collections.IEnumerator or one of the generic iterator interfaces.

The other feature of iterators is you can give names to the iterators, such as MyIterator Let's rewrite the previous example with named iterators.

using System;
using System.Collections.Generic;

public class List
{
    public IEnumerable<int> MyIterator(int number, int exponent)
    {
        int counter = 0;
        int result = 1;

        while (counter++ < exponent)
        {
            result = result * number;
            yield return result;
        }
    }

    static void Main()
    {
        List myList = new List();

        // Display powers of 2 up to the exponent 8:
        foreach (int i in myList.MyIterator(2, 8))
            Console.Write("{0} ", i);
    }
}

Likewise, you can use iterators with Generics, for example, creating iterators block for Generic list as below.

using System;
using System.Collections.Generic;
class MyGenericClass<T>
{
    T[] value;
    public void AddElement(T[] t)
    {
        value = t;
    }
    public IEnumerator<T> GetEnumerator()
    {
        foreach (T t in value)
            yield return t;
    }
}
class MainClass
{
    static void Main()
    {
        MyGenericClass<int> myGenericObject = new MyGenericClass<int>();
        myGenericObject.AddElement(new int[] { 1, 3, 5, 7, 9 });
        Console.WriteLine("The elements of \"myGenericObject\" are:");
        foreach (int i in myGenericObject)
        {
            Console.WriteLine(i);
        }
    }
}

value = t; } public IEnumerator<T> GetEnumerator() { foreach (T t in value) yield return t; } } class MainClass { static void Main() { MyGenericClass<int> myGenericObject = new MyGenericClass<int>(); myGenericObject.AddElement(new int[] { 1, 3, 5, 7, 9 }); Console.WriteLine("The elements of \"myGenericObject\" are:"); foreach (int i in myGenericObject) { Console.WriteLine(i); } } }

Output

3. Partial class in C#

Partial class is one of the language enhancements in Visual Studio 2005. Partial class means the class definition can be split into multiple physical files (.cs or .vb files). Each source file contains a section of class definition, and at compile time compiler groups together all partial classes and treats them as a single entity. The benefits of partial class are.

1. It spreads the class into multiple files and allows the developers to work on different parts of the class instead of sharing the same physical file. We often face this problem while working on large projects.
2. It separates the business logic and system-generated code ( code generated when creating Windows form or web service wrapper code ). This makes debugging easier because the designer-generated code is separated from business logic and prevents developers from messing with the code.

To split the class, use the partial keyword, for example.

// PartialDemo1.cs
partial public class MyClass
{
    public TestMethod1() { }
}

// PartialDemo2.cs
partial public class MyClass
{
    public TestMethod2() { }
}

Note. Partial class does not make any difference to the compiler; during compile time, it simply groups all the partial classes and treats them as a single entity (class).

There are a few points one should register in his/her mind while working with a partial class, as below.

1. Partial type definition must be in the same assembly/module (dll or exe), and it can not span multiple modules
2. All partial type definitions must be meant to be parts of the same type and must be specified with partial keywords.

   partial public class MyClass { }
   public class MyClass { } // generates a compile-time error
   

3. Generics type can be partial to the class name, and generic type parameters must match. For example

   partial public class MyList<T>
   {
       T[] items;
       int counter;
   
       public void Add(T item)
       {
           // code here
       }
   }
   
   partial public class MyList<T>
   {
       public void Remove(T item)
       {
           // code here
       }
   }
   
   
   

Note. You can also specify the constraints (where clauses) along with partial type definition.

• Any accessibility modifier is allowed with partial type definitions like public/private/protected/internal.
• .Nested partial type allowed in the partial type definition, For example

  // Myclass1.cs
  partial class Myclass
  {
      partial class MyNested { }
  }
  
  // Myclass2.cs
  partial class Myclass
  {
      partial class MyNested { }
  }
  

• Attributes of partial classes are merged at compile time. For example

  // Myclass1.cs
  [XYZ]
  partial class Myclass { }
  
  // Myclass2.cs
  [ABC]
  partial class Myclass { }
  

4. Nullable types in C#

Suppose we look at the existing Framework 1. X One of the main differences between reference type and value type is reference type supports null value. That means if you do not want the reference type ( such as string, class) to refer to any value, simply assign null (Nothing in VB.NET) to it as the value type always contains a value. One interesting thing about value type is that even if you explicitly pass null to it, value type just gets assigned to its default value; let's say if you assign null to an integer, it is just assigned to Zero. Framework 2.0 allows to assignment of null to variable types; it's called Nullable types.

The next question is, what are the benefits of nullable types? To answer this question, let me explain one example let's say you are interacting with a database column called Employee. Salary, In some scenarios, it stores NULL ( salary of retired employee). If you capture this value to an integer, it stores zero, which means it misleads that still the employee is working without salary, but for this, we have a System.Data.SqlTypes namespace, But those types do a lot of extra SQL-type stuff. Wouldn't it be nice to have this for all value types? There are a few other ways to assign null to primitive data types like boxed value type. This is not strongly typed at compile-time and involves doing a heap allocation for every type or a class wrapper for the value type. This is strongly typed but still involves a heap allocation, and you have to write the wrapper, which is not recommended and involves performance issues. One best solutions to this problem is Nullable Type.

Nullable types address the scenario where you want to be able to have a primitive type with a null value. Nullable types are constructed using the? type modifier. For example, int? is the nullable form of the predefined type int. A nullable type's underlying type must be a value type. Now how it is possible? yes, the answer is because of Generics, for example.

// Nullable Type Example
int? x;

if (x != null)
{
    Console.WriteLine(x.Value);
}
else
{
    Console.WriteLine("Undefined");
}

If we look at the design of nullable type in VS2005, it's nothing but a nullable type is a structure that combines a value of the underlying type with a boolean null indicator. An instance of a nullable type has two public read-only properties: HasValue, of type bool, and Value, of the nullable type's underlying type. HasValue is true for a non-null instance and false for a null instance. When HasValue is true, the Value property returns the contained value. When HasValue is false, an attempt to access the Value property throws an exception as below.

struct Nullable<T>
{
    public bool HasValue;
    public T Value;
}

You can use this struct directly, but we have also added some shortcut syntax to make the resulting code much cleaner. The first is the introduction of a new syntax for declaring a nullable type rather than typing.

Nullable<int> x = new Nullable<int>(125);

You can write.

int? x = 125; // more simplified way of working

Likewise, if I wanted to add two nullable ints together and preserve null, then here is the sample code.

int? x = 125; 
int? y = 33; 
int? z = x + y;

Let's have a quick recap of the properties of of Nullable type.

1. Nullable types are used to create variables that can contain an undefined state.
2. The syntax T? is shorthand for System.Nullable<T>, where T is a data type. The two forms are interchangeable.
3. The HasValue property returns true if the variable contains a value or false if it is null.
4. The Value property returns a value if one is assigned; otherwise, a System.InvalidOperationException is thrown.
5. The default value for a nullable type variable sets HasValue to false. The Value is undefined.

5. Anonymous Method in C#

The anonymous method is one of the new features of C# 2.0. As the name implies, it is a nameless method called by a delegate, which means it is a mechanism to pass a block of code as a parameter. The anonymous method reduces the coding overhead in instantiating delegates by eliminating the need to create a separate method, increasing usability and code maintainability, for example, in .NET Framework 1. X to invoke a delegate, we attach a method to it as below.

partial class MyClass
{
    delegate void MyDelegate();
    
    public void TestMessage()
    {
        MessageBox.Show("Hello User group");
    }
    
    public void CallDelegate()
    {
        MyDelegate myDel = new MyDelegate(TestMessage);
        MyDel();
    }
}

Now let's rewrite the above code to demonstrate the anonymous method.

partial class MyClass
{
    delegate void MyDelegate();

    public void CallDelegate()
    {
        MyDelegate myDel = delegate()
        {
            MessageBox.Show("Hello User group");
        };
        MyDel();
    }
}

Anonymous method is defined in-line and not as a member of the class while invoking the delegate. Anonymous method can be used anywhere that a delegate is expected (you can pass an anonymous method into any method that accepts the appropriate delegate type as a parameter). One very good example is while creating a thread containing the code that the thread executes without creating an additional delegate method, as below.

Thread myThread = new Thread(delegate() 
{ 
    //code here 
}
myThread.Start();

Syntax

delegate (parameter list) 
{
  block of code
}.

Note. The scope of the parameter is the anonymous method block.

The following are the few important points you should keep in mind while working with the anonymous method.

1. Unsafe code can not be accessed with an anonymous block.
2. It is an error to have statements like goo, break, or continue inside the anonymous block whose target is outside the block.
3. It is also an error to have the above statements outside the anonymous block whose target is inside the block.
4. The anonymous method can not access the ref or out parameters of an outer scope.
5. When defining an anonymous method with parameters, you define the parameter types and names after the delegate keyword just as if it were a conventional method. The method signature must match the definition of the delegate to which it is assigned.
6. The parameter list of a delegate is compatible with an anonymous method if an anonymous method has no parameter list and the delegate has no out parameters, or the anonymous method includes a parameter list that exactly matches the delegate's parameters in number, types, and modifiers.
7. The return type of a delegate is compatible with an anonymous method if The delegate's return type is void and the anonymous method has no return statements or only return statements with no expression or the delegate's return type is not void, and the expressions associated with all return statements in the anonymous method can be implicitly converted to the return type of the delegate.

6. Global Alias Operator in C#

This is called namespace alias qualifier (:: operator), sometime When we add a type or assembly to another assembly, the names of those types or namespaces may conflict with names because they are already in use in the current assembly, for example.

class MyClass
{
    public int Console = 7;

    static void Main()
    {
        Console.WriteLine("Test Message"); // compile time error
    }
}

If we observe Console, writeLine causes a compile-time error because the System namespace is hidden by MyClass. Sometimes we need to compromise with the variable name in order to overcome this problem, but in C# 2.0, it can be resolved using a Global Alias Operator like global::Console.WriteLine("Test Message"). The key point is when the left identifier is global, the search for the right identifier starts at the global namespace, and you can specify your class as a global space like class MyClass: global::MyParent.The next question is, what about defining or creating your own namespace called System? The answer is it is strongly recommended that we should not create a namespace called system. The global namespace qualifier is your guarantee that you are calling the root namespace. the:: operator is useful in a large project. It's very rare, but sometimes we face that namespace duplication may occur in one to another form.

7. Static class in C#

In C# 1. X if all the members and methods of a class are static and can not be instantiated i.e. having a pubic constructor does not make any sense, to prevent instantiation of such a class, we have to make the constructor private, and one important thing is class has to mark as sealed because static members are not meant for inheritance. In C# 2.0, the static class makes the above tasks more safe and convenient way, The Static class marks the class as sealed with no constructor, and it's a compile-time error if you instantiate the static class. The main problem of the earlier approach ( C# 1. X) is the private constructor takes up space in the IL. Actually, it's not a big issue but has little effect or accidentally, a developer can derive a class from it if you forget to mark it as sealed, and finally, there is no protection against the instance method. The main advantages of a static class are.

• Static classes only contain static members.
• Static classes cannot be instantiated.
• Static classes are sealed.
• Static classes cannot contain a constructor.

The following example demonstrates static class.

public static class MyStaticClass
{
    public static void DispMessage(string strMessage)
    {
        Console.WriteLine(strMessage);
    }
}

partial class Class1
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main(string[] args)
    {
        MyStaticClass.DispMessage("This is a static class");
    }
}

The answer is very simple if the class's methods do not need to be attached to a specific instance of the class, instead of creating unnecessary instances of this class, declare it as a static class for example, if you have a class called Company contains only Two methods called GetCompanyName() and GetCompanyAddress() these methods do not need to be attach to a specific instance of any class so you can make this a static class and call where ever you need company information instead of making unnecessary instance of the class.

8. Fixed Size Buffer

Fixed-size buffer provides flexibility to create fixed-size data structure useful when you are working with unmanaged world such as DLLs or COM components. For example, it's impossible to declare a C++ style fixed-size structure because C# struct containing an array doesn't contain the array elements but instead contains a reference to the elements in C# 2.0, providing flexibility to embed an array of fixed size in a struct when used in an unsafe code block as below.

public struct Employee
{
    public fixed char EmpName[50];
    public int EmpID;
}

The first element is a 50-byte array, and EmpID is a 4-byte int. The main advantage of the above code is EmpName array is of is fixed size and location and can be used with unsafe code.

If we want to implement the above in C# 1. X, it will be as below.

public struct Employee
{
    public string EmpName; // Use string for variable-sized text data
    public int EmpID;
}

The difference between the above code and the C# 2.0 fixed size buffer is that the above code struct would be 8 bytes in size, where the EmpName array is a reference to the heap-allocated array.

The other difference between an unsafe buffer array and a normal array is.

• You can only use unsafe buffers in an unsafe context.
• Unsafe buffers are always one-dimensional arrays.
• The declaration of the array should include a count, for example, char Name[15]. You cannot use char Name[] instead.
• Unsafe buffers can only be instance fields of structs in an unsafe context.
• The C# compiler and the CLR do not perform any security buffer overrun checks as with all unsafe code.

9. Friend Assemblies in C#

The friend assemblies are one of the cool stuff of C# 2.0. The philosophy behind friend assemblies is all the non-public types in an assembly can be accessed by another assembly by declaring the first assembly as a "friend" of the second For example, you have some types in your assembly A, and you have another assembly B. You really want assembly B to see those types. But you don't want them to open to the world. In order to implement in C# 2.0, we have to make assembly B a friend of assembly A. A friend assembly is declared by using the InternalsVisibleToAttribute as below.

[assembly: InternalsVisibleTo("AssemblyB, PublicKeyToken=32ab4ba45e0a69a1")]

In C# 1. X, you can implement by marking those types as public and then decorating them with StrongNameIdentityPermission.

The main difference between StrongNameIdentityPermission and friend assembly is.

1. StrongNameIdentityPermission applies to individual types, while friend assembly applies to the whole assembly example; if there are hundreds of types in assembly A that you want to share with assembly B, you have to decorate all of them with StrongNameIdentityPermission. While using friend assembly, you only need to state it once.
2. More importantly, with StrongNameIdentityPermission, the types you want to share have to be declared as public. In the friend assembly case, those types can (and should) be nonpublic.
3. There can be only one StrongNameIdentityPermission on one type. But you can declare as many assemblies as your friends.

Finally, we must keep two things in mind while working with friend assemblies. Friend Assemblies are one way only, which means When assembly A says assembly B is its friend, it does not imply assembly A is assembly B's friend. You will have to declare the friendship explicitly in assembly B, and Friendship is not transitive. That means if Assembly C is a friend of Assembly B, and Assembly B is the friend of Assembly A, Assembly C does not automatically become a friend of Assembly A.

10. #Pragma warning in C#

C# language has many preprocessor directives like #if,#else,#endif Similarly, #pragma warning is one type of preprocessor directive. These directives are used to aid in conditional compilation. Unlike C and C++ directives, you cannot use these directives to create macros, and the preprocessor directive must be the only instruction on a line.

The #Pragma warning directive is used to enable or restore all or certain warning messages during compilation.

Syntax

#pragma warning disable warning-list (disable directive disables the specified set of warnings)
#pragma warning restore warning-list (restore directives restore the specified set of warnings)

If you disable the warning externally ( I mean by setting /nowarn option), # pragma restore will not enable the warning.

For example, disable and restore the CLSCompliant attribute (cs3021).

// pragma_warning.cs
using System;

#pragma warning disable 3021
[CLSCompliant(false)]
public class MyClass
{
    int i = 1;

    public static void Main()
    {
        // Write your code here
    }
}
#pragma warning restore 3021
[CLSCompliant(false)]
public class MyClass
{
    int i = 1;

    public static void Main()
    {
        // Write your code here
    }
}