Sharepoint online chiamate batch con C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.SharePoint.Client;
using Newtonsoft.Json;
using PnP.Core.Services;

namespace ConsoleAppNet48.Data
{
    /// <summary>
    /// https://github.com/pnp/pnpframework
    /// https://learn.microsoft.com/en-us/sharepoint/dev/sp-add-ins/make-batch-requests-with-the-rest-apis
    /// https://www.andrewconnell.com/blog/part-2-sharepoint-rest-api-batching-exploring-batch-requests-responses-and-changesets/
    /// </summary>
    public class SPBatchManager
    {
        private readonly string _accessToken = null;
        private readonly string _siteUrl;

        const string HEADER_ACCEPT_VALUE = "application/json;odata=nometadata";

        const string API_GET_WEB = "/_api/web?$select=Id,Title,Created";
        const string API_GET_LISTS = "/_api/web/lists?$select=Id,Title,Created,ItemCount";
        const string API_BATCH = "/_api/$batch";

        public SPBatchManager(string siteUrl, string user, string password)
        {
            _siteUrl = siteUrl.TrimEnd('/');

            _accessToken = GetAccessToken(siteUrl, user, password);
        }

        #region Authentication/Token 
        private string GetAccessToken(string siteUrl, string user, string password)
        {
            SecureString securePassword = ToSecureString(password);
            PnP.Framework.AuthenticationManager authManager = new PnP.Framework.AuthenticationManager(user, securePassword);
            return authManager.GetAccessToken(siteUrl);
        }

        private SecureString ToSecureString(string plainString)
        {
            if (plainString == null) return null;

            SecureString secureString = new SecureString();
            foreach (char c in plainString.ToCharArray())
            {
                secureString.AppendChar(c);
            }
            return secureString;
        }

        #endregion



        #region Http base methods

        private HttpClient GetHttpClient(bool includeAccept = true)
        {
            HttpClient client = new HttpClient();
            if (includeAccept == true)
            {
                client.DefaultRequestHeaders.Add("accept", HEADER_ACCEPT_VALUE);
            }
            client.DefaultRequestHeaders.Add("authorization", "Bearer " + _accessToken);
            return client;
        }
        private async Task<string> GetAsync(string relativeUrl)
        {
            try
            {
                using (HttpClient client = GetHttpClient())
                {
                    return await client.GetStringAsync(_siteUrl + relativeUrl);
                }
            }
            catch (Exception ex)
            {
                throw;
            }

        }

        private string GetMulipartAction(System.Net.Http.HttpMethod method, string url, object item)
        {
            StringBuilder sb = new StringBuilder(500);

            sb.AppendFormat("{0} {1} HTTP/1.1", method, url);
            sb.AppendLine();
            sb.AppendLine("Content-Type: application/json;odata=nometadata");
            sb.AppendLine("Accept: application/json;odata=nometadata");
            sb.AppendLine();
            if (item != null)
            {
                sb.AppendLine(JsonConvert.SerializeObject(item));
            }

            return sb.ToString();
        }

        private const string BOUNDARY_BATCH = "batch_19676457-165F-46AF-9A8C-8202812CCEEE_sgart-it";
        private const string BOUNDARY_CHANGESET = "changeset_C5946BFE-6A35-462D-9E3D-0A7CC4D9A1E3_sgart-it";

