Documentation – עבודה עם פריטי Outlook

Net: יצירת ושמירת קבצי Outlook

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email תומך ביצירת קבצי הודעת Outlook (MSG). מאמר זה מסביר כיצד:

צור ושמור הודעות Outlook

ה MailMessage מחלקה מכילה את Save() מתודה שיכולה לשמור קבצי Outlook MSG לכונן או ל‑stream. הקטעי קוד למטה יוצרים מופע של ה‑ MailMessage מחלקה, הגדר מאפיינים כמו from, to, subject ו‑body. ה‑ Save() מתודה מקבלת את שם הקובץ כארגומנט. בנוסף, ניתן ליצור הודעות Outlook עם a גוף RTF דחוס באמצעות ה- MapiConversionOptions.

צור מופע חדש של ה‑ MailMessage מחלקה ומגדירה את המאפיינים From, To, Subject ו‑Body.
הפעל את MapiMessage מחלקה FromMailMessage מתודה שמקבלת את האובייקט של ה‑ MailMessage סוג. ה‑ FromMailMessage מתודה ממירה את MailMessage ל‑ MapiMessage (MSG).
הפעל את MapiMessage.Save() מתודה לשמירת קובץ MSG.

כתוב את הקוד הבא באירוע הלחיצה של כפתור בבקר של יישום Windows.

צור קבצי MSG עם קבצים מצורפים

בדוגמה למעלה, יצרנו קובץ MSG פשוט. Aspose.Email גם תומך בשמירת קבצי הודעות עם קבצים מצורפים. כל שעליך לעשות הוא להוסיף את הקבצים המצורפים ל‑ MailMessage מופע. הוסף קבצים מצורפים על ידי קריאה למתודה Add() על MailMessage.Attachments אוסף. הוסף ListBox לטופס שנוצר למעלה והוסף שני כפתורים, אחד להוספה ואחד להסרה של קבצים מצורפים. היישום שמוסיף קבצים מצורפים פועל כך:

כאשר לוחצים על הכפתור Add Attachment, מוצגת Open File Dialog שתסייע למשתמשים לעיין ולבחור את הקובץ המצורף.
כאשר קובץ נבחר, הנתיב המלא מתווסף לרשימה.
כאשר קובץ MSG נוצר, נתיבי הקבצים המצורפים נלקחים מהרשימה ומתווספים ל- MailMessage.Attachments אוסף.

כתוב את הקוד הבא באירוע לחיצה על הכפתור Add Attachment.

כאשר הכפתור Remove Attachment נלחץ, הסר את הפריטים שנבחרו מה-ListBox. כתוב את הקוד הבא באירוע לחיצה על הכפתור Remove Attachment.

הוסף את הקוד להוספת הקבצים המצורפים ל- MailMessage מופע. הקוד הסופי לפונקציית Write Msg נכתב כמפורט להלן.

צור קובצי MSG עם גוף RTF

ניתן גם ליצור קבצי Outlook Message (MSG) עם גופי טקסט עשיר (RTF) באמצעות Aspose.Email. גוף ה‑RTF תומך בעיצוב טקסט. צור אחד על‑ידי הגדרת ה‑ MailMessage.HtmlBody מאפיין. כאשר ממירים a MailMessage מופע ל‑ MapiMessage במקרה זה, גוף ה‑HTML מומר ל‑RTF. כך נשמר העיצוב של גוף האימייל.

הדוגמה הבאה יוצרת קובץ MSG עם גוף RTF. יש כותרת אחת, ועיצוב מודגש וקו תחתי מיושמים בגוף ה‑HTML. עיצוב זה נשמר כאשר ה‑HTML מומר ל‑RTF.

כיווץ RTF עבור גוף הודעת MAPI

הערה: תהליך הכיווץ עשוי להאט את הביצועים בעת יצירת הודעות. בהבנת עובדה זו והגדרת דגל הכיווץ בהתאם לדרישות ספציפיות ולשיקול בין גודל הקובץ לביצועים, מפתחים יכולים לנהל בצורה יעילה את יצירת קבצי MSG ו‑PST בעבודה עם הודעות דוא"ל.

כווץ RTF נועד להפחית את גודל ההודעה וכן את קבצי PST (Personal Storage Table) שנוצרו, שבהם משתמש Microsoft Outlook לאחסון הודעות דוא"ל ונתונים אחרים. באמצעות כיווץ RTF בעת קביעת גוף ההודעה, מפתחים יכולים להפחית את כמות הזיכרון הנדרשת לאחסון הודעות דוא"ל או לייעל את רוחב הפס ברשת בעת העברת הודעות.

למטרה זו, עוצבו שתי מתודות בעלות עומס יתר:

MapiMessageItemBase.SetBodyContent(string content, BodyContentType contentType, bool compression): מתודה זו מאפשרת לך להגדיר את תוכן גוף ההודעה באמצעות מחרוזת תוכן ספציפית והגדרת סוג תוכן הגוף (למשל, טקסט פשוט, HTML, וכו’). הפרמטר האופציונלי compression הוא ערך שמציין האם יש לדחוס את התוכן באמצעות דחיסת RTF. אם פרמטר ה-compression הוא true, התוכן יידחס, מה שמוביל לגודל הודעה קטן יותר.
MapiMessageItemBase.SetBodyRtf(string content, bool compression): מתודה זו מגדירה במפורש את תוכן גוף ההודעה בפורמט RTF. הפרמטר content הוא מחרוזת המייצגת את תוכן ה-RTF שיוגדר כגוף ההודעה. כפי במתודה הקודמת, פרמטר ה-compression מקביע האם יש להחיל דחיסת RTF על התוכן. אם compression הוא true, תוכן ה-RTF יידחס כדי להפחית את הגודל.

דוגמת הקוד הבאה מציגה כיצד להגדיר גוף HTML ולשמור אותו דחוס:

var msg = new MapiMessage("from@doamin.com", "to@domain.com", "subject", "body");
// set the html body and keep it compressed
// this will reduce the message size
msg.SetBodyContent(htmlBody, BodyContentType.Html, true);

קיימת גם MapiConversionOptions.UseBodyCompression מאפיין. כאשר מאפיין זה פעיל, דחיסת גוף RTF מיושמת במהלך המרת MailMessage ל-MapiMessage, מה שמביא לגודל קובץ MSG קטן יותר. זה מוצג בדוגמת הקוד למטה:

var message = MailMessage.Load(fileName);
var options = new MapiConversionOptions();
options.UseBodyCompression = true;
var msg = MapiMessage.FromMailMessage(message, options);

שמור הודעה במצב טיוטה

הודעות אימייל נשמרות כטיוטות כאשר מישהו החל לערוך אותן אך רוצה לחזור אליהן כדי להשלים אותן מאוחר יותר. Aspose.Email תומך בשמירת הודעות אימייל במצב טיוטה על ידי הגדרת דגל הודעה. להלן קוד לדוגמה לשמירת הודעת Outlook (MSG) כטיוטה.

Net: טעינה ופענוח קבצי MSG

Mon, 01 Jan 0001 00:00:00 +0000

ב‑Aspose.Email for .NET, מפתחים יכולים לטעון ולפענח תכנים מקבצי הודעות Outlook.

כדי לטעון קבצי MSG מהדיסק, השתמשו בסטטיק MapiMessage.Load שיטה של MapiMessage מחלקה. המחלקה מספקת מספר פונקציות טעינה סטטיות לתרחישים שונים.
כדי לפענח את תוכן קובץ MSG, ה- MapiMessage חשוף מספר מתודות ומאפיינים.

במאמר זה תלמדו כיצד לטעון ולפענח קובץ MSG כדי להציב את תכולתו. דוגמות קוד עם שלבים יעניקו לכם הבנה ברורה כיצד ליישם את הפונקציונליות של טעינה ופענוח קבצי Outlook MSG בפרויקט שלכם.

ראשית, למדו כיצד לטעון קבצי MSG מקובץ או מהזרם.

טעינת קבצי MSG

הקטע הקוד שלהלן מציג כיצד לטעון קבצי MSG.

// Create an instance of MapiMessage from file
var msg = MapiMessage.Load(@"message.msg");

// Get subject
Console.WriteLine("Subject:" + msg.Subject);

// Get from address
Console.WriteLine("From:" + msg.SenderEmailAddress);

// Get body
Console.WriteLine("Body" + msg.Body);

// Get recipients information
Console.WriteLine("Recipient: " + msg.Recipients);

// Get attachments
foreach (var att in msg.Attachments)
{
    Console.Write("Attachment Name: " + att.FileName);
    Console.Write("Attachment Display Name: " + att.DisplayName);
}

דוגמת הקוד הבאה מראה כיצד להשתמש ב‑MailMessage לטעון הודעה בפורמט MSG.


var eml = MailMessage.Load("message.msg");

יש לציין שההודעה המתקבלת מומרת לפורמט EML, כולל קבצי ההודעה המשובצים. אל תשתמש בשיטת טעינה זו אם ברצונך לשמר תכונות פורמט msg ספציפיות של ההודעה המקורית.

כדי לשמר את הפורמט המקורי של קבצי ההודעה המשובצים, השתמש ב‑ msgLoadOptions.PreserveEmbeddedMessageFormat מאפיין.


var msgLoadOptions = new MsgLoadOptions();
msgLoadOptions.PreserveEmbeddedMessageFormat = true;
var msg = MailMessage.Load(stream, msgLoadOptions);

טעינה מהזרם

קטע הקוד הבא מראה כיצד לטעון קובץ מזרם.

// Create an instance of MapiMessage from file
byte[] bytes = File.ReadAllBytes(@"message.msg");

using (MemoryStream stream = new MemoryStream(bytes))
{
    stream.Seek(0, SeekOrigin.Begin);
    // Create an instance of MapiMessage from file
    MapiMessage msg = MapiMessage.Load(stream);

    // Get subject
    Console.WriteLine("Subject:" + msg.Subject);

    // Get from address
    Console.WriteLine("From:" + msg.SenderEmailAddress);

    // Get body
    Console.WriteLine("Body" + msg.Body);

}

המרת EML ל‑MSG תוך שמירת פורמט ה‑EML המשובץ

