Documentation – עבודה עם לקוח SMTP

Net: התחברות לשרת SMTP

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

אופטימיזציית חיבורי לקוח דוא"ל

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

כדי לשפר את היעילות של חיבורים אלה, Aspose.Email for .NET מציע מאפיינים כגון זמן קצוב ו GreetingTimeout. בעוד שה Timeout המאפיין מנהל את משך הזמן הכולל לפעולות דוא"ל, ה GreetingTimeout המאפיין מתמקד במיוחד בזמן שלוקח לשרת לשלוח מחרוזת ברכה בעת החיבור.

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

כאשר משתמשים ב‑ Timeout המאפיין, חשוב לציין שהערכים המוקצים לו צריכים להיות עם מרווחים מספיקים כדי להכיל פעולות ממושכות.

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

בעת חיבור לשרתים SMTP, IMAP ו‑POP3, נשלחת מחרוזת ברכה ללקוח לאחר הקמת חיבור מוצלחת. השרתים עשויים להשתמש באתחול חיבור SSL/TLS באופן מרומז או מפורש (START TLS). במקרים שבהם מצב החיבור אינו תואם (לדוגמה, השרת מצפה להתחברות SSL מרומזת בעוד שהלקוח מנסה להקים חיבור SSL לא מאובטח או מפורש), השרת לא ישלח מחרוזת ברכה.

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

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

דוגמת הקוד הבאה מציגה כיצד להגדיר את EmailClient.GreetingTimeout מאפיין:

using (SmtpClient client = new SmtpClient("localhost", 25, "username", "password"))
{
    client.GreetingTimeout = 4000;
}

קבלת הרחבות שרת

ה SmtpClient מאפשר לך לאחזר את הרחבות השרת שמשרת תומך בהם כגון IDLE, UNSELECT, QUOTA, וכד’. זה מסייע בזיהוי זמינות ההרחבה לפני שימוש בלקוח עבור תפקוד זה. ה GetCapabilities() method מחזירה את סוגי ההרחבות הנתמכות בצורת מערך מחרוזות.

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

אימות אישורי שרת דוא"ל ללא שליחת הודעות

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

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

using (SmtpClient client = new SmtpClient(server.SmtpUrl, server.SmtpPort, "username", "password", SecurityOptions.Auto))
{
    client.Timeout = 4000;
   
    if (client.ValidateCredentials())
    {
        //to do something
    }
}

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

שליחת דוא"ל דרך שרת SOCKS Proxy

במקרים כאלה, לקוחות דוא"ל אינם יכולים לתקשר דרך האינטרנט ללא ציון כתובת ה‑proxy. Aspose.Email מספק תמיכה לגרסאות 4, 4a ו‑5 של פרוטוקול ה‑SOCKS proxy. כדי לשלוח דוא"ל דרך שרת proxy, יש לבצע את השלבים הבאים:

אתחול הפרוקסי עם המידע הנדרש, כלומר כתובת הפרוקסי, הפורט, וגירסת SOCKS.
אתחול SmtpClient עם כתובת המארח, שם המשתמש והסיסמה, וכל ההגדרות האחרות.
הגדר את מאפיין ה‑Proxy של הלקוח ל פרוקסי אובייקט שנוצר קודם.

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

שליחת דוא"ל דרך שרת Proxy HTTP

זיהוי שיטות אימות לחיבור SMTP מאובטח

Aspose.Email מציע מאפיינים המאפשרים לבדוק אילו שיטות אימות ניתן להשתמש בהן להקמת חיבור מאובטח עם שרת ה‑SMTP לפני שליחת דוא"ל:

ה SmtpClient.SupportedAuthentication המאפיין מחזיר רשימת שיטות אימות הנתמכות על ידי שרת ה‑SMTP.
ה SmtpClient.AllowedAuthentication המאפיין מחזיר רשימת שיטות אימות שהוגדרו על ידי המשתמש.

smtpClient.AllowedAuthentication = SmtpKnownAuthenticationType.Login;

טעינת מידע אימות SMTP מקובץ CONFIG

