Come può un programma Delphi inviare un'e-mail con allegati tramite il client e-mail DEFAULT?

Question

All'interno del mio programma, sto componendo un'e-mail da inviare utilizzando il software client e-mail predefinito installato sul computer dell'utente.

Ho composto l'indirizzo mailto, il soggetto, il corpo multilinea e ho diversi allegati da includere.

ho quasi avuto questo lavoro utilizzando mailto e ShellExecute come segue:

Message := 'mailto:someone@somewhere.com' 
    + '?subject=This is the subjectBehold Error Report' 
    + '&body=This is line 1' + '%0D%0A' 
    + 'This is line 2' + '%0D%0A' 
    + 'This is line 3' 
    + '&Attach=c:\file1.txt'; 
    RetVal := ShellExecute(Handle, 'open', PChar(Message), nil, nil, SW_SHOWNORMAL); 
    if RetVal <= 32 then 
    MessageDlg('Cannot find program to send e-mail.', mtWarning, [mbOK], 0); 

Utilizzando Delphi 2009 su una macchina Windows Vista, questo aprirà una Microsoft Mail finestra "mail Crea", con la A, Oggetto e Il corpo è stato riempito correttamente. Tuttavia il file non viene allegato.

Come ho cercato questo, ho notato alcuni commenti affermando che questa tecnica non funziona con tutti i client di posta. Tuttavia, la maggior parte dei commenti è piuttosto vecchia, poiché mi rendo conto che questa è una tecnica molto antica.

Quindi ho trovato che Zarko Gajic said che "questo approccio è ok, ma non è possibile inviare allegati in questo modo".

Ho visto anche l'API di Windows Simple Mail (MAPI), ma Zarko dice che funziona solo se l'utente finale ha un software di posta elettronica compatibile MAPI. Esistono tecniche ben documentate sull'utilizzo di MAPI con Delphi (ad esempio Sending e-mail using mapi), ma tutte hanno la dichiarazione di non responsabilità che MAPI non è sempre installato con Windows.

Inoltre, desidero davvero che il messaggio venga visualizzato per primo nel programma di posta elettronica predefinito dell'utente, in modo che lo includano come parte dei loro record di posta elettronica e possano modificarlo e decidere se e quando inviarlo. Non sono sicuro di come funziona MAPI e se lo farà.

Quindi le mie esigenze sono:

1. Per portare l'e-mail nel programma di posta elettronica dell'utente.

2. Per consentire uno o più allegati.

3. Per lavorare con (si spera) tutti i client di posta elettronica su qualsiasi macchina Windows da XP su (ad esempio XP, Vista o 7).

Esiste un animale simile? O forse qualcuno sa come ottenere gli allegati per lavorare con la tecnica mailto/ShellExecute?

Cosa fa la maggior parte della gente?

---

Edit:

ci sono state alcune risposte con soluzioni MAPI e persino una soluzione Indy.

Il problema che ho con loro è che non usano necessariamente il client di posta predefinito. Ad esempio, sul mio computer Vista ho installato Windows Mail come client predefinito. Quando eseguo l'invio MAPI, non viene visualizzato Windows Mail, ma viene richiamato e viene impostata l'email in Outlook. Non lo voglio

Due dei miei utenti del mio programma è lamentato:

Vostra routine di debug non riesce a inviare il file, come si tenta di avviare Windows Mail per qualche motivo conosciuto per è di per sé piuttosto che utilizzare il client di posta predefinito (nel mio caso Thunderbird)

ho cercato di riempire il rapporto eccezione ma ha rinunciato quando ha chiesto per questo server, il server! Ho quindi ottenuto davvero infastidito perché ha lanciato Outlook - Non lo uso mai, mai, né voglio usarlo.

Non ho bisogno del codice per MAPI o Indy. Sono facilmente disponibili. Ma se suggerisci MAPI o Indy, quello di cui ho veramente bisogno è un modo per trovare il client predefinito e assicurarti che sia quello che ha passato l'email da inviare.

Inoltre, ho bisogno di sapere se MAPI è ora universale. 5 anni fa, non era garantito il funzionamento su tutte le macchine perché non era installato come parte del sistema operativo. È ancora vero o MAPI ora viene fornito con Windows XP, Vista e 7 per impostazione predefinita?

