Microsoft Graph के साथ Microsoft 365 डेटा पहुंच और प्रबंधन

Aspose.Email Graph Client के साथ Microsoft 365 डेटा एक्सेस और मैनेजमेंट का अनुकूलन करें

Microsoft Graph Microsoft 365 डेटा तक पहुंचने के लिए एक REST API है। Aspose.Email for .NET में Graph Client का इम्प्लीमेंटेशन हमारे API से Microsoft Graph तक पहुंच प्रदान करता है। नीचे दिए गए उदाहरणों में, हम टोकन प्रदान करके MS Graph Client की एक इंस्टेंस बनाएँगे। फिर, हम फ़ोल्डर को प्रबंधित करने, अपडेट करने, कॉपी और डिलीट करने के मुख्य मेथड्स का निरीक्षण करेंगे। संदेश, उनकी सामग्री और अटैचमेंट्स को भी हमारे MS Graph Client के साथ पहुंचा या बदला जा सकता है। श्रेणियां, नियम, नोटबुक और ओवरराइड को प्रबंधित करना Aspose.Email द्वारा Microsoft Graph Client की एक विस्तारित सुविधा है।

MSAL का उपयोग करके .NET में IGraphClient के साथ प्रमाणीकरण और अनुरोध करें

Microsoft Graph सेवाओं के साथ इंटरैक्ट करने के लिए, आपको एक बनाना होगा IGraphClient ऑब्जेक्ट। एक बार प्रमाणीकरण हो जाने पर, यह क्लाइंट आपको विभिन्न सर्विस अनुरोध करने की अनुमति देता है। यह GetClient मेथड, जो बनाता है IGraphClient, आवश्यक है एक ITokenProvider इम्प्लीमेंटेशन को पहले पैरामीटर के रूप में। यह ITokenProvider ज़रूरी प्रमाणीकरण टोकन प्रदान करने के लिए जिम्मेदार है। टोकन प्राप्त करने के लिए, हम उपयोग करेंगे Microsoft Authentication Library (MSAL) .NET के लिए।

यहाँ बताया गया है कि प्रमाणीकरण प्रक्रिया कैसे सेट करें:

चरण 1: प्रमाणीकरण सेट अप करना

निम्नलिखित चरण आपको ऑथराइज़ेशन टोकन प्राप्त करने की प्रक्रिया बताएँगे:

AccessParameters क्लास बनाएं।

अपने क्रेडेंशियल्स को स्टोर करने के लिए एक AccessParameters क्लास परिभाषित करें।

public class AccessParameters
{
    public string TenantId { get; init; }
    public string ClientId { get; init; }
    public string ClientSecret { get; init; }
    public string UserId { get; init; }
    public Uri Authority => new ($"https://login.microsoftonline.com/{TenantId}");
    public string ApiUrl => "https://graph.microsoft.com/.default";
}

जोड़ें MSAL.NET पैकेज**.

इंस्टॉल करें Microsoft.Identity.Client NuGet पैकेज, जिसमें प्रमाणीकरण के लिए आवश्यक MSAL.NET बाइनरी शामिल हैं।
ITokenProvider इंटरफ़ेस को लागू करें।

एक बनाएं GraphTokenProvider क्लास जो लागू करती है ITokenProvider इंटरफ़ेस। यह क्लास एक्सेस टोकन प्राप्त करने के लिए MSAL.NET लाइब्रेरी का उपयोग करेगी।

using Microsoft.Identity.Client;
using Microsoft.Identity.Web;
using Aspose.Email.Clients;

public class GraphTokenProvider : ITokenProvider
{
    private readonly IConfidentialClientApplication _app;
    private readonly string[] _scopes;
    private string? _token;

