Common causes of NullReferenceExceptions
Any reference type variable can be null. Local variables, the properties of a class, method parameters, and method return values can all contain a null reference. Calling methods or properties of these variables when they are null causes a NullReferenceException. Specific cases:

Run the following code:

using System;
using System.Windows.Forms;

public static class ControlExtensions
{
/// <summary>
/// Executes the Action asynchronously on the UI thread, does not block execution on the calling thread.
/// </summary>
/// <param name="control"></param>
/// <param name="code"></param>
public static void ThreadCall(this Control @this, Action code)
{
if (@this.InvokeRequired)
{
@this.BeginInvoke(code);
}
else
{
code.Invoke();
}
}
}

Then call that by using the following code:

this.ThreadCall(() => this.Label1.Text = "Write New Text Here");

// Procedure to create random number
private static readonly Random random = new Random();
private static readonly object syncLock = new object();
public static int RandomNumber(int min, int max)
{
lock(syncLock) { // synchronize
return random.Next(min, max);
}
}

public class Sample
{
public void Example(string typeName)
{
Type newType = FindType(typeName);

// What goes here to call GenericMethod<T>()?
GenericMethod<newType>(); // It does not work

// What changes to call StaticMethod<T>()?
Sample.StaticMethod<newType>(); // This also doesn't work
}

public void GenericMethod<T>()
{
// ...
}

public static void StaticMethod<T>()
{
//...
}
}

You need to use reflection to get the method to start with, then create that by sending type params with MakeGenericMethod:

MethodInfo method = typeof(Sample).GetMethod("GenericMethod");
MethodInfo generic = method.MakeGenericMethod(myType);
generic.Invoke(this, null);

Worksheet sheet = excelApp.Worksheets.Open(...);
...
Marshal.ReleaseComObject(sheet);

Worksheets sheets = excelApp.Worksheets; // assign a variable
Worksheet sheet = sheets.Open(...);
...
Marshal.ReleaseComObject(sheets);
Marshal.ReleaseComObject(sheet);

Please use an extension method and lambdas to make your code much cleaner.

using System.ComponentModel; public static class ISynchronizeInvokeExtensions
{
public static void InvokeEx<T>(this T @this, Action<T> action) where T : ISynchronizeInvoke
{
if (@this.InvokeRequired)
{
@this.Invoke(action, new object[] { @this });
}
else
{
action(@this);
}
}
}

this.InvokeEx(f => f.listView1.Items.Clear());

One way to guarantee that an object will be cloned exactly how you want it is to manually clone every field in the object. The disadvantage to this method is it's tedious and error prone: if you add or change a field in the class, chances are you will forget to update the Clone method. Note that care must be taken to avoid an infinite loop when cloning referenced objects that may refer back to the original object. Here is a simple example that performs a deep copy:

public class Person : ICloneable{
public string Name;
public Person Spouse;
public object Clone()
{
Person p = new Person();
p.Name = this.Name;
if (this.Spouse != null)
p.Spouse = (Person)this.Spouse.Clone();
return p;
}
}

public class Person : ICloneable{
public string Name;
public Person Spouse;
public object Clone()
{
return this.MemberwiseClone();
}
}

To create an Excel Spreadsheet in .NET we recommend to use Rustemsoft's XMLFox conversion module with command-line interface.
XMLFox conversion module (XMLFoxCmd) is a data conversion software lets users to interactively create XML data transformation. It allows you to use XML documents by exporting it to several other data formats. It is used for quickly building application integration solutions. It will allow you to map and integrate some types of data stored in XML document in a user-friendly command-line interface.

Also you may use Open XML SDK 2.0 for Microsoft Office

The most important benefits:
That does not require MS Office to be installed on your PC
Since it made by Microsoft it supported by the decent MSDN documentation
You will need a just one .NET dll to use in your project
Open XML SDK comes with many tools like: diff, validator, etc.

Links:
Download SDK
Main MSDN Landing
How Do I...

Consider this code which is trying to mutate a readonly mutable struct. What the output is expected to be?

struct Mutable {
private int x;
public int Mutate() {
this.x = this.x + 1;
return this.x;
}
}

class Test {
public readonly Mutable m = new Mutable();
static void Main(string[] args) {
Test t = new Test();
System.Console.WriteLine(t.m.Mutate());
System.Console.WriteLine(t.m.Mutate());
System.Console.WriteLine(t.m.Mutate());
}
}

It is easy. First, Byte Array to String:

public static string ByteArrayToString(byte[] ba)
{
string hex = BitConverter.ToString(ba);
return hex.Replace("-","");
}

Revers conversion, String to Byte Array:

public static byte[] StringToByteArray(String hex)
{
int NumberChars = hex.Length;
byte[] bytes = new byte[NumberChars / 2];
for (int i = 0; i < NumberChars; i += 2)
bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
return bytes;
}

The exception's error message says that you are trying to access a collection item by its index, using an invalid index. An index number value is incorrect when it is greater than (or equal) the collection's number of elements it contains or lower than to the collection?s lower bound. For example you have declared an array as:

string[] stringArray = new string[5];