Le stesse domande vanno per Indy o altre soluzioni suggerite. Può funzionare con il client predefinito e funzionerà su quasi tutte le macchine Windows XP e successive?

Il motivo per cui la soluzione "mailto" è così bella, è che tutte le macchine devono supportarlo allo scopo di gestire l'istruzione mailto HTML trovata nelle pagine Web. Ora, se solo potessi usarlo per aggiungere allegati ...

---

soluzione Probabile trovato: mjustin sottolineato alternativa che fa uso del comando sendto del sistema operativo. Questa è probabilmente la strada da percorrere.

Il mailto non era limitato a 256 caratteri come il mailto HTML, ma sono stato devastato nello scoprire che è stato limitato a 2048 caratteri. Fortunatamente poche ore dopo, mjustin ha dato la sua risposta.

Se l'implementazione di ciò va bene, la sua risposta lo avrà fatto per me. In caso contrario, aggiungerò i miei commenti qui.

---

No. Come risulta, la soluzione sendto non apre sempre il programma di posta elettronica predefinito. Sulla mia macchina, apre Outlook quando il mio mailer predefinito è Windows Mail. Peccato. Ho dovuto tornare al metodo mailto, nonostante il limite di 2048 caratteri.

Ho, tuttavia, trovo in questo articolo: SendTo mail recipient che:

A questo punto, è possibile sostituire :: ShellExecute con un ben pensato :: WinExec chiamata, utilizzando l'attuale mailto comando riga dichiarata nel registro e destinazione del client e-mail corrente (ad esempio, "% Programmi% \ Outlook Express \ msimn.exe"/mailurl:% 1). Ma quindi la limitazione è 32 KB. Come conclusione , non è possibile inviare e-mail superiori a 32 KB utilizzando il protocollo mailto .

ma poi dovrei determinare chi è il client di posta in ogni caso. Mi aspetto che porterebbe a ulteriori complicazioni.

L'altra cosa che ho scoperto è che mailto consente l'impostazione di "a", "cc", "bcc", "soggetto" e "corpo" ma senza allegati. Considerando che sendto consente SOLO gli allegati e quindi imposta un'e-mail predefinita con un messaggio predefinito e nessun modo per impostare i vari campi e il corpo.

Answer 1

Sembra che mailto in una ShellExecute non è in grado di inviare allegati.

MAPI e Indy hanno la spiacevole caratteristica di non selezionare necessariamente il client di posta dell'utente.

Quindi l'altra possibilità è continuare a utilizzare ShellExecute, ma trovare un altro modo per ottenere gli allegati nel client di posta elettronica.

Quello che ho deciso di fare era sul mio Dialog che crea l'e-mail, ora ho un FileListBox che elenca i file che l'utente potrebbe voler allegare all'e-mail. Quando appare l'e-mail, possono semplicemente trascinarli e-mail.

Nel mio caso, questa è in realtà una buona soluzione, poiché consente agli utenti di selezionare i file che desiderano includere. L'altro metodo (allegandoli automaticamente) richiederà che cancellino quelli che non vogliono includere. (Ad esempio, se l'opzione "Aggiungi Google toolbar" è già stata verificata per te NON è positivo)

Per il momento questa soluzione funzionerà.

Grazie a tutti coloro che hanno contribuito alle risposte e mi hanno aiutato a vedere la mia strada attraverso questo (tutti i +1).

Answer 2

Utilizzo due metodi per l'invio di una posta MAPI, a seconda che sia necessario un aggancio. Per il semplice caso senza alcun attaccamento che utilizzare il seguente:

function SendShellEmail(ARecipientEmail, ASubject, ABody : string) : boolean; 
// Send an email to this recipient with a subject and a body 
var 
    iResult : integer; 
    S  : string; 
begin 

If Trim(ARecipientEmail) = '' then 
    ARecipientEmail := 'mail'; 
S := 'mailto:' + ARecipientEmail; 

S := S + '?subject=' + ASubject; 

If Trim(ABody) <> '' then 
    S := S + '&body=' + ABody; 

iResult := ShellExecute(Application.Handle,'open', PChar(S), nil, nil, SW_SHOWNORMAL); 
Result := iResult > 0; 
end; 

