Implementing factory design pattern with generics
Several considerations: 


Base Factory class does all the work, so I would simply merge it into the generic method.
Your singleton instance is stored in a public field. This means any part of your program can easily replace it. You should make it readonly, or (even better) expose it through a readonly property.
If you are not abstracting the factory (i.e. exposing the Instance property as an interface), it means there is no way to use any other factory in your program. This has two possible consequences:


you can either skip accessing Instance every time and use a plain static method (Factory&lt;T&gt;.Instance.DoStuff(...) becomes Factory&lt;T&gt;.DoStuff(...), which is slightly shorter)
or, you can decide that you want to hide the implementation of the factory behind an interface (IFactory&lt;T&gt;, for example), in which case a concrete factory will be stored in an instance of a separate class, which would completely change the call to something like DAL.GetFactory&lt;T&gt;().DoStuff(...) (DoStuff becomes an instance method). This leaves allows greater flexibility, since you can pass an IFactory&lt;T&gt; to a part of code which doesn't need to know about your static DAL classes. But it would require additional redesign.

If you add a new generic parameter to the RegisterProductType method, you can use the where clause to limit the type to derived types at compile time. Getting a compile error is much better than getting a run-time one.
Are you sure that you need to pass the constructor parameters to the GetProduct method? This part might be slightly unusual (although there might be cases where you would want to instantiate your classes by passing a parameter). What it there is a specific derived type which accepts different parameters than other types? Activator.CreateInstance indicates that you are forcing all your callers to know which constructor your method will use.


First four points (simplified) would result in something like:

public class Factory&lt;T&gt;
{
    private Factory() { }

    static readonly Dictionary&lt;int, Type&gt; _dict = new Dictionary&lt;int, Type&gt;();

    public static T Create(int id, params object[] args)
    {
        Type type = null;
        if (_dict.TryGetValue(id, out type))
            return (T)Activator.CreateInstance(type, args);

        throw new ArgumentException("No type registered for this id");
    }

    public static void Register&lt;Tderived&gt;(int id) where Tderived : T
    {
        var type = typeof(Tderived);

        if (type.IsInterface || type.IsAbstract)
            throw new ArgumentException("...");

        _dict.Add(id, type);
    }
}


Usage:

Factory&lt;IAnimal&gt;.Register&lt;Dog&gt;(1);
Factory&lt;IAnimal&gt;.Register&lt;Cat&gt;(2);

// this is the "suspicious" part.
// some instances may require different parameters?
Factory&lt;IAnimal&gt;.Create(2, "Garfield");


Fifth point is worth considering. If you change your factory to this:

public class Factory&lt;T&gt;
{
    private Factory() { }

    static readonly Dictionary&lt;int, Func&lt;T&gt;&gt; _dict 
         = new Dictionary&lt;int, Func&lt;T&gt;&gt;();

    public static T Create(int id)
    {
        Func&lt;T&gt; constructor = null;
        if (_dict.TryGetValue(id, out constructor))
            return constructor();

        throw new ArgumentException("No type registered for this id");
    }

    public static void Register(int id, Func&lt;T&gt; ctor)
    {
        _dict.Add(id, ctor);
    }
}


Then you can use it like this:

Factory&lt;IAnimal&gt;.Register(1, () =&gt; new Dog("Fido"));
Factory&lt;IAnimal&gt;.Register(2, () =&gt; new Cat("Garfield", something_else));

// no need to pass parameters now:
IAnimal animal = Factory&lt;IAnimal&gt;.Create(1);


This delegates all construction logic to init time which allows complex scenarios for different object types. You can, for example, make it return a singleton on each call to Create:

// each call to Factory&lt;IAnimal&gt;.Create(3) should return the same monkey
Factory&lt;IAnimal&gt;.Register(3, () =&gt; Monkey.Instance);