קבצי EML ניתנים לטעינה לתוך MapiMessage מחלקה על‑ידי יצירת מופע של MailMessage אובייקט ולהעבירו ל‑ MapiMessage.FromMailMessage שיטה. אם קובץ ה‑EML מכיל קבצי EML משובצים, השתמש ב‑ MapiConversionOptions.PreserveEmbeddedMessageFormat כדי לשמור על הפורמט של קבצי EML משובצים. הקטע הקוד שלהלן מציג כיצד לטעון קבצי EML לתוך MapiMessage במקביל לשימור הפורמט של קבצי EML משובצים.

// Load the EML file into a MailMessage object
var mailMessage = MailMessage.Load(emlFilePath);

// Set conversion options to preserve the format of embedded EML messages
var options = new MapiConversionOptions
    {
        PreserveEmbeddedMessageFormat = true
    };

// Convert MailMessage to MapiMessage, preserving embedded EML files
var mapiMessage = MapiMessage.FromMailMessage(mailMessage, options);

// Save the converted message in MSG format
mapiMessage.Save(msgFilePath);

נסו זאת!

המרת אימיילים וארכיוני הודעות באופן מקוון בחינם יישום המרה של Aspose.Email.

פענוח קבצי הודעות Outlook

Aspose.Email for .NET מספק את MapiMessage מחלקה המשמשת לפתיחה וניתוח קובץ MSG. מכיוון שיכולים להיות רבים ממקבלי ההודעה בקובץ MSG, ה- MapiMessage המחלקה מציגה את נמענים מאפיין המחזיר MapiRecipientCollection שמייצג אוסף של MapiRecipient אובייקטים. ה- MapiRecipient האובייקט חשוף עוד שיטות לעבודה עם תכונות הנמענים.

הסדרת הצעדים הבאים משמשת למטרה זו:

צור מופע של MapiMessage מחלקה באמצעות ה- MapiMessage.Load מתודה סטטית.
הצג את שם השולח, הנושא והגוף מקובץ MSG באמצעות SenderName, נושא ו גוף מאפיינים.
השתמש ב- נמענים מאפיין לקבלת הפנייה לאוסף של MapiRecipient אובייקטים הקשורים לקובץ MSG.
לולאה על ה- MapiRecipientCollection אוסף להצגת תוכן עבור כל MapiRecipient אובייקט דרך המתודות הציבוריות שלו.

//Instantiate an MSG file to load an MSG file from disk
var outlookMessageFile = MapiMessage.Load(dataDir + "message.msg");
//Display sender's name
Console.WriteLine("Sender Name : " + outlookMessageFile.SenderName);
//Display Subject
Console.WriteLine("Subject : " + outlookMessageFile.Subject);
//Display Body
Console.WriteLine("Body : " + outlookMessageFile.Body);
//Display Recipient's info
Console.WriteLine("Recipients : \n");

//Loop through the recipients collection associated with the MapiMessage object
foreach (var rcp in outlookMessageFile.Recipients)
{
	//Display recipient email address
	Console.WriteLine("Email : " + rcp.EmailAddress);
	//Display recipient name
	Console.WriteLine("Name : " + rcp.DisplayName);
	//Display recipient type
	Console.WriteLine("Recipient Type : " + rcp.RecipientType);
}

נסו זאת!

פענח קבצי דוא"ל אונליין בחינם אפליקציית Aspose.Email Parser.

Net: ניהול הודעות Outlook

Mon, 01 Jan 0001 00:00:00 +0000

שמירת הודעות דוא"ל כ-HTML

Aspose.Email מאפשר לשמור משאבי דוא"ל עם נתיבים יחסיים בעת יצוא הודעות לפורמט HTML. תכונה זו מספקת גמישות רבה יותר באופן קישור המשאבים בקובץ HTML המיוצא, מה שמקל על שיתוף והצגת הודעות שמורות במערכות שונות. כדי לשמור משאבים עם נתיבים יחסיים, השתמש ב- HtmlSaveOptions.UseRelativePathToResources מאפיין. ערך ברירת המחדל של המאפיין הוא false (המשאבים נשמרים עם נתיבים מוחלטים). כאשר מוגדר ל-true, המשאבים נשמרים עם נתיבים יחסיים.

קבצי HTML עם נתיבים יחסיים ניידים יותר וניתנים לצפייה נכונה ללא קשר למבנה הקבצים של סביבת האירוח. ניתן לבחור בין נתיבים מוחלטים ליחסיים בהתאם לדרישות. ניתן להגדיר נתיבים מותאמים אישית למשאבים באמצעות ה- ResourceHtmlRendering אירוע.

דוגמת הקוד שלהלן מציגה כיצד לשמור דוא"ל עם נתיב יחסי ברירת מחדל למשאבים:

var msg = MapiMessage.Load(sourceFileName);

var htmlSaveOptions = new HtmlSaveOptions
{
    ResourceRenderingMode = ResourceRenderingMode.SaveToFile,
    UseRelativePathToResources = true
};

msg.Save(Path.Combine("target_files"), htmlSaveOptions);

במקרה זה, המשאבים יישמרו בתיקייה [html file name]_files, באותו מסלול שבו קובץ .html, וה-HTML יפנה אל המשאבים דרך נתיבים יחסיים.

דוגמת הקוד שלהלן מציגה כיצד לשמור עם נתיב מוחלט למשאבים:

var msg = MapiMessage.Load(sourceFileName);

var htmlSaveOptions = new HtmlSaveOptions
{
    ResourceRenderingMode = ResourceRenderingMode.SaveToFile,
    UseRelativePathToResources = false
};

msg.Save(Path.Combine("target_files"), htmlSaveOptions);

כדוגמת הראשונה, המשאבים יישמרו בתיקייה [html file name]_files כברירת מחדל, אך ה-HTML יפנה אל המשאבים באמצעות נתיבים מוחלטים.

על ידי שימוש ב- ResourceHtmlRendering אירוע, אתה יכול להגדיר נתיבים מותאמים יחסיים או מוחלטים למשאבים. בעת התאמת נתיבים עם ה- ResourceHtmlRendering מטפל אירוע, ומכיוון ש- UseRelativePathToResources מוגדר ל-true, עליך להקצות נתיב יחסי ל- PathToResourceFile מאפיין כדי להבטיח הפנייה נכונה.

דוגמת הקוד שלהלן מציגה כיצד להגדיר נתיב יחסי מותאם אישית באמצעות אירוע ResourceHtmlRendering

var msg = MapiMessage.Load(sourceFileName);

var htmlSaveOptions = new HtmlSaveOptions
{
    ResourceRenderingMode = ResourceRenderingMode.SaveToFile,
    UseRelativePathToResources = true
};

htmlSaveOptions.ResourceHtmlRendering += (o, args) =>
{
    if (o is AttachmentBase attachment)
    {
	    // Since UseRelativePathToResources = true, you should assign a relative path to the PathToResourceFile property.
        args.PathToResourceFile = $@"images\{attachment.ContentType.Name}";
    }
};

msg.Save(Path.Combine(targetPath, "A Day in the Park.html"), htmlSaveOptions);

המרת MSG להודעות MIME

ממשק ה‑API של Aspose.Email מספק אפשרות להמרת קובצי MSG להודעות MIME באמצעות ה- ToMailMessage שיטה.

הגדרת זמני קצוב להמרת הודעות וטעינה

התכונות הבאות יאפשרו להגדיר את זמן הקצוב במילישניות לתהליך ההמרה והטעינה:

MailConversionOptions.Timeout property- מגביל את הזמן במילישניות בעת המרת הודעה.
MailConversionOptions.TimeoutReached - נזרק אם הזמן תם במהלך ההמרה ל‑MailMessage.
MsgLoadOptions.Timeout - מגביל את הזמן במילישניות בעת המרת הודעה.
MsgLoadOptions.TimeoutReached - נזרק אם הזמן תם במהלך ההמרה ל‑MailMessage.

דוגמת הקוד שלהלן תציג כיצד להגדיר זמן קצוב בעת המרת הודעה:

var options = new MailConversionOptions();
// Set the timeout to 5 seconds
options.Timeout = 5000;

options.TimeoutReached += (object sender, EventArgs args) =>
{
    string subj = (sender as MailMessage).Subject;
	 // Set a flag indicating the timeout was reached
    isTimedOut = true;
};

var mailMessage = mapiMessage.ToMailMessage(options);

המרת MSG ל-EML עם שימור גוף RTF

המרת קובץ MSG ל-EML תוך שימור גוף ה-RTF יכולה להתבצע בשתי דרכים:

באמצעות MsgLoadOptions.PreserveRtfContent מאפיין של MsgLoadOptions class;
באמצעות MailConversionOptions.PreserveRtfContent מאפיין של MailConversionOptions class;

שני המאפיינים משיגים או מגדירים ערך המציין האם לשמור את גוף ה-rtf ב-MailMessage.

קטעי הקוד הבאים מציגים כיצד להמיר קובץ MSG ל-EML ולשמר את גוף ה-RTF:

var loadOptions = new MsgLoadOptions
{
    PreserveRtfContent = true
};

var eml = MailMessage.Load("my.msg", loadOptions);

var conversionOptions = new MailConversionOptions
{
    PreserveRtfContent = true
};

var msg = MapiMessage.Load("my.msg");

var eml = msg.ToMailMessage(conversionOptions);

טיפול בקבצי תבנית Outlook (.OFT)

תבניות Outlook הן שימושיות מאוד כאשר ברצונך לשלוח הודעת דוא"ל דומה שוב ושוב. במקום להכין את ההודעה מאפס בכל פעם, ראשית הכין את ההודעה ב-Outlook ושמור אותה כתבנית Outlook (OFT). לאחר ذلك, בכל פעם שתצטרך לשלוח את ההודעה, תוכל ליצור אותה מהתבנית, וחוסך זמן בכתיבת הטקסט זהה בגוף או בנושא, קביעת עיצוב וכדומה. של Aspose.Email MailMessage class ניתן להשתמש כדי לטעון ולקרוא קובץ תבנית Outlook (OFT). ברגע שתבנית Outlook נטענת במופע של MailMessage class, תוכל לעדכן את השולח, הנמען, הגוף, הנושא ונתונים נוספים. לאחר עדכון המאפיינים:

שלח את האימייל באמצעות SmtpClient class או
שמור את ההודעה כ‑MSG ובצע עדכונים/אימות נוספים באמצעות Microsoft Outlook.

במקטעי הקוד שלהלן, אנו:

טען את התבנית באמצעות ה- MailMessage מחלקה.
עדכן חלק מהמאפיינים.
שמור את ההודעה בפורמט MSG.

