{
  "type": "FeatureCollection",
  "features": [
    {
      "type": "Feature",
      "geometry": {
        "type": "Polygon",
        "coordinates": [
          [
            [10.0, 55.0],
            [12.0, 55.0],
            [12.0, 57.0],
            [10.0, 57.0],
            [10.0, 55.0]
          ]
        ]
      },
      "properties": {
        "name": "My Region"
      }
    }
  ]
}

using System.Text.Json;
using System.Text.Json.Serialization;

public class FeatureCollection
{
  [JsonPropertyName("type")]
  public string? Type { get; set; }

  [JsonPropertyName("features")]
  public List<Feature>? Features { get; set; }
}

public class Feature
{
  [JsonPropertyName("type")]
  public string? Type { get; set; }

  [JsonPropertyName("geometry")]
  public FeatureGeometry? Geometry { get; set; }

  [JsonPropertyName("properties")]
  public JsonElement? Properties { get; set; }
}

public class FeatureGeometry
{
  [JsonPropertyName("type")]
  public string? Type { get; set; }

  // MultiPolygon: double[polygon][ring][point][coordinate]
  // Polygon: double[ring][point][coordinate]
  [JsonPropertyName("coordinates")]
  public JsonElement? Coordinates { get; set; }
}

var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };

await using var stream = File.OpenRead("regions.geojson");
var collection = await JsonSerializer.DeserializeAsync<FeatureCollection>(stream, options);

using Microsoft.SqlServer.Types;
using System.Text.Json;

public class SqlGeographyService
{
  public static SqlGeography ToSqlGeography(FeatureGeometry geometry)
  {
    if (!geometry.Coordinates.HasValue)
      throw new ArgumentException("Geometry coordinates cannot be null.");

    SqlGeography sqlGeography;
    switch (geometry.Type)
    {
      case "Polygon":
        var polygon = geometry.Coordinates.Value.Deserialize<List<List<double[]>>>();
        sqlGeography = BuildPolygon(polygon ?? new List<List<double[]>>());
        break;
      case "MultiPolygon":
        var multiPolygon = geometry.Coordinates.Value.Deserialize<List<List<List<double[]>>>>();
        sqlGeography = BuildMultiPolygon(multiPolygon ?? new List<List<List<double[]>>>());
        break;
      default:
        throw new NotSupportedException($"Geometry type '{geometry.Type}' is not supported.");
    }

    if (!sqlGeography.STIsValid())
    {
      sqlGeography = sqlGeography.MakeValid();
    }
    return sqlGeography;
  }

  public static SqlGeography BuildPolygon(List<List<double[]>> coordinates)
  {
    var builder = new SqlGeographyBuilder();
    builder.SetSrid(4326);
    builder.BeginGeography(OpenGisGeographyType.Polygon);

    foreach (var ring in coordinates)
    {
      if (ring == null || ring.Count < 4)
        continue;

      bool first = true;
      foreach (var coord in ring)
      {
        double lon = Math.Round(coord[0], 5);
        double lat = Math.Round(coord[1], 5);

        if (first) { builder.BeginFigure(lat, lon); first = false; }
        else { builder.AddLine(lat, lon); }
      }
      builder.EndFigure();
    }
    builder.EndGeography();
    return builder.ConstructedGeography;
  }

  public static SqlGeography BuildMultiPolygon(List<List<List<double[]>>> coordinates)
  {
    var builder = new SqlGeographyBuilder();
    builder.SetSrid(4326);
    builder.BeginGeography(OpenGisGeographyType.MultiPolygon);

    foreach (var polygon in coordinates)
    {
      builder.BeginGeography(OpenGisGeographyType.Polygon);
      foreach (var ring in polygon)
      {
        if (ring == null || ring.Count < 4)
          continue;

        bool first = true;
        foreach (var coord in ring)
        {
          double lon = Math.Round(coord[0], 5);
          double lat = Math.Round(coord[1], 5);

          if (first) { builder.BeginFigure(lat, lon); first = false; }
          else { builder.AddLine(lat, lon); }
        }
        builder.EndFigure();
      }
      builder.EndGeography();
    }
    builder.EndGeography();
    return builder.ConstructedGeography;
  }
}

