.NET 5 获得SharePoint Online的Client Context

当使用.NET core 或者.NET 5时，安装完SharePoint Online CSOM 包以后，需要获得Client Context。发现SharePointOnlineCredentials class不可用了。因为微软已经删除了这个class。https://docs.microsoft.com/en-us/answers/questions/58183/net-core-sharepointonlinecredentials-class.html

微软网站也给出了解决方案，就是重写AuthenticationManager。我参照上面的方法，重写了通过App Only获得Client Context的方法。废话不多说，上代码。

AuthenticationManager.cs

using Microsoft.SharePoint.Client;
using System;
using System.Collections.Concurrent;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

namespace DownloadSPLibAndUploadToAzureBlobWithNet5
{
    public class AuthenticationManager : IDisposable
    {
        private static readonly HttpClient httpClient = new HttpClient();
        private const string tenantName = "";  //tenant name or id.

        // Token cache handling
        private static readonly SemaphoreSlim semaphoreSlimTokens = new SemaphoreSlim(1);
        private AutoResetEvent tokenResetEvent = null;
        private readonly ConcurrentDictionary<string, string> tokenCache = new ConcurrentDictionary<string, string>();
        private bool disposedValue;


        internal class TokenWaitInfo
        {
            public RegisteredWaitHandle Handle = null;
        }

        public ClientContext GetContext(Uri web, string clientId, string clientSecret)
        {
            ClientContext context = new ClientContext(web);
            context.ExecutingWebRequest += (sender, e) =>
            {
                string accessToken = EnsureAccessTokenAsync(web, clientId, clientSecret).GetAwaiter().GetResult();
                e.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + accessToken;
            };

            return context;
        }

        public async Task<string> EnsureAccessTokenAsync(Uri web, string clientId, string clientSecret)
        {
            string accessTokenFromCache = TokenFromCache(web, tokenCache);
            if (accessTokenFromCache == null)
            {
                await semaphoreSlimTokens.WaitAsync().ConfigureAwait(false);
                try
                {
                    // No async methods are allowed in a lock section
                    string accessToken = await AcquireTokenAsync(web, clientId, clientSecret).ConfigureAwait(false);
                    AddTokenToCache(web, tokenCache, accessToken);

                    // Register a thread to invalidate the access token once's it's expired
                    tokenResetEvent = new AutoResetEvent(false);
                    TokenWaitInfo wi = new TokenWaitInfo();
                    wi.Handle = ThreadPool.RegisterWaitForSingleObject(
                        tokenResetEvent,
                        async (state, timedOut) =>
                        {
                            if (!timedOut)
                            {
                                TokenWaitInfo wi = (TokenWaitInfo)state;
                                if (wi.Handle != null)
                                {
                                    wi.Handle.Unregister(null);
                                }
                            }
                            else
                            {
                                try
                                {
                                    // Take a lock to ensure no other threads are updating the SharePoint Access token at this time
                                    await semaphoreSlimTokens.WaitAsync().ConfigureAwait(false);
                                    RemoveTokenFromCache(web, tokenCache);
                                    Console.WriteLine($"Cached token for resource {web.DnsSafeHost} and clientId {clientId} expired");
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine($"Something went wrong during cache token invalidation: {ex.Message}");
                                    RemoveTokenFromCache(web, tokenCache);
                                }
                                finally
                                {
                                    semaphoreSlimTokens.Release();
                                }
                            }
                        },
                        wi,
                        (uint)CalculateThreadSleep(accessToken).TotalMilliseconds,
                        true
                    );

                    return accessToken;
                }
                finally
                {
                    semaphoreSlimTokens.Release();
                }
            }
            else
                return accessTokenFromCache;
        }

        private async Task<string> AcquireTokenAsync(Uri web, string clientId, string clientSecret)
        {
            var body = "grant_type=client_credentials" +
                $"&resource=00000003-0000-0ff1-ce00-000000000000/{web.DnsSafeHost}@{tenantName}" +
                $"&client_id={clientId}@{tenantName}" +
                $"&client_secret={clientSecret}";

            using (var stringContent = new StringContent(body, Encoding.UTF8, "application/x-www-form-urlencoded"))
            {
                var result = await httpClient.PostAsync($"https://accounts.accesscontrol.windows.net/{tenantName}/tokens/OAuth/2", stringContent)
                    .ContinueWith((response) =>
                    {
                        return response.Result.Content.ReadAsStringAsync().Result;
                    })
                    .ConfigureAwait(false);

                var tokenResult = JsonSerializer.Deserialize<JsonElement>(result);
                var token = tokenResult.GetProperty("access_token").GetString();
                return token;
            }
        }

