<!-- Remove or update old packages -->
<PackageReference Include="Microsoft.Graph" Version="5.x.x" />
<PackageReference Include="Azure.Identity" Version="1.x.x" />

// Using DelegateAuthenticationProvider
var authenticationProvider = new DelegateAuthenticationProvider(
    async (requestMessage) =>
    {
        var accessToken = await GetAccessTokenAsync();
        requestMessage.Headers.Authorization = 
            new AuthenticationHeaderValue("Bearer", accessToken);
    });

var graphServiceClient = new GraphServiceClient(authenticationProvider);

using Azure.Identity;
using Microsoft.Graph;

// Using TokenCredential from Azure.Identity
var interactiveBrowserCredential = new InteractiveBrowserCredential(
    new InteractiveBrowserCredentialOptions 
    { 
        ClientId = clientId,
        TenantId = tenantId
    }
);

var graphServiceClient = new GraphServiceClient(interactiveBrowserCredential);

using Microsoft.Kiota.Abstractions.Authentication;

public class TokenProvider : IAccessTokenProvider
{
    public Task<string> GetAuthorizationTokenAsync(
        Uri uri, 
        Dictionary<string, object> additionalAuthenticationContext = default,
        CancellationToken cancellationToken = default)
    {
        var token = "your-access-token";
        return Task.FromResult(token);
    }

    public AllowedHostsValidator AllowedHostsValidator { get; }
}

var authenticationProvider = new BaseBearerTokenAuthenticationProvider(new TokenProvider());
var graphServiceClient = new GraphServiceClient(authenticationProvider);

// Get user
var user = await graphServiceClient
    .Me
    .Request()
    .GetAsync();

// Update user
await graphServiceClient
    .Users[userId]
    .Request()
    .UpdateAsync(user);

// Add group
await graphServiceClient
    .Groups
    .Request()
    .AddAsync(group);

using Microsoft.Graph.Models;

// Get user
var user = await graphServiceClient
    .Me
    .GetAsync();

// Update user (UpdateAsync renamed to PatchAsync)
await graphServiceClient
    .Users[userId]
    .PatchAsync(user);

// Add group (AddAsync renamed to PostAsync)
await graphServiceClient
    .Groups
    .PostAsync(group);

using Microsoft.Graph;

// All types were in Microsoft.Graph namespace
User user = new User();
GraphServiceClient client = new GraphServiceClient(authProvider);

using Microsoft.Graph;
using Microsoft.Graph.Models; // Model types in separate namespace
using Microsoft.Graph.Me.SendMail; // Request body types in operation namespaces

User user = new User();
GraphServiceClient client = new GraphServiceClient(authProvider);

var options = new List<Option>
{
    new HeaderOption("ConsistencyLevel", "eventual"),
    new QueryOption("$select", "id,displayName")
};

var users = await graphServiceClient
    .Users
    .Request(options)
    .Top(10)
    .Filter("startsWith(displayName, 'J')")
    .GetAsync();

var users = await graphServiceClient
    .Users
    .GetAsync(requestConfiguration =>
    {
        requestConfiguration.Headers.Add("ConsistencyLevel", "eventual");
        requestConfiguration.QueryParameters.Select = new string[] { "id", "displayName" };
        requestConfiguration.QueryParameters.Top = 10;
        requestConfiguration.QueryParameters.Filter = "startsWith(displayName, 'J')";
    });

try
{
    var user = await graphServiceClient.Me.Request().GetAsync();
}
catch (ServiceException ex)
{
    Console.WriteLine($"Error: {ex.Error.Code}");
    Console.WriteLine($"Message: {ex.Error.Message}");
    Console.WriteLine($"Status Code: {ex.StatusCode}");
}

using Microsoft.Graph.Models.ODataErrors;

try
{
    var user = await graphServiceClient.Me.GetAsync();
}
catch (ODataError odataError)
{
    Console.WriteLine($"Error: {odataError.Error.Code}");
    Console.WriteLine($"Message: {odataError.Error.Message}");
    // Status code available in the exception details
    throw;
}

var users = await graphServiceClient
    .Users
    .Request()
    .GetAsync();

// Iterate through current page
foreach (var user in users)
{
    Console.WriteLine(user.DisplayName);
}

// Get next page
if (users.NextPageRequest != null)
{
    var nextPageUsers = await users.NextPageRequest.GetAsync();
}

