- Presentasi Microsoft Graph
- Tentang Aspose.Email untuk .NET
- Konfigurasikan Aplikasi Anda di Portal Azure
- Dapatkan Token Akses dan Inisialisasi GraphClient
- Dapatkan Hierarki Folder dan Ambil Folder Berdasarkan Nama
- Daftar Pesan di Folder Tertentu
Integrasi Microsoft Graph API dan Aspose.Email untuk .NET dengan aplikasi email memungkinkan pengembang untuk dengan mudah mengakses dan memanipulasi data kotak surat, melakukan operasi seperti mengambil pesan, mengambil hierarki folder, dan menyimpan email dalam berbagai format. Dalam artikel ini, kita akan menjelajahi cara memanfaatkan kombinasi kuat ini dalam memproses dan mengelola kotak surat.
Presentasi Microsoft Graph
Microsoft Graph adalah platform API yang komprehensif yang disediakan oleh Microsoft yang menawarkan titik akhir terpadu untuk mengakses berbagai layanan dan data Microsoft. Ini berfungsi sebagai gerbang ke data luas yang tersedia di Microsoft 365, termasuk kotak surat Outlook, kalender, kontak, OneDrive, Teams, dan banyak lagi.
Dengan Microsoft Graph, pengembang dapat membangun aplikasi yang berinteraksi secara mulus dengan data dan wawasan pengguna di seluruh ekosistem cloud Microsoft. Ini dicapai melalui API RESTful dan SDK yang menyediakan cara untuk mengautentikasi, mengotorisasi, dan men-query data dengan mudah.
Tentang Aspose.Email untuk .NET
Aspose.Email untuk .NET adalah perpustakaan kaya fitur yang memungkinkan pengembang untuk bekerja dengan berkas email dan protokol dalam aplikasi .NET mereka. Ini menyediakan seperangkat API yang kuat untuk membuat, memanipulasi, dan mengonversi pesan email dalam berbagai format, seperti MSG, EML, dan MBOX. Selain itu, perpustakaan ini mendukung protokol email seperti SMTP, POP3, dan IMAP, memungkinkan manajemen email yang serbaguna.
Dalam panduan ini, kita akan menggunakan Aspose.Email untuk berinteraksi dengan Microsoft Graph, memproses data kotak surat secara programatis. Dengan GraphClient dari Aspose.Email, kita dapat dengan efisien melakukan operasi kotak surat dengan mengautentikasi dengan Microsoft Graph.
Untuk mulai menggunakan perpustakaan, Anda perlu mengintegrasikannya ke dalam proyek Anda. Cara termudah untuk mendapatkan Aspose.Email untuk .NET adalah melalui NuGet Package Manager:
- Buka proyek Anda di Visual Studio.
- Navigasikan ke Tools > NuGet Package Manager > Manage NuGet Packages for Solution.
- Cari Aspose.Email.
- Pilih paket dan klik Install.
Sebagai alternatif, Anda dapat menggunakan Package Manager Console:
Install-Package Aspose.Email
Anda juga dapat mengunduh versi terbaru dari API langsung dari situs web Aspose.
Konfigurasikan Aplikasi Anda di Portal Azure
Sebelum kita masuk ke dalam kode, penting untuk mengonfigurasi aplikasi Anda di dalam portal Azure untuk mengaktifkan akses Microsoft Graph. Ikuti langkah-langkah berikut:
Buat Aplikasi Azure Active Directory (AAD):
- Navigasikan ke Portal Azure.
- Pergi ke Azure Active Directory > App registrations.
- Klik New registration untuk membuat aplikasi baru.
- Berikan nama dan atur URI pengalihan jika diperlukan.
- Klik Register untuk menyelesaikan proses.
Atur Izin API:
- Dalam aplikasi terdaftar Anda, navigasikan ke API permissions.
- Klik Add a permission > Microsoft Graph.
- Pilih Application permissions untuk panggilan server-ke-server.
- Pilih izin yang diperlukan seperti
Mail.Read,Mail.ReadWrite,User.Read, dll. - Klik Add permissions untuk menerapkan.
Buat Rahasia Klien:
- Pergi ke Certificates & secrets di aplikasi Anda.
- Klik New client secret dan berikan deskripsi.
- Atur periode kedaluwarsa, lalu klik Add.
- Catat nilai rahasia klien yang dihasilkan, karena Anda akan membutuhkannya nanti.
Kumpulkan Nilai Konfigurasi:
- Dapatkan Tenant ID, Client ID, dan Client Secret dari halaman overview aplikasi Anda dan bagian rahasia.
- Anda akan menggunakan nilai-nilai ini untuk mengautentikasi dan berinteraksi dengan Microsoft Graph.
Setelah aplikasi Anda dikonfigurasi, Anda siap untuk melanjutkan dengan tugas pengembangan.
Dapatkan Token Akses dan Inisialisasi GraphClient
Sebelum menyelami operasi kotak surat, kita perlu membuka pintu ke ekosistem data dan layanan Microsoft Graph yang luas. Akses ini diberikan melalui token akses OAuth 2.0 - kunci digital yang mengotorisasi aplikasi Anda untuk berinteraksi dengan Microsoft Graph atas nama pengguna atau layanan. Bayangkan ini sebagai pas aman yang memberikan Anda akses ke seluruh alam semesta kemungkinan, dari mengambil email hingga mengelola kontak dan lebih banyak lagi.
Langkah 1: Siapkan File Konfigurasi
Langkah pertama untuk memperoleh token adalah menyiapkan file konfigurasi yang menyimpan detail penting seperti Tenant ID, Client ID, dan Client Secret aplikasi Anda. Nilai-nilai ini adalah kredensial aplikasi Anda dan bertindak sebagai pengidentifikasi saat berkomunikasi dengan server Microsoft.
Berikut adalah contoh konfigurasi JSON Anda:
{
"Instance": "https://login.microsoftonline.com/{0}",
"ApiUrl": "https://graph.microsoft.com/.default",
"TenantId": "YOUR_TENANT_ID_HERE",
"ClientId": "YOUR_APP_ID_HERE",
"ClientSecret": "YOUR_CLIENT_SECRET_HERE",
"UserId": "YOUR_ID_HERE"
}
Langkah 2: Peta Konfigurasi JSON ke Objek C#
Sekarang, mari kita ubah konfigurasi ini menjadi objek C# yang dapat digunakan aplikasi kita. Kita akan membaca file JSON dan memetakan isinya ke kelas AuthenticationConfig, memastikan bahwa aplikasi kita tahu di mana menemukan informasi penting yang dibutuhkan.
class AuthenticationConfig
{
public string Instance { get; set; }
public string ApiUrl { get; set; }
public string TenantId { get; set; }
public string ClientId { get; set; }
public string UserId { get; set; }
public string Authority => string.Format(CultureInfo.InvariantCulture, Instance, TenantId);
public string ClientSecret { get; set; }
public static AuthenticationConfig ReadFromJsonFile(string path)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(path);
var configuration = builder.Build();
return configuration.Get<AuthenticationConfig>();
}
}
Langkah 3: Dapatkan Token Akses
Dengan konfigurasi kita siap, saatnya untuk memperoleh token akses. Kita akan mengimplementasikan kelas GraphTokenProvider yang menangani proses autentikasi menggunakan Microsoft Authentication Library (MSAL). Kelas ini menangani pekerjaan berat - berkomunikasi dengan Microsoft Graph untuk mendapatkan token yang memberdayakan aplikasi kita.
class GraphTokenProvider : ITokenProvider
{
private readonly IConfidentialClientApplication _app;
private readonly string[] _scopes;
private string? _token;
public GraphTokenProvider(AuthenticationConfig config)
{
_app = ConfidentialClientApplicationBuilder.Create(config.ClientId)
.WithClientSecret(config.ClientSecret)
.WithAuthority(config.Authority)
.Build();
// In memory token caches (App and User caches)
_app.AddInMemoryTokenCache();
_scopes = new[] { config.ApiUrl };
}
public void Dispose()
{
throw new NotImplementedException();
}
public OAuthToken GetAccessToken()
{
return GetAccessToken(false);
}
public OAuthToken GetAccessToken(bool ignoreExistingToken)
{
if (!ignoreExistingToken && _token != null)
{
return new OAuthToken(_token);
}
_token = GetAccessTokenAsync().GetAwaiter().GetResult();
return new OAuthToken(_token);
}
private async Task<string?> GetAccessTokenAsync()
{
AuthenticationResult? result;
try
{
result = await _app.AcquireTokenForClient(_scopes)
.ExecuteAsync();
Console.WriteLine($"Token diperoleh dari {result.AuthenticationResultMetadata.TokenSource} {Environment.NewLine}");
}
catch (MsalServiceException ex)
{
Console.WriteLine($"Kesalahan Mendapatkan Token:{Environment.NewLine}{ex}{Environment.NewLine}");
result = null;
}
if (result == null) return null;
_token = result.AccessToken;
return result.AccessToken;
}
}
Langkah 4: Inisialisasi GraphClient
Akhirnya, kita inisialisasi GraphClient dengan token yang telah kita peroleh. GraphClient bertindak sebagai jembatan kita ke Microsoft Graph, memungkinkan kita untuk berinteraksi dengan kotak surat pengguna dengan mulus.
var config = AuthenticationConfig.ReadFromJsonFile("appsettings.json");
var tokenProvider = new GraphTokenProvider(config);
using var client = GraphClient.GetClient(tokenProvider, config.TenantId);
client.Resource = ResourceType.Users;
client.ResourceId = config.UserId;
Dapatkan Hierarki Folder dan Ambil Folder Berdasarkan Nama
Setelah Anda memperoleh akses ke Microsoft Graph, saatnya untuk menjelajahi kotak surat. Dalam bagian ini, kita akan membahas cara mengambil dan menavigasi hierarki folder kotak surat, memungkinkan Anda untuk mengakses folder tertentu berdasarkan nama.
Langkah 1: Memahami Hierarki Folder
Menavigasi Struktur Folder
Kotak surat terstruktur secara hierarkis, mirip dengan pohon. Folder root bercabang menjadi beberapa subfolder, masing-masing berisi set emailnya sendiri dan mungkin lebih banyak subfolder. Struktur bersarang ini memungkinkan manajemen yang terorganisir dan navigasi email yang mudah.
Mari kita definisikan dan gunakan kelas FolderNode untuk merepresentasikan setiap folder dalam hierarki:
// Mewakili sebuah node dalam hierarki folder,
// memperluas properti FolderInfo dan menyimpan koleksi subfolder.
class FolderNode
{
// Mendapatkan objek FolderInfo yang mewakili informasi folder.
public FolderInfo Folder { get; }
// Mendapatkan koleksi subfolder yang terdapat dalam folder saat ini.
public List<FolderNode?> SubFolders { get; }
// Menginisialisasi instance baru dari kelas FolderNode dengan objek FolderInfo yang ditentukan.
public FolderNode(FolderInfo folder)
{
Folder = folder;
SubFolders = new List<FolderNode?>();
}
// Mencetak semua folder dengan cara hierarkis mulai dari node saat ini.
public void PrintHierarchy()
{
PrintFolderNode(this, 0);
}
private void PrintFolderNode(FolderNode node, int indentLevel)
{
// Mencetak node folder saat ini dengan indentasi
Console.WriteLine($"{new string(' ', indentLevel * 2)}{node}");
// Mencetak subfolder secara rekursif
foreach (var subFolder in node.SubFolders)
{
PrintFolderNode(subFolder, indentLevel + 1);
}
}
// Mendapatkan nama tampilan folder.
public override string ToString()
{
return $"{Folder.DisplayName} ({Folder.ContentCount})";
}
}
Untuk mengambil hierarki folder lengkap, kita akan membuat kelas FolderHierarchy, yang memanfaatkan GraphClient untuk mendaftar semua folder secara rekursif. Inilah cara kerjanya:
static class FolderHierarchy
{
// Mengambil semua folder di kotak surat secara rekursif dan mengembalikan koleksi hierarkis dari objek FolderNode.
public static List<FolderNode> Retrieve(IGraphClient client)
{
// Mengambil folder root
var rootFolders = client.ListFolders();
var allFolders = new List<FolderNode>();
// Mengambil subfolder secara rekursif
foreach (var folder in rootFolders)
{
var folderNode = new FolderNode(folder);
RetrieveSubFolders(client, folderNode);
allFolders.Add(folderNode);
}
return allFolders;
}
// Mengambil subfolder secara rekursif dan menambahkannya ke properti SubFolders dari FolderNode induk.
private static void RetrieveSubFolders(IGraphClient client, FolderNode parentFolderNode)
{
if (parentFolderNode.Folder.HasSubFolders)
{
var subFolders = client.ListFolders(parentFolderNode.Folder.ItemId);
foreach (var subFolder in subFolders)
{
var subFolderNode = new FolderNode(subFolder);
RetrieveSubFolders(client, subFolderNode);
parentFolderNode.SubFolders.Add(subFolderNode);
}
}
}
}
Langkah 2: Ambil Hierarki Folder
Dengan menggunakan metode FolderHierarchy.Retrieve, Anda dapat dengan mudah menjelajahi kotak surat untuk mengungkap struktur foldernya. Berikut adalah cara Anda dapat mencapainya:
// Mengambil hierarki folder dari kotak surat
var folderNodes = FolderHierarchy.Retrieve(client);
// Mencetak hierarki folder dalam format terstruktur
foreach (var folderNode in folderNodes)
{
folderNode.PrintHierarchy();
}
Langkah 3: Ambil Folder Berdasarkan Nama
Setelah hierarki folder diambil, Anda dapat menentukan folder tertentu berdasarkan nama. Apakah Anda tertarik untuk mengakses Inbox atau folder kustom, metode ini memastikan Anda dapat menemukannya dengan cepat:
// Tentukan nama folder yang Anda cari
string targetFolderName = "Inbox";
// Temukan folder target berdasarkan nama
var targetFolder = folderNodes.FirstOrDefault(
folderNode => folderNode.Folder.DisplayName.Equals(targetFolderName, StringComparison.OrdinalIgnoreCase))
?.Folder;
Daftar Pesan di Folder Tertentu
Dengan hierarki folder berhasil diambil, langkah selanjutnya adalah menyelami konten folder tertentu. Bayangkan Anda telah menavigasi ke Inbox Anda; sekarang, Anda ingin melihat semua pesan yang dimilikinya.
Dalam bagian ini, kita akan menjelajahi cara mendaftar pesan dalam folder tertentu menggunakan GraphClient dan Aspose.Email untuk .NET.
Setelah Anda memiliki folder, mendaftar pesan di dalamnya sangatlah sederhana. GraphClient menyediakan metode ListMessages untuk mengambil semua pesan dalam folder, yang kemudian dapat Anda proses atau tampilkan.
Inilah kode untuk mendaftar pesan dari folder yang ditentukan:
Console.WriteLine("Mendaftar pesan di folder yang ditentukan...");
// Panggil metode klien untuk mendaftar pesan di folder yang dipilih
var messageInfoCollection = client.ListMessages(targetFolder.ItemId);
Console.WriteLine($"{targetFolderName}:");
// Cetak subjek dari pesan-pesan
foreach (var messageInfo in messageInfoCollection)
{
Console.WriteLine($" - {messageInfo.Subject}");
}
messageInfoCollection berisi detail penting tentang setiap email. Informasi ini dapat digunakan untuk menampilkan ringkasan, menghasilkan laporan, atau bahkan memicu pemberitahuan berdasarkan kriteria tertentu.
Kesimpulan
Dalam artikel ini, kita telah menjelajahi cara memanfaatkan kekuatan Microsoft Graph dan perpustakaan Aspose.Email untuk .NET untuk memproses kotak surat secara efektif, menavigasi hierarki folder, dan mendaftar pesan dalam folder tertentu. Dengan mengikuti langkah-langkah ini, Anda dapat membangun aplikasi yang kuat yang berinteraksi dengan data email secara mulus, memberikan fungsionalitas yang lebih baik dan pengalaman pengguna yang lebih baik.
Konsep dalam Tindakan
Jika Anda ingin melihat konsep-konsep ini dalam tindakan, Anda dapat mengunduh contoh aplikasi yang sepenuhnya berfungsi. Aplikasi ini mencakup kode sumber yang dijelaskan dalam artikel ini dan menunjukkan cara mengimplementasikan fitur-fitur ini langkah demi langkah.
Kunjungi repositori GitHub kami untuk mengakses aplikasi contoh: Aspose.Email untuk .NET - Contoh GraphApp.
Memproses kotak surat melalui Microsoft Graph menawarkan akses yang tak tertandingi ke data email dan kemampuan manajemen. Dengan alat dan teknik yang tepat, Anda dapat membangun aplikasi canggih yang memberikan wawasan berarti dan mengotomatiskan tugas yang kompleks, pada akhirnya meningkatkan produktivitas dan kepuasan pengguna.
Coba Gratis
Selain itu, Aspose.Email menyediakan dokumentasi yang komprehensif, referensi API yang luas, dan berbagai alat online dan aplikasi gratis untuk meningkatkan proses pengembangan Anda. Pengembang juga dapat mengakses forum dukungan gratis untuk bantuan dan wawasan komunitas, serta tetap diperbarui dengan tips dan tutorial terbaru melalui blog Aspose.