כדי ש‑Aspose.Email יוכל לקרוא קובץ תצורה, הוא צריך להיות בפורמט הנכון. למטה מציגים קובץ תצורת XML לדוגמה ולאחריו הקוד הקורא אותו. קטע הקוד הבא מראה כיצד לטעון מידע אימות SMTP מקובץ CONFIG.

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

קישור לקוח SMTP לכתובת IP ספציפית

יתכן שמארח יכיל מספר פתחות זמינות לשליחת אימיילים, ולכן לא ניתן לשלול אפשרות זאת. במקרים כאלה, ייתכן הצורך לקשר את לקוח שליחת האימייל לפורט ספציפי במארח לצורך שליחת המיילים. ניתן להשיג זאת גם באמצעות Aspose.Email API בעזרת SmtpClient BindIPEndPoint המאפיין. ה‑API של SmtpClient ניתן להגדיר להשתמש בכתובת IP ספציפית במארח על ידי ציון נקודת הקצה של ה‑IP הספציפית. הקטע הקוד הבא מציג כיצד לקשר את לקוח ה‑SMTP לכתובת IP ספציפית במארח.

הגדרת זמן קצוב לפעולות דוא"ל

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

הערה: אין להגדיר ערכים גבוהים מאוד כדי למנוע המתנות ארוכות ביישום שלך.

using (SmtpClient smtpClient = new SmtpClient("host", 587, "username", "password", SecurityOptions.SSLExplicit))
{
    smtpClient.Timeout = 60000; // 60 seconds

    // some code...
}

שימוש בפרוטוקולי קריפטוגרפיה

Aspose.Email תומך בפרוטוקולים הקריפטוגרפיים SSL (מיושן) ו‑TLS כדי לספק אבטחת תקשורת. ניתן להפעיל הצפנה קריפטוגרפית כדי להגן על חילופי נתונים בין היישום שלך לשרתי הדוא"ל.

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

דוגמת הקוד שלהלן מראה כיצד להגדיר TLS 1.3 עבור SmtpClient מופע של מחלקה.

using (SmtpClient smtpClient = new SmtpClient("host", 587, "username", "password", SecurityOptions.SSLExplicit))
{
    smtpClient.SupportedEncryption = EncryptionProtocols.Tls13;

    // some code...
}

במקרה שהפרוטוקול ההצפנה שהוגדר אינו נתמך בגרסה הנוכחית של .NET Framework, ההבדל בהתנהגות בין SetSupportedEncryptionUnsafe שיטה ו SupportedEncryption המאפיין הוא כדלקמן:

אם SupportedEncryption כאשר המאפיין משמש, לקוח הדוא"ל מוריד את פרוטוקול ההצפנה לרמה נתמכת.
אם SetSupportedEncryptionUnsafe כאשר השיטה משמשת, לקוח הדוא"ל זורק שגיאות.

אימות SMTP עם מנגנון CRAM-MD5

מנגנון האימות CRAM-MD5 של Aspose.Email for .NET מספק שכבה נוספת של אבטחה בעת גישה לשרת. קטע הקוד הבא מציג כיצד ליישם תכונה זו בפרויקט שלך:

smtpClient.AllowedAuthentication = SmtpKnownAuthenticationType.CramMD5;

Net: שליחת אימיילים והעברת הודעות באמצעות לקוח SMTP ב‑C#

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

שליחת אימיילים

שליחת אימיילים עם מחלקת SmtpClient

ה SmtpClient המחלקה מאפשרת ליישומים לשלוח אימיילים דרך פרוטוקול Simple Mail Transfer Protocol (SMTP).

אחת מהתכונות המרכזיות שלה היא היכולת ל‑ שליחת הודעות בכמות.

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

בנוסף, SmtpClient תומך בשליחת הודעות ב‑ Transport Neutral Encapsulation Format (TNEF).

שליחת הודעות דוא"ל סינכרונית

הודעת אימייל יכולה להישלח באופן סינכרוני באמצעות שלח שיטה של SmtpClient מחלקה. היא שולחת את הודעת האימייל שצוינה דרך שרת SMTP למטרת מסירה. כדי לשלוח הודעת אימייל באופן סינכרוני, עקוב אחר הצעדים המופיעים להלן:

