Cacher is the code snippet organizer for pro developers

using System;
using System.Data;
using System.Reflection;
using System.Xml;

public class Program
{
	public static void Main()
	{
		int myIntVariable = 0;
		System.Type myType = myIntVariable.GetType();
		Console.WriteLine("AssmeblyQualifiedName: {0}", myType.AssemblyQualifiedName);
		Console.WriteLine("FullName: {0}", myType.FullName);
		Console.WriteLine("IsValueType: {0}", myType.IsValueType);
		Console.WriteLine("Name: {0}", myType.Name);
		Console.WriteLine("Namespace: {0}", myType.Namespace);
		
		int[,, ] myIntArray = new int[5, 6, 7];
		Type myIntArrayType = myIntArray.GetType();
		Console.WriteLine("Array Rank: {0}", myIntArrayType.GetArrayRank());
		
		DataTable myDataTable = new DataTable();
		Type myDataTableType = myDataTable.GetType();
		ConstructorInfo[] myDataTableConstructors = myDataTableType.GetConstructors();
		for (int i = 0; i <= myDataTableConstructors.Length - 1; i++)
		{
			ConstructorInfo constructorInfo = myDataTableConstructors[i];
			Console.WriteLine("\nConstructor #{0}", i + 1);
			ParameterInfo[] parameters = constructorInfo.GetParameters();
			Console.WriteLine("Number Of Parameters: {0}", parameters.Length);
			foreach (ParameterInfo parameter in parameters)
			{
				Console.WriteLine("Parameter Name: {0}", parameter.Name);
				Console.WriteLine("Parameter Type: {0}", parameter.ParameterType.Name);
			}
		}
		
		Type myCustomEnumType = typeof(MyCustomEnum);
		string[] enumNames = myCustomEnumType.GetEnumNames();		
		foreach (string enumName in enumNames)
		{
			Console.WriteLine(string.Format("Name: {0}", enumName));
		}
		
		Array enumValues = myCustomEnumType.GetEnumValues();
		foreach (object enumValue in enumValues)
		{
			Console.WriteLine(string.Format("Enum Value: {0}", enumValue.ToString()));
		}
		
		for (int i = 1; i <= 3; i++)
		{
			string enumName = myCustomEnumType.GetEnumName(i);
			Console.WriteLine(string.Format("{0}: {1}", enumName, i));
		}
		
		
		ReflectionExample reflectionExample = new ReflectionExample();
		Type reflectionExampleType = typeof(ReflectionExample);		
		FieldInfo[] fields = reflectionExampleType.GetFields(BindingFlags.Public |
		BindingFlags.Instance |
		BindingFlags.Static |
		BindingFlags.NonPublic |
		BindingFlags.FlattenHierarchy);		
		foreach (FieldInfo field in fields)
		{
			object fieldValue = field.GetValue(reflectionExample);			
			Console.WriteLine(string.Format("Field Name: {0}, Value: {1}", field.Name, fieldValue.ToString()));
		}
		
		
		reflectionExampleType.GetField("privateField", BindingFlags.NonPublic |
		BindingFlags.Instance).SetValue(reflectionExample, "My New Value");		
		Console.WriteLine("Private Field Value: {0}",
		reflectionExample.PrivateField);
		
		MethodInfo methodInfo = reflectionExampleType.GetMethod("Multiply");
		double returnValue = (double)methodInfo.Invoke(reflectionExample, new object[] { 4, 5 });		
		Console.WriteLine("Return Value: {0}", returnValue);
		
		double returnValue1 = (double)reflectionExampleType.InvokeMember("Multiply",
			BindingFlags.InvokeMethod,
			null,
			reflectionExample,
			new object[] { 4, 5 });		
		Console.WriteLine(string.Format("Return Value: {0}", returnValue1));	
	}
	
	private enum MyCustomEnum
	{
		Red = 1,
		White = 2,
		Blue = 3
	}
	
	class ReflectionExample
	{
		private string _privateField = "Hello";
		public string _publicField = "Goodbye";
		internal string _internalfield = "Hola";
		protected string _protectedField = "Adios";
		static string _staticField = "Bonjour";
		
		public string PrivateField
		{
			get { return _privateField; }
		}
		
		public double Multiply(double x, double y)
		{
			return x * y;
		}
	}
}