Partage via

Modifier une pièce jointe d'un message électronique Outlook

  • Article

Cette rubrique décrit comment vous pouvez modifier par programmation une pièce jointe de message électronique Microsoft Outlook sans modifier le fichier d'origine.

Fourni par : Ken Getz, MCW Technologies, LLC

Il est facile d'envoyer un message électronique avec une ou plusieurs pièces jointes dans l'interface Outlook comme par programmation. Toutefois, dans certains cas, vous souhaiterez peut-être modifier la pièce jointe après qu'elle a été jointe à l'élément de messagerie, sans modifier le fichier d'origine dans le système de fichiers. En d'autres termes, vous aurez peut-être besoin d'une méthode par programmation pour accéder au contenu de la pièce jointe dans la mémoire.

Par exemple, imaginez que votre application nécessite la conversion en majuscules du texte de toutes les pièces jointes portant une extension .txt. Dans un complément Outlook géré, vous pouvez facilement gérer l’événement ItemSend . Dans ce cas, effectuez le travail avant d'envoyer l'élément de messagerie. La partie difficile du scénario consiste à récupérer les contenus des pièces jointes pour modifier le contenu de chaque fichier texte.

L’exemple de code de cette rubrique montre comment résoudre ce problème particulier à l’aide des méthodes GetProperty(String) et SetProperty(String, Object) de l’interface Attachment . Dans chaque cas, vous fournissez une valeur qui contient la propriété MAPI PidTagAttachDataBinary pour obtenir (puis définir) le contenu de la pièce jointe.

Note La représentation de l’espace de noms de la propriété PidTagAttachDataBinary est https://schemas.microsoft.com/mapi/proptag/0x37010102. Pour plus d'informations sur l'utilisation de l'objet PropertyAccessor sur des propriétés référencées par un espace de noms, consultez la rubrique Référencer les propriétés par un espace de noms.

L’exemple de code gère l’événement ItemSend d’un élément de courrier. Dans le gestionnaire d'événements personnalisé, pour toute pièce jointe portant une extension .txt, le code appelle la méthode ConvertAttachmentToUpperCase. ConvertAttachmentToUpperCase prend un objet Attachment et un objet MailItem comme arguments d'entrée, il extrait un tableau d'octets rempli avec le contenu de la pièce jointe, il convertit le tableau d'octets en chaîne, il convertit la chaîne en majuscules, puis il définit le contenu de la pièce jointe sur la chaîne convertie comme tableau d'octets.

Les exemples de code managé suivants sont écrits dans C# et Visual Basic. Pour exécuter un exemple de code managé .NET Framework qui doit appeler un modèle COM (Component Object Model), vous devez utiliser un assembly d’interopérabilité qui définit et mappe des interfaces managées avec des objets COM dans la bibliothèque de types de modèle objet. Pour Outlook, vous pouvez utiliser Visual Studio et l’assembly d’interopérabilité de base (PIA) d’Outlook. Avant d’exécuter des exemples de code managé pour Outlook 2013, assurez-vous que vous avez installé le PIA d’Outlook 2013 et que vous avez ajouté une référence au composant Bibliothèque d’objets Microsoft Outlook 15.0 dans Visual Studio.

Vous devez utiliser les exemples de code suivants dans la ThisAddIn classe d’un complément Outlook (à l’aide des outils de développement Office pour Visual Studio). L'objet Application dans le code doit être un objet Application Outlook approuvé fourni par ThisAddIn.Globals. Pour plus d’informations sur l’utilisation de l’assembly PIA Outlook pour développer des solutions Outlook managées, consultez bienvenue dans la référence de l’assembly d’interopérabilité principal Outlook sur MSDN.

Le code suivant montre comment modifier par programmation une pièce jointe de message électronique Outlook sans modifier le fichier d'origine. Pour illustrer cette fonctionnalité, dans Visual Studio, créez un complément Outlook managé nommé ModifyAttachmentAddIn. Remplacez le code dans ThisAddIn.cs ou ThisAddIn.vb par le code suivant.

Note Pour accéder aux données de la pièce jointe, l’élément de courrier doit être enregistré à l’aide de la méthode MailItem.Save .

using Outlook = Microsoft.Office.Interop.Outlook;
 
namespace ModifyAttachmentAddIn
{
    public partial class ThisAddIn
    {
        private void ThisAddIn_Startup(object sender, System.EventArgs e)
        {
            Application.ItemSend += new Outlook.ApplicationEvents_11_ItemSendEventHandler(Application_ItemSend);
        }
 