public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string property)
{
return ApplyOrder<T>(source, property, "OrderBy");
}
public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> source, string property)
{
return ApplyOrder<T>(source, property, "OrderByDescending");
}
public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source, string property)
{
return ApplyOrder<T>(source, property, "ThenBy");
}
public static IOrderedQueryable<T> ThenByDescending<T>(this IOrderedQueryable<T> source, string property)
{
return ApplyOrder<T>(source, property, "ThenByDescending");
}
static IOrderedQueryable<T> ApplyOrder<T>(IQueryable<T> source, string property, string methodName) {
string[] props = property.Split('.');
Type type = typeof(T);
ParameterExpression arg = Expression.Parameter(type, "x");
Expression expr = arg;
foreach(string prop in props) {
// use reflection (not ComponentModel) to mirror LINQ
PropertyInfo pi = type.GetProperty(prop);
expr = Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);

object result = typeof(Queryable).GetMethods().Single(
method => method.Name == methodName
&& method.IsGenericMethodDefinition
&& method.GetGenericArguments().Length == 2
&& method.GetParameters().Length == 2)
.MakeGenericMethod(typeof(T), type)
.Invoke(null, new object[] {source, lambda});
return (IOrderedQueryable<T>)result;
}

We will not bother and go deep into the jungle. We will just show you how to decrypt and encrypt a string by using a wrapper object to access the cryptographic service provider (CSP) version of the Data Encryption Standard (DES) algorithm.

public string EncryptString(string inputString){
MemoryStream ms = null;
try{
byte[] IV = {12, 43, 67, 27, 17, 21, 57, 35};
string encryptKey = "password"; // 8 characters key
byte[] key = {};
key = Encoding.UTF8.GetBytes(encryptKey);
byte[] byteInput = Encoding.UTF8.GetBytes(inputString);
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();
ms = new MemoryStream();
ICryptoTransform transform = provider.CreateEncryptor(key, IV);
CryptoStream cryptoStream = new CryptoStream(ms, transform, CryptoStreamMode.Write);
cryptoStream.Write(byteInput, 0, byteInput.Length);
cryptoStream.FlushFinalBlock();
}
catch (Exception ex){
Response.Write(ex.Message);
}
return Convert.ToBase64String(ms.ToArray());
}

public string DecryptString(string inputString){
MemoryStream ms = null;
try{
byte[] IV = {12, 43, 67, 27, 17, 21, 57, 35};
string decryptKey = "password"; // 8 characters key
byte[] key = {};
key = Encoding.UTF8.GetBytes(decryptKey);
byte[] byteInput = new byte[inputString.Length];
byteInput = Convert.FromBase64String(inputString);
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();
ms = new MemoryStream();
ICryptoTransform transform = provider.CreateDecryptor(key, IV);
CryptoStream cryptoStream = new CryptoStream(ms, transform, CryptoStreamMode.Write);
cryptoStream.Write(byteInput, 0, byteInput.Length);
cryptoStream.FlushFinalBlock();
}
catch (Exception ex){
Response.Write(ex.Message);
}
Encoding encoding1 = Encoding.UTF8;
return encoding1.GetString(ms.ToArray());
}

Use Gmail Smtp client which allows you to send email messages by using SMTP Protocol.

using System;
using System.Net;
using System.Net.Mail;

static void SendMail(){
// Sender's gmail address
string fromAddress = "Sender@gmail.com";
// Receiver's gmail address
string toAddress = "Receiver@yahoo.com";
const string SendersPassword = "Password";
const string subject = "Subject";
// Message content
const string body = "Hello!";

try{
// Gmail SMTP server name is smtp.gmail.com and port number is 587
SmtpClient smtp = new SmtpClient{
Host = "smtp.gmail.com",
Port = 587,
EnableSsl = true,
DeliveryMethod = SmtpDeliveryMethod.Network,
Credentials = new NetworkCredential(fromAddress, SendersPassword),
Timeout = 3000
};
MailMessage message = new MailMessage(fromAddress, toAddress, subject, body);
// Send the message
smtp.Send(message);
Console.WriteLine("Message has been sent");
}
catch (Exception ex){
Console.WriteLine(ex.Message);
}
}

StringBuilder String = new StringBuilder(); // compiles
StringBuilder string = new StringBuilder(); // does not compile

StringBuilder @string = new StringBuilder();

public class LogContext : IDisposable {
public EnteringLog(string enterID) {
Console.WriteLine("Entering Log Context {0}", enterID);
Log.Indent();
}
public void Dispose() {
Log.Outdent();
}
public static void Main() {
Console.WriteLine("Your initial stuff");
try {
using(new LogContext()) {
Console.WriteLine("Your stuff inside the context");
throw new Exception();
}
} catch {
Console.WriteLine("An exception got from inside a child logging context");
} finally {
Console.WriteLine("Your final stuff");
}
}
}

You can accomplish that creating checks by using exception handling only.

static bool FileInUse(string path)
{
try
{
using (FileStream fs = new FileStream(path, FileMode.OpenOrCreate))
{
fs.CanWrite
}
return false;
}
catch (IOException ex){
return true;
}
}

string filePath = "C:\\Documents Folder\\FileName";
bool isFileInUse;

isFileInUse = FileInUse(filePath);

// Do File checking here
if (isFileInUse)
Console.WriteLine("File is in use");
else
Console.WriteLine("File is not in use");