Skicka e‑post och vidarebefordra meddelanden via SMTP

Den SmtpClient klassen i Aspose.Email for Python via .NET tillhandahåller ett robust och flexibelt gränssnitt för att skicka e‑post med Simple Mail Transfer Protocol (SMTP). Det är den huvudsakliga ingångspunkten för utvecklare som vill leverera e‑postmeddelanden inom sina applikationer.

Nyckelfunktioner i SmtpClient klass inkluderar:

  • SMTP-e‑postleverans: Möjliggör att skicka e‑post direkt via en SMTP‑server.

  • Alternativa leveransalternativ: Stöder ytterligare leveransmetoder såsom att spara meddelanden i filsystemet eller skriva till en meddelandekö.

  • Synkrona och asynkrona operationer:

    • Synchronous Mode: Använd Send‑metoder för att blockera den aktuella tråden tills e‑postmeddelandet är helt överfört.

    • Asynkront läge: Använd SendAsync‑metoder för att skicka meddelanden i bakgrunden, så att applikationen förblir responsiv.

  • TNEF‑stöd: Tillåter att skicka meddelanden i Transport Neutral Encapsulation Format (TNEF) för kompatibilitet med Microsoft Outlook‑funktioner.

Denna artikel täcker alla huvudsakliga funktioner som är tillgängliga via SmtpClient klassen, som demonstrerar hur man skickar standard- och avancerade e‑postmeddelanden med full kontroll över konfiguration och leverans.

Skicka e‑post synkront

Den SmtpClient.send metoden låter dig skicka ett e‑postmeddelande synkront. Detta tillvägagångssätt är användbart när applikationen måste bekräfta leverans innan den fortsätter.

För att skicka ett e‑postmeddelande i klartext synkront med Aspose.Email för Python via .NET, använd stegen och kodexemplet nedan:

  1. Skapa en MailMessage instans och ange avsändare, mottagare, ämne och meddelandetext.
  2. Konfigurera SmtpClient med serverns värd, port, användarnamn och lösenord.
  3. Anropa send metod på SmtpClient instans och skicka in MailMessage objekt.
# 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)

Skicka en förkomponerad EML-fil via SMTP

Om du behöver skicka ett e‑postmeddelande som redan har skrivits och sparats i EML‑format, kan du ladda och skicka det programatiskt med Aspose.Email for Python via .NET.

Följande kodexempel med steg visar hur man skickar en EML-fil med hjälp av SmtpClient:

  1. Läs in EML-filen med hjälp av MailMessage.load metod.
  2. Skapa och konfigurera en instans av SmtpClient, som tillhandahåller SMTP‑serverns värd, användarnamn och lösenord för autentisering.
  3. Anropa send metod på SmtpClient instans och skicka det inlästa meddelandet.
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)

Skicka ett e‑postmeddelande i vanlig text

Du kan skicka ett e‑postmeddelande i vanlig text med Aspose.Email genom att ange meddelandekroppen som enkel text. The MailMessage.body egenskapen används för att definiera innehållet, medan SmtpClient klassen hanterar sändningsprocessen.

Följande kodexempel med steg visar hur man skickar ett e‑postmeddelande i vanlig text:

  1. Skapa en instans av MailMessage klass.
  2. Ange avsändar‑ och mottagarepostadresserna.
  3. Tilldela vanlig textinnehåll till egenskapen body.
  4. Skapa en instans av SmtpClient klass med serverdetaljer och inloggningsuppgifter.
  5. Skicka e‑posten med hjälp av send metod.

Skicka HTML‑e‑post

Aspose.Email for Python via .NET låter dig skicka e‑post med HTML‑formaterade meddelanden med hjälp av MailMessage klass. Genom att tilldela HTML‑innehåll till html_body egenskap och inställning is_body_html till True kan du skapa rika, stiliserade meddelanden.

Följande kodexempel med steg visar hur man skickar ett HTML‑e‑postmeddelande:

  1. Skapa en instans av MailMessage klass.
  2. Ange avsändar‑ och mottagarepostadresserna.
  3. Ställ in is_body_html = True för att ange HTML‑formatering.
  4. Tilldela ditt HTML‑innehåll till html_body egenskap.
  5. Skapa och konfigurera SmtpClient instans.
  6. Använd send metod för att överföra meddelandet.

Obs: Även om detta exempel använder grundläggande HTML kan du inkludera mer komplexa HTML‑strukturer för att skapa responsiva och varumärkesanpassade e‑postlayouter.

Skicka HTML‑e‑post med alternativ i vanlig text

När du skickar HTML‑e‑post är det bästa praxis att inkludera en version i vanlig text för mottagare vars e‑postklienter inte stödjer HTML. Aspose.Email for Python via .NET erbjuder AlternateView klass för att inkludera både HTML‑ och vanlig text i ett enda meddelande, vilket förbättrar kompatibilitet och användarupplevelse.

Följande kodexempel och steg visar hur man skickar ett e‑postmeddelande med alternativ textinhåll:

  1. Skapa en instans av MailMessage klass.
  2. Ange avsändar‑ och mottagarepostadresserna.
  3. Tilldela HTML‑innehåll till html_body egenskap och sätt is_body_html = True.
  4. Skapa en alternativ vy med vanlig text med hjälp av create_alternate_view_from_string.
  5. Lägg till den alternativa vyn till alternate_views samling av MailMessage.
  6. Skapa och konfigurera SmtpClient instans.
  7. Skicka e‑posten med hjälp av send metod.

Hur man skickar massutskick av e‑post

Att skicka massutskick innebär att leverera flera meddelanden samtidigt — var och en kan vara adresserad till en annan mottagare. Aspose.Email tillhandahåller denna funktion med hjälp av SmtpClient klass.