var usersResponse = await graphServiceClient
    .Users
    .GetAsync();

// Access the collection via Value property
foreach (var user in usersResponse.Value)
{
    Console.WriteLine(user.DisplayName);
}

// Next page link is in OdataNextLink property
if (!string.IsNullOrEmpty(usersResponse.OdataNextLink))
{
    // Use PageIterator or create new request builder with the link
}

var users = await graphServiceClient
    .Users
    .Request()
    .GetAsync();

var pageIterator = PageIterator<User>
    .CreatePageIterator(
        graphServiceClient,
        users,
        (user) => 
        {
            Console.WriteLine(user.DisplayName);
            return true;
        }
    );

await pageIterator.IterateAsync();

var usersResponse = await graphServiceClient
    .Users
    .GetAsync();

var userList = new List<User>();
var pageIterator = PageIterator<User, UserCollectionResponse>
    .CreatePageIterator(
        graphServiceClient,
        usersResponse,
        (user) => 
        {
            userList.Add(user);
            return true;
        }
    );

await pageIterator.IterateAsync();

using Newtonsoft.Json.Linq;

var customData = user.AdditionalData["customField"] as JObject;
var value = customData["property"].ToString();

using System.Text.Json;

if (user.AdditionalData["customField"] is JsonElement jsonElement)
{
    if (jsonElement.ValueKind == JsonValueKind.Object)
    {
        var property = jsonElement.GetProperty("property");
        var value = property.GetString();
    }
}

// Send mail
await graphClient.Me
    .SendMail(message, saveToSentItems)
    .Request()
    .PostAsync();

using Microsoft.Graph.Me.SendMail;

// Send mail with parameter object
var body = new SendMailPostRequestBody
{
    Message = message,
    SaveToSentItems = saveToSentItems
};

await graphServiceClient.Me
    .SendMail
    .PostAsync(body);

// Get the object
var event = await graphServiceClient
    .Me.Events["event-id"]
    .GetAsync();

// Only modified properties will be sent
event.Subject = "Updated Subject";
event.Recurrence = null; // Can now set to null directly

await graphServiceClient.Me.Events["event-id"]
    .PatchAsync(event);

// No workarounds needed
var count = await graphServiceClient.Users.Count
    .GetAsync(requestConfiguration => 
        requestConfiguration.Headers.Add("ConsistencyLevel", "eventual"));

// Get only users from group members
var usersInGroup = await graphServiceClient
    .Groups["group-id"]
    .Members
    .GraphUser
    .GetAsync();

// Get only applications from group members
var applicationsInGroup = await graphServiceClient
    .Groups["group-id"]
    .Members
    .GraphApplication
    .GetAsync();

// Support for RequestInformation
var requestInformation = graphServiceClient.Users.ToGetRequestInformation();

var batchRequestContent = new BatchRequestContent(graphServiceClient);
var requestStepId = await batchRequestContent.AddBatchRequestStepAsync(requestInformation);

var batchResponseContent = await graphServiceClient.Batch.PostAsync(batchRequestContent);
var usersResponse = await batchResponseContent.GetResponseByIdAsync<UserCollectionResponse>(requestStepId);

// Automatic batch size management
var batchRequestCollection = new BatchRequestContentCollection(graphServiceClient);

The type or namespace name 'User' could not be found

using Microsoft.Graph.Models; // Add this import

'IUserRequestBuilder' does not contain a definition for 'Request'

// Remove .Request() from your code
await graphServiceClient.Me.GetAsync(); // Correct

'IUserItemRequestBuilder' does not contain a definition for 'UpdateAsync'

// Use PatchAsync instead of UpdateAsync
await graphServiceClient.Users[userId].PatchAsync(user);

// Use PostAsync instead of AddAsync
await graphServiceClient.Groups.PostAsync(group);

The type or namespace name 'ServiceException' could not be found

using Microsoft.Graph.Models.ODataErrors;

try 
{
    // Your code
}
catch (ODataError odataError) // Use ODataError instead
{
    // Handle error
}

Cannot convert from 'UserCollectionResponse' to 'IEnumerable<User>'

var usersResponse = await graphServiceClient.Users.GetAsync();
// Access collection via .Value property
foreach (var user in usersResponse.Value)
{
    // Process user
}