    public GraphTokenProvider(AccessParameters accessParams)
    {
        _app = ConfidentialClientApplicationBuilder.Create(accessParams.ClientId)
            .WithClientSecret(accessParams.ClientSecret)
            .WithAuthority(accessParams.Authority)
            .Build();

        _app.AddInMemoryTokenCache();

        _scopes = new[] { accessParams.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 acquired");
        }
        catch (MsalServiceException ex) when (ex.Message.Contains("AADSTS70011"))
        {
            Console.WriteLine("Scope provided is not supported");
            result = null;
        }

        if (result == null) return null;
        _token = result.AccessToken;
        return result.AccessToken;
    }

चरण 2: ITokenProvider इंस्टेंस बनाएँ

परिभाषित करने के बाद GraphTokenProvider क्लास, आप एक इंस्टेंस बना सकते हैं AccessParameters और इसका उपयोग करके इंस्टैंसिएट करें GraphTokenProvider.

var accessParams = new AccessParameters()
{
    TenantId = "Your Tenant ID",
    ClientId = "Your Client ID",
    ClientSecret = "Your Client Secret",
    UserId = "User's Object ID"
};

var tokenProvider = new GraphTokenProvider(accessParams);

चरण 3: IGraphClient के साथ अनुरोध करें

अंत में, उपयोग करें GraphTokenProvider एक प्रमाणीकृत बनाने के लिए IGraphClient और सेवा अनुरोध करना शुरू करें।

using var client = GraphClient.GetClient(tokenProvider, accessParams.TenantId);

client.Resource = ResourceType.Users;
client.ResourceId = accessParams.UserId;

इन चरणों को पूरा करने के बाद, आपका IGraphClient अब प्रमाणीकृत अनुरोधों का उपयोग करके Microsoft Graph सेवाओं के साथ इंटरैक्ट करने के लिए तैयार है।

GCC High एन्डपॉइंट्स से कनेक्ट करना

यह GraphClient GCC High एन्डपॉइंट्स से कनेक्ट करने के लिए उपयोग करता है EndPoint प्रॉपर्टी। निम्नलिखित कोड उदाहरण दिखाता है कि फ़ोल्डर सूचीबद्ध करने और संदेश प्राप्त करने के लिए GCC High एन्डपॉइंट से जुड़ने हेतु GraphClient को कैसे कॉन्फ़िगर किया जाए।

client.EndPoint = "https://graph.microsoft.us";

var folders = client.ListFolders();
string folderId = folders.Find(x => x.DisplayName == "Inbox").ItemId;
var msgs = client.ListMessages(folderId);

IGraphClient के साथ फ़ोल्डर प्रबंधन

फ़ोल्डर सूचीबद्ध करें

कॉल करके ListFolders MS Graph क्लाइंट की विधि से, फ़ोल्डरों की सूची प्राप्त करना संभव है। प्रत्येक फ़ोल्डर में DisplayName जैसे पैरामीटर का सेट होता है, जिसे पढ़ा जा सकता है FolderInfo प्रकार।

var folders = client.ListFolders();

foreach (var folder in folders)
{
    Console.WriteLine(folder.DisplayName);
}

फ़ोल्डर अपडेट करें

MS Graph क्लाइंट के साथ फ़ोल्डर बनाने के लिए, उपयोग करें CreateFolder मेथड। आपको प्राप्त होगा एक FolderInfo ऑब्जेक्ट और DisplayName, ItemId, HasSubFolders और अन्य प्रॉपर्टीज़ तक पहुँचने की संभावना।

var folderInfo = client.CreateFolder("FolderName");
folderInfo.DisplayName = "FolderAnotherName";
client.UpdateFolder(folderInfo);

फ़ोल्डर कॉपी करें

CopyFolder यह मेथड MS Graph के साथ फ़ोल्डर ऑब्जेक्ट को कॉपी करने की मुख्य विधि है।

var folderInfo1 = client.CreateFolder("Folder1");
var folderInfo2 = client.CreateFolder("Folder2");
    
// copy Folder2 to Folder1
client.CopyFolder(folderInfo1.ItemId, folderInfo2.ItemId);

फ़ोल्डर को स्थानांतरित करें और हटाएँ

उपयोग करें MoveFolder यह मेथड फ़ोल्डर को स्थानांतरित करने के लिए उपयोग किया जाता है, यह newParentId और itemId को स्वीकार करता है। डिलीट यह मेथड आईडी द्वारा एक मेथड को हटाने के लिए उपयोग किया जाता है।

var folderInfo1 = client.CreateFolder("Folder1");
var folderInfo2 = client.CreateFolder("Folder2");
    
// move Folder2 to Folder1
client.MoveFolder(folderInfo1.ItemId, folderInfo2.ItemId);
    
// delete Folder1
client.Delete(folderInfo1.ItemId)

IGraphClient के साथ संदेशों का प्रबंधन

Aspose.Email for .NET में लागू किया गया MS Graph क्लाइंट, संदेशों और अटैचमेंट्स को प्रबंधित करने के लिए विधियों का सेट प्रदान करता है:

संदेश सूचीबद्ध करें

var folders = client.ListFolders();

foreach (var folder in folders)
{
    if (folder.DisplayName.Equals("Inbox"))
    {
        // list messages in inbox
        var inboxMessages = client.ListMessages(folder.ItemId);

        foreach (var messageInfo in inboxMessages)
        {
            Console.WriteLine(messageInfo.Subject);
        }
    }
}

भेजे जाने की तिथि द्वारा संदेशों को फ़िल्टर करें

यह OrderBy लाइब्रेरी कलेक्शन का मेथड आपको भेजे जाने की तिथि के आधार पर विभिन्न सॉर्टिंग क्रम (आरोही और अवरोही) के साथ संदेशों को प्राप्त करने की सुविधा देता है। निम्नलिखित कोड उदाहरण दिखाता है कि संदेशों को उनके भेजे जाने की तिथि के अनुसार कैसे क्रमबद्ध किया जाए:

IGraphClient client = GraphClient.GetClient(provider, TenantId);

var builder = new GraphQueryBuilder();

// create orderby messages query 'DESC'
builder.SentDate.OrderBy(false);
var messagePageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(10), builder.GetQuery());
var messages = messagePageInfo.Items;

