An all-code post, just paste the whole thing into a console app

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

class Program
{
	static void Main(string[] args)
	{
		// Here's the usage of a "traditional" factory, which returns objects that implement a common interface.
		// This is a great pattern for a lot of different scenarios.
		// The only downside is that you have to update your factory class whenever you add a new class.
		TraditionalFactory.Create("A_ID").DoIt();
		TraditionalFactory.Create("B_ID").DoIt();		
		Console.ReadKey();

		// But what if we make a class that uses reflection to find attributes of classes it can create? Reflection!
		// This works great and now all we have to do is add an attribute to new classes and this thing will just work.
		// (It could also be more generic in its input / output, but I simplified it for this example)
		ReflectionFactory.Create("A_ID").DoIt();
		ReflectionFactory.Create("B_ID").DoIt();
		// Wait, that's great and all, but everyone always says reflection is so slow, and this thing's going to reflect 
		// on every object creation...that's not good right?
		Console.ReadKey();

		// So I created this magical factory which gives the speed of the traditional factory combined with the flexibility 
		// of the reflection-based factory.
		// The reflection done here is only performed once. After that, it is as if the Create() method is using a switch
		// statement (plus a delegate invocation, but we'll ignore that little detail)		
		Factory<string, IDoSomething>.Create("A_ID").DoIt();
		Factory<string, IDoSomething>.Create("B_ID").DoIt();

		Console.ReadKey();
	}
}

class TraditionalFactory
{
	public static IDoSomething Create(string id)
	{
		switch (id)
		{
			case "A_ID":
				return new A();
			case "B_ID":
				return new B();
			default:
				throw new InvalidOperationException("Invalid factory identifier");
		}
	}
}

class ReflectionFactory
{
	private readonly static Dictionary<string, Type> ReturnableTypes;

	static ReflectionFactory()
	{
		ReturnableTypes = GetReturnableTypes();
	}

	private static Dictionary<string, Type> GetReturnableTypes()
	{
		// get a list of the types that the factory can return
		// criteria for matching types:
		// - must have a parameterless constructor
		// - must have correct factory attribute, with non-null, non-empty value
		// - must have correct BaseType (if OutputType is not generic)
		// - must have matching generic BaseType (if OutputType is generic)

		Dictionary<string, Type> returnableTypes = new Dictionary<string, Type>();

		Type outputType = typeof(IDoSomething);
		Type factoryLabelType = typeof(FactoryAttribute);
		foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
		{
			string assemblyName = assembly.GetName().Name;
			if (!assemblyName.StartsWith("System") &&
				assemblyName != "mscorlib" &&
				!assemblyName.StartsWith("Microsoft"))
			{
				foreach (Type type in assembly.GetTypes())
				{
					if (type.GetCustomAttributes(factoryLabelType, false).Length > 0)
					{
						foreach (object label in ((FactoryAttribute)type.GetCustomAttributes(factoryLabelType, true)[0]).Labels)
						{
							if (label != null && label.GetType() == typeof(string))
							{
								if (outputType.IsAssignableFrom(type))
								{
									returnableTypes.Add((string)label, type);
								}
							}
						}
					}
				}
			}
		}

		return returnableTypes;
	}

	public static IDoSomething Create(string id)
	{
		if (ReturnableTypes.ContainsKey(id))
		{
			return (IDoSomething)Activator.CreateInstance(ReturnableTypes[id]);
		}
		else
		{
			throw new Exception("Invalid factory identifier");
		}
	}
}

[Factory("A_ID")]
class A : IDoSomething
{
	public void DoIt()
	{
		Console.WriteLine("Letter A");
	}
}

[Factory("B_ID")]
class B : IDoSomething
{
	public void DoIt()
	{
		Console.WriteLine("Letter B");
	}
}

public interface IDoSomething
{
	void DoIt();
}

#region magic factory code
/// <summary>
/// Attribute class for decorating classes to use with the generic Factory
/// </summary>
public sealed class FactoryAttribute : Attribute
{
	public IEnumerable<object> Labels { get; private set; }
	public FactoryAttribute(params object[] labels)
	{
		if (labels == null)
		{
			throw new ArgumentNullException("labels cannot be null");
		}
		Labels = labels;
	}
}

/// <summary>
/// Custom exception class for factory creation errors
/// </summary>
public class FactoryCreationException : Exception
{
	public FactoryCreationException()
		: base("Factory failed to create object")
	{
	}
}

