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

Python-Net: הגדרת חיבור לקוח SMTP

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

התחבר לשרת SMTP עם SSL

כדי להקים חיבור מאובטח עם שרת SMTP שתומך ב‑SSL, יש להגדיר את המאפיינים המרכזיים הבאים של ה‑ SmtpClient מחלקה:

Host: כתובת שרת ה‑SMTP (למשל smtp.gmail.com)
Port: הפורט המשמש לתקשורת עם SSL (בדרך כלל 465 עבור SSL מרומז או 587 עבור SSL/TLS מפורש)
Username: שם החשבון המשמש לאימות
Password: הסיסמה לחשבון ה‑SMTP
Security Options: סוג ההצפנה לשימוש (SSLEXPLICIT, SSLIMPLICIT, וכו׳)

דוגמת הקוד הבאה מציגה כיצד להגדיר ולהתחבר לשרת SMTP עם SSL:

הגדר זמן קצוב לתגובת הפתיחה מהשרת

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

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

כדי לשפר התנהגות זו, Aspose.Email מספקת את greeting_timeout מאפיין ב‑ SmtpClient מחלקה. מאפיין זה מגדיר זמן קצוב ספציפי (במילישניות) להמתנה למחרוזת הפתיחה של השרת. אם הפתיחה לא מתקבלת במסגרת הזמן שהוגדרה, הלקוח מנסה מיד את ההגדרה הבאה — מה שהאיץ משמעותית תהליכי חיבור אוטומטיים.

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

import aspose.email as ae

client = ae.clients.smtp.SmtpClient("localhost", 25, "username", "password")
client.greeting_timeout = 4000

שליחת אימיילים דרך SMTP באמצעות פרוקסי SOCKS

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

import aspose.email as ae

client = ae.clients.smtp.SmtpClient("smtp.domain.com", "username", "password")

client.security_options = ae.clients.SecurityOptions.SSL_IMPLICIT
# proxy address
proxy_address = "192.168.203.142"
#proxy port
proxy_port = 1080
socks_proxy = ae.clients.SocksProxy(proxy_address, proxy_port, ae.clients.SocksVersion.SOCKS_V5)
client.proxy = socks_proxy
client.send(ae.MailMessage("sender@domain.com", "receiver@domain.com", "Sending Email via proxy", "Implement socks proxy protocol for versions 4, 4a, 5 (only Username/Password authentication)"))

שליחת אימיילים דרך SMTP באמצעות פרוקסי HTTP

דוגמת הקוד למטה מציגה את השימוש בפרוקסי HTTP כדי לשלוח אימייל דרך שרת SMTP:

import aspose.email as ae

http_proxy = ae.clients.HttpProxy("18.222.124.59", 8080)
client = ae.clients.smtp.SmtpClient("host", 587, "username", "password")
client.proxy = http_proxy
client.send(ae.MailMessage("sender@domain.com", "receiver@domain.com", "Sending Email via proxy", "Body"))

בחר שיטות אימות SMTP נתמכות בפייתון

כדי להבטיח חיבור מאובטח ונתמך לשרת SMTP, חשוב להשתמש בשיטת אימות הנתמכת הן על ידי הלקוח והן על ידי השרת. Aspose.Email for Python via .NET מספקת מובנית תכונות לניהול זה:

supported_authentication — מחזיר רשימת שיטות אימות הנתמכות על ידי שרת SMTP.
allowed_authentication — מקבל או מגדיר את שיטות האימות שהלקוח מורשה להשתמש בהן.

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

קטע הקוד הבא מציג כיצד לציין את שיטת האימות המותאמת ל‑SMTP באמצעות allowed_authentication מאפיין:

client.allowed_authentication = ae.clients.smtp.SmtpKnownAuthenticationType.LOGIN

הגדר זמן קצוב לשרת SMTP

בעת שליחת אימיילים ברשת, הגדרת זמן קצוב מתאים היא חיונית למניעת קפיאת היישום אם השרת לא מגיב. ה‑ timeout מאפיין של SmtpClient מחלקה ב‑Aspose.Email for Python via .NET מאפשרת להגדיר את זמן ההמתנה המקסימלי (במילישניות) לתגובות השרת.

מאפיין זה חל על פעולות כגון הקמת חיבור או שליחת פקודות SMTP. אם השרת אינו מגיב בתוך הזמן المحدד, הלקוח זורק חריגת זמן קצוב, מה שמאפשר טיפול יעיל יותר בשרתים שאינם מגיבים.

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

import aspose.email as ae

