Accessing Excel.Application objects of other excel instances in Running Object Table in C#

I think we are facing the same problem. I'm using windows7 and office2010, using the same way as you mentioned to get ROT table to deal with all opened excel.

you have GetRunningCOMObjectByName(string objectDisplayname) to get com object, and try to convert to Excel.Application, but it's not of that type. I've tried, if you get the object by the fullName, the object you get is the type of Excel.Workbook, so it can be converted to Workbook.It works for me.

So you can see from the ROT, every doc you opened in Excel, there is a fullName related to it.And the comObj you get by name is type of Workbook .

But I still have some questions about ROT. if we look into the ROT table, it has two items with names:!{00024505-0014-0000-C000-000000000046} and !{00024500-0000-0000-C000-000000000046}, the similar classId with Excel.Application . And if you get comObj of these 2 item, you can convert to Excel.Application. Just like the way Marshal.GetActiveObject("Excel.Application") does. And the 2 item are reference equaled.

But when there are more than one EXCEL.EXE process running, I guess that I can get more items of Application in ROT, but the truth is

1. there is still 2 items I mentioned above in ROT, which means only one Application in ROT(you can open 2 excel workbook to check it, workbook1 and workbook2)
2. But the Workbook works well, you can get alll Workbook opened(workbook1 and workbook2).
3. workbook1.Application reference equals to Application in ROT, but workbook2.Application not.

So, if there is only one Application in ROT and equals to workbook1.Applicaton, Where is the workbook2.Application? Why workbook2.Application is not registered in ROT Table?

Try the following code snippet for C# 4.0+ :

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;

namespace ROT.TestConsole
{

    /// <summary>
    /// Gets MS Excel running workbook instances via ROT
    /// </summary>
    public class MSExcelWorkbookRunningInstances
    {
        [DllImport("ole32.dll")]
        static extern int CreateBindCtx(uint reserved, out IBindCtx ppbc);

        [DllImport("ole32.dll")]
        public static extern void GetRunningObjectTable(int reserved, out IRunningObjectTable prot);

        public static IEnumerable<dynamic> Enum()
        {
            // get Running Object Table ...
            IRunningObjectTable Rot;
            GetRunningObjectTable(0, out Rot);

            // get enumerator for ROT entries
            IEnumMoniker monikerEnumerator = null;
            Rot.EnumRunning(out monikerEnumerator);

            IntPtr pNumFetched = new IntPtr();
            IMoniker[] monikers = new IMoniker[1];

            IBindCtx bindCtx;
            CreateBindCtx(0, out bindCtx);

            while (monikerEnumerator.Next(1, monikers, pNumFetched) == 0)
            {
                string applicationName = "";
                dynamic workBook = null;
                try
                {
                    Guid IUnknown = new Guid("{00000000-0000-0000-C000-000000000046}");                    
                    monikers[0].BindToObject(bindCtx, null, ref IUnknown, out workBook);
                    applicationName = workBook.Application.Name;
                }
                catch { }

                if (applicationName == "Microsoft Excel") yield return workBook;
            }
        }

    }
}

Test it with:

using System;

namespace ROT.TestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int index = 1;
                foreach (dynamic workbook in MSExcelWorkbookRunningInstances.Enum())
                    System.Console.WriteLine("{0}.  '{1}' '{2}'", index++, workbook.Application.Name, workbook.FullName);
            }
            catch (Exception ex)
            {
                System.Console.WriteLine("Error = '{0}'", ex.Message);   
            }
        }
    }
}

ShamilS's code worked perfectly for me. But I don't really like using dynamic. So I modified it a little to work with Microsoft.Office.Interop.Excel. Also I found out that it is better to use typeof(Excel.Workbook).GUID instead of hardcoded new Guid("{00000000-0000-0000-C000-000000000046}"), because it only gives you excel workbooks without redundant com objects.

using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;

using Excel = Microsoft.Office.Interop.Excel;

private IEnumerable<Excel.Workbook> GetExcelWorkbooks()
{
    GetRunningObjectTable(0, out var rot);

    rot.EnumRunning(out var monikerEnumerator);

    IntPtr numFetched = new IntPtr();
    IMoniker[] monikers = new IMoniker[1];

    CreateBindCtx(0, out var bindCtx);

    while (monikerEnumerator.Next(1, monikers, numFetched) == 0)
    {
        Excel.Workbook? workBook = null;
        try
        {
            var workBookGuid = typeof(Excel.Workbook).GUID;
            monikers[0].BindToObject(bindCtx, null, ref workBookGuid, out var tmpWbObject);
            workBook = (Excel.Workbook)tmpWbObject;
        }
        catch (Exception ex)
        {
            continue;
        }

        if (workBook == null)
            continue;

        yield return workBook;
    }
}