Uploading files to ADLS Gen 2 and OneLake using C#

Program.cs

using Azure;
using Azure.Storage.Files.DataLake;
using Azure.Storage.Files.DataLake.Models;
using Azure.Storage;
using System.IO;
using Azure.Identity;
using System.IO.Enumeration;
using System.Net.Http.Headers;
using Azure.Identity;
using Azure.Storage.Files.DataLake;
using Azure.Core;
using System.Net;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using System.Globalization;
using Newtonsoft.Json.Linq;
using Azure.Storage.Blobs;

namespace OneLakeFileUploader
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            /*
             Install below nugets:
                Azure.Storage.Files.DataLake
                Azure.Identity
             */
            Console.WriteLine("Hello, World!");

            //Create new container + folder, then upload file to ADLS Gen2
            //Adls_Gen2_CreateContainerAndFolderThenUploadFile();

            ////use existing container + folder, then upload file to ADLS Gen2
            //Adls_Gen2_UseExistingContainerAndFolderThenUploadFile();

            //Upload file to existing Lakehouse in Fabric
            Fabric_UploadFile();

            //Upload file to existing Lakehouse in Fabric using REST API
            //Fabric_UploadFileUsingREST_API();

        }
        
        public static void Fabric_UploadFileUsingREST_API()
        {
            string workspace = "jlfabricdemo2";
            string item = "jlalakehouse";
            string itemType = "Lakehouse";
            string fileName = "well architecture.txt";
            string filePath = "C:\\Users\\jeffreylai\\OneDrive - Microsoft\\Desktop\\" + fileName;

            string url = $"https://onelake.dfs.fabric.microsoft.com/{workspace}/{item}.{itemType}/Files/{fileName}?resource=file";

            // Create a new instance of DefaultAzureCredential
            var credential = new DefaultAzureCredential();

            // Create a new instance of BlobServiceClient using the credential
            var blobServiceClient = new BlobServiceClient(new Uri("https://minsynapselake.blob.core.windows.net"), credential);

            // Retrieve the Azure AD token as a string
            string userAADToken = credential.GetToken(
                new Azure.Core.TokenRequestContext(
                    new[] { "https://storage.azure.com/.default" }
                )
            ).Token;

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "PUT";
            request.Headers.Add("Authorization", $"Bearer {userAADToken}");

            using (Stream stream = request.GetRequestStream())
            {
                request.ContentLength = 0;
                using (FileStream fileStream = new FileStream(filePath, FileMode.Open))
                {
                    byte[] buffer = new byte[4096];
                    int bytesRead = 0;
                    while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        stream.Write(buffer, 0, bytesRead);
                    }
                }
            }

            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            Console.WriteLine($"Status code: {response.StatusCode}");
            Console.WriteLine("File uploaded");
        }
        public static void Fabric_UploadFile()
        {
            string workspaceName = "jlfabricdemo2";
            string itemName = "jlalakehouse";
            string itemType = "Lakehouse";
            string itemFolder = "Files";
            string uploadFolder = itemName + "." + itemType +"/" + itemFolder + "/"; //"jlalakehouse.Lakehouse/Files/"

            string localFileName = "well architecture.txt";
            string localFilePath = "C:\\Users\\jeffreylai\\OneDrive - Microsoft\\Desktop\\";
            string localFileFullPath = localFilePath + localFileName;

            MyADLSGenConnector myADLSGenConnector2 = new MyADLSGenConnector();

            DataLakeServiceClient serviceClient = myADLSGenConnector2.GetServiceClientTokenCredential();

            DataLakeFileSystemClient file_system_client = myADLSGenConnector2.CreateFileSystemClient(serviceClient, workspaceName);

            DataLakeDirectoryClient directoryClient = file_system_client.GetDirectoryClient(uploadFolder);

            myADLSGenConnector2.UploadFile(directoryClient, localFileName, localFileFullPath).GetAwaiter().GetResult();

            Console.WriteLine("File uploaded");
        }
        public static void Adls_Gen2_CreateContainerAndFolderThenUploadFile()
        {
            string accountName = "minsynapselake";
            string containerName = "mincontainer2";
            string folderName = "test";
            string subFolderName = "test1";

            string localFileName = "well architecture.txt";
            string localFilePath = "C:\\Users\\jeffreylai\\OneDrive - Microsoft\\Desktop\\" + localFileName;

            MyADLSGenConnector myADLSGenConnector = new MyADLSGenConnector();

            DataLakeServiceClient serviceClient = MyADLSGenConnector.GetDataLakeServiceClient(accountName);

            //Create folders
            Task<DataLakeFileSystemClient> fileSystemClient = myADLSGenConnector.CreateFileSystem(serviceClient, containerName);

            Task<DataLakeDirectoryClient> directoryClient = myADLSGenConnector.CreateDirectory(fileSystemClient.Result, folderName, subFolderName);

            Task fileUploadTask = myADLSGenConnector.UploadFile(directoryClient.Result, localFileName, localFilePath);

            Console.WriteLine("File uploaded");

        }
        public static void Adls_Gen2_UseExistingContainerAndFolderThenUploadFile(){

            string accountName = "minsynapselake";
            string containerName = "mincontainer1";
            string folderName = "test";
            string localFileName = "well architecture.txt";
            string localFilePath = "C:\\Users\\jeffreylai\\OneDrive - Microsoft\\Desktop\\" + localFileName;

            MyADLSGenConnector myADLSGenConnector = new MyADLSGenConnector();

            DataLakeServiceClient serviceClient = MyADLSGenConnector.GetDataLakeServiceClient(accountName);

            DataLakeFileSystemClient fileSystemClient = serviceClient.GetFileSystemClient(containerName);

            DataLakeDirectoryClient directoryClient = fileSystemClient.GetDirectoryClient(folderName);

            myADLSGenConnector.UploadFile(directoryClient, localFileName, localFilePath).GetAwaiter().GetResult();

            Console.WriteLine("File uploaded");
        }
        public class MyADLSGenConnector
        {
            public static DataLakeServiceClient GetDataLakeServiceClient(string accountName)
            {
                string dfsUri = $"https://{accountName}.dfs.core.windows.net";

                DataLakeServiceClient dataLakeServiceClient = new DataLakeServiceClient(
                    new Uri(dfsUri),
                    new DefaultAzureCredential());

                return dataLakeServiceClient;
            }
            public async Task<DataLakeFileSystemClient> CreateFileSystem(DataLakeServiceClient serviceClient, string fileSystemName)
            {
                return await serviceClient.CreateFileSystemAsync(fileSystemName);
            }
            public async Task<DataLakeDirectoryClient> CreateDirectory(DataLakeFileSystemClient fileSystemClient, string directoryName, string subdirectoryName)
            {
                DataLakeDirectoryClient directoryClient =
                    await fileSystemClient.CreateDirectoryAsync(directoryName);

                return await directoryClient.CreateSubDirectoryAsync(subdirectoryName);
            }
            public async Task UploadFile(
                DataLakeDirectoryClient directoryClient,
                string fileName,
                string localPath)
            {
                DataLakeFileClient fileClient =
                    directoryClient.GetFileClient(fileName);

                FileStream fileStream = File.OpenRead(localPath);

                await fileClient.UploadAsync(content: fileStream, overwrite: true);
            }
           
            public DataLakeServiceClient GetServiceClientTokenCredential()
            {
                string accountName = "onelake";
                string accountUrl = $"https://{accountName}.dfs.fabric.microsoft.com";
                var tokenCredential = new DefaultAzureCredential();

                var serviceClient = new DataLakeServiceClient(new Uri(accountUrl), tokenCredential);

                return serviceClient;
            }
            public DataLakeFileSystemClient CreateFileSystemClient(DataLakeServiceClient serviceClient, string workspaceName)
            {
                DataLakeFileSystemClient fileSystemClient = serviceClient.GetFileSystemClient(workspaceName);

                return fileSystemClient;
            }

            public void ListDirectoryContents(DataLakeFileSystemClient fileSystemClient, string directoryName)
            {
                var paths = fileSystemClient.GetPaths(directoryName);

                foreach (var path in paths)
                {
                    Console.WriteLine(path.Name + "\n");
                }
            }
        }
        
    }

}