קטע הקוד הבא מציג כיצד לטעון את קובץ ה-OFT, לעדכן את ההודעה ולשמור אותה בפורמט MSG.

שמירת קבצי MSG כתבניות

קטע הקוד הבא מראה כיצד לשמור את קובץ ה‑Outlook MSG כתבנית.

קביעת סוג הודעת MAPI (OFT או MSG)

בעת טעינת אובייקט MapiMessage מקובץ, ייתכן ותצטרך לקבוע האם ההודעה שהוטענה היא קובץ תבנית או קובץ אימייל רגיל. באמצעות IsTemplate מאפיין של MapiMessage המחלקה מאפשרת לך לזהות במדויק אם אימייל הוא תבנית או לא. פונקציונליות זו יכולה להיות יקרת ערך בטיפול ועיבוד של סוגי קבצי אימייל שונים בתוך יישומים ומערכות.

דוגמת הקוד למטה מדגימה כיצד לקבוע האם MapiMessage הוא OFT או MSG:

var msg = MapiMessage.Load("message.msg");
var isOft = msg.IsTemplate; // returns false

var msg = MapiMessage.Load("message.oft");
var isOft = msg.IsTemplate; // returns true

שמור MapiMessage או MailMessage בפורמט OFT

ה SaveOptions המחלקה מאפשרת לך לציין אפשרויות נוספות בעת שמירת MailMessage או MapiMessage בפורמט מסוים.

דוגמת הקוד הבאה מדגימה כיצד לשמור הודעה בפורמט OFT:

// Save the MailMessage to OFT format
using (var eml = MailMessage.Load("message.eml"))
{
    eml.Save("message.oft", SaveOptions.DefaultOft);
	
	// or alternative way #2
	var saveOptions = new MsgSaveOptions(MailMessageSaveType.OutlookTemplateFormat);
    eml.Save("message.oft", saveOptions);
	
	// or alternative  way #3
	saveOptions = SaveOptions.CreateSaveOptions(MailMessageSaveType.OutlookTemplateFormat);
    eml.Save("message.oft", saveOptions);

}

// Save the MapiMessage to OFT format
using (var msg = MapiMessage.Load("message.msg"))
{
    msg.Save("message.oft", SaveOptions.DefaultOft);
	
	// or alternative way #2
	var saveOptions = new MsgSaveOptions(MailMessageSaveType.OutlookTemplateFormat);
    msg.Save("message.oft", saveOptions);
	
	// or alternative  way #3
	saveOptions = SaveOptions.CreateSaveOptions(MailMessageSaveType.OutlookTemplateFormat);
    msg.Save("message.oft", saveOptions);
}

ניהול הודעות חתומות דיגיטלית

Aspose.Email מיישמת את האלגוריתם המלא של אובייקט דוא"ל S/MIME. זה מעניק ל-API יכולת מלאה לשמר חתימות דיגיטליות בעת המרת הודעות בין פורמטים.

שימור חתימה במהלך המרת EML ל-MSG

Aspose.Email שומרת על החתימה הדיגיטלית בעת המרה מ‑EML ל‑MSG. קטע הקוד הבא מראה כיצד לבצע המרה מ‑EML ל‑MSG.

המרת הודעות S/MIME מ‑MSG ל‑EML

Aspose.Email שומרת על החתימה הדיגיטלית בעת המרה מ‑MSG ל‑EML כפי שמוצג במקטע הקוד הבא.

בדיקת חתימות של אימיילים מאובטחים

המאפיינים הבאים זמינים לבדיקת החתימה של אובייקטי MapiMessage.

SecureEmailManager מחלקה לבדיקת החתימה של אימיילים מאובטחים.
SmimeResult מחלקה לאחסון תוצאות הבדיקה.
SecureEmailManager.CheckSignature(MapiMessage msg) שיטה.
SecureEmailManager.CheckSignature(MapiMessage msg, X509Certificate2 certificateForDecrypt) שיטה.
SecureEmailManager.CheckSignature(MapiMessage msg, X509Certificate2 certificateForDecrypt, X509Store store) שיטה.

דוגמת הקוד למטה מציגה כיצד ליישם את התכונות בפרויקט שלך:

var msg = MapiMessage.Load(fileName, new EmlLoadOptions());
var result = new SecureEmailManager().CheckSignature(msg);

var certFileName = "cert.pfx";
var cert = new X509Certificate2(certFileName, "pass");
var eml = MapiMessage.Load(fileName);
var store = new X509Store();
store.Open(OpenFlags.ReadWrite);
store.Add(cert);
store.Close();

var result = new SecureEmailManager().CheckSignature(eml, cert, store);

הסרת חתימות מ-MapiMessages

לשיפור התאימות, ה MapiMessage.RemoveSignature שיטה ו MapiMessage.IsSigned המאפיין משמש להסרת חתימה דיגיטלית מהודעה.

קוד הדוגמה הבא מראה כיצד ליישם תכונות אלו בפרויקט שלך:

var msg = MapiMessage.Load(fileName);

if (msg.IsSigned)
{
    var unsignedMsg = msg.RemoveSignature();
}

פענוח MapiMessages באמצעות תעודות

אם ברשותך הודעות MAPI מוצפנות ואתה צריך לפענח אותן באמצעות המפתח הפרטי השמור באישור, התכונות הבאות של Aspose.Email עשויות להיות מועילות:

MapiMessage.IsEncrypted - מקבל ערך המציין האם ההודעה מוצפנת.
MapiMessage.Decrypt() - מפענח הודעה זו (השיטה מחפשת בחנויות My של המשתמש והמחשב הנוכחי את האסימון והתעודה המתאימים).
MapiMessage.Decrypt(X509Certificate2 certificate) - מפענח הודעה זו עם תעודה.

קטוד המקטע הבא מראה כיצד לעבוד עם הודעות MAPI מוצפנות:

var privateCert = new X509Certificate2(privateCertFile, "password");
var msg = MapiMessage.Load("encrypted.msg");

if (msg.IsEncrypted);
{
    var decryptedMsg = msg.Decrypt(privateCert);
}

הגדרת קטגוריות צבע עבור קובצי MSG

קטגוריית צבע מסמנת הודעת דוא"ל לחשיבות או לקטגוריה מסוימת. Microsoft Outlook מאפשרת למשתמשים לשייך קטגוריות צבע כדי להבדיל בין הודעות. כדי לטפל בקטגוריית הצבע, השתמש ב- FollowUpManager. הוא מכיל פונקציות כגון AddCategory, RemoveCategory, ClearCategories ו GetCategories.

AddCategory מקבל MapiMessage והמחרוזת של קטגוריית הצבע, לדוגמה "קטגוריית סגול" או "קטגוריית אדום" כפרמטרים.
RemoveCategory מקבל MapiMessage והמחרוזת של קטגוריית הצבע שתוסר מההודעה.
ClearCategories משמש להסרת כל קטגוריות הצבע מההודעה.
GetCategories משמש לשחזור כל קטגוריות הצבע מהודעה מסוימת.

הדוגמה שלהלן מבצעת את המשימות כמפורט להלן:

הוסף קטגוריית צבע.
הוסף קטגוריית צבע נוספת.
קבל את רשימת כל הקטגוריות.
הסר את כל הקטגוריות.

גישה למידע מעקב בקובצי MSG

ממשק ה-API של Aspose.Email מספק אפשרות לגשת למידע המשך מהודעה שנשלחה או התקבלה. הוא יכול לשחזר מידע על קריאה, קבלת קבלה וקבלת תוצאות הצבעה מקובץ הודעה.

שחזור מידע על קבלה וקבלת קבלת קריאה

קטע הקוד הבא מראה כיצד לקבל מידע על קבלת קריאה וקבלת משלוח.

צור הודעות קידום ותגובה

ממשק ה-API של Aspose.Email מספק את היכולת ליצור ולעצב הודעות קידום והתגובה. ה ReplyMessageBuilder ו ForwardMessageBuilder מחלקות ה‑API משמשות ליצירת הודעות Reply ו‑Forward בהתאמה. ניתן לציין הודעת Reply או Forward שתיווצר באמצעות כל אחת מהשיטות של OriginalMessageAdditionMode enum. enum זה מכיל את הערכים הבאים:

OriginalMessageAdditionMode.None - ההודעה המקורית אינה נכללת בהודעת התגובה.
OriginalMessageAdditionMode.Attachment - ההודעה המקורית כלולה כקובץ מצורף בהודעת התגובה
OriginalMessageAdditionMode.Textpart - ההודעה המקורית נכללת כטקסט בגוף הודעת המענה

צור הודעות תגובה

קוד הדוגמה הבא מציג כיצד ליצור הודעת תגובה.

צור הודעות קידום

קוד הדוגמה הבא מראה כיצד ליצור הודעת Forward.

Net: שימוש ב‑Aspose Outlook Control לגרירה והשלכה של הודעות Outlook אל טפסי Windows Forms

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email תומכת בתכונת גרירה והשלכה של Microsoft Outlook. היא מאפשרת למפתחים ליצור בקלות אלמנטים בממשק משתמש אשר מגיבים לאירועי גרירה‑השלכה של Outlook. הדוגמה הבאה מציגה כיצד ליצור פאנל שבו משתמשים יכולים לגרור הודעה מ‑Outlook ולהשיל אותה, והתכנית שומרת את ההודעות לקבצי MSG. קטע הקוד הבא מראה כיצד להגדיר פקד Aspose Outlook שיכול לקבל הודעות Outlook שהושלכו.

צור יישום Windows Form.
הוסף הפנייה ל‑assembly של Aspose.Email.
דפדף ל‑Aspose.Email.dll ולחץ OK.

רכיב ה‑UI שנוצר בדוגמה זו הוא פאנל. ליצירת פאנל:

לחץ לחיצה ימנית על הפרויקט שלך בפאנל הפתרון ובחר Add ולאחר מכן New item מהתפריט.
צור מחלקה בשם MyPanel:
תן ל‑MyPanel להיות תת‑מחלקה של System.Windows.Form.Panel, והוסף למאפיין Aspose.Email.Windows.Forms.FileDropTargetManager ל‑MyPanel:

העתק (Override) את המתודות OnHandleCreated ו‑OnHandleDestroyed כדי לרשום את MyPanel באמצעות Aspose.Email.Windows.Forms.FileDropTargetManager:

