Imports Office = Microsoft.Office.Core
Imports Outlook = Microsoft.Office.Interop.Outlook

using Office = Microsoft.Office.Core;
using Outlook = Microsoft.Office.Interop.Outlook;

Private Sub btnSend_Click(ByVal sender As System.Object, _
            ByVal e As System.EventArgs) Handles btnSend.Click

    ' Obtient l'objet Outlook Application
    Dim outlookApplication As Outlook.Application = New Outlook.Application()

    ' Obtient l'objet d'espace de nom
    Dim olNamespace As Outlook.NameSpace = _
                okApplication.GetNamespace("MAPI")

    ' Se loggue à la session : ici, nous utilisons un Outlook déjà ouvert
    olNamespace.Logon(, , True, True)

    ' Création d'un nouveau mail et remplissage avec les informations fournies dans le formulaire 
    Dim newMail As Outlook.MailItem = _
        lookApplication.CreateItem(Outlook.OlItemType.olMailItem)
    newMail.To = tbxRecipientAddress.Text
    newMail.Subject = tbxSubject.Text
    newMail.Body = tbxMessage.Text

    newMail.Send()
    newMail = Nothing

    ' logoff de l'espace de nom (session)
    olNamespace.Logoff()

    ' Libère la référence à l'objet Outlook
    outlookApplication = Nothing

    ' Laisse le Garbagecollector faire son boulot

    GC.Collect()
    GC.WaitForPendingFinalizers()

End Sub

private void btnSend_Click(object sender, EventArgs e)
{
    object missing = System.Reflection.Missing.Value;

    // Obtient l'objet Outlook Application
    Outlook.Application outlookApplication = new Outlook.Application();

    // Obtient l'objet d'espace de nom
    Outlook.NameSpace nameSpace = outlookApplication.GetNamespace("MAPI");

    // Se loggue à la session : ici, nous utilisons un Outlook déjà ouvert
    nameSpace.Logon(missing, missing, true, true);

    // Création d'un nouveau mail et remplissage avec les informations fournies dans le formulaire
    Outlook.MailItem newMail = _
        lookApplication.CreateItem(Outlook.OlItemType.olMailItem);
    newMail.To = tbxRecipientAddress.Text;
    newMail.Subject = tbxSubject.Text;
    newMail.Body = tbxMessage.Text;

    newMail.Send();
    newMail = null;

    // logoff de l'espace de nom (session)
    olNamespace.Logoff();

    // Libère la référence à l'objet Outlook
    outlookApplication = Nothing;

    // Laisse le Garbagecollector faire son boulot
    GC.Collect();
    GC.WaitForPendingFinalizers();
}

#pragma once
#include <MAPIX.h>
#include <MapiUtil.h>
#include <MAPIGuid.h>
#include <MAPITags.h>

#pragma once

using namespace System;
using namespace System::Runtime::InteropServices;

namespace MAPIConcubine 
{

    ///
    /// The Fabric Class defines Methods and Functions to access 
    /// Extended MAPI Functions from .NET
    ///
    public ref class Fabric
    {
        // private methods and variables
        private:

        // destructor
        ~Fabric();

        ///
        /// Used to retrieve a human readable Errormessage from a 
        /// MAPI Errorcode.
        ///
        /// [in]dw - the error number returned from MAPI
        /// [returns] Returns the Errormessage to the given Errornumber.
        String^ GetErrorText(DWORD dw);


        // All public visible methods
        public:

        // construction code
        Fabric();

        ///
        /// Adds an InternetHeader to an outgoing Outlook- Email Message
        ///
        /// [in]mapiObject - The MAPIOBJECT property of the Outlook mailItem
        /// [in]headerName - The name of the header to add
        /// [in]headerValue - The value of the header to add
        void AddMessageHeader(Object^ mapiObject, String^ headerName, 
                            String^ headerValue);

    };
}