צור מופע של MailMessage class והגדר את תכונותיו.
צור מופע של SmtpClient class וציין את המארח, הפורט, שם המשתמש והסיסמה.
שלח את ההודעה באמצעות שלח שיטה של SmtpClient class והעבר את MailMessage מופע.

קטע הקוד הבא ב‑C# מציג כיצד לשלוח הודעות Outlook באופן סינכרוני.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Declare msg as MailMessage instance
MailMessage msg = new MailMessage();

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port # and Security option
client.Host = "mail.server.com";
client.Username = "username";
client.Password = "password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.SSLExplicit;

try
{
    // Client.Send will send this message
    client.Send(msg);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

שליחת אימיילים באופן אסינכרוני

לעיתים, ייתכן שתרצה לשלוח דואר באופן אסינכרוני כדי שהתוכנית תמשיך לבצע משימות אחרות בזמן שהאימייל נשלח ברקע. החל מ‑.NET Framework 4.5 ניתן להשתמש בשיטות אסינכרוניות המיושמות לפי TAP מודל. קטע הקוד ב‑C# שלהלן מציג כיצד לשלוח הודעות Outlook באמצעות שיטות במודל אסינכרוני מבוסס משימות:

SendAsync שולח את ההודעות שצוינו.
IAsyncSmtpClient - מאפשר ליישומים לשלוח הודעות באמצעות פרוטוקול העברת דוא"ל פשוט (SMTP).
SmtpClient.CreateAsync - יוצר מופע חדש של המחלקה Aspose.Email.Clients.Smtp.SmtpClient
SmtpSend - קבוצת פרמטרים של המתודה Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend).
SmtpForward - הפרמטרים של Aspose.Email.Clients.Smtp.IAsyncSmtpClient.ForwardAsync(Aspose.Email.Clients.Smtp.Models.SmtpForward).

// Authenticate the client to obtain necessary permissions
static readonly string tenantId = "YOU_TENANT_ID";
static readonly string clientId = "YOU_CLIENT_ID";
static readonly string redirectUri = "http://localhost";
static readonly string username = "username";
static readonly string[] scopes = { "https://outlook.office.com/SMTP.Send" };

// Use the SmtpAsync method for asynchronous operations
static async Task Main(string[] args)
{
    await SmtpAsync();
    Console.ReadLine();
}

static async Task SmtpAsync()
{
    // Create token provider and get access token
    var tokenProvider = new TokenProvider(clientId, tenantId, redirectUri, scopes);
    var client = SmtpClient.CreateAsync("outlook.office365.com", username, tokenProvider, 587).GetAwaiter().GetResult();

    // Create a message to send
    var eml = new MailMessage("from@domain.com", "to@domain.com", "test subj async", "test body async");
    
    // send message
    var sendOptions = SmtpSend.Create();
    sendOptions.AddMessage(eml);
    await client.SendAsync(sendOptions);
    Console.WriteLine("message was sent");

    // forward message
    var fwdOptions = SmtpForward.Create();
    fwdOptions.SetMessage(eml);
    fwdOptions.AddRecipient("rec@domain.com");
    await client.ForwardAsync(fwdOptions);
    Console.WriteLine("message was forwarded");
}

// Token provider implementation
public class TokenProvider : IAsyncTokenProvider
{
    private readonly PublicClientApplicationOptions _pcaOptions;
    private readonly string[] _scopes;

    public TokenProvider(string clientId, string tenantId, string redirectUri, string[] scopes)
    {
        _pcaOptions = new PublicClientApplicationOptions
        {
            ClientId = clientId,
            TenantId = tenantId,
            RedirectUri = redirectUri
        };

        _scopes = scopes;
    }

