Support generic version of Get[Type] & Set[Type] in ISessionCollection

[hishamco]

There are many cases the require using more than Int & String, It will be nice if there's a generic version of getting and setting Session objects. I hope to see something like

context.Session.Get<bool>("isLoggedIn") 

[Eilon]

The problem with having fully generic type support is that there is no standard way to convert from an object to a completely arbitrary type. The critical thing to keep in mind with session state is that all data must be serializable because session state might (and often is) on a remote server. This means that complex object graphs or "live" objects cannot be used in session state.

If there are some specific types that you think should be added, we can certainly look at those (e.g. bool).

[davidfowl]

We could also look into allowing a generic overload that requires an implementation of an interface, ISerializer to go from T -> byte[]. Somebody can plug in protobuf or bond

[hishamco]

You're right @Eilon the object must be serializable, but what i mean is to introduce something like what @davidfowl suggest or we can do something like this

if(obj.GetType().IsSerializable)
{
...
}

[hishamco]

@davidfowl @Eilon If this may helps the developer to use various types such as bool, DataTable and so on, I can start to plug protobuf or bond

[davidfowl]

/cc @Tratcher @lodejard

[lodejard]

+1 for @davidfowl 's earlier suggestion. I like the idea of a set of byte[] <-> T formatters the web dev can add explicitly.

Though TBH, I think you would probably add that system as a different service which takes the ISessionCollection as a dependency. Separation of concerns between session provider and the data formatting, ya know.

[hishamco]

@davidfowl @lodejard i think it will be nice if we can provide getting and setting the primitive data types out of the box and let web devs to implement ISerializer for custom and complex objects

[hishamco]

This is a prototype for ProtobufSessionFormatter that implements ISessionFormatter which is suggested here aspnet/HttpAbstractions#286

public class ProtobufSessionFormatter<T> : ISessionFormatter<T>
    {
        public ProtobufSessionFormatter()
        {
            if (typeof(T).IsValueType==false)
            {
                var members = GetPublicMembers();
                RuntimeTypeModel.Default.Add(typeof(T), false).Add(members);
            }
        }

        private string[] GetPublicMembers()
        {
            return typeof(T).GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly).Where(m=>m.MemberType==MemberTypes.Field||m.MemberType==MemberTypes.Property).Select(m => m.Name).ToArray();
        }

        public T Deserialize(byte[] value)
        {
            T obj;
            using (var ms = new MemoryStream(value))
            {
                obj= Serializer.Deserialize<T>(ms);
            }
            return obj;
        }

        public byte[] Serialize(T value)
        {
            byte[] data;
            using (var ms = new MemoryStream())
            {
                Serializer.Serialize(ms, value);
                data = ms.ToArray();
            }
            return data;
        }
    }

[muratg]

I don't believe we will be implementing something like this in V1. Putting it in backlog for now.

[hishamco]

Thanks @muratg, hope to be in consideration in the future

[OlsonDev]

Understandable that you wouldn't implement everything in V1 but how about support for the "easy" ones?

// Not valid syntax, just conveying a list of types to support
public T Get<T>(string key) where T : 
    byte,
    sbyte,
    int,
    uint,
    short,
    ushort,
    long,
    ulong,
    float,
    double,
    char,
    bool,
    decimal,
    System.Guid,
    string {
    // basically struct, without the ability to have nested reference types (like an actual struct type)
    // ...
}

public T Get<T>(string key) where T : struct, IConvertible {
    if (!typeof(T).IsEnum) throw new ArgumentException("T must be an enum");
    // ...
}

Int32 & String alone is pretty limited. 😕