C# XmlSerialization - Generating XSD from XML, Classes from XSD, Serializing Array of Custom Type and Enumerations etc

Generating XSD from XML:

XSD.exe tool can be used to generate schema file from an XML file. XSD.exe will be available with Visual Studio installation. 

• Open Visual Studio Command Prompt 
• Type in the command "xsd <xml file name(including path) to be used for schema generation>"
• Done. XSD gets generated in the same folder where you XSD command is executed.

Now you have the XSD, What next? 

Note: Generated XSD might not be exactly what you want. It is only according to the XML provided. Enumeration Types or Complex Types might not be created in XSD as you are expecting. Example: Printer Type below looks like an enumeration field, but it isn't obvious from the given XML file.

Example XML File:

<XmlSerializable xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">    <Printers>       <Printer Name="Denali" Type="Mfp"/>       <Printer Name="Garnet" Type="NetworkScanner"/>    </Printers> </XmlSerializable>

Generate XSD File:

<?xml version="1.0" encoding="utf-8"?> <xs:schema id="XmlSerializable" xmlns="" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">   <xs:element name="XmlSerializable" msdata:IsDataSet="true" msdata:UseCurrentLocale="true">     <xs:complexType>       <xs:choice minOccurs="0" maxOccurs="unbounded">         <xs:element name="Printers">           <xs:complexType>             <xs:sequence>               <xs:element name="Printer" minOccurs="0" maxOccurs="unbounded">                 <xs:complexType>                   <xs:attribute name="Name" type="xs:string" />                   <xs:attribute name="Type" type="xs:string" />                 </xs:complexType>               </xs:element>             </xs:sequence>           </xs:complexType>         </xs:element>       </xs:choice>     </xs:complexType>   </xs:element> </xs:schema>

Generate Class from XSD(Schema file):

Again, XSD utility is our buddy here. Run XSD tool with /classes options and provided XSD generated in previous step as input. There you go, XSD generates classes for you.

Auto generated class will have properties and classes generated the way those were present in XSD. In above example, There would be three classes generated, one "XmlSerializable" element, another for element Printers and another for element Printer. Each of these types will "contain" other type as defined by complex types in XSD. 

That said, most of the day to day development activities involve writing classes by serializable by ourselves instead of defining XSDs.  Let's see in brief about how to write xml serializable class in C#.

Coding a Serializable class:

[Everything pertaining to xml serialization is available under the namespace " System.Xml.Serialization"]

Create a class with properties for data that you want to contain in that class. Each of these property can again be a type that is serializable. Attributes on the top of properties control the way the data gets serialized or organized in the XML file. You can find the complete list of attributes available here. Each type which is part of another serializable type can be thought of as Complex type in XSD.

Note: Adding wrong attributes may result in a different xml than what you expect. Read through use the attributes list and their usage for creating serializable class

Example: Marking a property as XmlArray indicates that the property will hold array of items,where you need also to mark the item type by specifying XmlArrayItem.

Enumeration values can be marked by attribute "XmlEnum". Serializer will then place the Enumeration Type in place of Enumeration value in the Serialized Xml.

Steps involved in serialization:

1. Create a XML Serializer isntance by proving the type which you are intending to serialize.
2. Open a stream to the ouput xml file.
3. Provide this stream and instance to the serialize method of serializer instance created.
4. Close the stream and serialized data will be in output file mentioned in step 2.

Serializing Code :

XmlSerializable x = new XmlSerializable();
            x.Printers = new Printer[2];

            x.Printers[0] = new Printer();
            x.Printers[0].Type = PrinterType.Mfp;
            x.Printers[0].Name = "Denali";

            x.Printers[1] = new Printer();
            x.Printers[1].Type = PrinterType.NetworkScanner;
            x.Printers[1].Name = "Garnet";

            XmlSerializer serializer = new XmlSerializer(typeof(XmlSerializable));
            XmlWriter writer = XmlWriter.Create("D:\\output.xml");
            serializer.Serialize(writer,x);
            writer.Close();

