Mahesh Kumar Yadav

Programmer

4 minute read

Introduction

In this post, we’ll explore how to create SharePoint Online Team Sites (both classic and modern) using C#, WinForms, and the Microsoft Authentication Library (MSAL) to support Multi-Factor Authentication (MFA). With MFA becoming a standard security measure, we’ll walk through how to integrate it into our SharePoint site creation process. We’ll also learn how to handle both classic and modern site templates. The complete source code for this project is available on GitHub.

Running Project

Prerequisites

Before diving into the code, ensure we have the following:

  1. Microsoft.SharePointOnline.CSOM: For interacting with SharePoint Online.
  2. Microsoft.Identity.Client (MSAL): For handling authentication with MFA.
  3. Azure AD App Registration: Register an app in Azure Active Directory to enable authentication. Ensure we have the Client ID and Tenant ID for this app, along with the appropriate permissions for SharePoint Online (e.g., Sites.FullControl.All and Group.ReadWrite.All for modern sites).

Project Setup

  1. Create a Windows Forms Application project in Visual Studio.
  2. Install the required NuGet packages: 
    Install-Package Microsoft.SharePointOnline.CSOM
Install-Package Microsoft.Identity.Client
  3. Add basic WinForms controls to allow input for Admin URL, Tenant ID, Client ID, Site Name, Owner, and Description.

SharePoint Site Templates

Here’s a table of common SharePoint site types and their corresponding template codes:

Site Type Template Code Description Category
Classic Team Site STS#0 Traditional team site with lists, libraries, and basic collaboration features. Classic
Modern Team Site GROUP#0 Modern team site connected to a Microsoft 365 Group (includes Teams integration). Modern
Communication Site SITEPAGEPUBLISHING#0 Modern site optimized for broadcasting news, reports, or marketing content. Modern
Document Center DOCSITE#0 Centralized repository for managing large volumes of documents. Classic
Publishing Portal BLANKINTERNET#0 Legacy site for public-facing websites with publishing workflows. Classic
Project Site PROJECTSITE#0 Modern site for tracking project deliverables and collaboration. Modern
Blog Site BLOG#0 Site for publishing blog posts and articles. Classic

The Code

Main Form Code (WinForms)

The main form collects the necessary details (like tenant admin URL, tenant ID, client ID, etc.) and triggers the creation process when a button is clicked.

using System;
using Form = System.Windows.Forms.Form;

namespace SharePointTeamSiteCreator
{
    public partial class Form1 : Form
    {
        private const string SiteTemplate = "STS#0"; // STS#0 is the template for a classic team site
        private const uint SiteLanguage = 1033; // English
        private const int SiteStorageQuota = 1000; // Storage quota in MB
        private const int SiteUserCodeQuota = 0; // User code quota (usually 0 unless required)

        public Form1()
        {
            InitializeComponent();
        }

        // Button click event to create the Team Site
        private async void btnCreateSite_Click(object sender, EventArgs e)
        {
            // Get user input from form fields
            var adminSiteUrl = txtAdminSiteUrl.Text; // Tenant admin url
            var tenantId = txtTenantId.Text; // Azure AD Tenant ID
            var clientId = txtClientId.Text; // Azure AD Client ID
            var siteDisplayName = txtSiteDisplayName.Text; // Desired Team Site name
            var siteOwner = textSiteOwner.Text; // Desired Team Site owner
            var siteDescription = txtSiteDescription.Text; // Site Description
            var siteUrl = adminSiteUrl.Replace("-admin", null) + "/sites/" +
                          siteDisplayName.Replace(" ", string.Empty).ToLower();

            await SharePointUtils.CreateTeamSiteAuthentication(adminSiteUrl, tenantId, clientId, SiteStorageQuota, SiteUserCodeQuota, siteDisplayName, siteOwner, siteUrl, SiteTemplate, SiteLanguage);
        }
    }
}

Utility Class for SharePoint Site Creation

This utility class handles the interaction with SharePoint Online, using MSAL for authentication and CSOM for creating the team site.

using System;
using System.Threading.Tasks;
using System.Windows.Forms;
using Microsoft.SharePoint.Client;
using Microsoft.Online.SharePoint.TenantAdministration;
using Microsoft.Identity.Client;