Questo utilizza un semplice shell metodo execute, quindi non dovreste avere problemi reali diversi gli allarmi più recenti per ottenere l'utente a confermare che sono ok, con il tuo programma inviando un'email.

Per gli attacchi, utilizzo il seguente codice originariamente tratto dalla rivista Delphi di Brian Long. E 'anche possibile inviare un messaggio di posta elettronica SENZA usare il client MAPI ma usando un server SMTP nominato, ma penso che tu non lo voglia esplicitamente. Posso fornire il codice per questo se lo fai.

uses 
    SysUtils, 
    Windows, 
    Dialogs, 
    Forms, 
    MAPI; 

procedure ArtMAPISendMail(
      const Subject, MessageText, MailFromName, MailFromAddress, 
        MailToName, MailToAddress: String; 
      const AttachmentFileNames: array of String); 
//Originally by Brian Long: The Delphi Magazine issue 60 - Delphi And Email 
var 
    MAPIError: DWord; 
    MapiMessage: TMapiMessage; 
    Originator, Recipient: TMapiRecipDesc; 
    Files, FilesTmp: PMapiFileDesc; 
    FilesCount: Integer; 
begin 
    FillChar(MapiMessage, Sizeof(TMapiMessage), 0); 

    MapiMessage.lpszSubject := PAnsiChar(AnsiString(Subject)); 
    MapiMessage.lpszNoteText := PAnsiChar(AnsiString(MessageText)); 

    FillChar(Originator, Sizeof(TMapiRecipDesc), 0); 

    Originator.lpszName := PAnsiChar(AnsiString(MailFromName)); 
    Originator.lpszAddress := PAnsiChar(AnsiString(MailFromAddress)); 
// MapiMessage.lpOriginator := @Originator; 
    MapiMessage.lpOriginator := nil; 


    MapiMessage.nRecipCount := 1; 
    FillChar(Recipient, Sizeof(TMapiRecipDesc), 0); 
    Recipient.ulRecipClass := MAPI_TO; 
    Recipient.lpszName := PAnsiChar(AnsiString(MailToName)); 
    Recipient.lpszAddress := PAnsiChar(AnsiString(MailToAddress)); 
    MapiMessage.lpRecips := @Recipient; 

    MapiMessage.nFileCount := High(AttachmentFileNames) - Low(AttachmentFileNames) + 1; 
    Files := AllocMem(SizeOf(TMapiFileDesc) * MapiMessage.nFileCount); 
    MapiMessage.lpFiles := Files; 
    FilesTmp := Files; 
    for FilesCount := Low(AttachmentFileNames) to High(AttachmentFileNames) do 
    begin 
    FilesTmp.nPosition := $FFFFFFFF; 
    FilesTmp.lpszPathName := PAnsiChar(AnsiString(AttachmentFileNames[FilesCount])); 
    Inc(FilesTmp) 
    end; 

    try 
    MAPIError := MapiSendMail(
     0, 
     Application.MainForm.Handle, 
     MapiMessage, 
     MAPI_LOGON_UI {or MAPI_NEW_SESSION}, 
     0); 
    finally 
    FreeMem(Files) 
    end; 

    case MAPIError of 
    MAPI_E_AMBIGUOUS_RECIPIENT: 
     Showmessage('A recipient matched more than one of the recipient descriptor structures and MAPI_DIALOG was not set. No message was sent.'); 
    MAPI_E_ATTACHMENT_NOT_FOUND: 
     Showmessage('The specified attachment was not found; no message was sent.'); 
    MAPI_E_ATTACHMENT_OPEN_FAILURE: 
     Showmessage('The specified attachment could not be opened; no message was sent.'); 
    MAPI_E_BAD_RECIPTYPE: 
     Showmessage('The type of a recipient was not MAPI_TO, MAPI_CC, or MAPI_BCC. No message was sent.'); 
    MAPI_E_FAILURE: 
     Showmessage('One or more unspecified errors occurred; no message was sent.'); 
    MAPI_E_INSUFFICIENT_MEMORY: 
     Showmessage('There was insufficient memory to proceed. No message was sent.'); 
    MAPI_E_LOGIN_FAILURE: 
     Showmessage('There was no default logon, and the user failed to log on successfully when the logon dialog box was displayed. No message was sent.'); 
    MAPI_E_TEXT_TOO_LARGE: 
     Showmessage('The text in the message was too large to sent; the message was not sent.'); 
    MAPI_E_TOO_MANY_FILES: 
     Showmessage('There were too many file attachments; no message was sent.'); 
    MAPI_E_TOO_MANY_RECIPIENTS: 
     Showmessage('There were too many recipients; no message was sent.'); 
    MAPI_E_UNKNOWN_RECIPIENT: 
     Showmessage('A recipient did not appear in the address list; no message was sent.'); 
    MAPI_E_USER_ABORT: 
     Showmessage('The user canceled the process; no message was sent.'); 
    SUCCESS_SUCCESS: 
     Showmessage('MAPISendMail successfully sent the message.'); 
    else 
    Showmessage('MAPISendMail failed with an unknown error code.'); 
    end; 