Serializable Class example which covers serializing a class which contains array of other class type and also enumerations:

    [Serializable]
    [XmlRoot()]
    public class XmlSerializable
    {
        Printer[] printers;

        [XmlArray("Printers")]
        [XmlArrayItem("Printer")] 
        public Printer[] Printers
        {
            get
            {
                return printers;
            }
            set
            {
                printers = value;
            }
        }
    }
   
    [XmlType("Printer")]         
    public class Printer
    {
        PrinterType type;

        [XmlAttribute()]

        public PrinterType Type
        {
            get
            {
                return type;
            }
            set
            {
                type = value;
            }
        }

        [XmlAttribute()]
        public string Name;


    }
 
    public enum PrinterType
    {
        [XmlEnum]
        None =0,
        [XmlEnum]
        Mfp,
        [XmlEnum]
        Sfp,
        [XmlEnum]
        NetworkScanner
    }

Catching Exceptions from a different thread, Exception Handling in multithreaded environment - C#

Note: Examples are on .NET 3.5 and does not consider .NET 4.0 features like Parallel Task Library.

If there is any exception in a method that is being executed on a different thread, those exception details will not shared with the main thread. It is necessary to catch any exception on a worker\different thread to debug issues especially in multithreaded environment.

// Wrong example: Attempting to catch exception from a thread in caller method
try
{
    Thread t = new Thread(new ThreadStart(LocalMethod));


t.Start();
}
catch (Exception ex)
{
    //do something with ex
}

Few points from MSDN about "there is no such thing called *Unhandled exception* in Managed code" after .NET version 2.0:

/** Straight from MSDN

The most significant change pertains to managed threads. In the .NET Framework versions 1.0 and 1.1, the common language runtime provides a backstop for unhandled exceptions in the following situations:

• There is no such thing as an unhandled exception on a thread pool thread. When a task throws an exception that it does not handle, the runtime prints the exception stack trace to the console and then returns the thread to the thread pool.
• There is no such thing as an unhandled exception on a thread created with the Start method of the Thread class. When code running on such a thread throws an exception that it does not handle, the runtime prints the exception stack trace to the console and then gracefully terminates the thread.
• There is no such thing as an unhandled exception on the finalizer thread. When a finalizer throws an exception that it does not handle, the runtime prints the exception stack trace to the console and then allows the finalizer thread to resume running finalizers.

The foreground or background status of a managed thread does not affect this behavior.

For unhandled exceptions on threads originating in unmanaged code, the difference is more subtle. The runtime JIT-attach dialog preempts the operating system dialog for managed exceptions or native exceptions on threads that have passed through native code. The process terminates in all cases.

**/

Let us take a look at possible ways of handling exceptions from different threads:

a. Adding a method which in turn invokes the method that executes on a different thread and which might be process heavy will allow to catch the exceptions and execute some code to handle this exception. By handling exceptions this way, application can made sure of running even when there are exceptions on different threads.

This pattern is used widely across different multithreaded applications. This method which allows calling thread method and handling exceptions will receive "method to execute" and "exception handler method" as arguments. It invokes "method to invoke" in try block and call the exception handler in catch block. Below code explains this approach, though it is not real-time example.

static void SafeThreadCaller(Action method, Action handler)
        {
            try
            {
                if (method != null)
                {
                    method();
                }
            }
            catch (Exception e)
            {
                handler(e);
            }
        }

        static void ExceptionHandler(Exception e)
        {            
            Console.WriteLine("Handled at ExceptionHandler in SafeHandler thread: "+ e.Message+". Thread ID: "+ Thread.CurrentThread.ManagedThreadId);
        }

        static void ThreadMethod(values v)
        {
            if (v.a > v.b)
                throw new ArgumentException("Arguments Invalid");
        }

Invoking above SafeThreadCaller method is easy using lamda expressions. It expects two Action delegates. If the thread method expects argument, it is easy to use lamda expressions as substitute for delegate as below:

//Caller method
public static void ThreadExceptions()
        {
            Console.WriteLine("In Main Method Thread ID: " + Thread.CurrentThread.ManagedThreadId);
            Thread t = new Thread(() => SafeThreadCaller(() => ThreadMethod(new values() { a = 5, b = 3 }), ExceptionHandler));
            t.Start();
        }

Note: "values" is a simple class created to hold two values a and b.

b. There is another way where information can be passed from thread method to caller through "out" parameters. I'm not big fan of this approach, since this might raise the need for the caller to wait for other thread to join.