/// Ajoute un entête à un mail sortant
///
/// [in]mapiObject - La propriété MAPIOBJECT du mailItem Outlook 
/// [in]headerName - Le nom de l'entête à ajouter
/// [in]headerValue - La valeur de l'entête à ajouter
void Fabric::AddMessageHeader(Object^ mapiObject, String^ headerName, 
    String^ headerValue)
{

    // Pointeur vers l'interface IUnknown
    IUnknown* pUnknown = 0;

    // Pointeur vers IMessage 
    IMessage* pMessage = 0;

    // Pointer to IMAPIProp Interface
    IMAPIProp* pMAPIProp = 0;

    // Une structure pour la variable MANEDProp 
    MAPINAMEID* pNamedProp = 0;

    // Un tableau de PropertyTags comme résultat pour la méthode GetIDdFromNames.
    SPropTagArray* lpTags = 0;

    // Converti les chaines de caractères .Net en blocs de mémoire non-managée
    IntPtr pHeaderName = Marshal::StringToHGlobalUni (headerName);
    IntPtr pHeaderValue = Marshal::StringToHGlobalUni  (headerValue);

    // si nous n'avons pas notre MAPIObject rien ne sert de continuer...
    if (mapiObject == nullptr)
            throw gcnew System::ArgumentNullException 
            ("mapiObject","The MAPIObject must not be null!");
    try
    {
        // récupère l'interface IUnknon depuis notre MAPIObject 
        // venant d'Outlook.
        pUnknown = (IUnknown*)Marshal::GetIUnknownForObject
                        (mapiObject).ToPointer ();

        // essaie de récupérer l'interface IMessage, 
        // si on ne l'a pas, autant arrêter de suite.
        if ( pUnknown->QueryInterface 
            (IID_IMessage, (void**)&pMessage) != S_OK)
           throw gcnew Exception
            ("QueryInterface failed on IUnknown for IID_Message");

        // Essaie de récupérer l'interface IMAPIProp depuis l'interface IMessage, 
        // sinon on s'arrête.
        if ( pMessage->QueryInterface 
            (IID_IMAPIProp, (void**)&pMAPIProp) != S_OK)
           throw gcnew Exception
        ("QueryInterface failed on IMessage for IID_IMAPIProp");

        // revérifie et si on a pas de pointeur, on quitte...
        if (pMAPIProp == 0)
           throw gcnew Exception
        ("Unknown Error on receiving the Pointer to MAPI Properties.");

        // Un ID super bien documenté par Google est utilisé pour accéder aux entêtes SMTP d'un message Outlook.
        GUID magicId = { 0x00020386, 0x0000, 0x0000, 
            { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } };

        // Le pointeur vers la structure namedProp 
        if (MAPIAllocateBuffer(sizeof(MAPINAMEID), 
                (LPVOID*)&pNamedProp) != S_OK)
           throw gcnew Exception("Could not allocate memory buffer.");

        // L'ID est utilisé pour accéder à la propriété nommée
        pNamedProp->lpguid = (LPGUID)&magicId;

        // Défini la propriété Nom
        pNamedProp->ulKind = MNID_STRING;
        pNamedProp->Kind.lpwstrName = (LPWSTR) pHeaderName.ToPointer();

        // Appelle GetIDsFromNames pour retrouver la propertyID à utiliser
        if(pMAPIProp->GetIDsFromNames
            (1, &pNamedProp,  MAPI_CREATE, &lpTags ) != S_OK)
          throw gcnew Exception(String::Format 
        ("Error retrieving GetIDsFromNames: {0}.",headerName) );

        // La variable qui sera passé à la méthode HrSetOneProp.
        SPropValue value;
        // La macro PROP_TAG créé la valleur correcte depuis la valeur type et la valeur ID

        value.ulPropTag = PROP_TAG(PT_UNICODE, PROP_ID
                    (lpTags->aulPropTag[0]));
        // Ici, nous passons une chaine unicode à la méthode et définissons la propriété LPSZ
        value.Value.LPSZ = (LPWSTR) pHeaderValue.ToPointer();

        // La méthode HrSetOneProp est utilisé pour définir la propriété sur l'objet MAPI
        if( HrSetOneProp(pMAPIProp, &value) != S_OK)
          throw gcnew Exception(String::Format 
                ("Error setting Header: {0}.",headerName) );
    }
    catch (Exception^ ex)
    {
        DWORD dw = GetLastError();
        throw gcnew Exception(GetErrorText(dw),ex);
    }
    finally
    {

        if (pNamedProp != 0) MAPIFreeBuffer(pNamedProp);
        if (lpTags != 0) MAPIFreeBuffer(lpTags);

        // libère la mémoire non managée
        Marshal::FreeHGlobal (pHeaderName);
        Marshal::FreeHGlobal (pHeaderValue);

        // Nettoie toutes les références aux objets COM
        if (pMAPIProp!=0) pMAPIProp->Release();
        if (pMessage!=0) pMessage->Release();
        if (pUnknown!=0) pUnknown->Release();
    }
}