    public async Task<OAuthToken> GetAccessTokenAsync(bool ignoreExistingToken = false, CancellationToken cancellationToken = default)
    {

        var pca = PublicClientApplicationBuilder
            .CreateWithApplicationOptions(_pcaOptions).Build();

        try
        {
            var result = await pca.AcquireTokenInteractive(_scopes)
                .WithUseEmbeddedWebView(false)
                .ExecuteAsync(cancellationToken);

            return new OAuthToken(result.AccessToken);
        }
        catch (MsalException ex)
        {
            Console.WriteLine($"Error acquiring access token: {ex}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex}");
        }

        return null;
    }

    public void Dispose()
    {

    }
}

שליחת הודעות מהדיסק

קבצי EML מכילים כותרת, גוף הודעה וקבצים מצורפים. Aspose.Email מאפשר למפתחים לעבוד עם קבצי EML במגוון דרכים. חלק זה מציג כיצד לטעון קבצי EML מהדיסק ולשלוח אותם כאימיילים עם SMTP. ניתן לטעון קבצי .eml מהדיסק או זרם אל ה‑ MailMessage מחלקה ולשלוח את הודעת האימייל באמצעות ה- SmtpClient מחלקה. ה- MailMessage ה‑class הוא המחלקה הראשית ליצירת הודעות אימייל חדשות, טעינת קבצי הודעות אימייל מדיסק או זרם ושמירת ההודעות. הקטע הבא בקוד C# מציג כיצד לשלוח הודעות שמורות מהדיסק.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Load an EML file in MailMessage class
var message = MailMessage.Load(dataDir + "test.eml");

// Send this message using SmtpClient
var client = new SmtpClient("host", "username", "password");
            
try
{
    client.Send(message);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

שליחת אימיילים בטקסט רגיל

ה גוף מאפיין, מאפיין של ה- MailMessage מחלקה, משמשת לציון תוכן הטקסט הפשוט של גוף ההודעה. כדי לשלוח הודעת אימייל טקסט פשוט, פעל לפי הצעדים הבאים:

צור מופע של MailMessage מחלקה.
ציין את כתובות האימייל של השולח והמקבל ב- MailMessage מופע.
ציין את גוף תוכן, משמש להודעת טקסט פשוט.
צור מופע של SmtpClient מחלקה ולשלוח את האימייל.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
//Create an instance of the MailMessage class
var message = new MailMessage();

// Set From field, To field and Plain text body
message.From = "sender@sender.com";
message.To.Add("receiver@receiver.com");
message.Body = "This is Plain Text Body";

// Create an instance of the SmtpClient class
var client = new SmtpClient();

// And Specify your mailing host server, Username, Password and Port
client.Host = "smtp.server.com";
client.Username = "Username";
client.Password = "Password";
client.Port = 25;

try
{
    //Client.Send will send this message
    client.Send(message);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    System.Diagnostics.Trace.WriteLine(ex.ToString());
}

שליחת אימיילים עם גוף HTML

דוגמאות קוד למטה מראות כיצד ניתן לשלוח הודעת אימייל HTML פשוטה. ה- HtmlBody, מאפיין של ה- MailMessage מחלקה, משמשת לציון תוכן ה-HTML של גוף ההודעה. כדי לשלוח אימייל HTML פשוט, פעל לפי הצעדים הבאים:

צור מופע של MailMessage מחלקה.
ציין כתובת אימייל של השולח והמקבל ב- MailMessage מופע.
ציין את HtmlBody תוכן.
צור מופע של SmtpClient מחלקה ולשלוח את האימייל באמצעות ה- שלח שיטה.

בהקשר של מאמר זה, תוכן ה‑HTML של האימייל הוא בסיסי: This is the HTML body רוב האימיילים בפורמט HTML יהיו מורכבים יותר. הקטע הבא מראה כיצד לשלוח אימייל עם גוף HTML.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
    // Declare msg as MailMessage instance
    var msg = new MailMessage();

    // Use MailMessage properties like specify sender, recipient, message and HtmlBody
    msg.From = "newcustomeronnet@gmail.com";
    msg.To = "asposetest123@gmail.com";
    msg.Subject = "Test subject";
    msg.HtmlBody = "<html><body>This is the HTML body</body></html>";

    var client = GetSmtpClient();

    try
    {
        // Client will send this message
        client.Send(msg);
        Console.WriteLine("Message sent");
    }
    catch (Exception ex)
    {
        Trace.WriteLine(ex.ToString());
    }

    Console.WriteLine(Environment.NewLine + "Email sent with HTML body.");
}

