<ItemGroup>
  <PackageReference Include="Microsoft.Identity.Client" Version="4.39.0" />
  <PackageReference Include="Microsoft.Graph" Version="4.11.0" />
  <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
</ItemGroup>

public void InitClient()
{
  _app = PublicClientApplicationBuilder.Create(ClientId)
            .WithAuthority(Authority)
            .WithRedirectUri("http://localhost:65419")
            .Build();

  TokenCacheHelper.EnableSerialization(_app.UserTokenCache);
}

public async Task<IAccount> SignIn()
{
	try
	{
		var result = await AcquireTokenSilent();
		return result.Account;
	}
	catch (MsalUiRequiredException)
	{
		return await AcquireTokenInteractive().ConfigureAwait(false);
	}
}

private async Task<IAccount> AcquireTokenInteractive()
{
	var accounts = (await _app.GetAccountsAsync()).ToList();

	var builder = _app.AcquireTokenInteractive(Scopes)
		.WithAccount(accounts.FirstOrDefault())
		.WithUseEmbeddedWebView(false)
		.WithPrompt(Microsoft.Identity.Client.Prompt.SelectAccount);

	var result = await builder.ExecuteAsync().ConfigureAwait(false);

	return result.Account;
}

public async Task<AuthenticationResult> AcquireTokenSilent()
{
	var accounts = await GetAccountsAsync();
	var result = await _app.AcquireTokenSilent(Scopes, accounts.FirstOrDefault())
			.ExecuteAsync()
			.ConfigureAwait(false);

	return result;
}

public async Task SendEmailAsync(Message message)
{
	var result = await AcquireTokenSilent();

	_httpClient.DefaultRequestHeaders.Authorization 
		= new AuthenticationHeaderValue("Bearer", result.AccessToken);
	_httpClient.DefaultRequestHeaders.Accept.Add(
		new MediaTypeWithQualityHeaderValue("application/json"));

	GraphServiceClient graphClient = new GraphServiceClient(_httpClient)
	{
		AuthenticationProvider = new DelegateAuthenticationProvider(async (requestMessage) =>
		{
			requestMessage.Headers.Authorization 
				= new AuthenticationHeaderValue("Bearer", result.AccessToken);
		})
	};

	var saveToSentItems = true;

	await graphClient.Me
		.SendMail(message, saveToSentItems)
		.Request()
		.PostAsync();
}

public class EmailService
{
	MessageAttachmentsCollectionPage MessageAttachmentsCollectionPage 
		= new MessageAttachmentsCollectionPage();

	public Message CreateStandardEmail(string recipient, string header, string body)
	{
		var message = new Message
		{
			Subject = header,
			Body = new ItemBody
			{
				ContentType = BodyType.Text,
				Content = body
			},
			ToRecipients = new List<Recipient>()
			{
				new Recipient
				{
					EmailAddress = new EmailAddress
					{
						Address = recipient
					}
				}
			},
			Attachments = MessageAttachmentsCollectionPage
		};

		return message;
	}

	public Message CreateHtmlEmail(string recipient, string header, string body)
	{
		var message = new Message
		{
			Subject = header,
			Body = new ItemBody
			{
				ContentType = BodyType.Html,
				Content = body
			},
			ToRecipients = new List<Recipient>()
			{
				new Recipient
				{
					EmailAddress = new EmailAddress
					{
						Address = recipient
					}
				}
			},
			Attachments = MessageAttachmentsCollectionPage
		};

		return message;
	}

	public void AddAttachment(byte[] rawData, string filePath)
	{
		MessageAttachmentsCollectionPage.Add(new FileAttachment
		{
			Name = Path.GetFileName(filePath),
			ContentBytes = EncodeTobase64Bytes(rawData)
		});
	}

	public void ClearAttachments()
	{
		MessageAttachmentsCollectionPage.Clear();
	}

	static public byte[] EncodeTobase64Bytes(byte[] rawData)
	{
		string base64String = System.Convert.ToBase64String(rawData);
		var returnValue = Convert.FromBase64String(base64String);
		return returnValue;
	}
}

<appSettings>
	<add key="AADInstance" value="https://login.microsoftonline.com/{0}/v2.0"/>
	<add key="Tenant" value="5698af84-5720-4ff0-bdc3-9d9195314244"/>
	<add key="ClientId" value="ae1fd165-d152-492d-b4f5-74209f8f724a"/>
	<add key="Scope" value="User.read Mail.Send Mail.ReadWrite"/>
</appSettings>

public partial class MainWindow : Window
{
	AadGraphApiDelegatedClient _aadGraphApiDelegatedClient = new AadGraphApiDelegatedClient();
	EmailService _emailService = new EmailService();

	const string SignInString = "Sign In";
	const string ClearCacheString = "Clear Cache";

	public MainWindow()
	{
		InitializeComponent();
		_aadGraphApiDelegatedClient.InitClient();
	}

	private async void SignIn(object sender = null, RoutedEventArgs args = null)
	{
		var accounts = await _aadGraphApiDelegatedClient.GetAccountsAsync();

		if (SignInButton.Content.ToString() == ClearCacheString)
		{
			await _aadGraphApiDelegatedClient.RemoveAccountsAsync();

			SignInButton.Content = SignInString;
			UserName.Content = "Not signed in";
			return;
		}

		try
		{
			var account = await _aadGraphApiDelegatedClient.SignIn();

			Dispatcher.Invoke(() =>
			{
				SignInButton.Content = ClearCacheString;
				SetUserName(account);
			});
		}
		catch (MsalException ex)
		{
			if (ex.ErrorCode == "access_denied")
			{
				// The user canceled sign in, take no action.
			}
			else
			{
				// An unexpected error occurred.
				string message = ex.Message;
				if (ex.InnerException != null)
				{
					message += "Error Code: " + ex.ErrorCode + "Inner Exception : " + ex.InnerException.Message;
				}

				MessageBox.Show(message);
			}

			Dispatcher.Invoke(() =>
			{
				UserName.Content = "Not signed in";
			});
		}
	}

	private async void SendEmail(object sender, RoutedEventArgs e)
	{
		var message = _emailService.CreateStandardEmail(EmailRecipientText.Text, 
			EmailHeader.Text, EmailBody.Text);

		await _aadGraphApiDelegatedClient.SendEmailAsync(message);
		_emailService.ClearAttachments();
	}

	private async void SendHtmlEmail(object sender, RoutedEventArgs e)
	{
		var messageHtml = _emailService.CreateHtmlEmail(EmailRecipientText.Text,
			EmailHeader.Text, EmailBody.Text);

		await _aadGraphApiDelegatedClient.SendEmailAsync(messageHtml);
		_emailService.ClearAttachments();
	}

	private void AddAttachment(object sender, RoutedEventArgs e)
	{
		var dlg = new OpenFileDialog();
		if (dlg.ShowDialog() == true)
		{
			byte[] data = File.ReadAllBytes(dlg.FileName);
			_emailService.AddAttachment(data, dlg.FileName);
		}
	}

	private void SetUserName(IAccount userInfo)
	{
		string userName = null;

		if (userInfo != null)
		{
			userName = userInfo.Username;
		}

		if (userName == null)
		{
			userName = "Not identified";
		}

		UserName.Content = userName;
	}
}