CREATE TABLE Regions (
    Id    INT PRIMARY KEY,
    Name  NVARCHAR(200),
    Shape geography
);

foreach (var feature in collection?.Features ?? [])
{
    if (feature.Geometry == null) continue;

    SqlGeography shape = SqlGeographyService.ToSqlGeography(feature.Geometry);

    using var cmd = new SqlCommand(
        "INSERT INTO Regions (Id, Name, Shape) VALUES (@Id, @Name, @Shape)", connection);

    cmd.Parameters.AddWithValue("@Id", id++);
    cmd.Parameters.AddWithValue("@Name",
        feature.Properties?.TryGetProperty("name", out var n) == true ? n.GetString() : "");

    var param = cmd.Parameters.Add("@Shape", System.Data.SqlDbType.Udt);
    param.UdtTypeName = "geography";
    param.Value = shape;

    await cmd.ExecuteNonQueryAsync();
}

{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      },
      "enableDependencyTracking": false
    },
    "logLevel": {
      "Default": "Information",
      "Host.Results": "Warning",
      "Host.Aggregator": "Error",
      "Microsoft": "Warning",
      "System": "Warning",
      "System.Net.Http.HttpClient": "Error",
      "Microsoft.AspNetCore": "Warning",
      "Azure.Core": "Warning",
      "Azure.Storage": "Warning",
      "Azure": "Warning"
    }
  }
}

using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var host = new HostBuilder()
    .ConfigureFunctionsWebApplication()
    .ConfigureServices((context, services) =>
    {
      // Setup proper logging levels for Application Insights 
      services.AddApplicationInsightsTelemetryWorkerService();
      services.ConfigureFunctionsApplicationInsights();
      services.Configure<LoggerFilterOptions>(options =>
      {
        // Add specific rules for Application Insights provider
        // Needed, as Application Insights ignore the host.json logging configuration 
        var defaultRule = options.Rules.FirstOrDefault(rule =>
              rule.ProviderName == "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider");
        if (defaultRule is not null)
        {
          options.Rules.Remove(defaultRule);
        }

        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              "Microsoft",
              LogLevel.Warning,
              null));

        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              "System",
              LogLevel.Warning,
              null));

        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              "Azure",
              LogLevel.Warning,
              null));

        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              "Host.Results",
              LogLevel.Warning,
              null));

        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              "Host.Aggregator",
              LogLevel.Error,
              null));

        // Default namespace at Information level for Application Insights
        // This allows you to write logger.LogInformation in your code and have it
        // show up in Application Insights, while still filtering out less
        // important logs from the framework and Azure SDKs
        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              "Default",
              LogLevel.Information,
              null));

        options.Rules.Add(new LoggerFilterRule(
              "Microsoft.Extensions.Logging.ApplicationInsights.ApplicationInsightsLoggerProvider",
              null,
              LogLevel.Information,
              null));
      });

      // Add your Dependency Injection registrations here   
      // Add your Dependency Injection registrations here   
      // Add your Dependency Injection registrations here   

    })
    .ConfigureLogging((context, logging) =>
    {
      // Apply logging configuration from host.json - to be used locally
      // and for non-Application Insights providers
      logging.AddConfiguration(context.Configuration.GetSection("logging"));
      logging.AddApplicationInsights();
    })
    .Build();

await host.RunAsync();