#pragma once

#define INITGUID
#define USES_IID_IMAPIProp
#define USES_IID_IMessage

#include <MAPIX.h>
#include <MapiUtil.h>
#include <MAPIGuid.h>
#include <MAPITags.h>

/// 
/// Code de construction - Nous pouvons initialiser la session MAPI ici 
/// 
Fabric::Fabric () 
{     
    MAPIInitialize(0); 
} 
/// 
/// Destructeur - Nettoyage de la session ici 
/// 
Fabric::~Fabric () 
{     
    MAPIUninitialize(); 
} 

/// Cette méthode prend un code erreur MAPI en paramètre (GetLastError()) 

/// et retourne le message d'erreur en chaîne de caractère managée. 
///
/// [in]dw - le code d'erreur MAPI.
/// [return] retourne le message d'erreur.
String^ Fabric::GetErrorText(DWORD dw)
{
    LPVOID lpMsgBuf;

    FormatMessage(
       FORMAT_MESSAGE_ALLOCATE_BUFFER |
       FORMAT_MESSAGE_FROM_SYSTEM,
       NULL,
       dw,
       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
       (LPTSTR) &lpMsgBuf,
       0, NULL );

    String^ result = Marshal::PtrToStringAuto (IntPtr::IntPtr (lpMsgBuf));

    LocalFree(lpMsgBuf);

    return result;

}

' Créez un nouveau mail et remplissez le avec les informations fournies dans le formulaire. 
Dim newMail As Outlook.MailItem = _     
    outlookApplication.CreateItem(Outlook.OlItemType.olMailItem) 
' Ici, nous pouvons utiliser notre bibliothèque C++ 
Dim fabric As MAPIConcubine.Fabric = New MAPIConcubine.Fabric() 
' Nous passons la propriété MAPIObject notre bibliothèque et nos parametres 
' notez qu'en VB.Net, vous ne pouvez pas voir la propriété MAPIOBJECT 
' mais soyez sûrs qu'elle est bien là 
fabric.AddMessageHeader(newMail.MAPIOBJECT, tbxHeaderName.Text, _
    tbxHeaderValue.Text) 
' C'est tout 
fabric = Nothing 
newMail.To = tbxRecipientAddress.Text 
newMail.Subject = tbxSubject.Text 
newMail.Body = tbxMessage.Text 
' Envoi de l'email 
newMail.Send()

// Crée un nouveau mail et le rempli avec les informations fournies dans le formulaire
Outlook.MailItem newMail = outlookApplication.CreateItem     
(Outlook.OlItemType.olMailItem) as Outlook.MailItem; 
// Ici, nous pouvons utiliser notre bibliothèque C++ 
MAPIConcubine.Fabric fabric = new MAPIConcubine.Fabric(); 
// Nous passons la propriété MAPIObject notre bibliothèque et nos parametres 
// notez qu'en VB.Net, vous ne pouvez pas voir la propriété MAPIOBJECT 
// mais soyez sûrs qu'elle est bien là 
fabric.AddMessageHeader(newMail.MAPIOBJECT, tbxHeaderName.Text,
     tbxHeaderValue.Text); 