builder.Clear();

// create orderby messages query 'ASC'
builder.SentDate.OrderBy(true);
messagePageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(10), builder.GetQuery());
messages = messagePageInfo.Items;

पेजिंग समर्थन के साथ संदेशों को लूप करें

API संदेशों को सूचीबद्ध करते समय पेजिंग और फ़िल्टरिंग की अनुमति देता है। यह उच्च मात्रा के संदेशों वाले मेलबॉक्स के लिए विशेष रूप से उपयोगी है, क्योंकि यह केवल आवश्यक सारांश जानकारी प्राप्त करके समय बचाता है।

कोड उदाहरण और नीचे दिए गए चरण दिखाते हैं कि पेजिंग और फ़िल्टरिंग सुविधाओं का उपयोग करके इनबॉक्स फ़ोल्डर से संदेशों को कैसे प्राप्त करें।

सबसे पहले, क्लाइंट को प्रारंभ करें।
फिर, प्रत्येक पृष्ठ पर दिखाने के लिए आइटम्स की संख्या सेट करें, उदाहरण के लिए, 10।
केवल अनरीड संदेशों को प्राप्त करने के लिए फ़िल्टर बनाएं, जिसका उपयोग GraphQueryBuilder क्लास। builder.IsRead.Equals(false) अनरीड संदेशों के फ़िल्टर की शर्त सेट कर रहा है।
कॉल करें ListMessages क्लाइंट ऑब्जेक्ट पर मेथड, जिसमें फ़ोल्डर (Inbox) और प्रति पृष्ठ आइटम्स (PageInfo(itemsPerPage)) को पैरामीटर के रूप में निर्दिष्ट किया गया है। यह अनरीड संदेशों के फ़िल्टर को लागू करने के लिए क्वेरी ऑब्जेक्ट भी पास करता है। लौटाया गया PageInfo ऑब्जेक्ट (pageInfo) वर्तमान पृष्ठ के प्राप्त संदेशों को Items प्रॉपर्टी में रखता है।
एक लूप बनाएं जो तब तक चलता रहे जब तक अंतिम पृष्ठ नहीं पहुंच जाता (pageInfo.LastPage false है)। प्राप्त संदेशों को messages.AddRange(pageInfo.Items) का उपयोग करके मौजूदा संदेशों की सूची में जोड़ा जाता है।

//  reading unread messages with paging
using var client = GraphClient.GetClient(tokenProvider, config.Tenant);

// paging option
var itemsPerPage = 10;
// create unread messages filter
GraphQueryBuilder builder = new GraphQueryBuilder();
builder.IsRead.Equals(false);
var query = builder.GetQuery();

// list messages
var pageInfo = client.ListMessages(KnownFolders.Inbox, new PageInfo(itemsPerPage), query);
var  messages = pageInfo.Items;

while (!pageInfo.LastPage)
{
    pageInfo = client.ListMessages(KnownFolders.Inbox, pageInfo.NextPage, query);
    messages.AddRange(pageInfo.Items);
}

// set messages state as read
foreach (var message in messages)
{
    client.SetRead(message.ItemId);
}

संदेश प्राप्त करें

var folders = client.ListFolders();

