Есть ли способ вернуть объект к исходному типу без указания каждого случая?

Вот решение для BinaryWriter, использующее отражение.

Это в основном сканирует BinaryWriter на предмет методов с именем Write, которые принимают ровно один параметр, затем строит словарь, в котором метод обрабатывает какой тип, затем для каждого объекта, который нужно записать, находит правильный метод и вызывает его на писателе.

Грязно, и вам, вероятно, следует поискать лучшие способы сделать все это (а не только письменную часть), но он должен работать для ваших текущих потребностей:

using System.IO;
using System;
using System.Reflection;
using System.Collections.Generic;
namespace ConsoleApplication14
{
    public class Program
    {
        public static void Main()
        {
            Dictionary<Type, MethodInfo> mapping = new Dictionary<Type, MethodInfo>();
            foreach (MethodInfo mi in typeof(BinaryWriter).GetMethods())
            {
                if (mi.Name == "Write")
                {
                    ParameterInfo[] pi = mi.GetParameters();
                    if (pi.Length == 1)
                        mapping[pi[0].ParameterType] = mi;
                }
            }

            List<Object> someData = new List<Object>();
            someData.Add((Byte)10);
            someData.Add((Int32)10);
            someData.Add((Double)10);
            someData.Add((Char)10);
            someData.Add("Test");

            using (FileStream file = new FileStream(@"C:\test.dat", FileMode.Create, FileAccess.ReadWrite))
            using (BinaryWriter writer = new BinaryWriter(file))
            {
                foreach (Object o in someData)
                {
                    MethodInfo mi;
                    if (mapping.TryGetValue(o.GetType(), out mi))
                    {
                        mi.Invoke(writer, new Object[] { o });
                    }
                    else
                        throw new InvalidOperationException("Cannot write data of type " + o.GetType().FullName);
                }
            }
        }
    }
}

Нет. Приведение должно быть известно во время компиляции, но фактический тип известен только во время выполнения.

Обратите внимание, однако, что есть лучший способ тестирования типа, вызывающего GetType. Вместо того:

if (x.GetType() == typeof(byte))

Использовать:

if (x is byte)

РЕДАКТИРОВАТЬ: Чтобы ответить на дополнительные вопросы:

"Какие бывают типы?" Что ж, я думаю, посмотрите документацию по BinaryWriter ...

"Мне нужно беспокоиться о байтах и ​​байтах?" Нет, byte - это псевдоним System.Byte в C #. Они одного типа.

Джон прав, но у меня была еще одна мысль, которая может вам пригодиться. Рассматривали ли вы добавление еще одного байта к передаче каждого объекта, а затем использование этого байта в качестве кода типа, сообщая вам, к чему его привести на другом конце?

Рассматривали ли вы использование BinaryFormatter вместо BinaryWriter?

Преимущества

• Вы можете передать object (т.е. что угодно), так что это решит вашу проблему приведения типов.
• Автоматическое управление типами (фактически записывает заголовки типов в поток).
• Также поддерживает сложные ссылочные типы.

Недостатки

Внутренне использует сериализацию, поэтому:

• Наверное, медленнее.
• Поток байтов увеличивается (из-за заголовков типов).
• У вас нет контроля над форматом байтов, поэтому это не вариант в сценариях взаимодействия.
• Возможные проблемы с версией (совместимость между разными версиями сборок сериализованного типа).
• Требуется разрешение на доступ к коду сериализации (актуально в сценариях частичного доверия).

Вы просите Dynamic Dispatch, а в C # 3.0 его нет.

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

Возможно, вы сможете сделать что-нибудь умное, если у вас есть Dictionary, который отображает типы на функции обработки. Вы можете заполнить отображение для всех функций обработки в одном месте. У вас больше шансов сделать это правильно, чем если бы вы написали переключатель везде, где происходит обработка.

Это случай, когда требуется нечто, называемое Double Dispatch.

Я собираюсь предположить, что объект wrt - это тот, который вы написали сами (допустим, он имеет тип Writer). Вот что можно было сделать:

class Writer
{
    void write(byte b)
    {
        // write bytes here
    }

    void write(Writable something)
    {
        something.writeOn(this);
    }
}

interface Writeable
{
    void writeOn(Writer writer);
}

class SomeObject implements Writeable
{
    private Object someData;
    private Object moreData;

    void writeOn(Writer writer)
    {
        writer.write(convertToByte(someData));
        writer.write(convertToByte(moreData));
    }
}

class AnotherObject implements Writeable
{
    private int x;
    private int y;
    private int z;

    void writeOn(Writer writer)
    {
        writer.write((byte)x);
        writer.write((byte)y);
        writer.write((byte)z);
    }
}

Что делает Writer, так это отправляет обратно на вход, говоря ему использовать его (Writer) для записи, однако это делается для этого объекта, который не может быть известен заранее.