How to serialize third party vendor classes so that I can send them to CSLA server side?

[adrianwright109]

Hi,

I am using Telerik Blazor UI components in a Blazor WebAssembly project and specifically the Telerik Grid.

Telerik supply a DataSourceRequest class and associated extension methods that work with this DataSourceRequest class object which contains all the required information from the grid instance about the current page number, how many records per page, any column filters or column groups applied.

I want to be able to send this object to the DataPortal_Fetch method so that I can use it in my data retrieval query.

At the moment when I pass it in I get the following error message:
Serialization of type object is not supported. (Telerik.DataSource.DataSourceRequest)

The Telerik class looks like this:

namespace Telerik.DataSource
{
  /// <summary>
  /// Provides information about paging, sorting, filtering and grouping of data.
  /// Usually created by a Telerik component and sent to a backend that will consume this data.
  /// Often used together with the DataSourceResult class that can automatically perform the needed operations over the full set of data.
  /// </summary>
  public class DataSourceRequest
  {
    public DataSourceRequest()
    {
      this.Page = 1;
      this.Aggregates = (IList<AggregateDescriptor>) new List<AggregateDescriptor>();
    }

    /// <summary>The number of items to skip</summary>
    public int Skip { get; set; }

    /// <summary>The current page.</summary>
    public int Page { get; set; }

    /// <summary>The page size.</summary>
    public int PageSize { get; set; }

    /// <summary>The sorting information for the data.</summary>
    public IList<SortDescriptor> Sorts { get; set; }

    /// <summary>The filtering information for the data.</summary>
    public IList<IFilterDescriptor> Filters { get; set; }

    /// <summary>The grouping information for the data.</summary>
    public IList<GroupDescriptor> Groups { get; set; }

    /// <summary>The data aggregation.</summary>
    public IList<AggregateDescriptor> Aggregates { get; set; }

    /// <summary>Indicates whether group paging is enabled.</summary>
    public bool GroupPaging { get; set; }
  }
}

I have tried to create a Wrapper class and have the Telerik.DataSource.DataSourceRequest object as a property on the wrapper and manually serialize/deserialized the property - this hasn't worked either, e.g:

    [Serializable]
    public class DataSourceRequestEnvelope : MobileObject
    {
        public Telerik.DataSource.DataSourceRequest Request { get; set; }

        #region MobileObject overrides for Serialization and De-Serialization

        protected override void OnGetState(SerializationInfo info, StateMode mode)
        {
            base.OnGetState(info, mode);

            info.AddValue(nameof(Request), Request);
        }

        protected override void OnSetState(SerializationInfo info, StateMode mode)
        {
            base.OnSetState(info, mode);

            Request = info.GetValue<Telerik.DataSource.DataSourceRequest>(nameof(Request));
        }

        #endregion MobileObject overrides for Serialization and De-Serialization
    }

[rockfordlhotka]

I think your wrapper is the right idea (if you can't alter the Telerik code itself).

But your wrapper's Get/Set state methods need to put primitive types into the serialization stream, you can't put complex types into the stream. The SerializationInfo only understands primitive types (int, float, string, datetime, etc.).

[adrianwright109]

@rockfordlhotka - I have spent all day creating CSLA compatible wrappers to wrap the third party Telerik class into.

I've now just realized that the Telerik class has a couple of properties of type System.Type and System.Object.

Is there any way that I could serialize these types - maybe using JSON.NET to serialize to a string and pass the entire class as a string and then use JSON.NET to de-serialize it on the CSLA DataPortal side?

Or should I abandon the whole idea of passing this class to the CSLA DataPortal, wrapped or not?

[hurcane]

I've run into this kind of obstacle several times, although not in the Blazor context. We use a ReadOnly stereotype to act as a DTO and ferry the simple properties we really need from client to server. The Telerik class would be passed in the constructor, but not as a field within the class. The server-side code can use the properties on the ReadOnly class instead of referencing the Telerik third-party class.

[rockfordlhotka]

Is the Telerik type serializable at all? As in, would BinaryFormatter serialize it?

More importantly, can it be deserialized because that's always the hard part. Taking apart an object's field is pretty easy, but putting them back together again often can't be done with all the king's horses and all the king's men.

The short answer is yes: if you can figure out a way to serialize/deserialize the Telerik object graph via json.net or protobuf or something, then you can put the byte array into your wrapper, b/c MobileFormatter understands how to serialize a string or byte[].