foreach (var folder in folders)
{
    if (folder.DisplayName.Equals("Inbox"))
    {
        // list messages in inbox
        var inboxMessages = client.ListMessages(folder.ItemId);

        if (inboxMessages.Count > 0)
        {
            // fetch the first message in inbox
            var msg = client.FetchMessage(inboxMessages[0].ItemId);
            
            Console.WriteLine(msg.BodyHtml);
        }
        
    }
}

संदेश बनाएं

var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);

// create message in inbox
client.CreateMessage(KnownFolders.Inbox, msg);

संदेश भेजें

// prepare the message
var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);
msg.SetProperty(KnownPropertyList.SenderName, "John");
msg.SetProperty(KnownPropertyList.SentRepresentingEmailAddress, "John@from.com");

// send message
client.Send(msg);

ड्राफ्ट संदेश भेजें

// prepare the message
var msg = new MapiMessage(OutlookMessageFormat.Unicode)
{
    Subject = "My message",
    Body = "Hi, it is my message"
};

msg.Recipients.Add("sam@to.com", "Sam", MapiRecipientType.MAPI_TO);
msg.SetProperty(KnownPropertyList.SenderName, "John");
msg.SetProperty(KnownPropertyList.SentRepresentingEmailAddress, "John@from.com");

// add message to Draft folder
var draftMessage = client.CreateMessage(KnownFolders.Drafts, msg);

// send a draft message
client.Send(draftMessage.ItemId);

EML संदेश भेजें

MailMessage ऑब्जेक्ट का उपयोग करके ईमेल बनाना और भेजना आसान है। निम्नलिखित कोड उदाहरण Graph API का उपयोग करके ईमेल संदेश बनाने और भेजने का प्रदर्शन करता है:

// prepare the message
var eml = new MailMessage
{
    From = "from@domain.com",
    To = "to1@domain.com, to2@domain.com",
    Subject = "New message",
    HtmlBody = "<html><body>This is the HTML body</body></html>"
};

// send the message
graphClient.Send(eml);
graphClient.Create(KnownFolders.Inbox, eml);

संदेशों की कॉपी बनाएं


// copy message to Inbox folder
var copiedMsg = client.CopyMessage(KnownFolders.Inbox, msg.ItemId);

संदेशों को स्थानांतरित करें

// move message to Inbox folder
var movedMsg = client.MoveMessage(KnownFolders.Inbox, msg.ItemId);

अटैचमेंट प्रबंधित करें


// create an attachment
var attachment = new MapiAttachment();
attachment.SetProperty(KnownPropertyList.DisplayName, "My Attachment");
attachment.SetProperty(KnownPropertyList.AttachDataBinary, new byte[1024]);

// add an attachment to message
var createdAttachment = client.CreateAttachment(messageInfo.ItemId, attachment);

// fetch a message attachment
var fetchedAttachment = client.FetchAttachment(createdAttachment.ItemId);

// delete a message attachment 
client.DeleteAttachment(createdAttachment.ItemId);

// list the message attachments
var attachments = client.ListAttachments(messageInfo.ItemId);

Graph क्लाइंट के साथ Outlook आइटम्स का प्रबंधन

कैलेंडर इवेंट्स का प्रबंधन

Aspose.Email कैलेंडर इवेंट्स तक पहुँचने, प्रबंधित करने और उनके साथ इंटरैक्ट करने के लिए API प्रदान करता है। इन उद्देश्यों के लिए, यह नीचे दी गई विधियों को उपलब्ध कराता है: IGraphClient इंटरफ़ेस:

ListCalendars() - कैलेंडर जानकारी का संग्रह प्राप्त करता है।
ListCalendarItems(string id) - निर्दिष्ट कैलेंडर आईडी से जुड़े कैलेंडर आइटम्स का संग्रह प्राप्त करता है।
FetchCalendarItem(string id) - प्रदान किए गए आईडी के आधार पर विशिष्ट कैलेंडर आइटम प्राप्त करता है।
CreateCalendarItem(string calId, MapiCalendar mapiCalendar) - निर्दिष्ट कैलेंडर में नया कैलेंडर आइटम बनाता है।
UpdateCalendarItem(MapiCalendar mapiCalendar) - मौज़दा कैलेंडर आइटम को अपडेट करता है।
UpdateCalendarItem(MapiCalendar mapiCalendar, UpdateSettings updateSettings) - निर्दिष्ट अपडेट सेटिंग्स के साथ मौजूदा कैलेंडर आइटम को अपडेट करता है।