end; 

Answer 3

Non complicare, basta utilizzare il codice JCL MAPI. È nell'unità JclMapi.pas. Penso che abbiano anche l'esempio per questo. Il codice è molto potente e puoi fare tutto ciò che ti consente MAPI.

Con ShellExecute non è possibile inviare l'allegato e si dispone anche di 255 caratteri per il corpo della posta.

Finché MAPI funziona, con le vecchie finestre è sempre installato (2000, XP). Viene fornito insieme a Outlook Express e Outlook Express è quasi sempre installato. Con Windows più recente (Vista, 7) non c'è Outlook Express e quindi nessun MAPI. Ma MAPI viene installato automaticamente se si installa MS Outlook o Mozzila Thunderbird. Quindi sei abbastanza sicuro. Questo è MAPI di base e MAPI estesa. Ma copre tutto ciò di cui hai bisogno.

È anche possibile controllare il codice (JCL) se MAPI è installato e agire in modo appropriato. Ho fatto una cosa simile non molto tempo fa e funziona bene. Non ho trovato un client di posta Windows popolare che non supporta MAPI semplice. Questo è un semplice wrapper codice JCL e l'utilizzo del campione sotto: utilizzo

unit MAPI.SendMail; 

interface 

uses 
    SysUtils, Classes, JclMapi; 

type 
    TPrerequisites = class 
    public 
    function IsMapiAvailable: Boolean; 
    function IsClientAvailable: Boolean; 
    end; 

    TMAPISendMail = class 
    private 
    FAJclEmail: TJclEmail; 
    FShowDialog: Boolean; 
    FResolveNames: Boolean; 
    FPrerequisites: TPrerequisites; 
    // proxy property getters 
    function GetMailBody: string; 
    function GetHTMLBody: Boolean; 
    function GetMailSubject: string; 
    // proxy property setters 
    procedure SetMailBody(const Value: string); 
    procedure SetHTMLBody(const Value: Boolean); 
    procedure SetMailSubject(const Value: string); 
    protected 
    function DoSendMail: Boolean; virtual; 
    public 
    constructor Create; 
    destructor Destroy; override; 
    // properties of the wrapper class 
    property MailBody: string read GetMailBody write SetMailBody; 
    property HTMLBody: Boolean read GetHTMLBody write SetHTMLBody; 
    property ShowDialog: Boolean read FShowDialog write FShowDialog; 
    property MailSubject: string read GetMailSubject write SetMailSubject; 
    property ResolveNames: Boolean read FResolveNames write FResolveNames; 
    property Prerequisites: TPrerequisites read FPrerequisites; 
    // procedure and functions of the wrapper class 
    procedure AddRecipient(const Address: string; const Name: string = ''); 
    procedure AddAttachment(const FileName: string); 
    function SendMail: Boolean; 
    end; 

implementation 

{ TMAPISendMail } 

constructor TMAPISendMail.Create; 
begin 
    FPrerequisites := TPrerequisites.Create; 
    FAJclEmail := TJclEmail.Create; 
    FShowDialog := True; 
end; 

destructor TMAPISendMail.Destroy; 
begin 
    FreeAndNil(FAJclEmail); 
    FreeAndNil(FPrerequisites); 

    inherited; 
end; 