{
  "version": "2.0",
  "Logging": {
    "ApplicationInsights": {
      "EnableLiveMetricsFilters": true,
      "SamplingSettings": {
        "IsEnabled": true,
        "ExcludedTypes": "Request"
      },
      "EnableDependencyTracking": false,
      "LogLevel": {
        "Default": "Information",
        "Function": "Warning",
        "System.Net.Http.HttpClient": "None",
      }
    },
    "LogLevel": {
      "Default": "Information",
      "Function": "Information",
      "System.Net.Http.HttpClient": "None",
    }
  }
}

_logger.LogInformation("This should end up in application insights");

var builder = FunctionsApplication.CreateBuilder(args);

// Add the host.json file
builder.Configuration.AddJsonFile("host.json", optional: true, reloadOnChange: false);

builder.Services.AddApplicationInsightsTelemetryWorkerService().ConfigureFunctionsApplicationInsights();
builder.Logging.AddApplicationInsights();

...
...

{
    "type": "Point",
    "coordinates": [
        <longitude>,
        <latitude>
    ]
}

using Newtonsoft.Json;
using System.Text.Json.Serialization;

namespace MyCode
{
  public class BeautifulWorldModel
  {
    [JsonPropertyName("panoId")]
    public string PanoId { get; set; }

    [JsonProperty("location")]
    [JsonPropertyName("location")]
    public Location Location { get; set; }
  }

  public class Location
  {
    [JsonProperty("type")]
    [JsonPropertyName("type")]
    public string? Type { get; set; }

    [JsonProperty("coordinates")]
    [JsonPropertyName("coordinates")]
    public double[] Coordinates { get; set; }
  }
}

SELECT * FROM c
WHERE ST_DISTANCE(c.location, {
  "type": "Point",
  "coordinates": [12.5757, 55.6796]
}) < 100

using Microsoft.Azure.Cosmos;

namespace MyCode
{
  public class BeautifulWorldRepository
  {
    private Container _container;

    public BeautifulWorldRepository()
    {
      CosmosClient cosmosClient = new CosmosClient("YOUR_COSMOSDB_URL", "YOUR_COSMOSDB_KEY");
      _container = cosmosClient.GetContainer(
        "YOUR_COSMOSDB_DATABASE", 
        "YOUR_COSMOSDB_CONTAINER");
    }

    public async Task<IEnumerable<BeautifulWorldModel>> GetByLocationAsync(double longitude, double latitude, int distanceInMeters)
    {
      var query = new QueryDefinition("SELECT * FROM c WHERE ST_DISTANCE(c.location, {\"type\": \"Point\", \"coordinates\": [@longitude, @latitude]}) < @distance")
        .WithParameter("@longitude", longitude)
        .WithParameter("@latitude", latitude)
        .WithParameter("@distance", distanceInMeters);
      FeedIterator<BeautifulWorldModel> resultSet = _container.GetItemQueryIterator<BeautifulWorldModel>(query);
      List<BeautifulWorldModel> results = new List<BeautifulWorldModel>();
      while (resultSet.HasMoreResults)
      {
        foreach (var item in await resultSet.ReadNextAsync())
        {
          results.Add(item);
        }
      }
      return results;
    }
  }
}

SELECT *
FROM c
WHERE ST_WITHIN(c.location, {
  "type": "Polygon",
  "coordinates": [[
    [-5.0, 42.0],   -- Southwest corner (near Bay of Biscay)
    [8.5, 42.0],    -- Southeast corner (near Mediterranean)
    [8.5, 51.5],    -- Northeast corner (near Belgium/Luxembourg)
    [-5.0, 51.5],   -- Northwest corner (near English Channel)
    [-5.0, 42.0]    -- Closing the polygon
  ]]
})

using AuthApi.Middlewares;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Reflection;

var builder = WebApplication.CreateBuilder(args);

// ----------------------------------------------------------------
// This is the actual code that should verify the JWT token
// ----------------------------------------------------------------