निम्नलिखित कोड उदाहरण Aspose.Email द्वारा प्रदान की गई विधियों का उपयोग करके Microsoft Graph API क्लाइंट में कैलेंडर घटनाओं के साथ कैसे इंटरैक्ट करें, दर्शाता है:


// List Calendars
CalendarInfoCollection calendars = graphClient.ListCalendars();

// List Calendar Items
MapiCalendarCollection calendarItems = graphClient.ListCalendarItems("calendarId");

// Fetch Calendar Item
MapiCalendar calendarItem = graphClient.FetchCalendarItem("calendarItemId");

// Create Calendar Item
MapiCalendar newCalendarItem = new MapiCalendar(
    location: "Conference Room",
    summary: "Team Meeting",
    description: "Discuss project status and updates.",
    startDate: startDate,
    endDate: endDate
);

MapiCalendar createdCalendarItem = graphClient.CreateCalendarItem("calendarId", newCalendarItem);

// Update Calendar Item
createdCalendarItem.Location = "Zoom Meeting";
MapiCalendar updatedCalendarItem = graphClient.UpdateCalendarItem(createdCalendarItem);

श्रेणियों का प्रबंधन

Aspose.Email for .NET द्वारा MS Graph के साथ श्रेणियों को प्रबंधित करने के लिए, निम्नलिखित विधियों का उपयोग करें:

// create a custom category with Orange color
var category = client.CreateCategory("My custom category", CategoryPreset.Preset1);

// fetch a category
var fetchedCategory = client.FetchCategory(category.Id);

// update category (change color to brown)
fetchedCategory.Preset = CategoryPreset.Preset2;
var updatedCategory = client.UpdateCategory(fetchedCategory);

// list available categories
var categories = client.ListCategories();

foreach (var cat in categories)
{
    Console.WriteLine(cat.DisplayName);
}

// delete a category
client.Delete(fetchedCategory.Id);

संपर्कों का प्रबंधन

Aspose.Email संपर्क आइटम्स तक पहुँचने, प्रबंधित करने और उनके साथ इंटरैक्ट करने के लिए API प्रदान करता है। इन उद्देश्यों के लिए, यह नीचे दिए गए विधियों को उपलब्ध कराता है: IGraphClient इंटरफ़ेस:

ListContacts(string id) - निर्दिष्ट फ़ोल्डर आईडी से जुड़े MAPI संपर्कों का संग्रह प्राप्त करता है।
FetchContact(string id) - प्रदान किए गए आइटम आईडी के आधार पर विशिष्ट संपर्क प्राप्त करता है।
CreateContact(string folderId, MapiContact contact) - निर्दिष्ट फ़ोल्डर में नया संपर्क बनाता है।
UpdateContact(MapiContact contact) - मौजूदा संपर्क को अपडेट करता है।

निम्नलिखित कोड उदाहरण Aspose.Email द्वारा प्रदान की गई विधियों का उपयोग करके Microsoft Graph API क्लाइंट में संपर्कों के साथ कैसे इंटरैक्ट करें, दर्शाता है:

// List Contacts
MapiContactCollection contacts = graphClient.ListContacts("contactFolderId");

// Fetch Contact
MapiContact contact = graphClient.FetchContact("contactId");

// Create Contact
MapiContact newContact = new MapiContact("Jane Smith", "jane.smith@example.com", "XYZ Corporation", "777-888-999");

MapiContact createdContact = graphClient.CreateContact("contactFolderId", newContact);

// Update Contact
createdContact.Telephones.PrimaryTelephoneNumber = "888-888-999";

MapiContact updatedContact = graphClient.UpdateContact(createdContact);

ओवरराइड्स प्रबंधित करें

Aspose.Email for .NET द्वारा MS Graph के साथ ओवरराइड्स को प्रबंधित करने के लिए, निम्नलिखित विधियों का उपयोग करें:

// Create an user's override
var userOverride = client.CreateOrUpdateOverride
    (new MailAddress("JohnBrown@someorg.com", "JohnBrown"), ClassificationType.Focused);

// list the overrides
var overrides = client.ListOverrides();

// update override
userOverride.Sender.DisplayName = "John Brown";
var updatedOverride = client.UpdateOverride(userOverride);

// delete override
client.Delete(updatedOverride.Id);

नियमों का प्रबंधन

Aspose.Email for .NET द्वारा MS Graph के साथ नियमों को प्रबंधित करने के लिए, निम्नलिखित विधियों का उपयोग करें:

// Create a rule
var rule = PrepareRule("user@someorg.com", "User");
var createdRule = client.CreateRule(rule);