namespace SharePointTeamSiteCreator
{
    internal static class SharePointUtils
    {
        /// <summary>
        /// Creates a new SharePoint Online Team Site using CSOM and MFA.
        /// </summary>
        internal static async Task CreateTeamSiteAsync(string adminSiteUrl, string tenantId, string clientId,
            long siteStorageQuota, long siteUserCodeQuota, string siteTitle, string siteOwner, string siteUrl,
            string template = "STS#0", uint siteLanguage = 1033)
        {
            var scopes = new string[] { adminSiteUrl + "/.default" }; // Scopes for SharePoint Online

            var app = GetPublicClientApp(tenantId, clientId);
            AuthenticationResult authResult = null;

            try
            {
                // Use interactive authentication to sign in
                authResult = await app.AcquireTokenInteractive(scopes).ExecuteAsync().ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error acquiring token: {ex.Message}", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            // Access token retrieved
            var accessToken = authResult.AccessToken;

            try
            {
                // Create a new ClientContext using the access token for MFA
                using (var clientContext = new ClientContext(adminSiteUrl))
                {
                    clientContext.ExecutingWebRequest += (sender, webRequestEventArgs) =>
                    {
                        webRequestEventArgs.WebRequestExecutor.RequestHeaders["Authorization"] = "Bearer " + accessToken;
                    };

                    // Tenant object to manage site creation
                    var tenant = new Tenant(clientContext);

                    var siteCreationInfo = new SiteCreationProperties
                    {
                        Url = siteUrl,
                        Title = siteTitle,
                        Lcid = siteLanguage, // Locale ID for English
                        Template = template, // Site template (e.g., STS#0 for classic, GROUP#0 for modern)
                        Owner = siteOwner,
                        StorageMaximumLevel = siteStorageQuota,
                        UserCodeMaximumLevel = siteUserCodeQuota
                    };

                    var spoOperation = tenant.CreateSite(siteCreationInfo);
                    clientContext.Load(spoOperation, i => i.IsComplete);
                    clientContext.ExecuteQuery();

                    // Check the operation status
                    while (!spoOperation.IsComplete)
                    {
                        Console.WriteLine("Creating site... Please wait");
                        await Task.Delay(10000); // Wait for 10 seconds
                        spoOperation.RefreshLoad();
                        clientContext.ExecuteQuery();
                    }

                    MessageBox.Show("Site has been created successfully.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error: {ex.Message}", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        /// <summary>
        /// Configures and returns a PublicClientApplication object for MSAL authentication.
        /// </summary>
        private static IPublicClientApplication GetPublicClientApp(string tenantId, string clientId)
        {
            try
            {
                var tenant = string.IsNullOrEmpty(tenantId) ? "common" : tenantId;
                var authorityUri = $"https://login.microsoftonline.com/{tenant}";
                var clientApp = PublicClientApplicationBuilder.Create(clientId)
                    .WithAuthority(authorityUri)
                    .WithDefaultRedirectUri()
                    .Build();
                return clientApp;
            }
            catch (Exception ex)
            {
                MessageBox.Show(@"Error: " + ex.Message, Application.ProductName, MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                throw;
            }
        }
    }
}

Explanation

  • Authentication with MFA: The application uses MSAL (Microsoft Identity Client) to perform interactive authentication. This ensures that Multi-Factor Authentication (MFA) is handled during login, improving security.

  • Site Creation Process: Once authenticated, the application uses the ClientContext object from the CSOM API to communicate with SharePoint Online. The Tenant.CreateSite method creates the classic team site based on the input provided by the user.

  • Status Checking: The application continuously checks if the site creation process has been completed by polling the server until the operation is marked as complete.

Conclusion

In this tutorial, we’ve walked through how to create SharePoint Online Team Sites (both classic and modern) using C#, WinForms, and MSAL for MFA. This approach ensures that SharePoint operations are secure and comply with modern authentication standards.

This solution is flexible and can be adapted to handle other types of SharePoint site creation and management tasks. Happy coding!

Leave a comment

You may also enjoy