// c'est tout 
fabric = null; 
newMail.To = tbxRecipientAddress.Text; 
newMail.Subject = tbxSubject.Text; 
newMail.Body = tbxMessage.Text; 
newMail.Send(); 

/// 
/// Lis l'entête depuis un message Outlook 
/// 
/// [in] mapiObject - la propriété MAPIOBJECT de l'objet mailItem 
/// [in] headerName - Nom de l'entête à retrouver. 
/// [returns] headerValue - la valeur de l'entête avec le nom donné 
String^ Fabric::ReadMessageHeader(Object^ mapiObject, String^ headerName) 
{         
   // Pointeur vers l'interface IUnknown
   IUnknown* pUnknown = 0;
   // Pointeur vers l'interface IMessage
   IMessage* pMessage = 0;
   // Pointeur vers l'interface IMAPIProp
   IMAPIProp* pMAPIProp = 0;
   // La structure pour la variable MANEDProp
   MAPINAMEID* pNamedProp = 0;
   // Un tableau de PropertyTags comme résultat pour la méthode GetIDdFromNames Method.
   SPropTagArray* lpTags = 0;
   // Pointeur vers la structure qui reçoit le résultat de HrGetOneProp
   LPSPropValue lpSPropValue = 0;
   // Converti les chaînes de caractères .Net en blocs de mémoire non managé
   IntPtr pHeaderName = Marshal::StringToHGlobalUni (headerName);
   // Si nous n'avons pas notre MAPIObject, autant tout arrêter
   if (mapiObject == nullptr)
      throw gcnew System::ArgumentNullException ("mapiObject","The MAPIObject must not be null!");     
   try   
   {         
      // Récupère l'interface IUnknon depuis notre MAPIObject venant d'Outlook         
      pUnknown = (IUnknown*)Marshal::GetIUnknownForObject(mapiObject).ToPointer ();         
      // Essaie de récupérer l'interface IMessag, si on ne peut pas, on arrêter         
      if ( pUnknown->QueryInterface (IID_IMessage, (void**)&pMessage) != S_OK)             
         throw gcnew Exception("QueryInterface failed on IUnknown for IID_Message");         
      // essaie de récupérer l'interface depuis l'interface IMessage, sinon on arrête.         
      if ( pMessage->QueryInterface (IID_IMAPIProp, (void**)&pMAPIProp) != S_OK)
         throw gcnew Exception("QueryInterface failed on IMessage for IID_IMAPIProp");         
      // double vérification         
      if (pMAPIProp == 0) 
         throw gcnew Exception("Unknown Error on receiving the Pointeur versMAPI Properties.");         
      // Un ID trouvable via google et « bien documenté » pour accéder aux entêtes SMTP d'un message Outlook        
      GUID magicId =         
         {             
            x00020386, 0x0000, 0x0000,             
            {                 
               0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46             
            }         
         };                 
      // Le pointeur vers la structure namedProp         
      if (MAPIAllocateBuffer(sizeof(MAPINAMEID), (LPVOID*)&pNamedProp) != S_OK) 
         throw gcnew Exception("Could not allocate memory buffer.");         
      // L'ID utilisé pour accéder la propriété nommée        
      pNamedProp->lpguid = (LPGUID)&magicId;         
      // Défini PropertyName         
      pNamedProp->ulKind = MNID_STRING;         
      NamedProp->Kind.lpwstrName = (LPWSTR) pHeaderName.ToPointer();         
      // Appelle GetIDsFromNames pour retrouver propertyID à utiliser         
      if(pMAPIProp->GetIDsFromNames(1, &pNamedProp,STGM_READ, &lpTags ) != S_OK)
         throw gcnew Exception(String::Format ( "Error retrieving GetIDsFromNames: {0}.",headerName) );         
      // La macro PROP_TAG créé la bonne valeur pour Type PropertyID         
      ULONG propTag = PROP_TAG(PT_UNICODE, PROP_ID(lpTags->aulPropTag[0]));         
      // utilise la méthode HrGetOneProp pour retrouver la propriété.