// List all rules defined for Inbox
var rules = client.ListRules();

// Fetch a rule
var fetchedRule = client.FetchRule(createdRule.RuleId);

// Update a rule
fetchedRule.DisplayName = "Renamed rule";
fetchedRule.IsEnabled = false;
var updatedRule = client.UpdateRule(createdRule);

// Delete a rule
client.Delete(updatedRule.RuleId);

InboxRule PrepareRule(string email, string displayName)
{
    var rule = new InboxRule()
    {
        DisplayName = "My rule",
        Priority = 1,
        IsEnabled = true,
        Conditions = new RulePredicates(),
        Actions = new RuleActions()
    };

    rule.Conditions.ContainsSenderStrings = new StringCollection { displayName };
    rule.Actions.ForwardToRecipients = new MailAddressCollection
        { new MailAddress(email, displayName, true) };
    rule.Actions.StopProcessingRules = true;

    return rule;
}

नोटबुक्स का प्रबंधन

Aspose.Email for .NET द्वारा MS Graph के साथ नोटबुक्स को प्रबंधित करने के लिए, निम्नलिखित विधियों का उपयोग करें:

// create a OneNote notebook
var newNotebook = new Notebook()
{
    DisplayName = "My Notebook"
};
var createdNotebook = client.CreateNotebook(newNotebook);

// fetch a notebook
var fetchedNotebook = client.FetchNotebook(createdNotebook.Id);

// list the notebooks
var notebooks = client.ListNotebooks();

Microsoft Graph में कार्य प्रबंधन

Aspose.Email डेवलपर्स को उपयोगकर्ताओं के कार्यों और टास्क सूचियों तक पहुँचने, प्रबंधित करने और संवाद करने के लिए APIs प्रदान करता है, निम्न मेथड्स का उपयोग करके IGraphClient इंटरफ़ेस:

ListTaskLists() - कार्य सूची जानकारी का संग्रह प्राप्त करता है।
GetTaskList(string id) - प्रदान किए गए आईडी के आधार पर विशिष्ट कार्य सूची को प्राप्त करता है।
DeleteTaskList(string id) - निर्दिष्ट टास्क सूची को हटाता है। -ListTasks(string id) - निर्दिष्ट टास्क लिस्ट ID से जुड़े टास्कों का संग्रह प्राप्त करता है।
FetchTask(string id) - प्रदान किए गए ID के आधार पर विशिष्ट टास्क प्राप्त करता है।
CreateTask(MapiTask task, string taskListUri) - निर्दिष्ट टास्क सूची में नया टास्क बनाता है।
UpdateTask(MapiTask task) - प्रदान की गई जानकारी के साथ मौजूदा टास्क को अपडेट करता है।
UpdateTask(MapiTask task, UpdateSettings updateSettings) - निर्दिष्ट अपडेट सेटिंग्स के साथ मौजूदा टास्क को अपडेट करता है।

निम्नलिखित कोड नमूना दर्शाता है कि टास्क सूची का प्रबंधन कैसे करें:

// List Task Lists
var taskLists = graphClient.ListTaskLists();

foreach (var tList in taskLists)
{
    Console.WriteLine($"Task List: {tList.DisplayName}");
}

// Get Task List
var taskList = graphClient.GetTaskList("taskListId");

// Delete Task List
graphClient.DeleteTaskList("taskListId");

निम्नलिखित कोड नमूना दर्शाता है कि कार्यों का प्रबंधन कैसे करें:

// List Tasks in a Task List
MapiTaskCollection tasks = graphClient.ListTasks("taskListId");

// Fetch Task
MapiTask task = graphClient.FetchTask("taskId");

// Create Task
var newTask = new MapiTask
{
    Subject = "New Task",
    DueDate = new DateTime(2023, 12, 31),
    Status = MapiTaskStatus.NotStarted
};

MapiTask createdTask = graphClient.CreateTask(newTask, "taskListUri");

// Update Task
createdTask.Subject = "Updated Task Subject";
MapiTask updatedTask = graphClient.UpdateTask(createdTask);

// Update Task with UpdateSettings
var updateSettings = new UpdateSettings { SkipAttachments  = true };
MapiTask updatedTaskWithSettings = graphClient.UpdateTask(createdTask, updateSettings);

Azure Active Directory एडमिन सेंटर में प्रोजेक्ट बनाना Microsoft Graph में मेल फ़ोल्डरों का प्रबंधन (Aspose.Email)