What is the default recommended serialization now in CSLA 9/10?

[richardbartley]

I'm upgrading CSLA 8.x solution and we have a mix of ASPNet API serving Android and Desktop (Winforms) client apps, all calling through the dataportal.

Upgrading to v9 (10 to come later) I'm struggling with getting the dataportal configuration and/or serialisation dataportal calls to work.

First my CriteriaBase objects needed changing as were not serializable, so have made them POCO.
Now I get....

The format of value 'application/base64,text/plain' is invalid.
   at Csla.DataPortalClient.DataPortalProxy.<Fetch>d__12.MoveNext()
   at Csla.DataPortal`1.<>c__DisplayClass15_0.<<DoFetchAsync>b__0>d.MoveNext()
   at Csla.DataPortalClient.DataPortalNoCache.<GetDataPortalResultAsync>d__0.MoveNext()
   at Csla.DataPortal`1.<DoFetchAsync>d__15.MoveNext()
   at Csla.DataPortal`1.<FetchAsync>d__20.MoveNext()

Should I be setting UseTextSerialization = true on client and server? Should the dataportal endpoint be /dataportal or /dataportaltext

What is recommended considering my need for WinForms and Android apps here?

Thanks.

[rockfordlhotka]

The UseTextSerialization was a temporary workaround. The CSLA 10 data portal (and maybe v9?) includes the correct fix so the data portal should work out of the box on Android. The "Upgrading to ..." markdown files in /docs should include the details about this.

In CSLA 10 you can use the PocoSerializer to serialize pretty much any POCO - details are in the upgrading doc and also in the MCP server.

[richardbartley]

Thanks, using binary/mobile formatter then......trying POCO and get the "Serialization of type object is not supported. ..... (CurrencyNVListCriteria)
I can work with passing a list of parameters, but would love to use a POCO when many properties needed.

What am I missing here?

// plain old class.....
[Serializable]
public class CurrencyNVListCriteria
{
    public bool PreferCodeOverDescription { get; set; }
    public bool BustCache { get; set; } = false;
}

// client calls like this....
var portal = GetDataPortal<CurrencyNVList>();
var crit = new CurrencyNVListCriteria() { PreferCodeOverDescription = true };
return await portal.FetchAsync(crit);

Server config like this;

builder.Services.AddCsla(o =>
{
    o.Serialization(s => s.UseMobileFormatter());
    CslaSerializationExtensions.RegisterPocoTypes(o);
    
    o.AddAspNetCore();
    o.DataPortal(dpo => dpo
        .AddServerSideDataPortal(ssp =>
        {
            ssp.RegisterExceptionInspector<MyDataPortalExceptionInspector>();
        }));
    o.Security(so =>
    {
        so.AuthenticationType = "Csla";
        so.FlowSecurityPrincipalFromClient = true;
    });
});

and client setup like this;

services.AddCsla(o =>
{
    o.Serialization(s => s.UseMobileFormatter());
    CslaSerializationExtensions.RegisterPocoTypes(o);
    
    o.AddWindowsForms();
    o.Security(so =>
    {
        so.AuthenticationType = "Csla";
        so.FlowSecurityPrincipalFromClient = true;
    });
    o.DataPortal(dp => dp
        .AddClientSideDataPortal(co => co
            .UseHttpProxy(opt =>
            {
                opt.DataPortalUrl = dataPortalUrl;
                opt.UseTextSerialization = false;
                opt.Timeout = TimeSpan.FromSeconds(15);

                opt.HttpClientFactory = sp =>
                {
                    // Return your custom HttpClient
                    return sp.GetRequiredService<IHttpClientFactory>()
                                .CreateClient("CslaDataPortal");
                };
            })));
});

with helper to register the types....

public static class CslaSerializationExtensions
{
    public static void RegisterPocoTypes(CslaOptions options)
    {
        options.Serialization(s => s
            .UseMobileFormatter(m =>
            {
                m.CustomSerializers.Add(
                    new TypeMap<CurrencyNVListCriteria, PocoSerializer<CurrencyNVListCriteria>>(PocoSerializer<CurrencyNVListCriteria>.CanSerialize)
                );

                // Add more POCOs here as needed
            }
        ));
    }
}

[hurcane]

For CSLA 9, the DataPortal can only serialize basic types and classes that inherit from MobileFormatter. I find the simplest solution is to make the criteria classes inherit from ReadOnlyBase and implement the following kind of pattern (hopefully I didn't make any typos).

// Criteria class
using Csla;

[Serializable]
public class CurrencyNVListCriteria : ReadOnlyBase<CurrencyNVListCriteria>
{
    [RunLocal]
    [Create]
    void Create(bool preferCodeOverDescription, bool bustCache)
    {
        PreferCodeOverDescription = preferCodeOverDescription;
        BustCache = bustCache;
    }
    public static readonly PropertyInfo<bool> PreferCodeOverDescriptionProperty = RegisterProperty<bool>(nameof(PreferCodeOverDescription));
    public bool PreferCodeOverDescription
    {
        get => ReadProperty(PreferCodeOverDescriptionProperty);
        private set => LoadProperty(PreferCodeOverDescriptionProperty, value);
    }
    public static readonly PropertyInfo<bool> BustCacheProperty = RegisterProperty<bool>(nameof(BustCache));
    public bool BustCache
    {
        get => ReadProperty(BustCacheProperty);
        private set => LoadProperty(BustCacheProperty, value);
    }
}

// client calls like this....
var critPortal = GetDataPortal<CurrencyNVListCriteria>();
var crit = critPortal.Create(true, false};
var portal = GetDataPortal<CurrencyNVList>();
return await portal.FetchAsync(crit);

[richardbartley]

Thanks.
I can see that would work here.
Was just trying to see if the POCOSerializer approach would work for me.

[hurcane]

There is the option of the PocoSerializer.

[StefanOssendorf]

If you don't need any DataPortal capability for that type I highly suggest using the serialization source generator.
https://github.com/MarimerLLC/csla/tree/main/Source/Csla.Generators/cs/AutoSerialization#using-the-source-generator-with-addresspoco-in-cslanet

This is a lot more efficient than the default PocoSerializer or the way with ReadOnlyBase.

Your class would look like

[AutoSerializable]
public partial class CurrencyNVListCriteria
{
    public bool PreferCodeOverDescription { get; set; }
    public bool BustCache { get; set; } = false;
}

You project has to reference the serialization source generator nuget package and you are done. Nothing else needs to be touched and the class becomes "mobile".

[hurcane]

I was not aware of this option in 9.x. Admittedly, my primary work is still on 8.x.