public static void ThreadExcetionsAtCaller()
        {
            Exception ex = null;
            Thread t = new Thread(() => ThreadMethodWithOutParameter(new values() { a = 5, b = 3 }, out ex));
            t.Start();
            Console.WriteLine("In Main Method Thread ID: " + Thread.CurrentThread.ManagedThreadId);
            t.Join();
            if (ex != null)
            {
                Console.WriteLine("Handled at Caller: " + ex.Message + ". Thread ID: " + Thread.CurrentThread.ManagedThreadId);
                File.AppendAllText(@"D:\temp\1.txt","Handled at Caller: " + ex.Message + ". Thread ID: " + Thread.CurrentThread.ManagedThreadId);
            }
        }
static void ThreadMethodWithOutParameter(values v,out Exception ex)
        {
            ex = null;
            try
            {
                ThreadMethod(v);
            }
            catch(Exception e)
            {
                ex = e;
            }
        }
static void ThreadMethod(values v)
        {
            if (v.a > v.b)
                throw new ArgumentException("Arguments Invalid");
        }

c. If you like to handle all thread exceptions at once, AppDomain has support for AppDomain.CurrentDomain.UnhandledException and also ThreadException events. Your application can add a event handler to these events to print necessary information for any exception.

This method might work allows us to graceful exit the application on unhandled exception instead of crashing with "Unhandled exception occurred" message to the user. Little of house keeping pertaining to the current application domain can also be taken care before exiting the application.

//Not a perfect example :)
 AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler
                                                (CurrentDomain_UnhandledException);
     void CurrentDomain_UnhandledException(object o, UnhandledExceptionEventArgs u)
     {
          Console.WriteLine("UNHANDLED EXCEPTION IN THE APPLICATION!");        
     }

Note: UnhandledExceptionEventArgs will not have information about StackTrace. We can get information about whether CLR instance is terminating because of the current unhandled exception.

Opening Google Chrome in InCognito mode by default (Private Browsing by default on chrome)

If you like to open chrome always in incognito mode, follow below simple steps:

1. Right click on Google Chrome Shortcut (either on Desktop or Start Menu or wherever the shortcut is located.)
2. Click on Properties.
3. In the Shortcut tab, you will see something like below as Target for the shortcut: C:\..\..\AppData\Local\Google\Chrome\Application\chrome.exe 
4. Add a parameter "incognito" to the Target so that Chrome would always pick this parameter while getting launched through shortcut i.e. change to target to include "-incognito" like below: C:\..\..\AppData\Local\Google\Chrome\Application\chrome.exe  -incognito

Whenever you launch chrome next time using shortcut, by default it gets launched in incognito mode(your browsing history is safe by default.)

Happy Browsing!

Strings in depth C# - Immutability, string interning, String.Intern, Intern Pool and StringBuilder

a. String are immutatble

Immutability means value of a string object can't be modified once its assigned. If a string object is modified to create a different value a new string object with that new value will be created.

Because of this immutable property of strings, any operation like Addition or Deletion  will result in new string creation and it will be performance penalty. 

In cases where we repeatedly add or delete from a string, StringBuilder is suggested. Unlike string any operation on StringBuilder object will work on single instance of string object and hence will be efficient in cases where repeated string modification operations are involved.

b. String is a reference type

I know it's a simple concept yet good to note it.

c. What is string interning?

String interning is a method of storing only one copy of each distinct string value, which must be immutable. Interning strings makes some string processing tasks more time- or space-efficient at the cost of requiring more time when the string is created or interned. The distinct values are stored in a string intern pool.

C# also uses string interning. It interns string based on the literal value. However any operation that results in same literal value as a literal in intern pool does not get to use the existing intern reference.  

Intern Pool:

The common language runtime(CLR) automatically maintains a table, called the "intern pool", which contains a single instance of each unique literal string constant declared in a program, as well as any unique instance of String you add programmatically.

The intern pool conserves string storage. If you assign a literal string constant to several variables, each variable is set to reference the same constant in the intern pool instead of referencing several different instances of String that have identical values.

There are two methods where you can get the intern of a string i.e. get the reference for a string if it's already in the Intern pool.

a. IsInterned

Returns reference to a string if the literal string is already in the intern pool otherwise it returns null.

string s1 = "hello";

