Drives

public DrivesRequestBuilder Drives { get; }

public async Task<DriveCollectionResponse> GetAsync(
    Action<RequestConfiguration<DrivesRequestBuilderGetQueryParameters>> requestConfiguration = default,
    CancellationToken cancellationToken = default
)

// List all drives
var drives = await graphClient.Drives.GetAsync();

foreach (var drive in drives.Value)
{
    Console.WriteLine($"{drive.Name} ({drive.DriveType})");
    Console.WriteLine($"  Owner: {drive.Owner.User?.DisplayName}");
    Console.WriteLine($"  Used: {drive.Quota.Used / (1024 * 1024)} MB");
    Console.WriteLine($"  Total: {drive.Quota.Total / (1024 * 1024)} MB");
}

// Current user's drive
var myDrive = await graphClient.Me.Drive.GetAsync();

// Specific user's drive
var userDrive = await graphClient.Users["user-id"].Drive.GetAsync();

Console.WriteLine($"Drive ID: {myDrive.Id}");
Console.WriteLine($"Web URL: {myDrive.WebUrl}");

var drive = await graphClient.Drives["drive-id"].GetAsync();

// Select specific properties
var drive = await graphClient.Drives["drive-id"].GetAsync(config =>
{
    config.QueryParameters.Select = new[] { "id", "name", "quota" };
});

var groupDrive = await graphClient.Groups["group-id"].Drive.GetAsync();

Console.WriteLine($"Group drive: {groupDrive.Name}");

// Default document library
var siteDrive = await graphClient.Sites["site-id"].Drive.GetAsync();

// All document libraries
var siteDrives = await graphClient.Sites["site-id"].Drives.GetAsync();

foreach (var drive in siteDrives.Value)
{
    Console.WriteLine($"Library: {drive.Name}");
}

var root = await graphClient.Me.Drive.Root.GetAsync();

Console.WriteLine($"Root folder ID: {root.Id}");
Console.WriteLine($"Child count: {root.Folder.ChildCount}");

var children = await graphClient.Me.Drive.Root.Children.GetAsync();

foreach (var item in children.Value)
{
    if (item.Folder != null)
    {
        Console.WriteLine($"[Folder] {item.Name} ({item.Folder.ChildCount} items)");
    }
    else if (item.File != null)
    {
        Console.WriteLine($"[File] {item.Name} ({item.Size} bytes)");
    }
}

var newFolder = new DriveItem
{
    Name = "Project Documents",
    Folder = new Folder { }
};

var folder = await graphClient.Me.Drive.Root.Children.PostAsync(newFolder);
Console.WriteLine($"Created folder: {folder.Id}");

// Small file (< 4MB)
using var fileStream = File.OpenRead("document.pdf");
var uploadedItem = await graphClient.Me.Drive.Root
    .ItemWithPath("document.pdf")
    .Content
    .PutAsync(fileStream);

Console.WriteLine($"Uploaded: {uploadedItem.Name}");
Console.WriteLine($"Download URL: {uploadedItem.AdditionalData["@microsoft.graph.downloadUrl"]}");

var searchResults = await graphClient.Me.Drive.Root
    .Search("project")
    .GetAsync();

foreach (var item in searchResults.Value)
{
    Console.WriteLine($"{item.Name} - {item.WebUrl}");
}

// Search with query parameters
var results = await graphClient.Me.Drive.Root
    .Search("*.pdf")
    .GetAsync(config =>
{
    config.QueryParameters.Select = new[] { "id", "name", "size" };
    config.QueryParameters.Top = 25;
});

var recentFiles = await graphClient.Me.Drive.Recent().GetAsync();

foreach (var item in recentFiles.Value)
{
    Console.WriteLine($"{item.Name} - Last accessed: {item.LastModifiedDateTime}");
}

var sharedItems = await graphClient.Me.Drive.SharedWithMe().GetAsync();

