Abstract factory or inversion of control pattern?
IOC vs Abstract factory is kind of an apples to oranges question.  Abstract factory assumes you have a collection of related classes for which you don't want to know any of details involved in creating instances of those classes.  IOC doesn't necessarily abstract you away from the creation, it just sort of moves it to another area of your code base. In your particular scenario, one way to simplify that code might be like this

public class DocumentMappingSelector
{
    private Dictionary&lt;Type, Type&gt; mappingRoutes = new Dictionary&lt;Type,Type&gt;();

    public void AddRoute(DocumentMappingRoute route)
    {
         if (this.mappingRoutes.ContainsKey(route.SourceType))
         {
                // you could throw an exception or replace the route here, for this                       
                // example i'll just replace it
                if (this.mappingRoutes[route.SourceType] != route.MapperType)
                {
                    this.mappingRoutes[route.SourceType] = route;
                }
                else
                {
                     this.mappingRoutes.Add(route.SourceType, route);
                }
         }
    }

    public DocumentMappingRoute SelectMappingRoute(Type sourceType)
    {
        DocumentMappingRoute result = null;
        if (this.mappingRoutes.ContainsKey(sourceType))
        {
            result = this.mappingRoutes[sourceType];
        }
        return result;
    }
}

public class DocumentMappingRoute
{
    public DocumentMappingRoute(Type sourceTypeToBeMapped, Type mappingStrategyType, Action&lt;object,UpdateStudentDocumentRequest&gt; mappingProcessAction)
    {
         this.SourceType = sourceTypeToBeMapped;
         this.MapperType = mappingStrategyType;
         this.MappingProcess = mappingProcessAction;

    }
    Type SourceType { get; private set; }
    Type MapperType  { get; private set; }
    Action&lt;object,UpdateStudentDocumentRequest&gt; PerformMapping { get; private set; }
}
internal UpdateStudentDocumentRequest MapDocToUpdateDocumentRequest&lt;T&gt;(T doc)
{
    Type sourceType = typeof(T);
     UpdateStudentDocumentRequest updateStudentDocumentRequestInstance = new UpdateStudentDocumentRequest ();
    return selectorInstance.SelectMappingRoute(sourceType).MappingProcess(doc, updateStudentDocumentRequestInstance);  // you might not need the updateStudentDocumentRequestIsntance paramter here
}


For give any errors, I didn't type this in visual studio I just typed it in this editor.  


Create and Add Document mapping routes to the selector
Get the mapping from the selector


Sorry this doesn't show the full code.  I ran short on time, but this should give you a general direction that will keep your code tight.  Let me know if you have any questions.