בנה את הפרויקט.

MyPanel מוכן לשימוש. פאנל זה מקבל אירועי גרירה והשלכה מ‑Outlook.

פתח את לוח הכלים שלך וגרור את MyPanel אל טופס ה‑Windows שלך:

הוסף מנהל אירוע (event handler) לאירוע DragDrop של MyPanel. (אל תשכח להגדיר את המאפיין AllowDrop ל‑true מהפאנל של המאפיינים ולשנות את מאפיין BackColor של MyPanel לצבע המועדף עליך.)

הוסף את השורה הבאה במתודה InitializeComponent() של הטופס הראשי:

ממש את מנהל אירוע DragDrop כדי לשמור את ההודעות שנגררו מ‑Outlook לקבצי MSG.
המר (cast) את DragEventArgs ל‑Aspose.Email.Windows.Forms.FileDragEventArgs המכיל מאפיין מערך Files שמייצג את יעד הגרירה של המשתמש.

אם משתמש גרור כמה הודעות מ‑Outlook ומשיל אותן על MyPanel, Files.Count הוא מספר ההודעות, וה‑Files יחזור על כל הודעה.

הפעל את הפרויקט ובדוק אותו.

כעת ניתן לגרור הודעות מ‑Outlook ולהשיל אותן ליישום שלך. היישום יבקש ממך לשמור את ההודעות האלה לקבצי MSG.

Net: עבודה עם אפשרויות הצבעה ותגובות ב‑MSG

Mon, 01 Jan 0001 00:00:00 +0000

צור אפשרויות הצבעה עם MapiMessage

Microsoft Outlook מציע אפשרות ליצור סקר בעת כתיבת הודעת דוא"ל חדשה, מאפשרת למשתמשים לכלול אפשרויות הצבעה כגון כן, לא, אולי ועוד. Aspose.Email מאפשרת תכונה דומה בעת יצירת הודעת Outlook חדשה בתכנות. ה FollowUpOptions class מספקת את VotingButtons מאפיין שניתן להשתמש בו להגדיר או לקבל את אפשרויות ההצבעה. MapiMessage מתייחסת למחלקה במרחב השמות Aspose.Email שמייצגת הודעת דוא"ל בפורמט Messaging Application Programming Interface (MAPI) השמש נפוץ ב-Microsoft Outlook. בעזרת המחלקה MapiMessage, מפתחים יכולים להוסיף כפתורי הצבעה להודעת דוא"ל. מאמר זה מספק דוגמה מפורטת כיצד ליצור MapiMessage עם אפשרויות הצבעה ליצירת סקר.

צור סקרים

קטע הקוד הבא מציג כיצד ליצור סקר בהודעת Outlook באמצעות Aspose.Email. ה FollowUpManager המחלקה מאפשרת הגדרת אפשרויות ההצבעה.

// Create a MapiMessage with the sender, recipient, subject, and body
var msg = new MapiMessage(
    "from@test.com",
    "to@test.com",
    "Flagged message",
    "Make it nice and short, but descriptive. The description may appear in search engines' search results pages..."
);

// Create FollowUpOptions and set the voting buttons
var options = new FollowUpOptions
{
    VotingButtons = "Yes;No;Maybe;Exactly!"
};

// Apply the follow-up options to the message
FollowUpManager.SetOptions(msg, options);

FollowUpOptions: מספקת מאפיינים להגדרת פעולות מעקב כגון כפתורי הצבעה.
VotingButtons: מאפיין מחרוזת שבו אפשרויות הצבעה שונות מופרדות בנקודות-פסיק.
FollowUpManager.SetOptions: מיישמת את אפשרויות המעקב שצוינו על ההודעה.

קריאת אפשרויות הצבעה

כדי לאחזר אפשרויות הצבעה מ‑ MapiMessage, ניתן להשתמש ב‑ GetOptions מתודה. מתודה זו לא רק מאחזרת את כפתורי ההצבעה אלא יכולה גם לספק פרמטרים נוספים כגון קטגוריות במידת הצורך.

// Retrieve follow-up options from the message
var options = FollowUpManager.GetOptions(msg);

// Voting buttons are returned as a string with a semicolon separator
string votingButtons = options.VotingButtons;

// Display the voting buttons
Console.WriteLine($"Voting Options: {votingButtons}");

GetOptions: מאחזר את FollowUpOptions אובייקט מההודעה, הכולל את כפתורי ההצבעה ואפשרויות נוספות.
VotingButtons: האפשרויות מופקות כמחרוזת מופרדת בנקודות-פסיק, מה שמאפשר הצגה או מניפולציה קלה.

קריאת כפתורי הצבעה

אם אתם זקוקים לגישה רק לכפתורי הצבעה כרשימה של מחרוזות נפרדות, ניתן להשתמש ב‑ GetVotingButtons מתודה המשיבה אותם כאוסף.

// Read only voting buttons as a collection of string values
var votingButtons = FollowUpManager.GetVotingButtons(msg);

// Display each voting button
foreach (var button in votingButtons)
{
    Console.WriteLine($"Voting Button: {button}");
}

GetVotingButtons: מחזיר אוסף של מחרוזות של כפתורי הצבעה, מה שמקל על חזרת לולאה עליהם וביצוע פעולות כגון הצגה או שינוי.

הוספת כפתורי הצבעה

אתם יכולים להוסיף כפתורי הצבעה נוספים להודעה קיימת באמצעות AddVotingButton מתודה. זה יכול להיות שימושי לעדכון דינמי של אפשרויות ההצבעה.

// Add a new voting button to the existing message
FollowUpManager.AddVotingButton(msg, "Indeed!");

AddVotingButton: מוסיף אפשרות הצבעה חדשה לכפתורי ההצבעה הקיימים של ההודעה, מאפשר התאמה דינמית של סקרים.

מחיקת כפתורי הצבעה

הייתם אולי רוצים להסיר כפתורי הצבעה ספציפיים או לנקות את כל הכפתורים מהודעה. הקוד הבא מדגים את שני הפעולות באמצעות RemoveVotingButton ו ClearVotingButtons שיטות.

// Delete a specific voting button
FollowUpManager.RemoveVotingButton(msg, "Exactly!");

// Or delete all voting buttons from the MapiMessage
FollowUpManager.ClearVotingButtons(msg);

RemoveVotingButton: מוחק כפתור הצבעה ספציפי לפי שם.
ClearVotingButtons: מסיר את כל כפתורי ההצבעה, ובכך מאפס את אפשרויות ההצבעה.

קריאת תוצאות הצבעה

Aspose.Email גם מאפשרת קריאת תוצאות הצבעה מנמעני הודעה. ניתן לגשת למאפיינים כגון תגובת הנמען וזמן התגובה.

// Load a MapiMessage from a file
var msg = MapiMessage.Load("sample.msg");

// Iterate through each recipient and display their vote information
foreach (var recipient in msg.Recipients)
{
    Console.WriteLine($"Recipient: {recipient.DisplayName}");

    // Get the recipient's response using the appropriate MapiPropertyTag
    var response = recipient.Properties[MapiPropertyTag.PR_RECIPIENT_AUTORESPONSE_PROP_RESPONSE].GetString();
    Console.WriteLine($"Response: {response}");

    // Get the response time
    var responseTime = recipient.Properties[MapiPropertyTag.PR_RECIPIENT_TRACKSTATUS_TIME].GetDateTime();
    Console.WriteLine($"Response time: {responseTime}\n");
}

MapiRecipient: מייצג נמען ב‑MapiMessage, ומאפשר גישה לנתוני תגובה אישיים.
*PR_RECIPIENT_AUTORESPONSE_PROP_RESPONSE: תגית מאפיין האוחזת בתשובת ההצבעה של הנמען.
PR_RECIPIENT_TRACKSTATUS_TIME: תגית מאפיין המתעדת את הזמן שבו הנמען הגיב.

קבלת מידע תגובה מ‑MSG

ה GetReactions שיטה של FollowUpManager המחלקה מאפשרת לך לאסוף רשימת תגובות על הודעת MAPI, מה שמקל על ניתוח מעורבות המשתמשים. קוד המקטע הבא מדגים כיצד לאסוף תגובות זמינות עבור הודעה ספציפית, ומספק תובנות על אינטראקציות המשתמש.

// Load the message file
var msg = MapiMessage.Load(fileName);

// Retrieve the list of reactions on the message
var reactions = FollowUpManager.GetReactions(msg);

// Iterate through each reaction and output the details to the console
foreach (var reaction in reactions)
{
    Console.WriteLine($"User: {reaction.Name}, Email: {reaction.Email}, Reaction: {reaction.Type}, Date: {reaction.ReactionDateTime}");
}

Net: ניהול דגלי המשך ותאריכי יעד עבור קבצי Outlook MSG

Mon, 01 Jan 0001 00:00:00 +0000

הגדרת דגלי המשך ותאריכי יעד עבור קבצי MSG

דגל המשך מסמן הודעת דואר אלקטרוני לפעולה מסוימת. Microsoft Outlook מאפשר למשתמשים לסמן הודעות בעזרת דגל, ובתצורת הדגל, להקצות תאריך יעד להמשך. Outlook שולח תזכורת לנמען כדי לעודד אותו לבצע את הפעולה. סימון הודעות והגדרת תאריכי יעד בתכנות מאפשר למפתחים לאוטומט סוגים מסוימים של הודעות ולעזור לנמענים לזכור לבצע פעולה. לדוגמה, אפשר להשתמש בזה כדי לשלוח הודעות חודשיות לצוות מכירות להזכיר להם להשלים דוחות; או לשלוח הודעה לכל העובדים להזכיר פגישה בחברה. Aspose.Email עבור .NET תומך בהגדרת דגל המשך ותאריך יעד עבור MapiMessage אובייקטים באמצעות FollowUpManager ו FollowUpOptions. ישנן מספר צורות שבהן ניתן להגדיר דגל המשך על הודעה. כולם משמשים בדוגמת הקוד שלהלן:

הגדר דגל מעקב להודעה
הוסף תאריך יעד ותאריך תזכורת להודעה
הוסף דגל להודעה של הנמען.
סמן כהושלם.
הסר דגל.
קרא אפשרויות תזכורת.

הגדרת דגלי המשך

קטטע הקוד הבא מראה לך כיצד להגדיר דגל תזכורת.

הגדרת המשך לנמענים

