Modificar um anexo de uma mensagem de email do Outlook
Este tópico descreve como modificar programaticamente um anexo de email do Microsoft Outlook sem alterar o arquivo original.
Fornecido por: Ken Getz, MCW Technologies, LLC
É fácil enviar uma mensagem de email com um ou mais anexos na interface do Outlook e por programação. Em algumas situações, no entanto, talvez você queira ter a capacidade de modificar o anexo após ele ter sido anexado ao item de email sem que o arquivo original no sistema de arquivos seja alterado. Em outras palavras, talvez seja necessária uma forma programática para acessar o conteúdo do anexo na memória.
Por exemplo, imagine que seu aplicativo exija a conversão em maiúsculas dos textos em todos os anexos que tenham uma extensão .txt. Em um suplemento gerenciado do Outlook, você pode lidar facilmente com o evento ItemSend . Nesse caso, realize o trabalho antes de enviar o item de email. A parte difícil do cenário é a recuperação do conteúdo dos anexos para modificar o conteúdo de cada arquivo de texto.
O código de exemplo neste tópico demonstra como resolver esse problema específico, usando os métodos GetProperty(String) e SetProperty(String, Object) da interface Attachment . Em cada caso, você fornece um valor que contém a propriedade MAPI PidTagAttachDataBinary para obter (e, em seguida definir) o conteúdo do anexo.
Nota A representação do namespace da propriedade PidTagAttachDataBinary é https://schemas.microsoft.com/mapi/proptag/0x37010102. Para obter mais informações sobre como usar o objeto PropertyAccessor em propriedades referenciadas pelo namespace, consulte Referencing Properties by Namespace.
O código de exemplo manipula o evento ItemSend de um item de email. No manipulador de eventos personalizado, para qualquer anexo que tenha uma extensão .txt, o código chama o ConvertAttachmentToUpperCase método. ConvertAttachmentToUpperCase usa um objeto Attachment e um objeto MailItem como argumentos de entrada, recupera uma matriz de bytes que é preenchida com o conteúdo do anexo, converte a matriz de bytes em uma cadeia de caracteres, converte a cadeia de caracteres em maiúsculas e define o conteúdo do anexo para a cadeia de caracteres convertida como uma matriz de bytes.
The following managed code samples are written in C# and Visual Basic. To run a .NET Framework managed code sample that needs to call into a Component Object Model (COM), you must use an interop assembly that defines and maps managed interfaces to the COM objects in the object model type library. For Outlook, you can use Visual Studio and the Outlook Primary Interop Assembly (PIA). Before you run managed code samples for Outlook 2013, ensure that you have installed the Outlook 2013 PIA and have added a reference to the Microsoft Outlook 15.0 Object Library component in Visual Studio.
Você deve usar os exemplos de código a ThisAddIn seguir na classe de um suplemento do Outlook (usando ferramentas de desenvolvedor do Office para Visual Studio). The Application object in the code must be a trusted Outlook Application object provided by ThisAddIn.Globals. For more information about using the Outlook PIA to develop managed Outlook solutions, see the Outlook 2013 Primary Interop Assembly Reference on MSDN.
O código a seguir mostra como você pode modificar programaticamente um anexo de email do Outlook sem alterar o arquivo original. Para demonstrar essa funcionalidade, no Visual Studio, crie um novo suplemento gerenciado do Outlook chamado ModifyAttachmentAddIn. Substitua o código em ThisAddIn.cs ou ThisAddIn pelo seguinte código.
Nota Para acessar os dados de anexo, o item de email deve ser salvo usando o método 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
Confira também
Anexar um arquivo a um item de email
Anexar um item de contato do Outlook a uma mensagem de Email
Limitar o tamanho de um anexo para uma mensagem de Email do Outlook
Suporte e comentários
Tem dúvidas ou quer enviar comentários sobre o VBA para Office ou sobre esta documentação? Confira Suporte e comentários sobre o VBA para Office a fim de obter orientação sobre as maneiras pelas quais você pode receber suporte e fornecer comentários.