Anonymous function

 class Program  
   {  
     static void Main(string[] args)  
     {  
       Func<int, int> func1 = x => x + 1;  
       Func<int, int> func2 = x => { return x + 1; };  
       Func<int, int> func3 = (int x) => x + 1;  
       Func<int, int> func4 = (int x) => { return x + 1; };  
       Func<int, int, int> func5 = (x, y) => x * y;  
       Action func6 = () => Console.WriteLine();  
       Func<int, int> func7 = delegate (int x) { return x + 1; };  
       Func<int> func8 = delegate { return 1 + 1; };  
       Console.WriteLine(func1.Invoke(1));  
       Console.WriteLine(func2.Invoke(1));  
       Console.WriteLine(func3.Invoke(1));  
       Console.WriteLine(func4.Invoke(1));  
       Console.WriteLine(func5.Invoke(2, 2));  
       func6.Invoke();  
       Console.WriteLine(func7.Invoke(1));  
       Console.WriteLine(func8.Invoke());  
       Console.ReadLine();  
     }  

Basic Dependency Injection control

I found a simple Inversion Controller on https://timross.wordpress.com/2010/01/21/creating-a-simple-ioc-container

   

public interface IContainer  
   {  
     void Register<TTypeToResolve, TConcrete>();  
     void Register<TTypeToResolve, TConcrete>(LifeCycle lifeCycle);  
     TTypeToResolve Resolve<TTypeToResolve>();  
     object Resolve(Type typeToResolve);  
   }  
   public enum LifeCycle   
   {   
    Singleton,   
    Transient   
   }   
   public class RegisteredObject  
   {  
     public RegisteredObject(Type typeToResolve, Type concreteType, LifeCycle lifeCycle)  
     {  
       TypeToResolve = typeToResolve;  
       ConcreteType = concreteType;  
       LifeCycle = lifeCycle;  
     }  
     public Type TypeToResolve { get; private set; }  
     public Type ConcreteType { get; private set; }  
     public object Instance { get; private set; }  
     public LifeCycle LifeCycle { get; private set; }  
     public void CreateInstance(params object[] args)  
     {  
       this.Instance = Activator.CreateInstance(this.ConcreteType, args);  
     }  
   }  
   public class SimpleIocContainer : IContainer  
   {  
     private readonly IList<RegisteredObject> registeredObjects = new List<RegisteredObject>();  
     public void Register<TTypeToResolve, TConcrete>()  
     {  
       Register<TTypeToResolve, TConcrete>(LifeCycle.Singleton);  
     }  
     public void Register<TTypeToResolve, TConcrete>(LifeCycle lifeCycle)  
     {  
       registeredObjects.Add(new RegisteredObject(typeof (TTypeToResolve), typeof (TConcrete), lifeCycle));  
     }  
     public TTypeToResolve Resolve<TTypeToResolve>()  
     {  
       return (TTypeToResolve) ResolveObject(typeof (TTypeToResolve));  
     }  
     public object Resolve(Type typeToResolve)  
     {  
       return ResolveObject(typeToResolve);  
     }  
     private object ResolveObject(Type typeToResolve)  
     {  
       var registeredObject = registeredObjects.FirstOrDefault(o => o.TypeToResolve == typeToResolve);  
       if (registeredObject == null)  
       {  
         throw new TypeNotRegisteredException(string.Format(  
           "The type {0} has not been registered", typeToResolve.Name));  
       }  
       return GetInstance(registeredObject);  
     }  
     private object GetInstance(RegisteredObject registeredObject)  
     {  
       if (registeredObject.Instance == null ||   
         registeredObject.LifeCycle == LifeCycle.Transient)  
       {  
         var parameters = ResolveConstructorParameters(registeredObject);  
         registeredObject.CreateInstance(parameters.ToArray());  
       }  
       return registeredObject.Instance;  
     }  
     private IEnumerable<object> ResolveConstructorParameters(RegisteredObject registeredObject)  
     {  
       var constructorInfo = registeredObject.ConcreteType.GetConstructors().First();  
       foreach (var parameter in constructorInfo.GetParameters())  
       {  
         yield return ResolveObject(parameter.ParameterType);  
       }  
     }  
   }  
   public class TypeNotRegisteredException : Exception  
   {  
     public TypeNotRegisteredException(string message)  
       : base(message)  
     {  
     }  
   }  

Extending HtmlHelper

Helpers.cs

 using System.Web;  
 using System.Web.Mvc;  
 using System.Web.Routing;  
 namespace mvc.Helpers  
 {  
   public static class ImageHelpers  
   {  
     public static IHtmlString Image(this HtmlHelper helper, string id, string url, string alternateText)  
     {  
       return Image(helper, id, url, alternateText, null);  
     }  
     public static IHtmlString Image(this HtmlHelper helper, string id, string url, string alternateText, object htmlAttributes)  
     {  
       var builder = new TagBuilder("img");  
       builder.GenerateId(id);  
       builder.MergeAttribute("src", url);  
       builder.MergeAttribute("alt", alternateText);  
       builder.MergeAttributes(new RouteValueDictionary(htmlAttributes));  
       return new MvcHtmlString(builder.ToString(TagRenderMode.SelfClosing));  
     }  
   }  
 }  

index.cshtml

 @{  
   ViewBag.Title = "Home Page";  
 }  
 @using mvc.Helpers;  
 @Html.Image("img1", "~/Content/XBox.jpg", "XBox Console")  

Array mapping using LINQ

 namespace ConsoleApplication1  
 {  
   public class Student  
   {  
     public string FirstName;  
     public string LastName;  
   }  
   public class StudentFullName  
   {  
     public string FullName;  
     public StudentFullName(Student student)  
     {  
       FullName = student.FirstName + " " + student.LastName;  
     }  
     public override string ToString()  
     {  
       return FullName;  
     }  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       Student s1 = new Student { FirstName = "Jack", LastName = "Frost" };  
       Student s2 = new Student { FirstName = "Mary", LastName = "Wong" };  
       Student s3 = new Student { FirstName = "Ronald", LastName = "McDonalds" };  
       Student s4 = new Student { FirstName = "John", LastName = "Smith" };  
       List<Student> studentArray = new List<Student>() { s1, s2, s3, s4 };  
       List<StudentFullName> fullNameArray = studentArray.Select(a => new StudentFullName(a)).ToList();  
       string nameList = fullNameArray.OrderBy(m => m.FullName).Select(m => m.FullName).Aggregate((current, next) => current + ", " + next);  
       Console.WriteLine(nameList);  
       Console.ReadLine();  
     }  
   }  
 }  