        private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
        {
        }
 
 
        void Application_ItemSend(object Item, ref bool Cancel)
        {
            Outlook.MailItem mailItem = Item as Outlook.MailItem;
 
            if (mailItem != null)
            {
                var attachments = mailItem.Attachments;
                // If the attachment a text file, convert its text to all uppercase.
                foreach (Outlook.Attachment attachment in attachments)
                {

                    ConvertAttachmentToUpperCase(attachment, mailItem);
                }
            }
        }
 
        private void ConvertAttachmentToUpperCase(Outlook.Attachment attachment, Outlook.MailItem mailItem)
        {
            const string PR_ATTACH_DATA_BIN =
                "https://schemas.microsoft.com/mapi/proptag/0x37010102";
 
            // Confirm that the attachment is a text file.
            if (System.IO.Path.GetExtension(attachment.FileName) == ".txt")
            {
                // There are other heuristics you could use to determine whether the 
                // the attachment is a text file. For now, keep it simple: Only
                // run this code for *.txt.
 
                // Retrieve the attachment as an array of bytes.
                var attachmentData =
                    attachment.PropertyAccessor.GetProperty(
                    PR_ATTACH_DATA_BIN);
 
                // Convert the byte array into a Unicode string.
                string data = System.Text.Encoding.Unicode.GetString(attachmentData);
                // Convert to upper case.
                data = data.ToUpper();
                // Convert the data back to an array of bytes.
                attachmentData = System.Text.Encoding.Unicode.GetBytes(data);
 
                //Set PR_ATTACH_DATA_BIN to attachmentData.
                attachment.PropertyAccessor.SetProperty(PR_ATTACH_DATA_BIN,
                    attachmentData);
            }
        }
 
        #region VSTO generated code
 
        /// <summary>
        /// Required method for Designer support - don't modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisAddIn_Startup);
            this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
        }
 
        #endregion
    }
}

Public Class ThisAddIn
 
 
    Private Sub ThisAddIn_Startup() Handles Me.Startup
 
    End Sub
 
    Private Sub ThisAddIn_Shutdown() Handles Me.Shutdown
 
    End Sub
 
    Private Sub Application_ItemSend(ByVal Item As Object, _
        ByRef Cancel As Boolean) Handles Application.ItemSend
 
        Dim mailItem As Outlook.MailItem = TryCast(Item, Outlook.MailItem)
 
        If mailItem IsNot Nothing Then
            Dim attachments = mailItem.Attachments
            For Each attachment As Outlook.Attachment In attachments
                ' If the attachment is a text file, convert to uppercase.
                ConvertAttachmentToUpperCase(attachment, mailItem)
            Next attachment
        End If
    End Sub
 
    Private Sub ConvertAttachmentToUpperCase(ByVal attachment As Outlook.Attachment, _
        ByVal mailItem As Outlook.MailItem)
        Const PR_ATTACH_DATA_BIN As String = "https://schemas.microsoft.com/mapi/proptag/0x37010102"
 
        ' Confirm that the attachment is a text file.
        If System.IO.Path.GetExtension(attachment.FileName) = ".txt" Then
 
            ' There are other heuristics you could use to determine whether the 
            ' the attachment is a text file. For now, keep it simple: Only
            ' run this code for *.txt.
 
            ' Retrieve the attachment as an array of bytes.
            Dim attachmentData = attachment.PropertyAccessor.GetProperty(PR_ATTACH_DATA_BIN)
 
            ' Convert the byte array into a Unicode string.
            Dim data As String = System.Text.Encoding.Unicode.GetString(attachmentData)
            ' Convert to upper case.
            data = data.ToUpper()
            ' Convert the data back to an array of bytes.
            attachmentData = System.Text.Encoding.Unicode.GetBytes(data)
 
            'Set PR_ATTACH_DATA_BIN to attachmentData.
            attachment.PropertyAccessor.SetProperty(PR_ATTACH_DATA_BIN, attachmentData)
         End If
    End Sub
 
End Class

Voir aussi

Joindre un fichier à un élément de courrier

Attacher un élément de Contact Outlook dans un Message électronique

Limiter la taille d'une pièce jointe à un Message de courrier électronique Outlook

Assistance et commentaires

Avez-vous des questions ou des commentaires sur Office VBA ou sur cette documentation ? Consultez la rubrique concernant l’assistance pour Office VBA et l’envoi de commentaires afin d’obtenir des instructions pour recevoir une assistance et envoyer vos commentaires.