        private static string TokenFromCache(Uri web, ConcurrentDictionary<string, string> tokenCache)
        {
            if (tokenCache.TryGetValue(web.DnsSafeHost, out string accessToken))
                return accessToken;

            return null;
        }

        private static void AddTokenToCache(Uri web, ConcurrentDictionary<string, string> tokenCache, string newAccessToken)
        {
            if (tokenCache.TryGetValue(web.DnsSafeHost, out string currentAccessToken))
                tokenCache.TryUpdate(web.DnsSafeHost, newAccessToken, currentAccessToken);
            else
                tokenCache.TryAdd(web.DnsSafeHost, newAccessToken);
        }

        private static void RemoveTokenFromCache(Uri web, ConcurrentDictionary<string, string> tokenCache)
        {
            tokenCache.TryRemove(web.DnsSafeHost, out string currentAccessToken);
        }

        private static TimeSpan CalculateThreadSleep(string accessToken)
        {
            var token = new System.IdentityModel.Tokens.Jwt.JwtSecurityToken(accessToken);
            var lease = GetAccessTokenLease(token.ValidTo);
            lease = TimeSpan.FromSeconds(lease.TotalSeconds - TimeSpan.FromMinutes(5).TotalSeconds > 0 ? lease.TotalSeconds - TimeSpan.FromMinutes(5).TotalSeconds : lease.TotalSeconds);
            return lease;
        }

        private static TimeSpan GetAccessTokenLease(DateTime expiresOn)
        {
            DateTime now = DateTime.UtcNow;
            DateTime expires = expiresOn.Kind == DateTimeKind.Utc ? expiresOn : TimeZoneInfo.ConvertTimeToUtc(expiresOn);
            TimeSpan lease = expires - now;
            return lease;
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    if (tokenResetEvent != null)
                    {
                        tokenResetEvent.Set();
                        tokenResetEvent.Dispose();
                    }
                }
                disposedValue = true;
            }
        }

        public void Dispose()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
    }
}

program.cs

using Microsoft.SharePoint.Client;
using System;
using System.Threading.Tasks;

namespace DownloadSPLibAndUploadToAzureBlobWithNet5
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Uri site = new Uri("https://******.sharepoint.com/sites/10000034");
            string clientId = "";
            string clientSecret = "";

            // Note: The PnP Sites Core AuthenticationManager class also supports this
            using (var authenticationManager = new AuthenticationManager())
            {
                using (var context = authenticationManager.GetContext(site, clientId, clientSecret))
                {
                    context.Load(context.Web, p => p.Title);
                    await context.ExecuteQueryAsync();
                    Console.WriteLine($"Title: {context.Web.Title}");

                    var list = context.Web.Lists.GetByTitle("Links");
                    ListItemCreationInformation itemCreateInfo = new ListItemCreationInformation();
                    ListItem newItem = list.AddItem(itemCreateInfo);
                    newItem["Title"] = "My New Item!";
                    newItem.Update();
                    await context.ExecuteQueryAsync();
                    Console.WriteLine(newItem.Id);
                }
            }

        }
    }
}

通过用户名和密码获得client context可以直接参考微软给的code. https://docs.microsoft.com/en-us/sharepoint/dev/sp-add-ins/using-csom-for-dotnet-standard

另外还有一种更简便的方发，就是使用pnp.framework包。

用VS生成新项目以后，安装pnp.framework包，然后用下面的code就可以得到client context了。

using Microsoft.SharePoint.Client;
using System;
using System.Threading.Tasks;

namespace DownloadSPLibAndUploadToAzureBlobWithNet5
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Uri site = new Uri("https://********.sharepoint.com/sites/10000034");
            string clientId = "";
            string clientSecret = "";

            // Note: The PnP Sites Core AuthenticationManager class also supports this
            using (var authenticationManager = new AuthenticationManager())
            {
                using (var context = authenticationManager.GetContext(site, clientId, clientSecret))
                {
                    context.Load(context.Web, p => p.Title);
                    await context.ExecuteQueryAsync();
                    Console.WriteLine($"Title: {context.Web.Title}");

                    var list = context.Web.Lists.GetByTitle("Links");
                    ListItemCreationInformation itemCreateInfo = new ListItemCreationInformation();
                    ListItem newItem = list.AddItem(itemCreateInfo);
                    newItem["Title"] = "My New Item!";
                    newItem.Update();
                    await context.ExecuteQueryAsync();
                    Console.WriteLine(newItem.Id);
                }
            }

        }
    }
}

 github 链接： https://github.com/HaiyeWang0717/DownloadSPLibAndUploadToAzureBlobWithNet5