string s2 = String.IsInterned("Hello") ;

IsInterned will check intern pool for string with value "hello" and returns reference to that string.

Hence s1 will have reference as s2.

Note: IsInterned does not return bool but returns "null" when value is not present in intern pool.

b. Intern

Returns reference to a string if the literal string is already in the intern pool otherwise create a string with given literal value.

Below block is straight from MSDN about performance considerations when working with intern pool.

Performance Considerations with intern pool:

If you are trying to reduce the total amount of memory your application allocates, keep in mind that interning a string has two unwanted side effects. First, the memory allocated for interned String objects is not likely be released until the common language runtime (CLR) terminates. The reason is that the CLR's reference to the interned String object can persist after your application, or even your application domain, terminates. Second, to intern a string, you must first create the string. The memory used by the String object must still be allocated, even though the memory will eventually be garbage collected.

The .NET Framework version 2.0 introduces CompilationRelaxations.NoStringInterning enumeration member. The NoStringInterning member marks an assembly as not requiring string-literal interning. You can apply NoStringInterning to an assembly using the CompilationRelaxationsAttribute attribute. Also, when you use the Native Image Generator (Ngen.exe) to compile an assembly in advance of run time, strings are not interned across modules.

Longest Common Substring and Longest Common Subsequence (LCS) - Code using C# (Part 1)

Before starting with algorithms, let us understand difference between a substring of a string and a susbsequence of a string. Substring and subsequence are confusing terms. 

Sub-string is the part of the input string itself. It has characters in the same order they appear in the main string. Whereas subsequence is the string which has sequence of characters of main string, which can be formed by deleting one or many characters randomly from the input string.

Example:

Input string    : "HELLO WELCOME EVERYONE"

Sub-string     : "EVERY" or "COME"

Subsequence : "LWCME"

Longest Common substring

Longest Common substring of two given strings is the string which is common substring of both given strings and longest of all such common substrings.

Example:
String 1   : "HELLO WELCOME EVERYONE"
String 2   : "NO TWEET NO NO WELEVERYONEWELHELL"
LCString : "EVERYONE"

One approach of solving this would be using Dynamic Programming.

a. Allocate a 2D array of size [str1.Length, str2.Length]
b. Each value of this matrix saves the information about length of longest substring that's ending at that position. e.g. L[3,4] gives length of longest common substring of first three characters of first input string and first four characters of second input string.
c. If we start with 1st character of string 1 and 1st character of string 2, if they match we can say L[0, 0] = 1
d. We then can build this array by seeing if LCS value at any postion is greater than cached LCS value.
e. We will also save the ending index of the longest common substring till every point when character do not match. This can be used to backtrack and get the actual LCS from given input string.
f. L[str1.Length, str2.Length] will have the final LCS length saved in it.
g. Each step uses LCS value calculated in previous steps and adds one to it if characters match at new indexes in both given strings.

In below C# code I'm assuming array of characters are passed as input instead of string.