function TMAPISendMail.DoSendMail: Boolean; 
begin 
    Result := FAJclEmail.Send(FShowDialog); 
end; 

function TMAPISendMail.SendMail: Boolean; 
begin 
    Result := DoSendMail; 
end; 

function TMAPISendMail.GetMailBody: string; 
begin 
    Result := FAJclEmail.Body; 
end; 

procedure TMAPISendMail.SetMailBody(const Value: string); 
begin 
    FAJclEmail.Body := Value; 
end; 

procedure TMAPISendMail.AddAttachment(const FileName: string); 
begin 
    FAJclEmail.Attachments.Add(FileName); 
end; 

procedure TMAPISendMail.AddRecipient(const Address, Name: string); 
var 
    LocalName: string; 
    LocalAddress: string; 
begin 
    LocalAddress := Address; 
    LocalName := Name; 

    if FResolveNames then 
    if not FAJclEmail.ResolveName(LocalName, LocalAddress) then 
     raise Exception.Create('Could not resolve Recipient name and address!'); 

    FAJclEmail.Recipients.Add(LocalAddress, LocalName); 
end; 

function TMAPISendMail.GetMailSubject: string; 
begin 
    Result := FAJclEmail.Subject; 
end; 

procedure TMAPISendMail.SetMailSubject(const Value: string); 
begin 
    FAJclEmail.Subject := Value; 
end; 

function TMAPISendMail.GetHTMLBody: Boolean; 
begin 
    Result := FAJclEmail.HtmlBody; 
end; 

procedure TMAPISendMail.SetHTMLBody(const Value: Boolean); 
begin 
    FAJclEmail.HtmlBody := Value; 
end; 

{ TPrerequisites } 

function TPrerequisites.IsClientAvailable: Boolean; 
var 
    SimpleMAPI: TJclSimpleMapi; 
begin 
    SimpleMAPI := TJclSimpleMapi.Create; 
    try 
    Result := SimpleMAPI.AnyClientInstalled; 
    finally 
    SimpleMAPI.Free; 
    end; 
end; 

function TPrerequisites.IsMapiAvailable: Boolean; 
var 
    SimpleMAPI: TJclSimpleMapi; 
begin 
    SimpleMAPI := TJclSimpleMapi.Create; 
    try 
    Result := SimpleMAPI.SimpleMapiInstalled; 
    finally 
    SimpleMAPI.Free; 
    end; 
end; 

end. 

Esempio:

unit f_Main; 

interface 

uses 
    Windows, SysUtils, Classes, Controls, Forms, Graphics, StdCtrls, XPMan, 

    // project units 
    JclMapi, MAPI.SendMail, Dialogs; 

type 
    TfMain = class(TForm) 
    XPManifest: TXPManifest; 
    gbMailProperties: TGroupBox; 
    eMailSubject: TEdit; 
    stMailSubject: TStaticText; 
    stMailBody: TStaticText; 
    mmMailBody: TMemo; 
    cbHTMLBody: TCheckBox; 
    gbAttachments: TGroupBox; 
    gbRecipients: TGroupBox; 
    btnSendMail: TButton; 
    lbRecipients: TListBox; 
    eRecipAddress: TEdit; 
    StaticText1: TStaticText; 
    eRecipName: TEdit; 
    btnAddRecipient: TButton; 
    stRecipName: TStaticText; 
    OpenDialog: TOpenDialog; 
    lbAttachments: TListBox; 
    btnAddAttachment: TButton; 
    stMAPILabel: TStaticText; 
    stClientLabel: TStaticText; 
    stMAPIValue: TStaticText; 
    stClientValue: TStaticText; 
    procedure btnSendMailClick(Sender: TObject); 
    procedure btnAddRecipientClick(Sender: TObject); 
    procedure btnAddAttachmentClick(Sender: TObject); 
    procedure FormCreate(Sender: TObject); 
    private 
    { Private declarations } 
    public 
    { Public declarations } 
    end; 

var 
    fMain: TfMain; 

implementation 

{$R *.dfm} 

procedure TfMain.btnSendMailClick(Sender: TObject); 
var 
    I: Integer; 
    Name: string; 
    Address: string; 
    ItemStr: string; 
    Pos1, Pos2: Integer; 
    MAPISendMail: TMAPISendMail; 
