ProxyGenerator/src-examples/ProxyInterfaceConsumerForPnP/Implementations/ClientContextProxy.cs

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Microsoft.SharePoint.Client;

// ReSharper disable once CheckNamespace
namespace ProxyInterfaceConsumerForPnP.Interfaces;

[SuppressMessage("ReSharper", "InconsistentNaming")]
public partial class ClientContextProxy
{
    public Task ExecuteQueryRetryAsync(Interfaces.IClientRuntimeContext clientContext, int retryCount = 10, string? userAgent = null)
    {
        ClientRuntimeContext clientObject_ = Mapster.TypeAdapter.Adapt<ClientRuntimeContext>(clientContext);
        return clientObject_.ExecuteQueryRetryAsync(retryCount, userAgent);
    }

    public void LoadOriginal<T>(T clientObject, params Expression<Func<T, object>>[] retrievals)
        where T : ClientObject
    {
        T clientObject_ = clientObject;
        Expression<Func<T, object>>[] retrievals_ = retrievals;
        _Instance.Load<T>(clientObject_, retrievals_);
    }

    public void Load<TSource, TTarget>(Interfaces.IClientObject clientObject, params Expression<Func<TSource, object>>[] retrievals)
        where TSource : Interfaces.IClientObject
        where TTarget : ClientObject
    {
        TTarget clientObject_ = Mapster.TypeAdapter.Adapt<TTarget>(clientObject);
        Expression<Func<TTarget, object>>[] retrievals_ = retrievals.Select(MapExpression<TSource, TTarget>).ToArray();

        _Instance.Load(clientObject_, retrievals_);
    }

    private static Expression<Func<TTarget, object>> MapExpression<TSource, TTarget>(Expression<Func<TSource, object>> expression)
        where TSource : Interfaces.IClientObject
        where TTarget : ClientObject
    {
        var parameterExpression = Expression.Parameter(typeof(TTarget));

        Expression memberAccessExpression;
        switch (expression.Body)
        {
            case MemberExpression memberExpression:
                memberAccessExpression = Expression.PropertyOrField(parameterExpression, memberExpression.Member.Name);
                break;

            case UnaryExpression unaryExpression:
                var expressionOperand = (MemberExpression)unaryExpression.Operand;
                memberAccessExpression = Expression.PropertyOrField(parameterExpression, expressionOperand.Member.Name);
                memberAccessExpression = Expression.Convert(memberAccessExpression, typeof(object));
                break;

            default:
                throw new NotSupportedException();

        }

        return Expression.Lambda<Func<TTarget, object>>(memberAccessExpression, parameterExpression);
    }
}