public static void PrintLongestCommonSubstring(char[] str1, char[] str2)         {             int[,] l = new int[str1.Length, str2.Length];             int lcs = -1;             string substr = string.Empty;             int end = -1;                         for (int i = 0; i < str1.Length; i++)             {                 for (int j = 0; j < str2.Length; j++)                 {                     //if character at 'i' in string 1 and character at 'j' in string 2                     matches then increment the length of lcs value for that position                     if (str1[i] == str2[j])                     {                         //taking care of array indexes                         if (i == 0 || j == 0)                         {                             l[i, j] = 1;                         }                         else                         {                             //characters match , lets update new lcs value                             l[i, j] = l[i - 1, j - 1] + 1;                         }                         //This is to get the longest common substring                         // use end index in the first string for longest common substring                         if (l[i, j] > lcs)                         {                             lcs = l[i, j];                             end = i;                         }                     }                     else                     {                         //characters do not match use set length of LCS at that position                         as 0                         l[i, j] = 0;                     }                 }             }             for (int i = end - lcs + 1; i <= end; i++)             {                 substr += str1[i];             }                         Console.WriteLine("Longest Common SubString Length = {0}, Longest Common                  Substring = {1}", lcs, substr);         }

NOTE: I hope comments in the above code helps in understanding the code block. 

I will continue this article and explain about finding Longest Common Subsequence in next article.

Algorithm and References: wikipedia (link provided above)

C# - throw or throw ex? Differences between "throw" and "throw ex" in exception handling

When we use throw ex, it throws a new exception with empty call stack or call stack starting from there to the higher\caller. It's always a good habit to use 'throw' instead on 'throw ex' inside catch block since it retains the complete call stack for the exception. 'Throw ex' can be replaced with 'throw new exception' to add mode details to the exception caught or add custom information to the exception. Throwing new exception is preferred in cases where code block raises an exception for cases like invalid input or format etc and add explanatory message about that case to that exception.

Choosing between throw and throw new exception("message") or throw ex mainly depends on ,

a. What 'call stack' you like to retain or send to the caller.

b. What information you like the caller to see on catching this exception like custom message for that exception or application specific information\exception types.

Safe Way To Abort A Thread in C# - Brief about ThreadAbortException, ThreadInterruptedException and volatile variables

Yeah, one of the favorite questions of any interviewer when it comes to multithreading. 

Are you thinking of Thread.Abort()? Let us see why we shouldn't we consider Abort() on a thread. If below information looks like content of MSDN, bear with me because most of the concepts in this article are from MSDN pages only.

    è When thread abort method is called, ThreadAbortException is raised in the method that is being                 executed. Even if the exception is handled in the thread method, it is re-thrown at the end of catch                   block. Yes, ThreadAbortException is a special kind of exception which is thrown even when it is assumed              to be "handled".

         è Unexecuted finally blocks are executed before the thread is aborted. The thread is not guaranteed                   to abort immediately, or at all. This situation can occur if a thread does an unbounded amount of                      computation in the finally blocks that are called as part of the abort procedure, thereby indefinitely                delaying the abort. To wait until a thread has aborted, you can call the Join method on the thread                   after calling the Abort method, but there is no guarantee the wait will end.

è  If Abort is called on a thread that has been suspended, a ThreadStateException is thrown in the thread that called Abort, and AbortRequested is added to the ThreadStateproperty of the thread being aborted. A ThreadAbortException is not thrown in the suspended thread until Resume is called.

è  If Abort is called on a managed thread while it is executing unmanaged code, a ThreadAbortException is not thrown until the thread returns to managed code.

è  If two calls to Abort come at the same time, it is possible for one call to set the state information and the other call to execute the Abort. However, an application cannot detect this situation.

Now that we saw why terminating a thread by calling Thread.Abort is not a good idea. Let us discuss few approaches of terminating a thread in safer way.

Method 1 – using volatile variable:

Variables that are marked as “volatile” can be accessed across multiple threads in thread-safe manner. We can use this property of volatile variable to control the execution of thread method. Yes, we can terminate the thread based on the value of this volatile variable, the caller can simply set this variable from its code.

Little about volatile keyword:

“The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.

The volatile modifier is usually used for a field that is accessed by multiple threads without using the lock statement to serialize access.”

A simple but not so accurate example (copy pasted from StackOverflow as-it-is):

volatile bool shutdown = false;

void RunThread()

{

   while (!shutdown)

   {

      ...

   }

}

void StopThread()

{

   shutdown = true;

}

This allows your thread to cleanly finish what it was doing, leaving your app in a known good state.

Method 2 using Thread.Interrupt(), volatile and exception handling for cleaned up termination:

ThreadInterruptedException is an exception which can be handled in the thread method. Thread.Interrupt can be called only on a thread that is in WaitSleepJoin state. Calling Interrupt when a thread is in the WaitSleepJoin state will cause a ThreadInterruptedException to be thrown in the target thread. If the thread is not in the WaitSleepJoin state, the exception is not thrown until the thread enters that state. If the thread never blocks, it could complete without ever being interrupted.

Approach is to handle this exception in the target thread method and exit gracefully. Combining this with a volatile variable like in method 1 will provide much safer way to terminate the thread. It also assures that thread will be “aborted”, sorry let us say terminated even when thread may block in a “sleep” or “wait” state.

Again an example from StackOverflow(as-it-is copied):

try

{

    while (keepGoing)

    {

        /* Do work. */

    }

}

catch (ThreadInterruptedException exception)

{

    /* Clean up. */

}

I have compiled this article from the answers I read on StackOverflow and MSDN articles. If you find useful please thank me by liking this post.

Lambda Expression, Statement Lambda, Action Delegate, Func Delegate, Differences Between Action and Func and Instantiating Delegates with Lambda

Continuing from last page:
Lambda expressions or statement lamda can be passed where a delegate is expected.

Lamda expressions may or may not expect input parameters and have an expression to right of lambda that may evaluate to a return value.

      Func<int, int, int, int, int> hello = (a, b, c, d) => a + b + c + d;

   here a,b,c,d are input parameters and return type is int which is result of expression (a+b+c+d). 

In above lambda expression is assigned to Func delegate which accepts 4 input parameters of type 'int' and return type is 'int' again.

We have to make sure, lambda expressions input is convertible to delegate's input type & return of lambda is convertible to delegate's return type.


In above case (a+b+c+d) will be of type of int which is same of Func<int,int,int,int,int TResult> delegate's return type i.e. int.


Lambda expression can also contain statements to right of lamda that might not return any value.


           Action<int> mm = (a) => Console.WriteLine("EEE");
      mm(5);

In above example right side of expression does not evaluate to anything though it accepts a parameter 'a'. This is assigned to default Action<int> delegate which does not expect any return type, but has an input parameter of type 'int'.

Now let us see what is a statement lambda. Statement lambda is similar to lambda expression but statement(s)/expression to the right of lambda is enclosed in {} braces.
They can contain multiple statement since they are enclosed in braces. Braces also indicate scope /block of lambda statement. 


                Action<int> actw = (a) => 
            {
                string s = "square = " + a * a;
                s = s + " - new";
                Console.WriteLine(s); 
            }

Here we are assigning statement lambda to a delegate that has single input parameter of type int. We are not returning anything from lambda but redirecting the square of number to console.

We use lambda and anonymous methods only in simple scenarios where a set of simple statements can be passed in method, instead of having dedicated method of handling or instantiating delegate.
In below example, I'm invoking a delegate and assigning a statement lambda for callback. Here having a callback method that would just print completion status would not make much sense and hence I replaced it with a lambda expression which outputs the delegate's method execution status in the callback.
Here AsyncCallback expects a method that accepts IAsyncResult parameter and return type is void. Our statement lambda accepts this IAsyncResult  as input and returns nothing and hence can be passed in as method that is expected by AsyncCallback.


        public static void ExecuteDelegate(Func<int, int, int, int, int> hello)
        {
                hello.BeginInvoke(2, 3, 4, 5,                
                   new AsyncCallback((asyncresult) => {  
                          Console.WriteLine("Completed = " +  
                                    asyncresult.IsCompleted); }),                
                                  null);
        }


Till now I have only use Func<> and Action<> delegates but lambda can be used for any delegate of matching return and input types. Func and Action are the delegates provided by default by the framework to avoid overhead of writing our own delegates for general cases. These delegates are generic they are extended to accept 0, 1, 2, 3 or more parameters. Number of input parameters that are accepted by both delegates was 0 to 4 in .NET 3.5.

Main difference between Action delegate and Func delegate is,

Action - delegate that does not have return value and accepts up-to four input parameters. (.NET 3.5)
Action also can encapsulate a method that take no input and no return value. 

Types:
Action
Action<in T1> - in represents input parameter.
Action<in T1,in T2>
Action<in T1,in T2,in T3>
Action<in T1,in T2,in T3,in T4>

Func<TResult> - Func delegate is used when we have a return value but input parameter list is optional. Func delegate can encapsulate method that returns a value and accepts no input. Func can encapsulate methods that have 0 - 4 in put parameters and return a value. Last value in parameter list represents the return type.

Func<TResult> - TResult represrents return type.
Func<in T1, out TResult> 
...............


delegate void PrintCharsDelegate(string s);


PrintCharsDelegate del = (s) =>
                   {
                       Console.WriteLine("Encryted String for {0} = ", s);
                              foreach (char ch in s)
                              {                                                   
                                                   Console.Write((char)((int)ch+1));
                              }
                   };
del("Hello");



Here statement lambda which encrypts the given string, is assigned to delegate which accepts string and returns nothing.

Anonymous methods are very similar to statement lambdas. They can be used to instantiate delegates just like statement lambda. We will see them in another article