foreach (var item in sharedItems.Value)
{
    var remoteItem = item.RemoteItem;
    Console.WriteLine($"{remoteItem.Name}");
    Console.WriteLine($"  Shared by: {remoteItem.SharedBy?.User?.DisplayName}");
    Console.WriteLine($"  Parent: {remoteItem.ParentReference?.DriveId}");
}

// Documents folder
var documents = await graphClient.Me.Drive.Special["documents"].GetAsync();

// Photos folder  
var photos = await graphClient.Me.Drive.Special["photos"].GetAsync();

// App root folder (for app-specific storage)
var appRoot = await graphClient.Me.Drive.Special["approot"].GetAsync();

// Available special folders:
// - documents
// - photos  
// - cameraroll
// - approot
// - music

var followedItems = await graphClient.Me.Drive.Following().GetAsync();

foreach (var item in followedItems.Value)
{
    Console.WriteLine($"{item.Name} - {item.WebUrl}");
}

await graphClient.Drives["drive-id"]
    .Items["item-id"]
    .Follow
    .PostAsync();

await graphClient.Drives["drive-id"]
    .Items["item-id"]
    .Unfollow
    .PostAsync();

// Initial delta query
var deltaResponse = await graphClient.Me.Drive.Root.Delta.GetAsync();

foreach (var item in deltaResponse.Value)
{
    if (item.Deleted != null)
    {
        Console.WriteLine($"Deleted: {item.Name}");
    }
    else
    {
        Console.WriteLine($"Added/Modified: {item.Name}");
    }
}

// Store deltaLink for next query
var deltaLink = deltaResponse.OdataDeltaLink;

// Subsequent delta query
if (!string.IsNullOrEmpty(deltaLink))
{
    var nextDelta = await graphClient.Me.Drive.Root.Delta
        .WithUrl(deltaLink)
        .GetAsync();
}

var drive = await graphClient.Me.Drive.GetAsync();
var quota = drive.Quota;

Console.WriteLine($"Total: {quota.Total / (1024 * 1024 * 1024):F2} GB");
Console.WriteLine($"Used: {quota.Used / (1024 * 1024 * 1024):F2} GB");
Console.WriteLine($"Remaining: {quota.Remaining / (1024 * 1024 * 1024):F2} GB");
Console.WriteLine($"Deleted: {quota.Deleted / (1024 * 1024):F2} MB");
Console.WriteLine($"State: {quota.State}"); // normal, nearing, critical, exceeded

var thumbnails = await graphClient.Me.Drive.Root.Thumbnails.GetAsync();

foreach (var thumbnailSet in thumbnails.Value)
{
    if (thumbnailSet.Large != null)
    {
        Console.WriteLine($"Large thumbnail: {thumbnailSet.Large.Url}");
    }
    if (thumbnailSet.Medium != null)
    {
        Console.WriteLine($"Medium thumbnail: {thumbnailSet.Medium.Url}");
    }
    if (thumbnailSet.Small != null)
    {
        Console.WriteLine($"Small thumbnail: {thumbnailSet.Small.Url}");
    }
}

// List bundles
var bundles = await graphClient.Me.Drive.Bundles.GetAsync();

foreach (var bundle in bundles.Value)
{
    Console.WriteLine($"Album: {bundle.Name}");
    Console.WriteLine($"Items: {bundle.Bundle.ChildCount}");
}

// Create album
var newBundle = new DriveItem
{
    Name = "Vacation Photos",
    Bundle = new Bundle
    {
        Album = new Album { }
    },
    AdditionalData = new Dictionary<string, object>
    {
        { "@microsoft.graph.conflictBehavior", "rename" }
    }
};

var album = await graphClient.Me.Drive.Bundles.PostAsync(newBundle);

using Microsoft.Graph.Models.ODataErrors;

try
{
    var drive = await graphClient.Drives["invalid-id"].GetAsync();
}
catch (ODataError error)
{
    if (error.Error.Code == "itemNotFound")
    {
        Console.WriteLine("Drive not found");
    }
    else if (error.Error.Code == "accessDenied")
    {
        Console.WriteLine("Access denied to drive");
    }
    else
    {
        Console.WriteLine($"Error: {error.Error.Message}");
    }
}