private static SmtpClient GetSmtpClient()
{
    var client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
    client.SecurityOptions = SecurityOptions.Auto;
    return client;
}

שליחת אימיילים ב‑HTML עם טקסט חלופי

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

צור מופע של MailMessage מחלקה.
ציין כתובות אימייל של השולח והמקבל ב- MailMessage מופע.
צור מופע של AlternateView מחלקה.

זה יוצר תצוגה חלופית להודעת אימייל באמצעות התוכן שמוגדר במחרוזת.

הוסף את המופע של ה- AlternateView מחלקה ל- MailMessage אובייקט.
צור מופע של SmtpClient מחלקה ולשלוח את האימייל באמצעות ה- שלח שיטה.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Declare message as MailMessage instance
var message = new MailMessage();

// Creates AlternateView to view an email message using the content specified in the //string
var alternate = AlternateView.CreateAlternateViewFromString("Alternate Text");
            
// Adding alternate text
message.AlternateViews.Add(alternate);

שליחת אימיילים בכמות

אנו יכולים לשלוח אצווה של אימיילים באמצעות SmtpClient מחלקת ה- שלח העמסת מתודה שמקבלת MailMessageCollection:

צור מופע של SmtpClient מחלקה.
ציין את SmtpClient מאפייני המחלקה.
צור מופע של MailMessage מחלקה.
ציין שולח, מקבל, נושא האימייל וההודעה במופע של ה- MailMessage מחלקה.
חזור על שני הצעדים שלמעלה שוב, אם ברצונך לשלוח אימייל לאדם אחר.
צור מופע של MailMessageCollection מחלקה.
הוסף מופע של MailMessage מחלקה במופע של ה- MailMessageCollection מחלקה.
כעת שלח את האימייל שלך באמצעות ה- SmtpClient מחלקה שלח מתודה על ידי העברת המופע של MailMessageCollection מחלקה בתוכה.

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

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create SmtpClient as client and specify server, port, user name and password
var client = new SmtpClient("mail.server.com", 25, "Username", "Password");

// Create instances of MailMessage class and Specify To, From, Subject and Message
var message1 = new MailMessage("msg1@from.com", "msg1@to.com", "Subject1", "message1, how are you?");
var message2 = new MailMessage("msg1@from.com", "msg2@to.com", "Subject2", "message2, how are you?");
var message3 = new MailMessage("msg1@from.com", "msg3@to.com", "Subject3", "message3, how are you?");

// Create an instance of MailMessageCollection class
var manyMsg = new MailMessageCollection();
manyMsg.Add(message1);
manyMsg.Add(message2);
manyMsg.Add(message3);