client = ae.clients.smtp.SmtpClient("host", 587, "username", "password", ae.clients.SecurityOptions.SSL_EXPLICIT)
# 60 seconds
client.timeout = 60000

הפעל הצפנת TLS לחיבורים מאובטחים ל‑SMTP

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

NOTE: Only versions of SSL/TLS supported by your current Python framework can be applied. Unsupported protocol versions will be silently ignored without raising exceptions. If you need to bypass compatibility checks and explicitly set the encryption protocols, use the `set_supported_encryption_unsafe(value)` method of the [SmtpClient](https://reference.aspose.com/email/python-net/aspose.email.clients.smtp/smtpclient/#smtpclient-class) class.

דוגמת הקוד הבאה מציגה כיצד להגדיר TLS 1.3 לתקשורת SMTP:

import aspose.email as ae

client = ae.clients.smtp.SmtpClient("host", 587, "username", "password", ae.clients.SecurityOptions.SSL_EXPLICIT)
client.supported_encryption = ae.clients.base.EncryptionProtocols.TLS13

שימוש במנגנון CRAM-MD5 לאימות

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

כדי להפעיל אימות CRAM-MD5, הגדר את allowed_authentication מאפיין של SmtpClient מחלקה ל‑CRAM_MD5, כפי שמוצג בדוגמת הקוד הבאה:

client.allowed_authentication = ae.clients.smtp.SmtpKnownAuthenticationType.CRAM_MD5

Python-Net: שליחת הודעות דוא"ל והעברת הודעות דרך SMTP ב-Python

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

ה SmtpClient מחלקה ב‑Aspose.Email for Python via .NET מספקת ממשק חזק וגמיש לשליחת דוא"לים באמצעות פרוטוקול Simple Mail Transfer Protocol (SMTP). זו הכניסה הראשית למפתחים שמעוניינים להעביר הודעות דוא"ל באפליקציות שלהם.

המאפיינים המרכזיים של SmtpClient הכללה של מחלקה:

משלוח דוא"ל באמצעות SMTP: מאפשר שליחת דוא"ל ישירות דרך שרת SMTP.
אפשרויות משלוח חלופיות: תומך במתודות משלוח נוספות כגון שמירת הודעות במערכת הקבצים או כתיבה לתור הודעות.
פעולות סינכרוניות וכן אסינכרוניות:
- מצב סינכרוני: השתמש בשיטות Send כדי לחסום את תהליך הריצה הנוכחי עד שהדוא"ל מועבר במלואו.
- מצב אסינכרוני: השתמש במתודות SendAsync כדי לשלוח הודעות ברקע, ולאפשר ליישום להישאר מגיב.
תמיכה ב‑TNEF: מאפשרת שליחת הודעות בפורמט Transport Neutral Encapsulation Format (TNEF) לתאימות עם תכונות של Microsoft Outlook.

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

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

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

כדי לשלוח הודעת דוא"ל בטקסט פשוט בצורה סינכרונית באמצעות Aspose.Email for Python דרך .NET, השתמש בצעדים ובדוגמת הקוד שלמטה:

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

# Create email
eml = ae.MailMessage()
eml.subject = "Message with Plain Text Body"
eml.body = "This is text body."
eml.from_address = "from@gmail.com"
eml.to.append(ae.MailAddress("to@gmail.com", "Recipient 1")) 

# Configure SmtpClient object
client = SmtpClient("smtp.gmail.com", 995, "username", "password")
client.security_options = SecurityOptions.AUTO 

# Send email
client.send(eml)

שליחת דוא"לים באופן אסינכרוני אינה נתמכת על‑ידי ה‑API.

שלח קובץ EML מוכן מראש דרך SMTP

אם אתה צריך לשלוח הודעת דוא"ל שכבר נכתבה ונשמרה בפורמט EML, ניתן לטעון ולשלוחה תכניתית באמצעות Aspose.Email for Python via .NET.

קטע הקוד הבא עם שלבים מציג כיצד לשלוח קובץ EML באמצעות SmtpClient:

טען את קובץ ה‑EML באמצעות ה‑ MailMessage.load שיטה.
צור והגדר מופע (instance) של SmtpClient, המספקים את כתובת ה‑SMTP, שם המשתמש והסיסמה לאימות.
הפעל את send שיטה על ה SmtpClient המאגר (instance) והעבר את ההודעה שהוטענה.

import aspose.email as ae

message = ae.MailMessage.load("test.eml")

# Send this message using SmtpClient
client = ae.clients.SmtpClient("host", "username", "password")
client.send(message)

שלח דוא"ל בטקסט פשוט

באפשרותך לשלוח דוא"ל בטקסט פשוט באמצעות Aspose.Email על‑ידי ציון גוף ההודעה בתור טקסט פשוט. ה‑ MailMessage.body המאפיין משמש להגדרת התוכן, בעוד שה‑ SmtpClient המחלקה מטפלת בתהליך השליחה.

קטע הקוד הבא עם שלבים מציג כיצד לשלוח דוא״ל בטקסט פשוט:

צור מופע של MailMessage מחלקה.
הגדר את כתובות הדוא"ל של השולח והמקבל.
הקצה את תוכן הטקסט הפשוט למאפיין body.
צור מופע של SmtpClient מחלקה עם פרטי השרת והאישורים.
שלח את האימייל באמצעות send שיטה.

שלח דוא"ל HTML

Aspose.Email for Python via .NET מאפשר לך לשלוח דוא"לים עם גוף בפורמט HTML באמצעות ה‑ MailMessage במחלקה. על‑ידי הקצאת תוכן HTML ל‑ html_body מאפיין והגדרה is_body_html ל‑True, תוכל ליצור הודעות עשירות ומעוצבות.

דוגמת הקוד הבאה עם שלבים מציגה כיצד לשלוח דוא״ל HTML:

צור מופע של MailMessage מחלקה.
הגדר את כתובות הדוא"ל של השולח והמקבל.
הגדר is_body_html = True כדי לציין פורמט HTML.
הקצה את תוכן ה‑HTML שלך ל‑ html_body מאפיין.
צור והגדר את ה‑ SmtpClient מופע.
השתמש ב- send שיטה להעברת ההודעה.

הערה: בעוד דוגמה זו משתמשת ב‑HTML בסיסי, אתה יכול לשלב מבנים מורכבים יותר של HTML ליצירת פריסות דוא"ל רספונסיביות וממותגות.

שלח דוא"ל HTML עם חלופה בטקסט רגיל

כאשר שולחים דוא"לים ב‑HTML, מומלץ לכלול גרסה בטקסט פשוט עבור נמענים שהלקוח שלהם אינו תומך ב‑HTML. Aspose.Email for Python via .NET מציע את ה‑ AlternateView מחלקה לכלול גם תוכן HTML וגם טקסט רגיל בהודעה אחת, משפרת את התאימות וחוויית המשתמש.

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

צור מופע של MailMessage מחלקה.
הגדר את כתובות הדוא"ל של השולח והמקבל.
הקצה תוכן HTML ל‑ html_body מאפיין והגדר is_body_html = True.
צור AlternateView בטקסט פשוט באמצעות create_alternate_view_from_string.
הוסף את תצוגת החלופה ל‑ alternate_views אוסף של ה‑ MailMessage.
צור והגדר את ה‑ SmtpClient מופע.
שלח את האימייל באמצעות send שיטה.

כיצד לשלוח דוא"לים בכמות

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

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

צור מופע של SmtpClient מחלקה והגדר את ה‑host, port, האישורים וההגדרות האבטחה שלה.
צור מספר MailMessage מופעים — כל אחד מייצג הודעת דוא"ל נפרדת.
ציין שלוח, מקבל, נושא וגוף ההודעה עבור כל דוא"ל.
הוסף את כל MailMessage אובייקטים ל‑ MailMessageCollection.
הפעל את send שיטה של SmtpClient מחלקה, מעבירה את MailMessageCollection כפרמטר.

import aspose.email as ae
from aspose.email.clients import SmtpClient, SecurityOptions
from aspose.email import MailMessage, MailMessageCollection

# Create individual email messages
message1 = MailMessage("from@gmail.com", "to1@gmail.com", "Bulk Email - Message 1", "Hello, this is message 1.")
message2 = MailMessage("from@gmail.com", "to2@gmail.com", "Bulk Email - Message 2", "Hello, this is message 2.")
message3 = MailMessage("from@gmail.com", "to3@gmail.com", "Bulk Email - Message 3", "Hello, this is message 3.")

# Add messages to a collection
many_messages = MailMessageCollection()
many_messages.append(message1)
many_messages.append(message2)
many_messages.append(message3)

# Configure SMTP client
client = SmtpClient("smtp.gmail.com", 995, "username", "password")
client.security_options = SecurityOptions.AUTO

# Send all messages in bulk
client.send(many_messages)

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

Aspose.Email for Python via .NET מאפשרת לך להשתמש במספר חיבורים סימולטניים בעת שליחת דוא"לים דרך ה‑ SmtpClient מחלקה. תכונה זו יכולה לסייע באופטימיזציית ביצועים בעת שליחת נפח גבוה של דוא"לים על‑ידי פיזור העומס על פני מספר חיבורים. עם זאת, שים לב שהפעלת מצב מרובה חיבורים אינה מבטיחה שיפוי ביצועים בכל התרחישים — זה תלוי בתצורת השרת ובתנאי הרשת.

מאפייני מפתח:

use_multi_connection: מאפשרת או משביתה את מצב מרובה חיבורים עבור לקוח ה‑SMTP.
connections_quantity: מציינת את מספר החיבורים לפתיחה כאשר מצב מרובה חיבורים מופעל.

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

צור והגדר מופע (instance) של SmtpClient.
הגדר פרטי שרת כגון host, port, שם משתמש, סיסמה והצפנה.
אפשר מצב מרובה חיבורים על‑ידי הגדרת use_multi_connection.
ציין את מספר החיבורים עם connections_quantity.

import aspose.email as ae

client = ae.clients.smtp.SmtpClient
client.host = "<HOST>"
client.username = "<USERNAME>"
client.password = "<PASSWORD>"
client.port = 587
client.supported_encryption = ae.clients.base.EncryptionProtocols.TLS
client.security_options = ae.clients.SecurityOptions.SSL_EXPLICIT

client.connections_quantity = 5
client.use_multi_connection = ae.clients.MultiConnectionMode.ENABLE
client.send(messages)

שלח דוא"לים בפורמט TNEF

Transport Neutral Encapsulation Format (TNEF) הוא פורמט דוא"ל קנייני המשמש את Microsoft Outlook ו‑Exchange לשימור עיצוב עשיר, אובייקטים משובצים ותכונות מיוחדות כגון כפתורי הצבעה. לקוחות דוא"ל רגילים עשויים לא לשמר עיצוב זה בעת שימוש בהודעות מבוססות MIME רגילות.

Aspose.Email for Python via .NET תומך בשליחת דוא"לים בפורמט TNEF כדי להבטיח שכל העיצוב המתקדם והתכונות יישמרו. זאת ניתן להשיג על‑ידי הפעלת ה‑ use_tnef מאפיין של SmtpClient מחלקה.

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

טען הודעת EML קיימת או צור אחת באמצעות ה‑ MailMessage מחלקה.
הגדר את כתובות השולח והמקבל.
אפשר פורמט TNEF על‑ידי הגדרת use_tnef = True ב‑ SmtpClient מופע.
שלח את ההודעה באמצעות ה‑ send() שיטה.

שלח בקשות פגישה בדוא"ל

Microsoft Outlook וקצין‑דוא"ל אחרים המאפשרים לוח שנה כגון IBM Lotus Notes מאפשרים למשתמשים לנהל פגישות ישירות מתיבת הדואר הנכנס. כאשר משתמש מקבל הזמנת פגישה, הוא יכול לקבל או לדחות אותה ישירות בממשק ה‑email שלו. עם Aspose.Email for Python via .NET, מפתחים יכולים ליצור ולשלוח הזמנות פגישה אלה באופן תכניתתי בהתאם לתקן iCalendar (RFC 2445).

כיצד לשלוח הזמנות לפגישות בדוא"ל

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

|בקשת פגישה iCalendar שנשלחת באימייל| | :- | ||

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

צור MailMessage מופע.
ציין את כתובות הדוא"ל של השולח והמקבל.
צור Appointment אובייקט עם מיקום, זמני התחלה/סיום, שולח ונמענים.
הגדר סיכום ותיאור של הפגישה.
צרף את הפגישה לדוא"ל באמצעות add_alternate_view().
שלח את האימייל באמצעות SmtpClient.

תמיכה ב‑iCalendar עבור IBM Lotus Notes

Aspose.Email משתמשת בפורמט iCalendar (RFC 2445), המבטיח שהזמנות הפגישה שלך תואמות ל‑Microsoft Outlook, IBM Lotus Notes וכל לקוח אחר שתומך בתקן. אפשר להשתמש באותה תהליך ללא תלות בפלטפורמת הנמען.

העבר דוא"לים באמצעות לקוח SMTP

העברת דוא"לים היא משימה נפוצה בתקשורת דיגיטלית, משמשת לעיתים קרובות לשיתוף הודעות שהתקבלו עם אחרים. Aspose.Email for Python via .NET מאפשרת למפתחים להעביר דוא"לים תכניתית באמצעות ה‑ SmtpClient מחלקה. מתודת forward מאפשרת להעביר הודעות דוא"ל שמורות או שהתקבלו למקבלים חדשים ללא מעורבות השולח המקורי.

להלן דוגמת קוד המציגה כיצד להעביר (forward) דוא"ל באמצעות ה‑ MailMessage מחלקה:

העבר קבצי EML ללא טעינה ל‑MailMessage

Aspose.Email תומכת גם בהעברת קבצי .eml ישירות מבלי קודם לטעון אותם לתוך MailMessage אובייקט. זה שימושי במיוחד בתרחישים שבהם יש צורך למזער את השימוש בזיכרון המערכת.

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

import aspose.email as ae

client = ae.clients.smtp.SmtpClient(host, smtp_port, username, password, ae.clients.SecurityOptions.AUTO)
file = open("test.eml", "rb")
client.forward(sender, recipients, file)

Python-Net: הפעלת רישום פעילות של לקוח SMTP

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

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

ה SmtpClient מחלקה מציעה את המאפיינים הבאים להפעלה והגדרת רישום פעילות:

log_file_name: מציין את הנתיב המלא ושם קובץ הרישום.
use_date_in_log_file_name: קובע האם להוסיף את התאריך הנוכחי לשם קובץ הרישום, דבר המועיל ליצירת רישומים יומיים.

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

import aspose.email as ae

# Initialize and configure the SMTP client
client = ae.clients.smtp.SmtpClient
client.host = "<HOST>"
client.username = "<USERNAME>"
client.password = "<PASSWORD>"
client.port = 587
client.security_options = ae.clients.SecurityOptions.SSL_EXPLICIT

# Set the log file name and enable/disable date in file name
client.log_file_name = "C:\Aspose.Email.Smtp.log"

# Set to True to append current date
client.use_date_in_log_file_name = False

# Prepare and send the email
eml = ae.MailMessage("from address", "to address", "this is a test subject", "this is a test body")
client.send(eml)

Python-Net: שחזור הרחבות שרת SMTP | אימות פרטי התחברות ל‑SMTP

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

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

שחזור הרחבות שרת נתמכות כגון IDLE, UNSELECT, QUOTA וכו’, כדי להבטיח תאימות לפני השימוש בתכונות מסוימות.
אימות פרטי התחברות ל‑SMTP ללא שליחת דוא"ל בפועל, דבר המועיל לאימות התחברות ובדיקת חיבור.

שחזור הרחבות שרת SMTP

לפני שימוש בתכונות ספציפיות של SMTP, מומלץ לבדוק אילו הרחבות תומך שרת הדואר. ה get_capabilities() מתודה זו מחזירה אותם כרשימת מחרוזות.

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

אימות פרטי התחברות ל‑SMTP ללא שליחת דוא"ל

כדי לבדוק אם פרטי ההתחברות שסופקו תקינים — ללא שליחת הודעת בדיקה — ניתן להשתמש ב- validate_credentials() שיטה של SmtpClient מחלקה. זה מועיל לבדיקות אימות ואבחון מערכת.

דוגמת הקוד הבאה ניתנת לשימוש כדי לאמת פרטי התחברות שניתנו לאימות מול שרת SMTP ללא שליחת דוא"ל:

import aspose.email as ae

client = ae.clients.smtp.SmtpClient("Url", port, "username", "password", ae.clients.SecurityOptions.AUTO)
client.timeout = 4000   # Set timeout in milliseconds

# Validate login
if client.validate_credentials():
    print("Credentials are valid.")
else:
    print("Invalid credentials or unable to connect.")

Python-Net: תכונות שירות - לקוח SMTP

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

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

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

אחזור הרחבות השרת

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

אימות אישורי שרת המייל ללא שליחת אימייל

המתודה ‘validate_credentials()’ של ה‑ SmtpClient המחלקה משמשת לבדוק את תקפות האישורים שסופקו על‑ידי הקמת חיבור לשרת SMTP. אם האישורים תקינים והחיבור מצליח, ניתן לבצע פעולות נוספות. דוגמת הקוד הבאה יכולה לשמש לאימות האישורים שסופקו לאימות מול שרת ה‑SMTP ללא שליחת דוא"ל:

import aspose.email as ae

client = ae.clients.smtp.SmtpClient("Url", port, "username", "password", ae.clients.SecurityOptions.AUTO)
client.timeout = 4000

if client.validate_credentials():
  # to do something