Concatenation using LINQ

 using System;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
 using System.Linq.Expressions;  
 namespace ConsoleApplication1  
 {  
   public class Student  
   {  
     public string FirstName;  
     public string LastName;  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       Student s1 = new Student { FirstName = "Jack", LastName = "Frost" };  
       Student s2 = new Student { FirstName = "Mary", LastName = "Wong" };  
       Student s3 = new Student { FirstName = "Ronald", LastName = "McDonalds" };  
       Student s4 = new Student { FirstName = "John", LastName = "Smith" };  
       List<Student> studentArray = new List<Student>() { s1, s2, s3, s4 };  
       string nameList = studentArray.OrderBy(m => m.LastName).Select(m => m.LastName).Aggregate((current, next) => current + ", " + next);  
       Console.WriteLine(nameList);  
       Console.ReadLine();  
     }  
   }  
 }  

Class extension example

 namespace ConsoleApplication1  
 {  
   public static class MyExtensions  
   {  
     public static int WordCount(this String str)  
     {  
       return str.Split(new char[] { ' ', '.', '?' },  
         StringSplitOptions.RemoveEmptyEntries).Length;  
     }  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       string s = "1.2.3";  
       Console.WriteLine( s.WordCount().ToString());  
       Console.ReadKey();  
     }  
   }  
 }  

Fancy LINQ operation

   class Myclass  
   {  
     public string name { get; set; }  
     public decimal age { get; set; }  
   }  
   class Program  
   {  
     static void Main(string[] args)  
     {  
       List<string> l = new List<string>();  
       l.Add("di"); l.Add("marks");  
       var list = new List<Myclass> { new Myclass { name = "di",age = 0 }, new Myclass { name = "marks", age = 0 }, new Myclass { name = "grade", age = 0 } };  
       list.Where(w => l.Contains(w.name)).ToList().ForEach(i => i.age = 10);  
       list.ForEach(i => Console.WriteLine(i.name + ":" + i.age));  
       Console.ReadKey();  
     }  
   }