/// <summary>
/// Generic Factory class.  Classes must have a parameterless constructor for use with this class.  Decorate classes with 
/// <c>FactoryAttribute</c> labels to match identifiers
/// </summary>
/// <typeparam name="TInput">Input identifier, matches FactoryAttribute labels</typeparam>
/// <typeparam name="TOutput">Output base class / interface</typeparam>
public class Factory<TInput, TOutput>
	where TOutput : class
{
	private static readonly Dictionary<TInput, int> JumpTable;
	private static readonly Func<TInput, TOutput> Creator;

	static Factory()
	{
		JumpTable = new Dictionary<TInput, int>();
		Dictionary<TInput, Type> returnableTypes = GetReturnableTypes();
		int index = 0;
		foreach (KeyValuePair<TInput, Type> kvp in returnableTypes)
		{
			JumpTable.Add(kvp.Key, index++);
		}
		Creator = CreateDelegate(returnableTypes);
	}

	/// <summary>
	/// Creates a TOutput instance based on the label
	/// </summary>
	/// <param name="label">Identifier label to create</param>
	/// <returns></returns>
	public static TOutput Create(TInput label)
	{
		return Creator(label);
	}

	/// <summary>
	/// Creates a TOutput instance based on the label
	/// </summary>
	/// <param name="label">Identifier label to create</param>
	/// <param name="defaultOutput">default object to return if creation fails</param>
	/// <returns></returns>
	public static TOutput Create(TInput label, TOutput defaultOutput)
	{
		try
		{
			return Create(label);
		}
		catch (FactoryCreationException)
		{
			return defaultOutput;
		}
	}

	private static Dictionary<TInput, Type> GetReturnableTypes()
	{
		// get a list of the types that the factory can return
		// criteria for matching types:
		// - must have a parameterless constructor
		// - must have correct factory attribute, with non-null, non-empty value
		// - must have correct BaseType (if OutputType is not generic)
		// - must have matching generic BaseType (if OutputType is generic)

		Dictionary<TInput, Type> returnableTypes = new Dictionary<TInput, Type>();

		Type outputType = typeof(TOutput);
		Type factoryLabelType = typeof(FactoryAttribute);
		foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
		{
			string assemblyName = assembly.GetName().Name;
			if (!assemblyName.StartsWith("System") &&
				assemblyName != "mscorlib" &&
				!assemblyName.StartsWith("Microsoft"))
			{
				foreach (Type type in assembly.GetTypes())
				{
					if (type.GetCustomAttributes(factoryLabelType, false).Length > 0)
					{
						foreach (object label in ((FactoryAttribute)type.GetCustomAttributes(factoryLabelType, true)[0]).Labels)
						{
							if (label != null && label.GetType() == typeof(TInput))
							{
								if (outputType.IsAssignableFrom(type))
								{
									returnableTypes.Add((TInput)label, type);
								}
							}
						}
					}
				}
			}
		}

		return returnableTypes;
	}

	private static Func<TInput, TOutput> CreateDelegate(Dictionary<TInput, Type> returnableTypes)
	{
		// get FieldInfo reference to the jump table dictionary
		FieldInfo jumpTableFieldInfo = typeof(Factory<TInput, TOutput>).GetField("JumpTable", BindingFlags.Static | BindingFlags.NonPublic);
		if (jumpTableFieldInfo == null)
		{
			throw new InvalidOperationException("Unable to get jump table field");
		}

		// set up the IL Generator
		DynamicMethod dynamicMethod = new DynamicMethod(
			"Magic",										// name of dynamic method
			typeof(TOutput),								// return type
			new[] { typeof(TInput) },						// arguments
			typeof(Factory<TInput, TOutput>),				// owner class
			true);
		ILGenerator gen = dynamicMethod.GetILGenerator();

		// define labels (marked later as IL is emitted)
		Label creationFailedLabel = gen.DefineLabel();
		Label[] jumpTableLabels = new Label[JumpTable.Count];
		for (int i = 0; i < JumpTable.Count; i++)
		{
			jumpTableLabels[i] = gen.DefineLabel();
		}

		// declare local variables
		gen.DeclareLocal(typeof(TOutput));
		gen.DeclareLocal(typeof(TInput));
		LocalBuilder intLocalBuilder = gen.DeclareLocal(typeof(int));

		// emit MSIL instructions to the dynamic method
		gen.Emit(OpCodes.Ldarg_0);
		gen.Emit(OpCodes.Stloc_1);
		gen.Emit(OpCodes.Volatile);
		gen.Emit(OpCodes.Ldsfld, jumpTableFieldInfo);
		gen.Emit(OpCodes.Ldloc_1);
		gen.Emit(OpCodes.Ldloca_S, intLocalBuilder);
		gen.Emit(OpCodes.Call, typeof(Dictionary<TInput, int>).GetMethod("TryGetValue"));
		gen.Emit(OpCodes.Brfalse, creationFailedLabel);
		gen.Emit(OpCodes.Ldloc_2);
		// execute the MSIL switch statement, effectively giving us O(1) access to each case
		gen.Emit(OpCodes.Switch, jumpTableLabels);

		// set up the jump table
		foreach (KeyValuePair<TInput, int> kvp in JumpTable)
		{
			gen.MarkLabel(jumpTableLabels[kvp.Value]);
			// create the type to return
			gen.Emit(OpCodes.Newobj, returnableTypes[kvp.Key].GetConstructor(Type.EmptyTypes));
			gen.Emit(OpCodes.Ret);
		}

		// CREATION FAILED label
		gen.MarkLabel(creationFailedLabel);
		gen.Emit(OpCodes.Newobj, typeof(FactoryCreationException).GetConstructor(Type.EmptyTypes));
		gen.Emit(OpCodes.Throw);

		// create a delegate so we can later invoke the dynamically created method
		return (Func<TInput, TOutput>)dynamicMethod.CreateDelegate(typeof(Func<TInput, TOutput>));
	}
}
#endregion