Microsoft Graph API

You can do something like this

namespace YourWpfApp
{
    public partial class MainWindow : Window
    {
        private static readonly string clientId = "YourClientId";
        private static readonly string tenantId = "YourTenantId";
        private static readonly string clientSecret = "YourClientSecret";
        private static readonly string[] scopes = { "Mail.Read" };

        private readonly IPublicClientApplication publicClientApp;
        private IConfidentialClientApplication confidentialClientApp;
        private IEnumerable emails;

        public MainWindow()
        {
            InitializeComponent();

            publicClientApp = PublicClientApplicationBuilder
                .Create(clientId)
                .WithAuthority(new Uri($"https://login.microsoftonline.com/{tenantId}"))
                .Build();

            AuthenticateAndLoadEmails();
        }

        private async void AuthenticateAndLoadEmails()
        {
            try
            {
                var result = await publicClientApp
                    .AcquireTokenForClient(scopes)
                    .ExecuteAsync();

                confidentialClientApp = ConfidentialClientApplicationBuilder
                    .Create(clientId)
                    .WithClientSecret(clientSecret)
                    .WithAuthority(new Uri($"https://login.microsoftonline.com/{tenantId}"))
                    .Build();

                var authProvider = new ClientCredentialProvider(confidentialClientApp, scopes);

                var graphClient = new GraphServiceClient(authProvider);

                // Fetch user's emails
                var messages = await graphClient.Me.Messages.Request().GetAsync();
                emails = messages.CurrentPage;
                DisplayEmails();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error: {ex.Message}");
            }
        }

        private void DisplayEmails()
        {
            // Populate your ListBox or DataGrid with email details
            // For example, if you have a ListBox named listBoxEmails:
            listBoxEmails.ItemsSource = emails.Select(e => $"{e.Subject} - {e.From?.EmailAddress?.Address}");
        }
    }
}

To create a WPF application that displays user emails using Graph Explorer, you will need to follow these steps:

1. Register your application in Azure Active Directory (AAD):

   • Go to the Azure portal and create a new AAD application registration.
   • Configure the necessary permissions to access the user's emails (e.g., Mail.Read, Mail.ReadWrite, etc.).
   • Note down the Application (client) ID and Tenant ID.

2. Obtain an access token:

   • Use the Microsoft Authentication Library (MSAL) to authenticate the user and obtain an access token.
   • Request the necessary scopes for accessing the user's emails.
   • Retrieve the access token from the authentication result.

3. Use the Graph API to retrieve email data:

   • Use the obtained access token to make requests to the Graph API.
   • Use the /me/messages endpoint to retrieve the user's emails.
   • Parse the response to extract the required email information.

4. Display the emails in your WPF application:

   • Create a user interface in your WPF application to display the emails.
   • Bind the retrieved email data to the UI elements (e.g., a ListView or DataGrid).

Here's an example of how you can obtain an access token using MSAL in a WPF application:

using Microsoft.Identity.Client;

string clientId = "Your_Application_Client_Id";
string tenantId = "Your_Azure_Tenant_Id";
string[] scopes = { "Mail.Read" };

public async Task GetAccessTokenAsync()
{
    var app = PublicClientApplicationBuilder.Create(clientId)
        .WithAuthority(AzureCloudInstance.AzurePublic, tenantId)
        .WithDefaultRedirectUri()
        .Build();

    var authResult = await app.AcquireTokenInteractive(scopes)
        .WithPrompt(Prompt.SelectAccount)
        .ExecuteAsync();

    return authResult.AccessToken;
}

Remember to handle authentication and token refreshing in your application to ensure a seamless user experience.