CreateSPAsyncReadJob sample

CreateSPAsyncReadJob.cs

using System;
using System.Linq;
using System.Security;
using System.Threading;
using Microsoft.SharePoint.Client;
using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Blob;
using Microsoft.WindowsAzure.Storage.Queue;

namespace ConsoleApp1
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var userName = "admin@tenant.onmicrosoft.com";
            var password = GetSecurePassword("password");
            var siteUrl = "https://tenant.sharepoint.com/sites/testsite";
            var listUrl = $"{siteUrl}/testlist";
            var azStorageConnectionStrong = "DefaultEndpointsProtocol=https;AccountName=abcd;AccountKey=xyz";

            using (var clientContext = new ClientContext(siteUrl))
            {
                clientContext.Credentials = new SharePointOnlineCredentials(userName, password);

                var azManifestContainer = CreateContainerIfNotExists(azStorageConnectionStrong, "spread-manifest-container");
                var azReportQueue = CreateQueueIfNotExists(azStorageConnectionStrong, "spread-report-queue");

                var azManifestContainerUrl = GetSASUrl(azManifestContainer);
                var azReportQueueUrl = GetSASUrl(azReportQueue);

                var output = clientContext.Site.CreateSPAsyncReadJob(
                    listUrl,
                    new AsyncReadOptions
                    {
                        IncludeDirectDescendantsOnly = true,
                        IncludeSecurity = true,
                    },
                    null,
                    azManifestContainerUrl,
                    azReportQueueUrl);
                clientContext.ExecuteQuery();

                CloudQueueMessage message;
                do
                {
                    Thread.Sleep(TimeSpan.FromSeconds(10));
                    message = azReportQueue.GetMessage();
                    if (message != null)
                    {
                        Console.WriteLine(message.AsString);
                        azReportQueue.DeleteMessage(message);

                    }
                } while (message != null);

                Console.ReadLine();
            }
        }

        private static SecureString GetSecurePassword(string pwd)
        {
            SecureString securePassword = new SecureString();
            foreach (var ch in pwd.ToArray())
            {
                securePassword.AppendChar(ch);
            }
            return securePassword;
        }

        private static CloudBlobContainer CreateContainerIfNotExists(string storageConnectionString, string containerName)
        {
            var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
            var blobClient = storageAccount.CreateCloudBlobClient();
            var container = blobClient.GetContainerReference(containerName);
            container.CreateIfNotExistsAsync().GetAwaiter().GetResult();
            return container;
        }

        private static CloudQueue CreateQueueIfNotExists(string storageConnectionString, string queueName)
        {
            var cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString);
            var queueClient = cloudStorageAccount.CreateCloudQueueClient();
            var queue = queueClient.GetQueueReference(queueName);
            queue.CreateIfNotExistsAsync().GetAwaiter().GetResult();
            return queue;
        }

        public static string GetSASUrl(CloudBlobContainer container)
        {
            var sharedAccessSignature = container.GetSharedAccessSignature(new SharedAccessBlobPolicy
            {
                Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.Write,
                SharedAccessStartTime = DateTime.UtcNow.AddDays(-1),
                SharedAccessExpiryTime = DateTime.UtcNow.AddDays(7),
            });
            return container.StorageUri.PrimaryUri + sharedAccessSignature;
        }

        public static string GetSASUrl(CloudQueue queue)
        {
            var sharedAccessSignature = queue.GetSharedAccessSignature(new SharedAccessQueuePolicy
            {
                Permissions = SharedAccessQueuePermissions.Add | SharedAccessQueuePermissions.Read,
                SharedAccessStartTime = DateTime.UtcNow.AddDays(-1),
                SharedAccessExpiryTime = DateTime.UtcNow.AddDays(7)
            });
            return queue.StorageUri.PrimaryUri + sharedAccessSignature;
        }
    }
}