COM Interop & Outlook - Make Outlook Visible?

Question

I'm automating Outlook from a VB.NET program, transferring items into the calendar and contacts at the user's request. It's all working, that isn't the problem; the problem is that automating Outlook like this when it wasn't already open creates a hidden instance. I can perhaps understand how this could be useful, to stop the user closing it down while you're still working on it, but since Outlook appears to force one instance only, if the user tries to inspect the changes made while my program is still hooked into Outlook, nothing happens - the one instance is that hidden instance and the user can't see anything.

In the old days of COM automation I used to be able to make Word or Excel visible, but I seem unable to do that with Outlook. I've tried:

OutlookApp.Visible = True

OutlookApp.Application.Visible = True

OutlookApp.ActiveWindow.Visible = True

OutlookApp.ActiveExplorer.Display()

but none of them work.

It's not critical, but does anyone know if I can get Outlook to show its main window? Bonus points if I can get it to disallow the user to close down the instance, but I'll settle for just showing the window :)

Only 9 years and 9 months later, I had the same question and found a simple solution that I described in my answer below. No need to look at the registry ... — Thomas Barnekow, Mar 01 '20 at 18:08

score 4 · Answer 1 · answered Jul 04 '13 at 08:14

4

You can show your create mail like this :

mailItem.Display();

It is c# code, but I think, this but be close to your vb.

answered Jul 04 '13 at 08:14

provençal le breton

1,428
4
26
43

score 2 · Accepted Answer · answered May 26 '10 at 16:55

2

I normaly test to see if the "Outlook" process is running first, if not then shell up Outlook.exe then attach. This way you should never get a hidden process.

There really is no way to cancel the shut down outlook, you can hook the application quit event to disconnect and dispose in your app though.

answered May 26 '10 at 16:55

76mel

3,993
2
22
21

Hmmm, I was going to say "I understand but that relies on knowing Outlook's path and filename...". Now it finally dawned on me that we *do* know that - the registry will tell us how who provides "Outlook.Application". So thanks - glad I came back to this answer now. – JTeagle Jun 02 '10 at 17:20
If you read this now, have a look at my answer below, which provides a simpler solution if you are using .NET. – Thomas Barnekow Mar 01 '20 at 18:02

score 2 · Answer 3 · answered Mar 01 '20 at 18:00

I came across this question just now because I had the same challenge. I wasn't entirely happy with the accepted answer since this meant I would have to determine the full path of Outlook.exe. "Shelling up Outlook.exe" does not work. Therefore, I looked for and found another solution. But before I present that, let's look at how you can determine the full path of Outlook.exe if you want to do that.

To determine the full path of Outlook.exe, you need to fetch the Path value from the

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office\16.0\Outlook\InstallRoot

registry key (assuming you have Office 16, a.k.a. Office 2016 or 2019) and build the full path of Outlook.exe. On my machine, the Path value is

C:\Program Files\Microsoft Office\root\Office16

so the full path is

C:\Program Files\Microsoft Office\root\Office16\Outlook.exe

However, you need to take into account that the user might have an older (e.g., Office 15, a.k.a. Office 2013) or newer Office version installed and pick the appropriate registry key. You can also get the Office version by retrieving the default value of the

HKEY_CLASSES_ROOT\Outlook.Application\CurVer

key (e.g., Outlook.Application.16). From this, you can infer the version number (e.g., 16) and build the segment of your registry key (e.g., 16.0). Or you can try to find the key with a subkey Outlook\InstallRoot having a Path value. Anyhow, you might see why I wanted to avoid this.

So let's look at an easier solution, noting that I am working with multiple Office applications and, therefore, have the following using directive:

using Outlook = Microsoft.Office.Interop.Outlook;

To make Outlook show its main window if no window is currently visible, I wrote the following utility method:

private static void EnsureOutlookIsVisible(Outlook.Application outlook)
{
    object window = null;
    NameSpace ns = null;
    MAPIFolder folder = null;

    try
    {
        // Check whether Outlook has an active window. If so, Outlook is visible
        // and we don't have to do anything.
        window = outlook.ActiveWindow();
        if (window != null) return;

        // No active window is shown, so Outlook is not visible and we need to
        // have Outlook display a window.
        ns = outlook.GetNamespace("MAPI");
        folder = ns.GetDefaultFolder(OlDefaultFolders.olFolderInbox);
        folder.Display();
    }
    finally
    {
        folder.ReleaseComObject();
        ns.ReleaseComObject();
        window.ReleaseComObject();
    }
}

The above method uses the following extension method to release COM objects:

public static void ReleaseComObject<T>(this T resource) where T : class
{
    if (resource != null && Marshal.IsComObject(resource))
    {
        Marshal.ReleaseComObject(resource);
    }
}

With the above methods, to attach to a new or existing Outlook process and make sure Outlook shows its main window, all you need are the following two lines of code:

var outlook = new Outlook.Application();
EnsureOutlookIsVisible(outlook);

COM Interop & Outlook - Make Outlook Visible?

3 Answers3

Linked