Как я могу реорганизовать этот код C #, который в настоящее время использует Dictionarys, чтобы иметь еще меньше избыточности и быть более безопасным для типов?

Во-первых, вместо сохранения типа List<T> в словаре просто сохраните базовый общий тип:

private static readonly Dictionary<string, Type> listTypeByFileName = new Dictionary<string, Type> {
    {"a.xml", typeof(A)},
    {"b.xml", typeof(B)}
    // etc.

Это немного облегчит дальнейшие шаги. При десериализации создайте общий тип списка. После получения типа из словаря вы можете сделать:

var listType = typeof(List<>).MakeGenericType(typeRetrievedFromDictionary);

После того, как вы его десериализовали, приведите его к IList. Это фактически приводит его к списку object. Это нормально. Поскольку вы десериализовали с использованием определенного типа, каждый элемент в списке будет иметь ожидаемый тип.

Создайте словарь для типобезопасных методов, которые вы хотите вызывать каждый раз в списке.

Dictionary<Type, Action<object>> methodsToInvokeByType;

Добавьте методы в словарь:

doSometingMethods.Add(typeof(A), dataItem => DoSomethingWithA((A)dataItem));
doSometingMethods.Add(typeof(B), dataItem => DoSomethingWithB((B)dataItem));

Теперь, когда ваш IList заполнен объектами, вы получаете типобезопасный метод для вызова:

var methodToInvoke = methodsToInvokeByType[typeRetrievedFromDictionary];

Затем сделайте следующее:

foreach(object itemInList in list) // this is your deserialized list cast as IList
{
    methodToInvoke(itemInList);
}

Итак, если тип A, вы будете вызывать

DoSomethingWithA((A)itemInList)

Это некрасиво. Связь между кодом, использующим объекты и Type, и типобезопасным универсальным кодом может быть запутанной. Но в конечном счете цель состоит в том, чтобы какими бы ни были эти конечные методы — DoSomethingWithA, DoSomethingWithB и т. д., по крайней мере, они были типобезопасными.

Можно еще упростить:

Создайте класс, который десериализует список и передает его методу для обработки и интерфейсу:

public interface IXmlFileProcessor
{
    void Process(byte[] xmlFile);
}

public class XmlFileProcessor<T> : IXmlFileProcessor
{
    private readonly Action<T> _doSomething;

    public XmlFileProcessor(Action<T> doSomething)
    {
        _doSomething = doSomething;
    }

    public void Process(byte[] xmlFile) // or string or whatever
    {
        // deserialize into a List<T>
        foreach (T item in deserializedList)
            _doSomething(item);
    }
}

Затем создайте Dictionary<Type, IXmlFileProcessor> и заполните его:

fileProcessors.Add(typeof(A), new XmlFileProcessor<A>(SomeClass.DoSomethingWithA));
fileProcessors.Add(typeof(B), new XmlFileProcessor<B>(SomeClass.DoSomethingWithB));

Этот подход (внедрение Action) предназначен для того, чтобы метод "сделать что-нибудь" был отделен от класса, ответственного за десериализацию. DoSomething также может быть общим методом в XmlFileProcessor<T>. Существуют разные способы составления этих классов и добавления их в этот словарь. Но в любом случае, определив тип, вы просто извлекаете из словаря правильный процессор для конкретного типа, передаете ему свой файл, а он делает все остальное.

Этот подход устраняет разрыв между универсальным и неуниверсальным, делая класс - XmlFileProcessor<T> - универсальным, но реализуя неуниверсальный интерфейс. Это работает до тех пор, пока вы предпринимаете шаги (используя словарь), чтобы убедиться, что вы выбираете правильную реализацию для любого типа, который вы десериализуете.