Kodexemplet nedan demonstrerar hur man skickar en grupp e‑postmeddelanden på en gång:

  1. Skapa en instans av SmtpClient klass och konfigurera dess värd, port, inloggningsuppgifter och säkerhetsinställningar.
  2. Skapa flera MailMessage instanser — var och en representerar ett enskilt e‑postmeddelande.
  3. Ange avsändare, mottagare, ämne och meddelandetext för varje e‑post.
  4. Lägg till alla MailMessage objekt till en MailMessageCollection.
  5. Anropa send metod för SmtpClient klass, skicka MailMessageCollection som argument.
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)

Skicka e‑post med stöd för flera anslutningar

Aspose.Email for Python via .NET låter dig använda flera samtidiga anslutningar när du skickar e‑post via SmtpClient klass. Denna funktion kan hjälpa till att optimera prestanda när man skickar stora volymer e‑post genom att fördela arbetsbelastningen över flera anslutningar. Tänk dock på att aktivering av fleranslutningsläge inte garanterar en prestandaförbättring i alla scenarier — det beror på serverkonfiguration och nätverksförhållanden.

Nyckelegenskaper:

  • use_multi_connection: Aktiverar eller inaktiverar fleranslutningsläge för SMTP‑klienten.

  • connections_quantity: Anger antalet anslutningar som ska öppnas när fleranslutningsläge är aktiverat.

Följande kodexempel visar hur man aktiverar fleranslutningsläge:

  1. Skapa och konfigurera en instans av SmtpClient.
  2. Ange serverdetaljer som värd, port, användarnamn, lösenord och kryptering.
  3. Aktivera fleranslutningsläge genom att sätta use_multi_connection.
  4. Ange antalet anslutningar med 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)

Skicka TNEF‑formaterade e‑postmeddelanden

Transport Neutral Encapsulation Format (TNEF) är ett proprietärt e‑postformat som används av Microsoft Outlook och Exchange för att bevara rik formatering, inbäddade objekt och speciella funktioner som röstningsknappar. Standard‑e‑postklienter behåller kanske inte denna formatering när de använder vanliga MIME‑baserade meddelanden.

Aspose.Email for Python via .NET stödjer att skicka e‑post i TNEF‑format för att säkerställa att all avancerad formatering och funktioner bevaras. Detta uppnås genom att aktivera use_tnef egenskap hos SmtpClient klass.

Följande kodexempel och steg visar hur man skickar ett TNEF‑e‑postmeddelande:

  1. Läs in ett befintligt EML‑meddelande eller skapa ett med hjälp av MailMessage klass.
  2. Ange avsändar‑ och mottagaradresserna.
  3. Aktivera TNEF‑formatering genom att sätta use_tnef = True på SmtpClient instans.
  4. Skicka meddelandet med send() metod.

Skicka mötesförfrågningar via e‑post

Microsoft Outlook och andra kalenderaktiverade e‑postklienter som IBM Lotus Notes låter användare hantera möten direkt från inkorgen. När en användare får en mötesinbjudan kan de acceptera eller avvisa den direkt i sin e‑postklient. Med Aspose.Email for Python via .NET kan utvecklare programatiskt skapa och skicka dessa mötesinbjudningar i enlighet med iCalendar‑standarden (RFC 2445).

Hur man skickar mötesinbjudningar via e‑post

Aspose.Email ger inbyggt stöd för att skapa och skicka iCalendar‑mötesförfrågningar som en del av ett e‑postmeddelande. Dessa förfrågningar är kompatibla med populära kalenderklienter och låter mottagarna svara på inbjudningar enkelt.

|iCalendar‑mötesförfrågan skickad via e‑post| | :- | |todo:image_alt_text|

Följande kodexempel visar hur du skickar förfrågningar via e‑post:

  1. Skapa en MailMessage instans.
  2. Ange avsändar‑ och mottagarpostadresser.
  3. Skapa en Appointment objekt med plats, start-/sluttider, avsändare och mottagare.
  4. Ange mötessammanfattning och beskrivning.
  5. Bifoga mötet till e‑posten med hjälp av add_alternate_view().
  6. Skicka e‑posten med hjälp av SmtpClient.

iCalendar‑stöd för IBM Lotus Notes

Aspose.Email använder iCalendar‑formatet (RFC 2445), vilket säkerställer att dina mötesförfrågningar är kompatibla med Microsoft Outlook, IBM Lotus Notes och alla andra klienter som stödjer standarden. Samma process kan användas oavsett mottagarens plattform.

Vidarebefordra e‑post med SMTP‑klient

Vidarebefordra e‑post är en vanlig uppgift i digital kommunikation, ofta använd för att dela mottagna meddelanden med andra. Aspose.Email for Python via .NET låter utvecklare vidarebefordra e‑post programatiskt med hjälp av SmtpClient klass. Metoden forward möjliggör att vidarebefordra sparade eller mottagna e‑postmeddelanden till nya mottagare utan att den ursprungliga avsändaren är inblandad.

Nedan är ett kodexempel som demonstrerar hur man vidarebefordrar ett e‑postmeddelande med hjälp av MailMessage klass:

Vidarebefordra EML‑filer utan att ladda in dem i MailMessage

Aspose.Email stödjer också att vidarebefordra .eml‑filer direkt utan att först ladda dem i en MailMessage objekt. Detta är särskilt användbart i scenarier där minnesanvändning i systemet behöver minimeras.

Kodexemplet nedan visar hur man vidarebefordrar en EML-fil direkt:

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)
SMTP‑klientens anslutningsinställning Aktivera SMTP‑klientaktivitetsloggning