        private async Task PostMultipartAsync<T>(string relativeUrl, List<UpdateBatch<T>> batchItems) where T : IBatchId
        {
            try
            {
                // create changesets
                StringBuilder sbChangesets = new StringBuilder(batchItems.Count * 100);
                int index = 0;
                batchItems.ForEach(batch =>
                {
                    sbChangesets.AppendLine("--" + BOUNDARY_CHANGESET);
                    sbChangesets.AppendLine("Content-Type: application/http");
                    sbChangesets.AppendLine("Content-Transfer-Encoding: binary");
                    sbChangesets.AppendLine($"Content-ID: {++index}");  // crea delle variabili $1, S2, ecc. che conterrano l'id, da usare per altre rischieste 
                    sbChangesets.AppendLine();

                    string batchAction = GetMulipartAction(batch.Method, batch.Url, batch.Item);

                    sbChangesets.AppendLine(batchAction);
                });
                int changesetsLength = sbChangesets.Length;

                // create batch
                StringBuilder sbBatch = new StringBuilder(changesetsLength + 350);
                sbBatch.AppendLine("--" + BOUNDARY_BATCH);
                sbBatch.AppendLine("Content-Type: multipart/mixed;boundary=" + BOUNDARY_CHANGESET);
                sbBatch.AppendLine("Content-Lenght: " + changesetsLength);
                sbBatch.AppendLine("Content-Transfer-Encoding: binary");
                sbBatch.AppendLine();
                sbBatch.Append(sbChangesets);
                sbBatch.AppendLine("--" + BOUNDARY_CHANGESET + "--");
                sbBatch.AppendLine("--" + BOUNDARY_BATCH + "--");

                using (HttpClient client = GetHttpClient())
                {
                    using (var content = new StringContent(sbBatch.ToString()))
                    {
                        content.Headers.Remove("Content-Type");
                        content.Headers.TryAddWithoutValidation("Content-Type", "multipart/mixed;boundary=" + BOUNDARY_BATCH);

                        using (HttpResponseMessage response = await client.PostAsync(_siteUrl + relativeUrl, content))
                        {
                            //response.EnsureSuccessStatusCode();
                            var result = await response.Content.ReadAsStringAsync();

                            if (response.IsSuccessStatusCode)
                            {
                                string boundaryResponse = result.Substring(0, result.IndexOf(Environment.NewLine));

                                //le risposte dei cnagesets sono nell'ordne in cui sono state inviate
                                string[] blocks = result.Split(new[] { boundaryResponse }, StringSplitOptions.RemoveEmptyEntries);

                                for (int i = 0; i < blocks.Length; i++)
                                {
                                    string r = blocks[i].Trim();
                                    if (r == "--")
                                    {
                                        break;
                                    }
                                    // risposta del batch attuale
                                    var batch = batchItems[i];

                                    // trovo lo stato HTTP
                                    Regex reHttp = new Regex(@"^HTTP/1\.1 (?<status>\d+) .+$", RegexOptions.Multiline | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
                                    var matchHttp = reHttp.Match(r);
                                    if (matchHttp.Success)
                                    {
                                        int.TryParse(matchHttp.Groups["status"].Value, out int status);

                                        batch.HTTPStatus = status;
                                        batch.Success = false;

                                        string objectResponse = r.Split('\n').Last();


                                        if (status >= 200 && status <= 299)
                                        {
                                            if (status == 201)
                                            {
                                                BatchId obj = JsonConvert.DeserializeObject<BatchId>(objectResponse);
                                                batch.Item.Id = obj.Id;
                                            }
                                            batch.Success = true;
                                        }
                                        else
                                        {
                                            var error = JsonConvert.DeserializeObject<SPError>(objectResponse);
                                            batch.Error = error.OdataError.Code + " - " + error.OdataError.Message.Value;
                                        }
                                    }
                                }
                            }
                            else
                            {
                                var error = JsonConvert.DeserializeObject<SPError>(result);
                                throw new Exception(error.OdataError.Code + " - " + error.OdataError.Message.Value);
                            }
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }

        }

        #endregion


        #region Relative list url

        /// <summary>
        /// Ritorna la url assoluta della lista
        /// es.:
        /// listName = TestBulkInsert => https://tenantName.sharepoint.com/sites/test/_api/web/lists/GetByTitle('TestBulkInsert')/items
        /// listName = dd4450ad-4fcc-440a-b188-493189631ddc => https://tenantName.sharepoint.com/sites/test/_api/web/lists(guid'dd4450ad-4fcc-440a-b188-493189631ddc')/items
        /// listName = /Lists/TestBulkInsert => https://tenantName.sharepoint.com/sites/test/_api/web/GetList('/sites/test/Lists/TestBulkInsert')/items
        /// listName = /NomeDocLib => https://tenantName.sharepoint.com/sites/test/_api/web/GetList('/sites/test/NomeDocLib')/items
        /// </summary>
        /// <param name="listName">Titolo della lista, oppure guid, oppure path relativo</param>
        /// <returns></returns>
        public string GetListUrl(string listName)
        {
            string urlPart;
            if (listName.StartsWith("/"))
            {
                urlPart = $"GetList('{new Uri(_siteUrl).AbsolutePath.TrimEnd('/')}{listName}')";
            }
            else
            {
                //{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
                bool isGuid = listName.Length == 38 && listName.StartsWith("{") && listName.EndsWith("}");
                if (isGuid)
                {
                    urlPart = $"lists(guid'{listName.TrimStart('{').TrimEnd('}')}')";
                }
                else
                {
                    urlPart = $"lists/GetByTitle('{listName}')";
                }
            }

            return $"{_siteUrl}/_api/web/{urlPart}";
        }

        public string GetListItemUrl(string listName, int id = 0)
        {
            return GetListUrl(listName) + "/items" + (id == 0 ? "" : $"({id})");
        }

        #endregion

        #region batch
        public async Task ExecuteBatch<T>(List<UpdateBatch<T>> batches) where T : IBatchId
        {
            await PostMultipartAsync(API_BATCH, batches);
        }

        #endregion
}

private string GetAccessToken(string siteUrl, string user, string password)
{
    SecureString securePassword = ToSecureString(password);
    PnP.Framework.AuthenticationManager authManager = new PnP.Framework.AuthenticationManager(user, securePassword);
    return authManager.GetAccessToken(siteUrl);
}

private SecureString ToSecureString(string plainString)
{
    if (plainString == null) return null;

    SecureString secureString = new SecureString();
    foreach (char c in plainString.ToCharArray())
    {
        secureString.AppendChar(c);
    }
    return secureString;
}

private HttpClient GetHttpClient(bool includeAccept = true)
{
    HttpClient client = new HttpClient();
    if (includeAccept == true)
    {
        client.DefaultRequestHeaders.Add("accept", HEADER_ACCEPT_VALUE);
    }
    client.DefaultRequestHeaders.Add("authorization", "Bearer " + _accessToken);
    return client;
}

private string GetMulipartAction(System.Net.Http.HttpMethod method, string url, object item)
{
    StringBuilder sb = new StringBuilder(500);

    sb.AppendFormat("{0} {1} HTTP/1.1", method, url);
    sb.AppendLine();
    sb.AppendLine("Content-Type: application/json;odata=nometadata");
    sb.AppendLine("Accept: application/json;odata=nometadata");
    sb.AppendLine();
    if (item != null)
    {
        sb.AppendLine(JsonConvert.SerializeObject(item));
    }

    return sb.ToString();
}

private const string BOUNDARY_BATCH = "batch_19676457-165F-46AF-9A8C-8202812CCEEE_sgart-it";
private const string BOUNDARY_CHANGESET = "changeset_C5946BFE-6A35-462D-9E3D-0A7CC4D9A1E3_sgart-it";

private async Task PostMultipartAsync<T>(string relativeUrl, List<UpdateBatch<T>> batchItems) where T : IBatchId
{
    try
    {
        // create changesets
        StringBuilder sbChangesets = new StringBuilder(batchItems.Count * 100);
        int index = 0;
        batchItems.ForEach(batch =>
        {
            sbChangesets.AppendLine("--" + BOUNDARY_CHANGESET);
            sbChangesets.AppendLine("Content-Type: application/http");
            sbChangesets.AppendLine("Content-Transfer-Encoding: binary");
            sbChangesets.AppendLine($"Content-ID: {++index}");  // crea delle variabili $1, S2, ecc. che conterrano l'id, da usare per altre rischieste 
            sbChangesets.AppendLine();

            string batchAction = GetMulipartAction(batch.Method, batch.Url, batch.Item);

            sbChangesets.AppendLine(batchAction);
        });
        int changesetsLength = sbChangesets.Length;

        // create batch
        StringBuilder sbBatch = new StringBuilder(changesetsLength + 350);
        sbBatch.AppendLine("--" + BOUNDARY_BATCH);
        sbBatch.AppendLine("Content-Type: multipart/mixed;boundary=" + BOUNDARY_CHANGESET);
        sbBatch.AppendLine("Content-Lenght: " + changesetsLength);
        sbBatch.AppendLine("Content-Transfer-Encoding: binary");
        sbBatch.AppendLine();
        sbBatch.Append(sbChangesets);
        sbBatch.AppendLine("--" + BOUNDARY_CHANGESET + "--");
        sbBatch.AppendLine("--" + BOUNDARY_BATCH + "--");

        using (HttpClient client = GetHttpClient())
        {
            using (var content = new StringContent(sbBatch.ToString()))
            {
                content.Headers.Remove("Content-Type");
                content.Headers.TryAddWithoutValidation("Content-Type", "multipart/mixed;boundary=" + BOUNDARY_BATCH);

                using (HttpResponseMessage response = await client.PostAsync(_siteUrl + relativeUrl, content))
                {
                    //response.EnsureSuccessStatusCode();
                    var result = await response.Content.ReadAsStringAsync();

                    if (response.IsSuccessStatusCode)
                    {
                        string boundaryResponse = result.Substring(0, result.IndexOf(Environment.NewLine));

                        //le risposte dei cnagesets sono nell'ordne in cui sono state inviate
                        string[] blocks = result.Split(new[] { boundaryResponse }, StringSplitOptions.RemoveEmptyEntries);

                        for (int i = 0; i < blocks.Length; i++)
                        {
                            string r = blocks[i].Trim();
                            if (r == "--")
                            {
                                break;
                            }
                            // risposta del batch attuale
                            var batch = batchItems[i];

                            // trovo lo stato HTTP
                            Regex reHttp = new Regex(@"^HTTP/1\.1 (?<status>\d+) .+$", RegexOptions.Multiline | RegexOptions.ExplicitCapture | RegexOptions.Compiled);
                            var matchHttp = reHttp.Match(r);
                            if (matchHttp.Success)
                            {
                                int.TryParse(matchHttp.Groups["status"].Value, out int status);

                                batch.HTTPStatus = status;
                                batch.Success = false;

                                string objectResponse = r.Split('\n').Last();


                                if (status >= 200 && status <= 299)
                                {
                                    if (status == 201)
                                    {
                                        BatchId obj = JsonConvert.DeserializeObject<BatchId>(objectResponse);
                                        batch.Item.Id = obj.Id;
                                    }
                                    batch.Success = true;
                                }
                                else
                                {
                                    var error = JsonConvert.DeserializeObject<SPError>(objectResponse);
                                    batch.Error = error.OdataError.Code + " - " + error.OdataError.Message.Value;
                                }
                            }
                        }
                    }
                    else
                    {
                        var error = JsonConvert.DeserializeObject<SPError>(result);
                        throw new Exception(error.OdataError.Code + " - " + error.OdataError.Message.Value);
                    }
                }

            }
        }
    }
    catch (Exception ex)
    {
        throw;
    }
}

public interface IBatchId
{
    int Id { get; set; }
}

// usato per deserializzare la risposta
public class BatchId : IBatchId
{
    public int Id { get; set; }
}

public class SPError
{
    [JsonProperty("odata.error")]
    public SPErrorOdata OdataError { get; set; }
}

public class SPErrorOdata
{
    [JsonProperty("code")]
    public string Code { get; set; }

    [JsonProperty("message")]
    public SPErrorMessage Message { get; set; }
}

public class SPErrorMessage
{
    [JsonProperty("lang")]
    public string Lang { get; set; }

    [JsonProperty("value")]
    public string Value { get; set; }

}

public class UpdateBatch<T> where T : IBatchId
{
    public bool Success { get; set; }

    public System.Net.Http.HttpMethod Method { get; set; }

    public string Url { get; set; }

    public T Item { get; set; }

    public int HTTPStatus { get; set; }

    public string Error { get; set; }

}

public class TestBatchData : IBatchId
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string CAP { get; set; }
    public int ProvinciaId { get; set; }
}

string itemAddUrl = sp.GetListItemUrl("TestBulkInsert");

List<UpdateBatch<TestBatchData>> batches = new List<UpdateBatch<TestBatchData>>();

UpdateBatch<TestBatchData> batch = new UpdateBatch<TestBatchData>
{
    Method = System.Net.Http.HttpMethod.Post,
    Url = itemAddUrl,
    Item = new TestBatchData
    {
        Id = 0,
        Title = $"Prova {DateTime.Now} - {i + 1}",
        CAP = (i + 1).ToString(),
        ProvinciaId = p
    }
};

batches.Add(batch);

await sp.ExecuteBatch(batches);

static async Task Main(string[] args)
{
    string siteUrl = "https://tenantName.sharepoint.com/";
    string user = "aaaaa@tenantName.onmicrosoft.com";
    string password = "xxxxxxxxxxx";

    SPBatchManager sp = new SPBatchManager(siteUrl, user, password);

    // recupero la url di inserimento item (sempre uguale)
    string itemAddUrl = sp.GetListItemUrl("TestBulkInsert");

    // creo la collection degli items da inserire
    List<UpdateBatch<TestBatchData>> batches = new List<UpdateBatch<TestBatchData>>();
    Random rnd = new Random();
    for (int i = 0; i < 50; i++)
    {
        int p = rnd.Next(1, 105);

        // creo la singola chiamata batch
        UpdateBatch<TestBatchData> batch = new UpdateBatch<TestBatchData>
        {
            Method = System.Net.Http.HttpMethod.Post,
            Url = itemAddUrl,
            Item = new TestBatchData
            {
                Id = 0,
                Title = $"Prova {DateTime.Now} - {i + 1}",
                CAP = (i + 1).ToString(),
                ProvinciaId = p
            }
        };

        batches.Add(batch);
    }

    DateTime startDate = DateTime.Now;

    // eseguo l'inserimento in batch
    await sp.ExecuteBatch(batches);

    Console.WriteLine($"Time: {DateTime.Now - startDate}");
}

// per leggere le proprietà dei siti
public class SPWeb
{
    public Guid Id { get; set; }
    public string Title { get; set; }
    public DateTime Created { get; set; }
    // TODO: aggiungere le proprietà necessarie
}

public class SPList
{
    public Guid Id { get; set; }
    public string Title { get; set; }
    public DateTime Created { get; set; }
    public int ItemCount { get; set; }
    // TODO: aggiungere le proprietà necessarie
}

public class SPValueArray<T>
{
    public List<T> Value { get; set; }
}