Deserialize Stream to List<T> or any other type

Question

Attempting to deserialize a stream to List<T> (or any other type) and am failing with the error:

The type arguments for method Foo.Deserialize<T>(System.IO.Stream) cannot be inferred from the usage. Try specifying the type arguments explicitly.

This fails:

public static T Deserialize<T>(this Stream stream)
{
    BinaryFormatter bin = new BinaryFormatter();
    return (T)bin.Deserialize(stream);
}

But this works:

public static List<MyClass.MyStruct> Deserialize(this Stream stream)
{
    BinaryFormatter bin = new BinaryFormatter();
    return (List<MyClass.MyStruct>)bin.Deserialize(stream);
}

or:

public static object Deserialize(this Stream stream)
{
    BinaryFormatter bin = new BinaryFormatter();
    return bin.Deserialize(stream);
}

Is it possible to do this without casting, e.g. (List<MyStruct>)stream.Deserialize()?

Update:
Using stream.Deserialize<List<MyClass.MyStruct>>() results in an error:

System.InvalidCastException: Unable to cast object of type 'System.RuntimeType'
to type 'System.Collections.Generic.List`1[MyClass+MyStruct]'.
at StreamExtensions.Deserialize[T](Stream stream)
at MyClass.RunSnippet()

Update 2 (sample console app) - run once to create the file, again to read from it

using System;
using System.IO;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Serialization.Formatters.Binary;

public static class StreamExtensions
{
    public static Stream Serialize<T>(this T o) where T : new()
    {
        Stream stream = new MemoryStream();
        BinaryFormatter bin = new BinaryFormatter();
        bin.Serialize(stream, typeof(T));
        return stream;
    }

    public static T Deserialize<T>(this Stream stream) where T : new()
    {
        BinaryFormatter bin = new BinaryFormatter();
        return (T)bin.Deserialize(stream);
    }

    public static void WriteTo(this Stream source, Stream destination)
    {
        byte[] buffer = new byte[32768];
        source.Position = 0;
        if(source.Length < buffer.Length) buffer = new byte[source.Length];
        int read = 0;
        while ((read = source.Read(buffer, 0, buffer.Length)) != 0)
        {
            destination.Write(buffer, 0, read);
        }
    }
}


public class MyClass
{
    public struct MyStruct
    {
        public string StringData;
        public MyStruct(string stringData)
        {
            this.StringData = stringData;
        }
    }

    public static void Main()
    {
        // binary serialization
        string filename_bin = "mydata.bin";
        List<MyStruct> l;
        if(!File.Exists(filename_bin))
        {
            Console.WriteLine("Serializing to disk");
            l = new List<MyStruct>();
            l.Add(new MyStruct("Hello"));
            l.Add(new MyStruct("Goodbye"));
            using (Stream stream = File.Open(filename_bin, FileMode.Create))
            {
                Stream s = l.Serialize();
                s.WriteTo(stream);
            }
        }
        else
        {
            Console.WriteLine("Deserializing from disk");
            try
            {
                using (Stream stream = File.Open(filename_bin, FileMode.Open))
                {
                    l = stream.Deserialize<List<MyStruct>>();
                }
            }
            catch(Exception ex)
            {
                l = new List<MyStruct>();
                Console.WriteLine(ex.ToString());
            }
        }

        foreach(MyStruct s in l)
        {
            Console.WriteLine(
                string.Format("StringData: {0}",
                    s.StringData
                )
            );
        }

        Console.ReadLine();
    }
}

Answer 1

I assume you're calling your extension method like this:

List<MyStruct> result = mystream.Deserialize();    

In this case, the compiler cannot determine the T for Deserialize (it doesn't look at the variable the method call result is assigned to).

So you need to specify the type argument explicitly:

List<MyStruct> result = mystream.Deserialize<List<MyStruct>>();

---

This works:

public static class StreamExtensions
{
    public static void SerializeTo<T>(this T o, Stream stream)
    {
        new BinaryFormatter().Serialize(stream, o);  // serialize o not typeof(T)
    }

    public static T Deserialize<T>(this Stream stream)
    {
        return (T)new BinaryFormatter().Deserialize(stream);
    }
}

[Serializable]  // mark type as serializable
public struct MyStruct
{
    public string StringData;
    public MyStruct(string stringData)
    {
        this.StringData = stringData;
    }
}

public static void Main()
{
    MemoryStream stream = new MemoryStream();

    new List<MyStruct> { new MyStruct("Hello") }.SerializeTo(stream);

    stream.Position = 0;

    var mylist = stream.Deserialize<List<MyStruct>>();  // specify type argument
}

Answer 2

You can use your original generic method, you just have to specify the generic type explicitly like so...

stream.Deserialize<List<MyClass.MyStruct>>();

Answer 3

You are serializing the Type of the list and not the actual list. It should be:

bin.Serialize(stream, o)

Also, you will have to mark MyStruct as Serializable for it to serialize it correctly.