try
{
    // Send Messages using Send method
    client.Send(manyMsg);                
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

מעקב אחר הצלחת אימיילים בכמות

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

דוגמת קוד:

using (var client = new SmtpClient(host, SecurityOptions.Auto))
{
    int messageCount = 0;

    client.SucceededSending += (sender, eventArgs) =>
    {
        Console.WriteLine("The message '{0}' was successfully sent.", eventArgs.Message.Subject);
        messageCount++;
    };

    client.Send(messages);

    Console.WriteLine("{0} messages were successfully sent.", messageCount);
}

שליחת אימיילים עם ריבוי חיבורים

ה UseMultiConnection מאפיין זה ניתן לשימוש ליצירת חיבורים מרובים לפעולות מותחרות. אתה יכול גם להגדיר את מספר החיבורים שישמשו במצב ריבוי‑חיבורים באמצעות SmtpClient.ConnectionsQuantity. הקטע קוד הבא מדגים את השימוש במצב מרובה חיבורים לשליחת מספר הודעות.

var smtpClient = new SmtpClient();
smtpClient.Host = "<HOST>";
smtpClient.Username = "<USERNAME>";
smtpClient.Password = "<PASSWORD>";
smtpClient.Port = 587;
smtpClient.SupportedEncryption = EncryptionProtocols.Tls;
smtpClient.SecurityOptions = SecurityOptions.SSLExplicit;

var messages = new List<MailMessage>();
for (int i = 0; i < 20; i++)
{
    MailMessage message = new MailMessage(
        "<EMAIL ADDRESS>",
        "<EMAIL ADDRESS>",
        "Test Message - " + Guid.NewGuid().ToString(),
        "SMTP Send Messages with MultiConnection");
    messages.Add(message);
}

smtpClient.ConnectionsQuantity = 5;
smtpClient.UseMultiConnection = MultiConnectionMode.Enable;
smtpClient.Send(messages);

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

שליחת הודעות כ‑TNEF

אימיילים בפורמט TNEF כוללים עיצוב מיוחד שעשוי ללכת לאיבוד אם נשלחים באמצעות ה‑API הסטנדרטי. ה SmtpClient מחלקה UseTnef ניתן להגדיר את המאפיין כדי לשלוח את האימייל בתור TNEF. קטע הקוד הבא מראה כיצד לשלוח הודעה בתור TNEF.

var emlFileName = RunExamples.GetDataDir_Email() + "Message.eml";     // A TNEF Email

// Load from eml
var eml1 = MailMessage.Load(emlFileName, new EmlLoadOptions());
eml1.From = "somename@gmail.com";
eml1.To.Clear();
eml1.To.Add(new MailAddress("first.last@test.com"));
eml1.Subject = "With PreserveTnef flag during loading";
eml1.Date = DateTime.Now;

var client = new SmtpClient("smtp.gmail.com", 587, "somename", "password");
client.SecurityOptions = SecurityOptions.Auto;
client.UseTnef = true;     // Use this flag to send as TNEF
client.Send(eml1);

שליחת בקשות פגישה

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

שליחת בקשות באמצעות אימייל

כדי לשלוח בקשות פגישה דרך אימייל, פעל לפי הצעדים הבאים:

צור מופע של MailMessage מחלקה.
ציין כתובות שולח ונמען באמצעות מופע של MailMessage מחלקה.
אתחל מופע של Appointment class והעבר את ערכיו.
ציין תקציר ותיאור ב Calendar מופע.
הוסף את ה- Calendar אל MailMessage מופע והעבר לו את Appointment מופע.

|בקשת פגישה iCalendar שנשלחת באימייל| | :- | || קטע הקוד הבא מראה כיצד לשלוח בקשות דרך אימייל.


// Create an instance of the MailMessage class
var msg = new MailMessage();

// Set the sender, recipient, who will receive the meeting request. Basically, the recipient is the same as the meeting attendees
msg.From = "newcustomeronnet@gmail.com";
msg.To = "person1@domain.com, person2@domain.com, person3@domain.com, asposetest123@gmail.com";

// Create Appointment instance
var app = new Appointment("Room 112", new DateTime(2015, 7, 17, 13, 0, 0), new DateTime(2015, 7, 17, 14, 0, 0), msg.From, msg.To);
app.Summary = "Release Meetting";
app.Description = "Discuss for the next release";

// Add appointment to the message and Create an instance of SmtpClient class
msg.AddAlternateView(app.RequestApointment());
var client = GetSmtpClient();

try
{
    // Client.Send will send this message
    client.Send(msg);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

העברת הודעות

העברת הודעות עם לקוח SMTP

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

//Create an instance of SmtpClient class
var client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port and SecurityOptions
client.Host = "mail.server.com";
client.Username = "username";
client.Password = "password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.SSLExplicit;
var message = MailMessage.Load(dataDir + "Message.eml");
client.Forward("Recipient1@domain.com", "Recipient2@domain.com", message);

העברת הודעות בלי MailMessage

ה‑API גם תומך בהעברת הודעות EML מבלי לטעון אותן קודם ל MailMessage. זה שימושי במקרים שבהם משאבי הזיכרון של המערכת מוגבלים.


using (var client = new SmtpClient(host, smtpPort, username, password, SecurityOptions.Auto))
{
    using (var fs = File.OpenRead(@"test.eml"))
    {
        client.Forward(sender, recipients, fs);
    }
}

העברת הודעות באופן אסינכרוני בלי MailMessage

using (var client = new SmtpClient(host, smtpPort, username, password))
{
    using (var fs = File.OpenRead(@"test.eml"))
    {
        await client.ForwardAsync(sender, recipients, fs);
    }
}

מיזוג דואר

כיצד למזג אימיילים

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

|הדגמה של איך מיזוג דואר עובד:| | :- | || Aspose.Email מאפשרת למפתחים להגדיר מיזוגי דואר הכוללים נתונים ממגוון מקורות נתונים.

כדי לבצע מיזוג דואר עם Aspose.Email, פעלו לפי הצעדים הבאים:

צור פונקציה עם חתימת שם
צור מופע של MailMessage מחלקה.
ציין את השולח, המקבל, הנושא והגוף.
צור חתימה לסיום המייל.
צור מופע של TemplateEngine מחלקה והעביר לה את MailMessage מופע.
קח חתימה ב‑ TemplateEngine מופע.
צור מופע של מחלקת DataTable.
הוסף את העמודות Receipt, FirstName ו-LastName כמקורות נתונים במחלקת DataTable.
צור מופע של מחלקת DataRow.
ציין את כתובת הנמען, שם פרטי ושם משפחה באובייקט DataRow.
צור מופע של MailMessageCollection מחלקה
ציין את TemplateEngine ו‑instances של DataTable ב‑ MailMessageCollection מופע.
צור מופע של SmtpClient class וציין את השרת, הפורט, שם המשתמש והסיסמה.
שלח אימיילים באמצעות SmtpClient מחלקה שלח שיטה.

בדוגמה שלמטה, #FirstName# מציין עמודת DataTable, שערכה נקבע על‑ידי המשתמש. קטע הקוד הבא מציג כיצד לבצע מיזוג דואר.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
    // The path to the File directory.
    string dataDir = RunExamples.GetDataDir_SMTP();
    string dstEmail = dataDir + "EmbeddedImage.msg";

    // Create a new MailMessage instance
    MailMessage msg = new MailMessage();

    // Add subject and from address
    msg.Subject = "Hello, #FirstName#";
    msg.From = "sender@sender.com";

    // Add email address to send email also Add mesage field to HTML body
    msg.To.Add("your.email@gmail.com");
    msg.HtmlBody = "Your message here";
    msg.HtmlBody += "Thank you for your interest in <STRONG>Aspose.Email</STRONG>.";

    // Use GetSignment as the template routine, which will provide the same signature
    msg.HtmlBody += "<br><br>Have fun with it.<br><br>#GetSignature()#";

    // Create a new TemplateEngine with the MSG message,  Register GetSignature routine. It will be used in MSG.
    TemplateEngine engine = new TemplateEngine(msg);
    engine.RegisterRoutine("GetSignature", GetSignature);

    // Create an instance of DataTable and Fill a DataTable as data source
    DataTable dt = new DataTable();
    dt.Columns.Add("Receipt", typeof(string));
    dt.Columns.Add("FirstName", typeof(string));
    dt.Columns.Add("LastName", typeof(string));

    DataRow dr = dt.NewRow();
    dr["Receipt"] = "abc<asposetest123@gmail.com>";
    dr["FirstName"] = "a";
    dr["LastName"] = "bc";
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["Receipt"] = "John<email.2@gmail.com>";
    dr["FirstName"] = "John";
    dr["LastName"] = "Doe";
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["Receipt"] = "Third Recipient<email.3@gmail.com>";
    dr["FirstName"] = "Third";
    dr["LastName"] = "Recipient";
    dt.Rows.Add(dr);

    MailMessageCollection messages;
    try
    {
        // Create messages from the message and datasource.
        messages = engine.Instantiate(dt);

        // Create an instance of SmtpClient and specify server, port, username and password
        SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "your.email@gmail.com", "your.password");
        client.SecurityOptions = SecurityOptions.Auto;

        // Send messages in bulk
        client.Send(messages);
    }
    catch (MailException ex)
    {
        Debug.WriteLine(ex.ToString());
    }

    catch (SmtpException ex)
    {
        Debug.WriteLine(ex.ToString());
    }

    Console.WriteLine(Environment.NewLine + "Message sent after performing mail merge.");
}