// Add authentication
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
  options.Authority = "https://login.microsoftonline.com/<Directory (tenant) ID>/v2.0";
  options.TokenValidationParameters = new TokenValidationParameters
  {
    ValidateIssuer = true,
    ValidateAudience = true,
    ValidateLifetime = true,
    ValidateIssuerSigningKey = true,
    ValidIssuer = "https://sts.windows.net/<Directory (tenant) ID>/",
    ValidAudience = "api://<Application (client) ID>"
  };
});

// Add authorization
builder.Services.AddAuthorization();

// ----------------------------------------------------------------
// This is other plumbing code
// ----------------------------------------------------------------

// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(options =>
  {
    var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
    options.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
  }
);

// Logging
builder.Logging.AddConsole();
builder.Services.AddControllers();
var app = builder.Build();

// ----------------------------------------------------------------
// This is the application part. The sequence of calls is important
// ----------------------------------------------------------------

app.UseSwagger();
app.UseSwaggerUI();

app.UseHttpsRedirection();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace AuthApi.Controllers
{
  [Authorize]  
  [ApiController]
  [Route("api/authtest")]
  public class AuthTestController : ControllerBase
  {
    private readonly ILogger<AuthTestController> _logger;

    public AuthTestController(ILogger<AuthTestController> logger)
    {
      _logger = logger;
    }

    [HttpGet]
    public async Task<IActionResult> Get()
    {
      return Ok("It works!!!");
    }
  }
}

[Function("MyFunction")]
public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
{
  // first order of things is to get the request body and serialize it into a class
}

using Microsoft.AspNetCore.Http;

namespace AzureFunctionApp.Foundation.Extensions
{
    public static class HttpRequestExtension
    {
        public static async Task<T?> DeserializeAsync<T>(this HttpRequest req)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var options = new System.Text.Json.JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            };
            return System.Text.Json.JsonSerializer.Deserialize<T>(requestBody, options);
        }
    }
}

[Function("MyFunction")]
public async Task<IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req)
{
  // first order of things is to get the request body and serialize it into a class
  var request = await req.DeserializeAsync<MyModelClass>();
  
  // now you can work with the data from the request body:
  var field = request.SomeField;
}

public class MyEntity : ITableEntity
{
  /// <summary>
  /// Mandatory field (partition id)
  /// </summary>
  public string? PartitionKey { get; set; }
  /// <summary>
  /// Mandatory field (row id)
  /// </summary>
  public string? RowKey { get; set; }
  /// <summary>
  /// Mandatory field (last modified)
  /// </summary>
  public DateTimeOffset? Timestamp { get; set; } = default!;
  /// <summary>
  /// Mandatory field (unique id)
  /// </summary>
  public ETag ETag { get; set; } = default!;

  /// <summary>
  /// Custom table field
  /// </summary>
  public string? Value1 { get; set; } 
}

using Azure.Data.Tables;

namespace MyCode
{
    public class MyRepository : AzureTableBaseRepository<MyEntity>
    {
        public MyRepository(TableServiceClient tableServiceClient) : base("MyTable", tableServiceClient)
        {
        }
    }
}

// Creating a connection to a storage account containing the 
// Azure Table
builder.Services.AddAzureClients(context => context.AddTableServiceClient(builder.Configuration.GetConnectionString("StorageAccount")));
// Allowing for depencency injection
builder.Services.AddTransient<MyRepository>();

public class MyClass 
{
    private MyRepository _myRepository;

    public MyClass(MyRepository myRepository)
    {
        _myRepository = myRepository;
    }

    ...
    ...
}

var entity = new MyEntity() 
{ 
    PartitionKey = "partition",
    RowKey = "row001",
    Value1 = "myvalue"
};

// Adds a new row. Will fail if the partitionkey/rowkey already exists
await _myRepository.AddAsync(entity);

// Updates a row. Will fail if the partitionkey/rowkey does not exist
await _myRepository.UpdateAsync(entity);

// If entity exists, updates the entity. If not, a new is created
await _myRepository.UpsertAsync(entity);