קטטע הקוד הבא מראה לך כיצד להגדיר תזכורת למקבלים.

סימון דגלי המשך כהושלמו

קטטע הקוד הבא מראה לך כיצד לסמן את דגל התזכורת כהושלם.

הסרת דגלי המשך

קטטע הקוד הבא מראה לך כיצד להסיר את דגל התזכורת.

קריאת אפשרויות דגל מעקב

קטטע הקוד הבא מראה לך כיצד לקרוא אפשרויות של דגל תזכורת עבור הודעה.

Net: עבודה עם מאפייני MAPI

Mon, 01 Jan 0001 00:00:00 +0000

גישה והגדרת מאפיין MAPI של Outlook

ה MapiProperty מחלקה המייצגת תכונת MAPI, הכוללת:

שם: מחרוזת שמייצגת את תכונת השם.
תג: ערך מסוג long שמייצג את תכונת התג.
נתונים: מערך בתים שמייצג את תכונת הנתונים.

קבל תכונות MAPI באמצעות תגי תכונה

כדי לקבל מאפייני MAPI:

צור מופע של MapiMessage בידי טעינה מקבצים או זרם.
קבל את MapiProperty מתוך MapiMessage.Properties בידי MapiPropertyTag מפתחות.

קטע הקוד הבא מראה כיצד לקבל מאפיין MAPI באמצעות תג מאפיין MAPI.

הגדרת תכונות MAPI

קטע הקוד הבא מראה לך כיצד להגדיר תכונות MAPI.

כאשר ההגדרה של המתודה convertDateTime היא כדלקמן:

תכונות נוספות

קוד הדוגמה הבא מציג כיצד להגדיר תכונות MAPI נוספות.

קריאת מאפייני MAPI בשם מקבצי MSG

קוד הדוגמה הבא מציג כיצד לקרוא תכונות MAPI בשם מהקובץ MSG.

קריאת מאפייני MAPI בשם מקבצים מצורפים

Aspose.Email גם מאפשרת לעבור דרך תכונות של MapiAttachment ולחפש תכונה בשם, בצורה דומה לדוגמה שלמעלה, עבור MapiMessage. קוד הדוגמה הבא מציג כיצד לחפש תכונה בשם דרך אוסף תכונות הקבצים המצורפים.

הסרת מאפיינים מ‑MSGs וקבצים מצורפים

קוד הדוגמה הבא מציג כיצד להסיר תכונות מ-MSGs וקבצים מצורפים.

Net: ניהול קבצים מצורפים להודעה

Mon, 01 Jan 0001 00:00:00 +0000

ניהול קבצים מצורפים ב‑Outlook

יצירת ושמירת קבצי הודעות Outlook (MSG) מסביר כיצד ליצור ולשמור הודעות, וכיצד ליצור קבצי MSG עם קבצים מצורפים. מאמר זה מסביר כיצד לנהל קבצים מצורפים של Microsoft Outlook עם Aspose.Email. קבצים מצורפים מקובץ הודעה ניגשים אליהם ונשמרים לכונן באמצעות ה‑ MapiMessage מחלקה קבצים מצורפים המאפיין. ה- קבצים מצורפים המאפיין הוא אוסף מסוג MapiAttachmentCollection מחלקה.

בדיקת סוג קובץ מצורף (משולב או רגיל)

קבצים מצורפים משולבים וקבצים מצורפים רגילים משמשים למטרות שונות. קבצים מצורפים משולבים משולבים חזותית בתוך הודעת האימייל והם בדרך כלל תמונות או קבצי מדיה. לעומת זאת, קבצים מצורפים רגילים הם קבצים נפרדים המצורפים להודעה ויכולים לכלול סוגים שונים של קבצים. The MapiAttachment.IsInline מאפיין של MapiAttachment מחלקה מקבלת ערך המציין האם הקובץ המצורף הוא מוטמע או רגיל.

קוד המקטע הבא מחלץ ומציג מידע על כל קובץ מצורף ב‑MapiMessage הטעון, כולל שמות התצוגה שלהם והאם הם קבצים מצורפים משולבים בטקסט או לא.

var message = MapiMessage.Load(fileName);

foreach (var attach in message.Attachments)
{
    Console.WriteLine($"{attach.DisplayName0} : {attach.IsInline)}");
}

בדיקת סוג קובץ מצורף (IsReference)

ה MapiAttachment מחלקה כוללת את IsReference מאפיון המאפשר למפתחים לזהות קבצים מצורפים רפרנסיים בהודעה. עם דוגמת הקוד הבאה, ניתן לבדוק אם קובץ מצורף הוא קובץ רפרנסי:

foreach (var attachment in msg.Attachments)
{
    if (attachment.IsReference)
    {
        // Process reference attachment
    }
}

שמירת קבצים מצורפים מקבצי MSG

כדי לשמור קבצים מצורפים מקובץ MSG:

איטרציה דרך ה- MapiAttachmentCollection אוסף וקבלו את הקבצים המצורפים האישיים.
כדי לשמור את הקבצים המצורפים, קרא למתודה Save() של מחלקת MapiAttachment.

קוד המקטע הבא מראה כיצד לשמור קבצים מצורפים לכונן המקומי.

חלץ קבצים מצורפים מקבצי MSG בפורמט RTF

להודעות המוּפַּרְמָטוֹת כ‑RTF, ניתן להשתמש בקוד הבא כדי להבדיל ולחלץ קבצים מצורפים שהם משולבים או מופיעים כאיקון בגוף ההודעה. קוד המקטע הבא מראה כיצד לזהות ולחלץ קובץ מצורף משובץ מקובץ MSG בפורמט RTF.


var eml = MapiMessage.Load("MSG file with RTF Formatting.msg");