begin 
    MAPISendMail := TMAPISendMail.Create; 
    try 
    for I := 0 to lbRecipients.Items.Count - 1 do 
    begin 
     ItemStr := lbRecipients.Items[I]; 
     Pos1 := Pos('[', ItemStr); 
     Pos2 := Pos(']', ItemStr); 

     Name := Trim(Copy(ItemStr, Pos1 + 1, Pos2 - Pos1 - 1)); 
     Address := Trim(Copy(ItemStr, 1, Pos1 - 1)); 
     MAPISendMail.AddRecipient(Address, Name); 
    end; 

    for I := 0 to lbAttachments.Items.Count - 1 do 
     MAPISendMail.AddAttachment(lbAttachments.Items[I]); 

    MAPISendMail.MailSubject := eMailSubject.Text; 
    MAPISendMail.HTMLBody := cbHTMLBody.Checked; 
    MAPISendMail.MailBody := mmMailBody.Text; 
    MAPISendMail.SendMail; 
    finally 
    MAPISendMail.Free; 
    end; 
end; 

procedure TfMain.btnAddRecipientClick(Sender: TObject); 
begin 
    lbRecipients.Items.Add(Format('%s [%s]', [eRecipAddress.Text, 
              eRecipName.Text])); 
end; 

procedure TfMain.btnAddAttachmentClick(Sender: TObject); 
begin 
    if OpenDialog.Execute then 
    lbAttachments.Items.Add(OpenDialog.FileName); 
end; 

procedure TfMain.FormCreate(Sender: TObject); 
var 
    ValidHost: Boolean; 
    MAPISendMail: TMAPISendMail; 
begin 
    MAPISendMail := TMAPISendMail.Create; 
    try 
    ValidHost := True; 

    if MAPISendMail.Prerequisites.IsMapiAvailable then 
    begin 
     stMAPIValue.Caption := 'Available'; 
     stMAPIValue.Font.Color := clGreen; 
    end 
    else 
    begin 
     stMAPIValue.Caption := 'Unavailable'; 
     stMAPIValue.Font.Color := clRed; 
     ValidHost := False; 
    end; 

    if MAPISendMail.Prerequisites.IsClientAvailable then 
    begin 
     stClientValue.Caption := 'Available'; 
     stClientValue.Font.Color := clGreen; 
    end 
    else 
    begin 
     stClientValue.Caption := 'Unavailable'; 
     stClientValue.Font.Color := clRed; 
     ValidHost := False; 
    end; 

    btnSendMail.Enabled := ValidHost; 
    finally 
    MAPISendMail.Free; 
    end; 
end; 

end. 

Answer 4

This article mostra come Delphi può simulare il comando del menu di scelta rapida "Invia a ..." e aprire il client di posta predefinito con allegati programmaticamente.

Questa soluzione non ha bisogno di MAPI e funziona con il client di posta predefinito, ma non è completa, poiché i destinatari del messaggio, il corpo e l'oggetto non verranno compilati automaticamente. (Il corpo del messaggio può essere copiato usando gli appunti).

Answer 5

Ecco un riepilogo di tutte le impostazioni di posta elettronica e quello che fanno:
http://thesunstroke.blogspot.de/2017/03/how-to-configure-eurekalog-to-send-bugs.html

Quindi, stare lontano da Shell (mailto).
Mapi è anche una cattiva idea poiché funziona solo con i client di posta elettronica MS.
Ho impostato per impostazione predefinita Simple MAPI ma raramente ricevo e-mail inviate da questo canale. La maggior parte delle e-mail viene ricevuta tramite il server SMTP.

GRANDE ATTENZIONE !!!!!!!!!
Ho visto che il numero di falsi allarmi positivi degli scanner antivirus è molto più alto quando si attiva EurekaLog. Quindi, usa EurekaLog solo quando è assolutamente necessario.
Inoltre, Eureka è costellato di bug (basta guardare la cronologia dei rilasci e vedere che per ogni nuova funzionalità (o anche il cambiamento) che rilasciano, in seguito correggono alcuni bug! Quindi, se stai rintracciando i bug, nota che EurekaLog si possono introdurre alcune nella vostra EXE!