int maxRetries = 10;
int retryCount = 0;
while (retryCount < maxRetries)
{
    try
    {
        var entity = _myRepository.GetAsync("partition", "row001");
        entity.Value1 = entity.Value1 + "1";
        await _myRepository.UpdateAsync(entity, entity.ETag, TableUpdateMode.Replace);
        break;
    }
    // 412 = Precondition Failed (ETag mismatch)
    catch (RequestFailedException ex) when (ex.Status == 412) 
    {
        retryCount++;
        if (retryCount == maxRetries)
        {
            throw new Exception("Cannot update entity");
        }
        else
        {
            // Exponential backoff (0.5s, 1s, 1.5s, ...)
            await Task.Delay(500 * retryCount);
        }
    }
}

List<MyEntity> entityList = new List<MyEntity>();

for (int i=0;i<100;i++)
{
    var entity = new MyEntity() 
    { 
        PartitionKey = "partition",
        RowKey = "row" + i,
        Value1 = "myvalue"
    };
}

// Adds new rows. Will fail if the partitionkeys/rowkeys already exists
await _myRepository.AddAsync(entityList);

// Updates rows. Will fail if the partitionkeys/rowkeys does not exist
await _myRepository.UpdateAsync(entityList);

// If entities exists, updates the entities. If not, new entities are created
await _myRepository.UpsertAsync(entityList);

// One specific entity
var entity = await _myRepository.GetAsync("partition", "row001");

// Using LINQ to query table. Returns all entities matching the 
// query.
var entities = await _myRepository.GetAsync(e => e.PartitionKey == "partition");

services.AddHttpClient("httpClient");

using System.Text.Json.Serialization;

namespace AzureFunctionApp.Salesforce
{
  public class OAuthToken
  {
        [JsonPropertyName("access_token")]
        public string AccessToken { get; set; }

        [JsonPropertyName("signature")]
        public string Signature { get; set; }

        [JsonPropertyName("scope")]
        public string Scope { get; set; }

        [JsonPropertyName("instance_url")]
        public string InstanceUrl { get; set; }

        [JsonPropertyName("id")]
        public string Id { get; set; }

        [JsonPropertyName("token_type")]
        public string TokenType { get; set; }

        [JsonPropertyName("issued_at")]
        public string IssuedAt { get; set; }
    } 
}

using System.Net.Http.Json;
using System.Text;

namespace MyCode
{
  public class SalesforceRepository
  {
    private IHttpClientFactory _httpClientFactory;

    public SalesforceAccessRepository(IHttpClientFactory httpClientFactory)
    {
      _httpClientFactory = httpClientFactory;
    }

    public async Task<OAuthToken?> GetOAuthTokenAsync()
    {
      string? username = "xxxxx";
      string? password = "xxxxx";
      string? oAuthUrl = "https://xxxxx.my.salesforce.com/services/oauth2/token"

      var client = _httpClientFactory.CreateClient("HttpClient");
      var authToken = Encoding.ASCII.GetBytes($"{username}:{password}");
      client.DefaultRequestHeaders.Authorization = 
	      new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(authToken));
      var content = new MultipartFormDataContent { { new StringContent("client_credentials"), "grant_type" } };

      var response = await client.PostAsync(oAuthUrl, content);
      if (!response.IsSuccessStatusCode)
        throw new Exception($"{response.StatusCode}: {response.ReasonPhrase}");

      var responseJson = await response.Content.ReadFromJsonAsync<OAuthToken>();
      return responseJson;
    }
  }
}

using System.Text.Json.Serialization;

namespace MyCode
{
  public class JsonWebToken
  {
    [JsonPropertyName("access_token")]
    public string AccessToken {  get; set; } 

    [JsonPropertyName("instance_url")]
    public string InstanceUrl {  get; set; } 

    [JsonPropertyName("token_type")]
    public string TokenType { get; set; }  

    [JsonPropertyName("issued_token_type")]
    public string IssuedTokenType { get; set; }  