foreach (var attachment in eml.Attachments)
{
    if (IsAttachmentInline(attachment))
    {
        try
        {
            SaveAttachment(attachment, Data.Out/new Guid().ToString());
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

static bool IsAttachmentInline(MapiAttachment attachment)
{
    foreach (var property in attachment.ObjectData.Properties.Values)
    {
        if (property.Name == "\x0003ObjInfo")
        {
            var odtPersist1 = BitConverter.ToUInt16(property.Data, 0);
            return (odtPersist1 & (1 << (7 - 1))) == 0;
        }
    }
    return false;
}

static void SaveAttachment(MapiAttachment attachment, string fileName)
{
    foreach (var property in attachment.ObjectData.Properties.Values)
    {
        if (property.Name == "Package")
        {
            using var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
            fs.Write(property.Data, 0, property.Data.Length);
        }
    }
}

קבלת קבצים מצורפים של הודעות דוא"ל משובצים

קבצים מצורפים משובצים מסוג OLE מופיעים גם ב‑ MapiMessage מחלקת אוסף Attachment. דוגמת הקוד הבאה מפענחת קובץ הודעה עבור קבצים מצורפים משובצים ושומרת אותו לכונן. The MapiMessage המחלקה FromProperties() מתודה סטטית שמאפשרת ליצור הודעה חדשה מקובץ מצורף משובץ. קוד המקטע הבא מראה כיצד לקבל קבצים מצורפים של הודעות דוא"ל משובצים.

הסרת קבצים מצורפים

ספריית Aspose Outlook מספקת פונקציונליות להסרת קבצים מצורפים מקבצי Microsoft Outlook Message (.msg):

קרא למתודה RemoveAttachments(). היא מקבלת את נתיב קובץ ההודעה כפרמטר. היא ממומשת כמתודה סטטית ציבורית, ולכן אין צורך ליצור מופע של האובייקט.

קטע הקוד הבא מראה כיצד להסיר קבצים מצורפים.

אתם יכולים גם לקרוא ל‑ MapiMessage מתודה סטטית של מחלקה DestroyAttachment(). הוא פועל מהר יותר מ‑RemoveAttachment(), מכיוון שמתודת RemoveAttachment() מפענחת את קובץ ההודעה.

הוספת קבצים מצורפים מסוג MSG

הודעת Outlook יכולה להכיל הודעות Microsoft Outlook אחרות בקבצים מצורפים, כאשר הן רגילות או משובצות. The MapiAttachmentCollection מספק חברים מוטענים של המתודה Add ליצירת הודעות Outlook עם שני סוגי הקבצים המצורפים.

נסו זאת!

הוספה או הסרה של קבצים מצורפים של דוא"ל באמצעות החינמי Aspose.Email Editor App.

הוספת קבצים מצורפים רפרנסיים ל‑MapiMessages

ה ReferenceAttachmentOptions המחלקה מפשטת הוספת קבצים מצורפים רפרנסיים על ידי אריזה של כל המאפיינים הדרושים באובייקט יחיד.

פרמטרים של ReferenceAttachmentOptions:

sharedLink: קישור משותף מלא לקובץ המצורף שמסופק על ידי שירות האינטרנט המאחסן את הקובץ.
url: מיקום הקובץ או כתובת ה‑URL של המשאב.
providerName: שם ספק הקובץ המצורף הרפרנס (למשל, Google Drive, Dropbox).
דוגמה: הוספת קובץ מצורף רפרנס עם ReferenceAttachmentOptions

var options = new ReferenceAttachmentOptions(
    "https://drive.google.com/file/d/1HJ-M3F2qq1oRrTZ2GZhUdErJNy2CT3DF/",
    "https://drive.google.com/drive/my-drive",
    "GoogleDrive");

// Add reference attachment
msg.Attachments.Add("Document.pdf", options);

שבירת הודעות כמקבצים מצורפים

קוד המקטע הבא מראה כיצד לשלב קובץ MSG כקובץ מצורף להודעה.

קריאת הודעות משובצות מקבצים מצורפים

קטע הקוד הבא מציג כיצד לקרוא הודעות משובצות מקבצים מצורפים.

הוספה והחלפת קובץ מצורף

Aspose.Email API מספקת אפשרות להכניס קבצים מצורפים במיקום אינדקס ספציפי בהודעה האב. היא גם מספקת אפשרות להחליף את תוכן הקובץ המצורף בקובץ מצורף הודעה אחר.

נסו זאת!

הפעל את ה‑ ReplaceAttach פרויקט אפליקציה פשוט, ולנסות את יכולות Aspose.Email להחלפת קבצים מצורפים בפעולה.

הוספת קבצים מצורפים במקומות ספציפיים

ממשק Aspose.Email API מספק אפשרות להכניס קובץ מצורף MSG ל‑MSG הורה באמצעות מתודת Insert של MapiAttachmentCollection – MapiAttachmentCollection Insert(int index, string name, MapiMessage msg). קוד המקטע הבא מראה כיצד להכניס קובץ מצורף במקום ספציפי.

החלפת תוכן קובץ מצורף

אפשר להשתמש בזה כדי להחליף את תוכן הקובץ המצורף המשובץ בתוכן חדש באמצעות המתודה Replace. עם זאת, לא ניתן להשתמש בו כדי להוסיף קובץ מצורף עם PR_ATTACH_NUM = 4 (לדוגמה) לאוסף שבו collection.Count = 2. קטע הקוד הבא מראה כיצד להחליף את תוכן הקובץ המצורף.

שינוי שם קבצים מצורפים ב‑MapiMessage

ניתן לערוך את ערך המאפיין DisplayName בקבצים מצורפים של MapiMessage.

var msg = MapiMessage.Load(fileName);
msg.Attachments[0].DisplayName = "New display name 1";
msg.Attachments[1].DisplayName = "New display name 2";

שמירת קבצים מצורפים מהודעות חתומות דיגיטלית

Aspose.Email API מספקת אפשרות לקבל או להגדיר ערך המציין האם הודעה חותמת (clear‑signed) תפוענח.

Net: ניהול אנשי קשר של Outlook

Mon, 01 Jan 0001 00:00:00 +0000

כמו MapiMessage, Aspose.Email מאפשרת ליצור אנשי קשר של Outlook. ה‑ MapiContact מחלקה זו מספקת את כל המאפיינים הקשורים לאיש קשר הדרושים ליצירת איש קשר של Outlook. מאמר זה מציג כיצד ליצור, לשמור ולקרא איש קשר של Outlook באמצעות MapiContact מחלקה.

יצירת ושמירת איש קשר של Outlook

כדי ליצור איש קשר ולשמור אותו בכונן:

צור מופע חדש של ה‑ MapiContact מחלקה.
הזן מידע על מאפייני האיש קשר.
הוסף נתוני תמונה (אם קיימים).
שמור את האיש קשר בפורמט MSG או VCard.

קטע הקוד הבא מראה כיצד ליצור ולשמור איש קשר של Outlook.

שמר רשימות הפצה MAPI לקבצי VCF

דוגמת הקוד שלהלן מציגה כיצד לשמור רשימת הפצה לקובץ VCF מרובה אנשי קשר:

// convert the `msg` object to a `MapiMessage` object
var dlist = (MapiDistributionList)msg.ToMapiMessageItem();

//save the distribution list
var options = new MapiDistributionListSaveOptions(ContactSaveFormat.VCard);
dlist.Save("distribution_list.vcf", options);

המר קבצי VCF מרובי אנשי קשר ל‑MapiDistributionList

Aspose.Email תומכת בהמרת קבצי VCF מרובי אנשי קשר ל‑ MapiDistributionList אובייקטים, מה שמקל על ניהול וייבוא של מספר אנשי קשר ישירות ליישומים שלך. תכונה זו נגישה דרך המתודות הסטטיות הבאות ב‑ MapiDistributionList מחלקה:

דוגמת הקוד שלהלן מציגה כיצד להשתמש בתכונה זו:

// Convert a multi-contact VCF file to a MapiDistributionList
MapiDistributionList dlist = MapiDistributionList.FromVCF(fileName);

שמירת אנשי קשר בתבנית VCF

כדי לשמור את איש הקשר בפורמט VCF גרסה 3, השתמש ב‑ VCardVersion אוסף להגדיר את ה‑ VCardSaveOptions.Version תכונה. קוד הדוגמה שלהלן מדגים את השימוש ב‑ VCardVersion רשימה (enumerable) לשמירת איש הקשר בפורמט VCF גרסה 3:

var options = new MapiDistributionListSaveOptions(ContactSaveFormat.VCard);
options.Version = VCardVersion.V30;
dlist.Save("distribution_list.vcf", options);

קריאת אנשי קשר MAPI

ה MapiContact מחלקה זו ניתנת לשימוש לטעון אנשי קשר הן בפורמט Outlook MSG והן בפורמט VCard. קטע הקוד הבא מציג כיצד לטעון אנשי קשר של Outlook שנשמרו כ‑MSG ו‑VCF אל MapiContact.

טען אנשי קשר מקבצי MSG

קטע קוד זה מציג כיצד לטעון אנשי קשר מ‑MSG.

טען אנשי קשר מ‑VCards

קטע קוד זה מציג כיצד לטעון אנשי קשר מ‑VCard.

טען אנשי קשר MAPI מ‑vCard עם אפשרויות מותאמות

כדי לספק גמישות רבה יותר בעת המרת קבצי vCard (.vcf) לאנשי קשר MAPI, Aspose.Email עבור .NET מספקת העמסת מתודה MapiContact.FromVCard(string filePath, VCardLoadOptions options) מתודה המקבלת VCardLoadOptions אובייקט. הוא מציע שליטה משופרת באופן שבו קבצי vCard מתפרשים - במיוחד כשעובדים עם פורמטים שונים של vCard, קידודים, או תרחישי ניתוח מתקדמים.

דוגמת הקוד הבאה מציגה כיצד לטעון קובץ איש קשר .vcf אל MapiContact אובייקט באמצעות העמסת המתודה שמקבלת VCardLoadOptions. האיש קשר שהועלה ניתן להמשך שימוש בקבצי PST, ייצוא MSG, או פורמטים אחרים תואמי Outlook.

var mapiContact = MapiContact.FromVCard("contact.vcf", new VCardLoadOptions());
Console.WriteLine(mapiContact.NameInfo.DisplayName);

טען אנשי קשר מ‑VCards עם קידוד מוגדר

קטע קוד זה מציג כיצד לטעון אנשי קשר מ‑VCard עם הקידוד המוגדר.

שמור פריטי איש קשר VCard עם קידוד מוגדר

התאם את התנהגות השמירה בעת עבודה עם קבצי VCard באמצעות VCardSaveOptions מחלקה. ה- PreferredTextEncoding מאפיין של המחלקה יציין את הקידוד שישמש בעת שמירת פריטי איש קשר VCard.

דוגמת הקוד שלהלן מראה כיצד ליישם מאפיין זה בפרויקט שלך:

var cont = VCardContact.Load(fileName, Encoding.UTF8);
var opt = new VCardSaveOptions();
opt.PreferredTextEncoding = Encoding.UTF8;
cont.Save("my.vcard", opt);

שמור קבצי VCard עם שדות מורחבים

ה UseExtensions מאפיין זה מאפשר לך לשלוט אם ניתן להשתמש בשדות מורחבים בעת שמירת קבצי VCard. כאשר מוגדר ל‑true (ברירת מחדל), הרחבות מותרות, מה שמספק תאימות לשדות מותאמים ומידע נוסף על איש הקשר.

קריאת מספר אנשי קשר בפורמט VCard

הספרייה שלנו מאפשרת לקבל את רשימת כל אנשי הקשר מתוך VCard. ניתן לעשות זאת באמצעות המתודות והצעדים הבאים:

// Checks whether VCard source stream contains multiple contacts.
VCardContact.IsMultiContacts(Stream stream)

// Loads list of all contacts from VCard file.
VCardContact.LoadAsMultiple(string filePath, Encoding encoding)

// Loads list of all contacts from VCard stream.
VCardContact.LoadAsMultiple(Stream stream, Encoding encoding)

קטע קוד זה מציג כיצד להתמודד עם קבצי VCard המכילים מספר אנשי קשר:

using (FileStream stream = new FileStream("test.vcf", FileMode.Open, FileAccess.Read))
{
    if(VCardContact.IsMultiContacts(stream))
    {
        List<VCardContact> contacts = VCardContact.LoadAsMultiple(stream, Encoding.UTF8);
    }
}

טען אנשי קשר vCard אסינכרונית

ה VCardContact מחלקה ב‑Aspose.Email עבור .NET תומכת בטעינה אסינכרונית של קבצי vCard. זה מאפשר ליישומים לקרוא ביעילות איש קשר בודד או מספר אנשי קשר מקבצי .vcf או זרמים מבלי לחסום את תהליך הראשי - אידיאלי ליישומי דסקטופ, ווב או מובייל מודרניים העוסקים ברשימות אנשי קשר גדולות. המתודות הבאות של מחלקה זו יכולות לבצע את המשימה:

LoadAsync
LoadAsMultipleAsync

דוגמת הקוד הבאה מציגה כיצד לטעון אסינכרונית מספר אנשי קשר vCard מקובץ .vcf באמצעות VCardContact.LoadAsMultipleAsync. אנשי הקשר שהוטענו מעובדים בלולאה, ומדפיסים את שם התצוגה של כל איש קשר לקונסול. הגישה האסינכרונית מבטיחה שהיישום נשאר מגיב, אפילו בעת קריאת קבצים גדולים.

var contacts = await VCardContact.LoadAsMultipleAsync("contacts.vcf", new VCardLoadOptions(), CancellationToken.None);

foreach (var contact in contacts)
{
    Console.WriteLine(contact.IdentificationInfo.DisplayName);
}

הצגת מידע איש קשר ל‑MHTML

איש קשר של Outlook ניתן להמרה ל‑MHTML באמצעות Aspose.Email API. דוגמה זו מציגה כיצד VCard נטען לתוך MapiContact ואז מומר ל‑MHTML בעזרת MailMessage API.

//Load VCF Contact and convert to MailMessage for rendering to MHTML
var contact = MapiContact.FromVCard("Contact.vcf");

MemoryStream ms = new MemoryStream();
contact.Save(ms, ContactSaveFormat.Msg);
ms.Position = 0;
MapiMessage msg = MapiMessage.Load(ms, new MsgLoadOptions());
MailConversionOptions op = new MailConversionOptions();
MailMessage eml = msg.ToMailMessage(op);

//Prepare the MHT format options
MhtSaveOptions mhtSaveOptions = new MhtSaveOptions();
mhtSaveOptions.CheckBodyContentEncoding = true;
mhtSaveOptions.PreserveOriginalBoundaries = true;
MhtFormatOptions formatOp = MhtFormatOptions.WriteHeader | MhtFormatOptions.RenderVCardInfo;
mhtSaveOptions.RenderedContactFields = ContactFieldsSet.NameInfo | ContactFieldsSet.PersonalInfo | ContactFieldsSet.Telephones | ContactFieldsSet.Events;
mhtSaveOptions.MhtFormatOptions = formatOp;
eml.Save("ContactMhtml_out.mhtml", mhtSaveOptions);

Net: עבודה עם רשימות הפצה

Mon, 01 Jan 0001 00:00:00 +0000

אפשר ליצור רשימת הפצה באמצעות Aspose.Email API שהיא אוסף של מספר אנשי קשר. ניתן לשמור רשימת הפצה לכונן בפורמט Outlook MSG ולצפות/לטפל בה על ידי פתיחתה ב‑MS Outlook.

צור ושמור רשימות הפצה

הקטע הקוד הבא מראה כיצד ליצור ולשמור רשימת הפצה.

קרא רשימות הפצה מקובצי PST

הקטע הקוד הבא מראה כיצד לקרוא רשימת הפצה מקובץ PST.

Net: צור, שמור וקרא משימות של Outlook

Mon, 01 Jan 0001 00:00:00 +0000

צור משימות Outlook

Aspose.Email ל-.NET מאפשרת ליצור משימות Outlook ולשמור אותן בפורמט MSG. ה MapiTask המחלקה מספקת מספר מאפיינים כגון PercentComplete, EstimatedEffort, ActualEffort, History, LastUpdate, ואחרים, כדי להתאים ולהגדיר מידע נדרש עבור משימת Outlook. מאמר זה מציג כיצד ליצור, לשמור ולקרוא MapiTask מהדיסק. כדי ליצור ולשמור משימה לכונן:

צור מופע חדש של ה‑ MapiTask מחלקה.
הכנס מידע על תכונת המשימה.
שמור את המשימה בכונן בפורמט MSG.

קטע הקוד הבא מראה כיצד ליצור, לשמור ולקרוא משימות.

קרא משימות MAPI

משימות שנשמרו בפורמט MSG יכולות להיטען ל- MapiMessage ולאחר מכן מומר ל- MapiTask עם גישה לתכונות הספציפיות שלהם, כגון הנושא והסטטוס. דוגמת הקוד הבאה מדגימה כיצד לקרוא ולשנות פרטי משימה מקבצי MSG שנשמרו:

קרא משימות VToDo

משימות Outlook שמיוצאות בפורמט iCalendar כאירועי VToDo ניתן לטעון באמצעות MapiTask מחלקה כפי שמוצג בדוגמת הקוד הבאה. קוד הדוגמה הבא מציג כיצד לקרוא משימת VToDo.

הוסף מידע תזכורת למשימות MAPI

בדומה ל-Microsoft Outlook, Aspose.Email יכול להוסיף מידע תזכורת ל- MapiTask. הקטע הקוד הבא מראה כיצד להוסיף מידע תזכורת ל- MapiTask.

הוסף קבצים מצורפים למשימות MAPI

הקטע הקוד הבא מראה כיצד להוסיף קבצים מצורפים ל- MapiTask.

הוסף חזרתיות למשימות MAPI

Aspose.Email מאפשרת ליצור משימה חוזרת שבה החזרתיות יכולה להיות יומית, שבועית, חודשית או שנתית. קוד הדוגמה הבא מציג כיצד ליצור משימה עם סוגי חזרתיות שונים.

המר משימות ל-MHT

Aspose.Email יכול ליצור MailMessage כמו פלט במהלך ההמרה של MapiTask ל-MHT.

המרת MSG ל-HTML תוך שמירת שדות משימה

ה HtmlFormatOptions.RenderTaskFields הEnum מאפשר לך לציין כי שדות המשימה צריכים לכלול בכותרת של קובץ HTML הנשמר. קוד הדוגמה הבא מראה כיצד לשמר שדות משימה בכותרת בעת שמירת קובץ html:

var msg = MapiMessage.Load("task.msg");
HtmlSaveOptions opt = SaveOptions.DefaultHtml;
opt.HtmlFormatOptions = HtmlFormatOptions.WriteHeader | HtmlFormatOptions.RenderTaskFields;
msg.Save("task.html", opt);

Net: ניהול פריטי לוח השנה של Outlook

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email MapiCalendar המחלקה מספקת שיטות ותכונות להגדרת מאפיינים שונים של פריט לוח שנה. קטע זה מספק דוגמות קוד עבור:

יצירת ושמירת פריטי לוח השנה

קטע הקוד הבא מציג איך ליצור ולשמור פריט יומן בפורמט ICS.

שמירת פריטי לוח שנה כקבצי MSG

קטע הקוד הבא מציג איך לשמור את פריט היומן כ‑MSG.

שמירת מזהי מוצר לפריטי לוח שנה של MAPI ל-ICS

ה ProductIdentifier מאפיין של MapiCalendarIcsSaveOptions המחלקה משמשת לשמירת פריט יומן MAPI לקובץ iCalendar (ICS) תוך שמירת מידע התאריך והשעה המקורי וכן מזהה מוצר מותאם. המאפיין מציין את המזהה למוצר שיצר את אובייקט iCalendar.

דוגמת הקוד הבאה מראה איך לעבוד עם נתוני iCalendar (ICS) בתוך אובייקט יומן MAPI:

var icsSaveOptions = new MapiCalendarIcsSaveOptions
{
    KeepOriginalDateTimeStamp = true,
    ProductIdentifier = "Foo Ltd"
};

mapiCalendar.Save("my.ics", icsSaveOptions);

קבלת מספר כולל של אירועים

מחלקת CalendarReader מאפשרת טיפול באירועי לוח שנה בקלות. המאפיינים והמתודה הבאים מאפשרים לך לעבוד עם אירועים מרובים:

CalendarReader.Count - המאפיין Count של המחלקה CalendarReader מאפשר לקבל את מספר רכיבי Vevent (אירועים) הנוכחים בלוח השנה, מה שמקל על מעקב אחרי מספר האירועים הכולל.
CalendarReader.IsMultiEvents - מאפיין זה קובע אם הלוח שנה מכיל מספר אירועים. הוא מחזיר ערך בוליאני המציין האם יש יותר מאירוע אחת, ועוזר בזיהוי לוחות שנה עם אירוע יחיד או מרובים.
CalendarReader.Method - המאפיין Method מקבל את סוג שיטת ה-iCalendar המקושרת לאובייקט הלוח שנה. הוא מחזיר את סוג השיטה, כגון “REQUEST”, “PUBLISH”, או “CANCEL”, ומספק תובנות חשובות לגבי מטרת הלוח שנה.
CalendarReader.Version - מקבל את גרסת ה-iCalendar.
CalendarReader.LoadAsMultiple() שיטה זו מאפשרת טעינת רשימת אירועים מלוח שנה המכיל מספר אירועים. היא מחזירה רשימת אובייקטים מסוג Appointment, המאפשרת גישה קלה ועיבוד של כל אירוע בנפרד.

דוגמת קוד זו מציגה כיצד ניתן ליישם את היכולות האלה בפרויקט שלך:

var reader = new CalendarReader(fileName);
Console.WriteLine("Calendar contains " + reader.Count + " events");
Console.WriteLine("The Version of the calendar is " + reader.Version);
Console.WriteLine("The Method of the calendar is " + reader.Method);
Console.WriteLine("Is calendar contains contains multiple events? - " + reader.IsMultiEvents);
List<Appointment> appointments = reader.LoadAsMultiple();

הוספת תזכורות תצוגה

קטע הקוד הבא מציג כיצד להוסיף תזכורת תצוגה ללוח שנה.

הוספת תזכורות קוליות

קטע הקוד הבא מציג איך להוסיף תזכורת שמע ליומן.

הוספה/קריאת קבצים מצורפים מקבצי יומן

קטע הקוד הבא מציג איך להוסיף/לקרוא קבצים מצורפים מקבצי יומן.

בדיקת מצב הנמענים בבקשות פגישה

קטע הקוד הבא מציג כיצד להציג את מצב הנמענים מבקשת פגישה.

יצירת אזור זמן MAPI Calendar ממחוז זמן סטנדרטי

קטע הקוד הבא מציג כיצד ליצור MapiCalendarTimeZone ממחוז זמן סטנדרטי.

הגדרת תזכורות לפגישות

תזכורת יכולה להתווסף כאשר נוצרה פגישה. ההתראות האלה יכולות להפעיל בהתבסס על קריטריונים שונים כגון n דקות לפני תחילת הלוז, חזרה n פעמים בביניים של n. ניתן להשתמש בתגים שונים ליצירת ההפעלות האלו בתסריט המוקף ב‑BEGIN:VALARM ו‑END:VALARM בתוך פגישה. קיימים מספר ווריאנטים שבהם ניתן להגדיר תזכורת לפגישה.

הוספת תגיות להגדרת תזכורות

קטע הקוד הבא מציג איך להגדיר תזכורת על ידי הוספת תגים.

המרת פגישת EML ל‑MSG עם גוף HTML

מאז גרסה 19.3, Aspose.Email מציעה אפשרות להמיר פגישות EML ל‑MSG תוך שמירת גוף HTML של הפגישה. Aspose.Email מספקת MapiConversionOptions.ForcedRtfBodyForAppointment מאפיין אשר ערך ברירת המחדל שלו הוא true. כאשר הערך של MapiConversionOptions.ForcedRtfBodyForAppointment כאשר מוגדר ל true, גוף הפגישה מומר לפורמט RTF. כדי לשמור על פורמט גוף הפגישה בפורמט HTML, הגדר את הערך של MapiConversionOptions.ForcedRtfBodyForAppointment ל false.

הדוגמה הבאה מדגימה את השימוש ב‑ MapiConversionOptions.ForcedRtfBodyForAppointment מאפיין לשמירת פורמט גוף הפגישה בפורמט HTML.

הגדרת מצב פריטי לוח שנה של MAPI באופן ידני

הגדר במפורש את המצב של אובייקט MAPI Calendar, תוך עקיפה של ההתנהגות המוגדרת כברירת מחדל. זה מאפשר שליטה טובה יותר על מצבי אירועי לוח השנה, במיוחד בטיפול בבקשות פגישה שנתקבלו. כברירת מחדל, כאשר פגישה נוצרת, מצבها הוא MapiCalendarState.Meeting. כאשר מתקבלת בתיבת הדואר של הנמען, היא משתנה אוטומטית ל‑ MapiCalendarState.Received, ומחלקת ההודעה שלו מתעדכנת ל-“IPM.Schedule.Meeting.Request”. באמצעות SetStateForced מאפשר הגדרה ידנית של המצב ל-Received, שיכול להיות שימושי לשימור מידע המארגן בעת שמירת הלוח שנה כקובץ MSG. עם זאת, זה עשוי למנוע העברה מחדש או שליחה מחודשת של הפגישה.

דוגמת הקוד שלהלן מציגה כיצד ליצור MapiCalendar אובייקט, הקצה מארגן, והגדר במפורש את מצבו לשניהם Meeting ו Received באמצעות SetStateForced. לאחר מכן הוא שומר את פריט הלוח שנה כקובץ .msg.

MapiCalendar appointment = new MapiCalendar(
    "LAKE ARGYLE WA 6743",
    "Appointment",
    "This is a very important meeting :)",
    new DateTime(2024, 5, 10, 12, 30, 0, DateTimeKind.Utc),
    new DateTime(2024, 5, 10, 13, 30, 0, DateTimeKind.Utc));

appointment.Organizer = new MapiElectronicAddress
{
    EmailAddress = "test@aaa.com",
    DisplayName = "test display Name"
};

appointment.SetStateForced(MapiCalendarState.Meeting | MapiCalendarState.Received);

appointment.Save("appointment.msg", AppointmentSaveFormat.Msg);

Net: צור, שמור וקרא פתקים של Outlook

Mon, 01 Jan 0001 00:00:00 +0000

צור ושמור פתקיות Outlook

Aspose.Email מספקת אפשרות ליצור פתקים של Outlook ולשמור אותם לכונן בפורמט MSG. ה MapiNote המחלקה מספקת תכונות ושיטות להגדרת מידע משימה. מאמר זה מציג כיצד ליצור, לשמור ולקרוא MapiNote מן הכונן.

השלבים הבאים ניתנים לשימוש ליצירת ושמירת פתק לכונן:

צור מופע של ה‑ MapiNote מחלקה.
הגדר מאפיינים שונים.
שמור את הפתק לכונן כקובץ MSG.

קוד הדוגמה הבא מציג כיצד ליצור ולשמור פתק Outlook.

קרא פתקים של MAPI

ה MapiNote אובייקט המחלקה משמש להמרת ה‑ MapiMessage האובייקט שמטען פתק מהדיסק בפורמט MSG. קוד הדוגמה הבא מציג כיצד לקרוא MapiNote.

Net: ניהול חזרות

Mon, 01 Jan 0001 00:00:00 +0000

עבודה עם חזרות יומיומיות

Aspose.Email תומך ביצירת חזרות יומיומיות באמצעות MapiCalendarDailyRecurrencePattern. ניתן להשתמש בשלושה סוגי סיום שונים של חזרת לוח שנה של Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. קטע זה מציג את יצירת תבניות חזרת יומיומיות שונות.

חזרות יומיומיות עם ספירת אירועים

בסוג חזרה זה, יש לקבוע את מספר החזרות יחד עם מידע נוסף כדלקמן:

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה היומי על ידי הגדרת המאפיינים כגון PatternType, Period, WeekStartDay, EndType ו‑OccurenceCount.
הגדר את המאפיין MapiTask.Recurrence לאובייקט החזרה היומי הזה.
שמור הודעה זו בדיסק.

קטע קוד זה מציג כיצד ליצור משימה עם סוג סיום חזרה EndAfterNOccurrence.

ניתן להשתמש בפונקציה הבאה לחישוב מספר האירועים בין שני התאריכים:

הגדרת ערך ספירת החזרות

הקטע הקוד הבא מראה כיצד להגדיר את ערך ספירת החזרות.

חזרות יומיות: סוג סיום EndAfterDate

"End By" אפשרות ב-Mapi Task מושגת על ידי הגדרת המאפיין OccurrenceCount המחושב על ידי הפונקציה GetOccurrenceCount(). הפונקציה מקבלת תאריך התחלה, תאריך סיום ומחרוזת RRULE.

חזרות יומיומיות: הגדרת ערך ‘כל יום’

הקטע הקוד הבא מראה כיצד להגדיר את ערך ה-period ל-1 ואת ערך ה-INTERVAL ל-1 במחרוזת RRULE גם כן.

ניתן להגדיר את ערך Every Day לכל ערך מתאים כפי שמוצג בדוגמה הבאה:

חזרות יומיות: סוג סיום NeverEnd

ניתן להגדיר סוג סיום באמצעות MapiCalendarRecurrenceEndType.NeverEnd. ניתן להגדיר את Period או INTERVAL לערך הדרוש, לדוגמה 1, בדוגמה הבאה.

עבודה עם חזרות שבועיות

Aspose.Email מציעה תכונות עשירות ליצירת חזרות שבועיות באמצעות MapiCalendarWeeklyRecurrencePattern. ניתן להשתמש בשלושה סוגי סיום שונים של חזרה בלוח השנה של Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. קטע זה מציג את יצירת תבניות חזרה שבועיות שונות.

חזרות שבועיות: סוג סיום EndAfterNOccurrences

בסוג חזרה זה, יש לקבוע את מספר החזרות יחד עם מידע נוסף כדלקמן:

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה השבועית על ידי קביעת המאפיינים כמו PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.Recurrence אל אובייקט החזרה השבועית הזה.
שמור הודעה זו בדיסק.

קטע הקוד הבא מציג כיצד ליצור משימה עם סוג סיום חזרה כ- EndAfterNOccurrence.

ניתן להשתמש בפונקציה הבאה לחישוב מספר האירועים בין שני התאריכים:

בחירת מספר ימים בשבוע

הקטע הקוד הבא מראה כיצד לבחור מספר ימות בשבוע.

בחירת מספר ימים בשבוע והגדרת מרווחים

הקטע הקוד הבא מראה כיצד לבחור מספר ימות בשבוע ולהגדיר מרווחים.

חזרות שבועיות: סוג סיום EndAfterDate

חזרות שבועיות: הגדרת ערך ‘כל יום’

הקטע הקוד הבא מראה כיצד להגדיר את ערך ה-period ל-1 ואת ערך ה-INTERVAL ל-1 במחרוזת RRULE גם כן.

ניתן להגדיר את ערך Every Day לכל ערך מתאים ולבחור מספר ימות כפי שמוצג בדוגמה הבאה:

חזרות שבועיות: סוג סיום NeverEnd

עבודה עם חזרות חודשיות

Aspose.Email תומך ביצירת חזרות חודשיות באמצעות MapiCalendarMonthlyRecurrencePattern. ניתן להשתמש בשלושה סוגי סיום שונים של חזרת לוח שנה של Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. קטע זה מציג את יצירת תבניות חזרה חודשיות שונות.

חזרות חודשיות: סוג סיום EndAfterNOccurrences

בסוג חזרה זה, יש לקבוע את מספר החזרות יחד עם מידע נוסף כדלקמן:

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה החודשי על ידי קביעת המאפיינים כמו PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.Recurrence אל אובייקט החזרה החודשי הזה.
שמור הודעה זו בדיסק.

קטע הקוד הבא מציג כיצד ליצור משימה עם סוג סיום חזרה כ- EndAfterNOccurrence.

ניתן להשתמש בפונקציה הבאה לחישוב מספר האירועים בין שני התאריכים:

הגדרת מספר קבוע של אירועים

קטע הקוד הבא מציג כיצד להגדיר מספר קבוע של אירועים.

חזרות חודשיות: סוג סיום EndAfterDate

"End By" אפשרות ב-Mapi Task מושגת על ידי הגדרת המאפיין OccurrenceCount המחושב על ידי הפונקציה GetOccurrenceCount(). הפונקציה מקבלת תאריך התחלה, תאריך סיום ומחרוזת RRULE. קטע הקוד הבא מציג כיצד ליצור חזרה בתאריך ה-15 של כל חודש בין תאריך התחלה ותאריך סיום.

חזרות חודשיות: סוג סיום NeverEnd

קטע הקוד הבא מציג כיצד להגדיר את סוג הסיום באמצעות MapiCalendarRecurrenceEndType.NeverEnd.

עבודה עם חזרות שנתיות

Aspose.Email תומך ביצירת חזרות שנתיות באמצעות MapiCalendarMonthlyRecurrencePattern. על ידי קביעת מאפיין period ל-12, ניתן להשיג תבנית חזרה שנתית. ניתן להשתמש בשלושה סוגי סיום שונים של חזרה בלוח השנה של Mapi כולל EndAfterNOccurrences, EndAfterDate ו-NeverEnd. קטע זה מציג את יצירת תבניות חזרה שנתיות שונות.

חזרות שנתיות: סוג סיום EndAfterNOccurrences

בסוג חזרה זה, יש לקבוע את מספר החזרות יחד עם מידע נוסף כדלקמן:

הגדר תאריך התחלה, סיום ותאריך יעד.
צור MapiTask.
הגדר את מצב המשימה ל-NotAssigned.
צור את אובייקט החזרה החודשי על ידי קביעת המאפיינים כמו PatternType, Period, WeekStartDay, EndType ו-OccurenceCount.
הגדר את המאפיין MapiTask.Recurrence אל אובייקט החזרה החודשי הזה כדי להשיג חזרה שנתית.
שמור הודעה זו בדיסק.

קטע הקוד הבא מציג כיצד ליצור משימה עם סוג סיום חזרה כ- EndAfterNOccurrence.

חזרות שנתיות: סוג סיום EndAfterDate

חזרות שנתיות: סוג סיום NeverEnd

קטע הקוד הבא מציג כיצד להגדיר את סוג הסיום באמצעות MapiCalendarRecurrenceEndType.NeverEnd.

יצירת חזרה מתוך כלל חזרה

ממשק ה-API של Aspose.Email מספק אפשרות ליצור תבנית חזרה מתוך כלל חזרה (RRULE). הוא מנתח את המידע מהמחרוזת RRULE לפי תקן RFC 5545 iCal ומייצר את תבנית החזרה באמצעות השיטה MapiCalendarRecurrencePatternFactory.FromString. קטע הקוד הבא מציג כיצד ליצור תבנית חזרה מתוך כלל חזרה.

הוספת קובץ מצורף לאירועי לוח שנה חוזרים

API של Aspose.Email מאפשרת להוסיף קבצים מצורפים לאירועי לוח שנה חוזרים.