// Template routine to provide signature
static object GetSignature(object[] args)
{
    return "Aspose.Email Team<br>Aspose Ltd.<br>" + DateTime.Now.ToShortDateString();
}

כיצד לבצע מיזוג דואר שורת‑בשורה

המשתמש יכול למזג שורת נתונים בודדת וכן לקבל תוצאה שלמה ומוכנה MailMessage אובייקט. ה TemplateEngine.Merge method יכולה לשמש לביצוע מיזוג דואר לפי שורה.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create message from the data in current row.
message = engine.Merge(currentRow);

Net: הפעלת רישום פעילות SMTP ב-.NET באמצעות appsettings.json

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

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

אפשר רישום פעילות

שימוש בקובץ appsettings.json להפעלת רישום פעילות

הערה: אפשרות זו מועדפת ליישומי .NET Core.

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

הוסף קובץ תצורת appsettings.json לפרויקט C#, אם הוא לא נוסף לפני כן.

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

   <Content Include="appsettings.json">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
   </Content>

לאחר מכן, הוסף את התוכן הבא לקובץ appsettings.json.

   {
     "SmtpDiagnosticLog": "smtp.log",
     "SmtpDiagnosticLog_UseDate": true
   }

שתי המאפיינים שהוזכרו מעלה הם:

