hi,
try this: I wrote this in builder but it should work in VC++


BOOL EnumWindowsProc(HWND hWnd, long lParam)
{
     char Buff[255], NameOfClass[255];

     GetWindowText(hWnd, Buff, 254);
     GetClassName(hWnd, NameOfClass, 254);
     cout << "Window Text: " << Buff << "\t" << "Class Name: "
           << NameOfClass << endl;

     return TRUE;
}

int main(int argc, char* argv[])
{
     EnumWindows((WNDENUMPROC)EnumWindowsProc, 0);
     cin.ignore();
     return 0;
}

Ok, You can use EnumProc instead here is a code example from the MSDN help

#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include "psapi.h"

void PrintProcessNameAndID( DWORD processID )
{
    TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");

    // Get a handle to the process.

    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
                                   PROCESS_VM_READ,
                                   FALSE, processID );

    // Get the process name.

    if (NULL != hProcess )
    {
        HMODULE hMod;
        DWORD cbNeeded;

        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod),
             &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName,
                               sizeof(szProcessName)/sizeof(TCHAR) );
        }
    }

    // Print the process name and identifier.

    _tprintf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );

    CloseHandle( hProcess );
}

void main( )
{
    // Get the list of process identifiers.

    DWORD aProcesses[1024], cbNeeded, cProcesses;
    unsigned int i;

    if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
        return;

    // Calculate how many process identifiers were returned.

    cProcesses = cbNeeded / sizeof(DWORD);

    // Print the name and process identifier for each process.

    for ( i = 0; i < cProcesses; i++ )
        PrintProcessNameAndID( aProcesses[i] );
}

If you're going to rely on the same calls in Visual C++ .Net that you're using in VB.Net, I seriously doubt if you'd see any speed difference between the two.  

I'm not sure how you're doing things, but based on what you posted it looks like you're iterating over your array and generating a process list each time.  If that's what you're actually doing, you can increase the efficiency significantly if you do things differently.  Hash your current process list and then just check if the hash contains the name you want to kill.  Here's a Visual C++.Net version of that:

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::Collections;


Hashtable* GetProcessListAsHash();

int _tmain()
{
      System::Collections::Hashtable* hProcessList = GetProcessListAsHash();

      String*      killList[] = {"notepad", "winword"};
      Process* processToKill;

      for (int i=0; i < killList->GetLength(0); i++)
      {
            String* lower = killList[i]->ToLower();
            if (hProcessList->ContainsKey(lower))
            {
                  ArrayList* processes = dynamic_cast<ArrayList*>(hProcessList->get_Item(lower));
                  IEnumerator* p = processes->GetEnumerator();
                  while (p->MoveNext())
                  {
                        processToKill = dynamic_cast<Process*>(p->Current);
                        Console::WriteLine("Killing {0} process id {1}", killList[i], __box(processToKill->get_Id()) );
                        processToKill->Kill();

                  }
            }
      }
}

Hashtable* GetProcessListAsHash()
{
      Hashtable* h = new System::Collections::Hashtable();
      IEnumerator* process = Process::GetProcesses()->GetEnumerator();
      Process* p;

      while (process->MoveNext())
      {
            p = dynamic_cast<Process*>(process->Current);
            String* processName = p->get_ProcessName()->ToLower();
            if (h->Contains(processName))
            {
                  ArrayList* list = dynamic_cast<ArrayList*>(h->get_Item(processName));
                  list->Add(p);
            }
            else
            {
                  ArrayList* list = new System::Collections::ArrayList();
                  list->Add(p);
                  h->Add(processName, list);
            }

      }

      return h;
}