Using DataTabe or DataSet types as cache value type

[amirhosseinmp02]

Description

In the way of using DataTabe or DataSet types as cache values in EasyCaching , we have Newtonsoft.Json and SystemTextJson options (we can't use other serializer such MessagePack or ProtoBuf because they do not support these types at all !) but there is a big problem with serializing and deserializing DataTable in json , imagine that your DataTable object has a column with type of GUID and you want to cache it with one of json serializers that it pointed in the top , The problem will occur because json did not save the structure of your table and the only thing that was saved was the data inside it, so when deserializing it, it Guid type is converted to a string !!
This problem will occur in many type that are related together like byte to int or int to long.

Example of DataTable json serializing and deserializing so you can see the problem to using json as serializer

var dt = new System.Data.DataTable();
		dt.Columns.Add("Id",typeof(System.Guid));
		dt.Rows.Add(System.Guid.NewGuid());
		
		var json = JsonConvert.SerializeObject(dt);
		Console.WriteLine(json);
		
		var newDt = JsonConvert.DeserializeObject<System.Data.DataTable>(json);
		
		var id = newDt.Rows[0].Field<Guid>("Id");
		Console.WriteLine(id);

Expected behavior: Store and restore DataSet and DataTable with EasyCaching without any problem (I saw an old project that used BinaryFormatter and no problem but unfortunately BinaryFormatter removed from EasyCaching).

Actual behavior: Disruption of the structure !

Specifications

• Provider : Redis
• Interceptor : .NET 6 - ASP.NET Core WebApi
• Serializer : Newtonsoft.Json and SystemTextJson
• System : Windows 10

[catcherwong]

@amirhosseinmp02 Thanks for your interest in this project.

We will take a look ASAP.

[catcherwong]

When I use Newtonsoft.Json to serializing and deserializing a DataTable, It works well.

test code is as follow

public JsonSerializerTest()
        {
            _serializer = new DefaultJsonSerializer("json", new JsonSerializerSettings());
        }

        [Fact]
        public void Isuue_415_Test()
        {
            var val = System.Guid.NewGuid();

            var dt = new System.Data.DataTable();
            dt.Columns.Add("Id", typeof(System.Guid));
            dt.Rows.Add(val);

            var dtBytes = _serializer.Serialize(dt);
            var dsDt = _serializer.Deserialize<System.Data.DataTable>(dtBytes);

            Assert.Single(dsDt.Columns);
            Assert.Equal("Id", dsDt.Columns[0].ColumnName);
            Assert.Equal(val, System.Guid.Parse(dsDt.Rows[0]["Id"].ToString()));
        }

[amirhosseinmp02]

No, Its not working if you don't parse it to GUID , many projects that use Ado.Net have a lot of methods/codes that return datatable and they can not refactor all of codes to parse staticly to they requested types and besides they have a lot of generic codes too , this is not the problem for only String and GUID, its also remains for types that are similar to eachother like byte-int-long-decimal-double and so on.I thing this is not going to resolve if we use json and instead we should use something that holds the strcuture with it like the old BinaryFormatter.

[catcherwong]

Could you provide a datatable/dataset sample that works in EasyCaching with BinaryFormatter and not works in EasyCaching with other serializer ?

[TenTonsOfHat]

The problem will occur because json did not save the structure of your table and the only thing that was saved was the data inside it, so when deserializing it, it Guid type is converted to a string !!

This isn't an EasyCaching problem, it's a general JSON problem.

From json.org:

A value can be a string in double quotes, or a number, or true or false or null, or an object or an array. These structures can be nested.

As a result, there isn't anything that could be stored in vanilla JSON to indicate to the deserializer what explicit types each column contains (GUID or otherwise). When you deserialize into a DataTable, the deserializer guesses at the type of each column because the DataTable type itself doesn't indicate anything about what types its columns are (so the serializer doesn't know either).

Json.net does include a TypeNameHandling setting that will cause the serializer to include more information about field types but the DataTableConverter that it ships with doesn't respect this setting.

You can write your own converter that handles this, and this stack overflow answer has an example of how to do this as well as a .net fiddle. For your case, you could use that approach and serialize your DataTable before caching them and deserialize them after retrieving them, storing the serialized string instead of the raw object.

I saw an old project that used BinaryFormatter and no problem but unfortunately BinaryFormatter removed from EasyCaching

BinaryFormatter is a massive security vulnerability tantamount to introducing a remote code execution exploit. It shouldn't be used in any projects going forward and support for BinaryFormatter being removed is a very good thing.