    [JsonPropertyName("expires_in")]
    public int ExpiresIn { get; set; } 

  }
}

    public async Task<JsonWebToken?> GetJsonWebTokenAsync(string bearerToken)
    {
      string? url = "https://xxxxx.my.salesforce.com/services/a360/token";

      var client = _httpClientFactory.CreateClient("HttpClient");
      var data = new[]
      {
        new KeyValuePair<string, string>("grant_type", "urn:salesforce:grant-type:external:cdp"),
        new KeyValuePair<string, string>("subject_token", bearerToken),
        new KeyValuePair<string, string>("subject_token_type", "urn:ietf:params:oauth:token-type:access_token")
      };
      var content = new FormUrlEncodedContent(data);

      var response = await client.PostAsync(url, content);
      if (!response.IsSuccessStatusCode)
        throw new Exception($"{response.StatusCode}: {response.ReasonPhrase}");

      var responseJson = await response.Content.ReadFromJsonAsync<JsonWebToken>();
      return responseJson;
    }

    public async Task<string> Ingest(string jsonData)
    {
      OAuthToken? oauthToken = await GetOAuthTokenAsync();
      JsonWebToken? jwt = await GetJsonWebTokenAsync(oauthToken.AccessToken);
      string? accessToken = jwt?.AccessToken;  

      var client = _httpClientFactory.CreateClient("HttpClient");
      client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);

      using (var content = new StringContent(jsonData, Encoding.UTF8, "application/json"))
      {
        var response = await client.PostAsync("https://xxxxx.salesforce.com/api/v1/ingest/sources/xxxxx", content);
        if (!response.IsSuccessStatusCode)
          throw new Exception($"{response.StatusCode}: {response.ReasonPhrase}");

        var responseJson = await response.Content.ReadAsStringAsync();
        return responseJson;
      }
    }

using System.Net.Http;
 
private static HttpClient _httpClient = new HttpClient();

public async Task<string> PostFormUrlEncodedData()
{
    var data = new[]
    {
        new KeyValuePair<string, string>("formfield1", "formvalue1"),
        new KeyValuePair<string, string>("formfield2", "formvalue2"),
        new KeyValuePair<string, string>("formfield3", "formvalue3")
    };
    var content = new FormUrlEncodedContent(data);

    var response = await client.PostAsync(url, content);
    if (!response.IsSuccessStatusCode)
        throw new Exception($"{response.StatusCode}: {response.ReasonPhrase}");

    var responseJson = await response.Content.ReadAsStringAsync();
      return responseJson;	
}

Example input array:

[
    { "a": "1" },
    { "a": "2" },
    { "a": "3" },
    { "a": "4" },
    { "a": "5" },
    { "a": "6" },
    { "a": "7" }
]

Converted into batches of 3:

[
    [
        {"a":"1"},
        {"a":"2"},
        {"a":"3"}
    ],
    [
        {"a":"4"},
        {"a":"5"},
        {"a":"6"}
    ],
    [
        {"a":"7"}
    ]
]

using System;
using System.Collections.Generic;
using System.Linq;

// For demo purpose: Grab a Json array and convert it into an array of objects
string jsonInputString = "[ { \"a\": \"1\" }, { \"a\": \"2\" }, { \"a\": \"3\" }, { \"a\": \"4\" }, { \"a\": \"5\" }, { \"a\": \"6\" }, { \"a\": \"7\" } ]";
List<object> jsonInput = System.Text.Json.JsonSerializer.Deserialize<List<object>>(jsonInputString);

// Create a new list of objects, and use the Chunk method to create batches
// of a certain size
List<object> batch = new List<object>();
foreach (var chunk in jsonInput.Chunk(3))
{
  batch.Add(chunk);
}

// For demo purposes, convert the batched objects as a Json string
string jsonOutputString = System.Text.Json.JsonSerializer.Serialize(batch);

// Output the contents
Console.WriteLine(jsonOutputString);