SmtpDiagnosticLog - מציין את הנתיב היחסי או המוחלט לקובץ הלוג.
SmtpDiagnosticLog_UseDate - מציין האם להוסיף ייצוג מחרוזת של התאריך הנוכחי לשם קובץ הלוג.

הפעלת רישום פעילות בקוד התוכנית

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

הערה: גם אם כבר הפעלת רישום באמצעות קובצי תצורה, אפשרות זו תיושם.

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

צור SmtpClient.
הגדר את הנתיב לקובץ הרישום באמצעות LogFileName מאפיין.
הגדר את UseDateInLogFileName מאפיין אם זה נדרש.

   using (var client = new SmtpClient("your smtp server"))
   {
       // Set username, password, port, and security options
       client.Username = "your username";
       client.Password = "your password";
       client.Port = 465;
       client.SecurityOptions = SecurityOptions.SSLImplicit;
   
       // Set the path to the log file using the LogFileName property.
       client.LogFileName = @"C:\Aspose.Email.Smtp.log";
       
       // Set the UseDateInLogFileName property if it is necessary.
       client.UseDateInLogFileName = false;
   
       var eml = new MailMessage("from address", "to address", "this is a test subject", "this is a test body");
   
       client.Send(eml);
   }

שימוש בקובץ App.config להפעלת רישום פעילות

ניתן לתעד פעילות של לקוח SMTP על‑ידי שינוי configSections בקובץ ההגדרות. רישום אבחון ניתן לביצוע בעזרת הצעדים הבאים:

הוסף קבוצת קטעים בשם "applicationSettings".
הוסף קטע בשם "Aspose.Email.Properties.Settings".
הכלל את ההגדרה בשם SmtpDiagonosticLog שבה שם הקובץ מוגדר ב‑applicationSettings/Aspose.Email.Properties.Settings

זהו יישום לדוגמה מבוסס טופס המשתמש ב SmtpClient לשליחת אימייל. כל הפעילות מתועדת על‑ידי שינוי קובץ App.config. צור יישום טופס עם כפתור יחיד. הוסף את קוד הלחיצה של הכפתור הבא:

הוסף הפנייה ל‑Aspose.Email.

הוסף את קובץ App.Config ושנה אותו כך שהתוכן שלו יהיה כדלקמן

ב‑C# .NET השתמש באפשרות הבאה

ב‑VB .NET השתמש באפשרות הבאה

הפעל את הקוד ולאחר מכן בדוק את תיקיית ה‑debug. הקובץ הבא יווצר.