Autor: Rodrigo Corral González

Si estas programando una aplicación nativa (en C++) debes usar la función SHGetFolderPath, si quieres añadir un subdirectorio al valor devuelto (p.e.: C:Archivos de programaTu applicacion) lo puedes hacer directamente con la función SHGetFolderPathAndSubDir. Estas funciones tienen como requisito Windows 95 con Internet Explorer 5.0, Windows 98 con Internet Explorer 5.0, Windows 98 Second Edition (SE), Windows NT 4.0 con Internet Explorer 5.0, Windows NT 4.0 con Service Pack 4 (SP4).

Tambien puedes utilizar las siguientes funciones:

GetSystemDirectory(), para obtener el directorio de sistema.
GetWindowsDirectory(), para obtener el directorio de windows.
GetTempPath(), para obtener el directorio temporal.

Si estas programado una aplicación manejada, usando C#, VB.Net, C++/CLI u otro lenguaje .net hechale un vistazo al método GetFolderPath de la clase Environment y a la enumeración SpecialFolder.

Basicamente, lo que necesitas conocer a es:
    1) Como levantar hilos
    2) Como sincronizar el trabajo realizado por hilos (conocer los objetos de sincronización)

Esto depende de la plataforma en la que estes programando (C ‘puro’, C++, UNIX, Win32, MFC) ya que cada plataforma expone diferentes objetos y funciones para realizar estas tareas. Existen librerias que te abstraen de estas diferencias (p.e.: Boost.Threads http://www.boost.org/libs/thread/doc/index.html)

Otro tema es el diseño de programas multihilo eficientes y sin problemas, que es un arte más que una ciencia y como tal depende mucho de la experiencia.

Si quieres centrarte en plataforma Windows, busca Multitherading en la MSDN, tienes información para dar y colgar.

Articulos interesantes en la MSDN son:

Multithreading for Rookies
Synchronization on the Fly
Using Multithreading and C++ to Generate Live Objects

Por ultimo dos libros, que te comento por que los he leido, no por que sean
los mejores que eso no lo se.

Este centrado en Windows:
Multithreading Applications in Win32 : The Complete Guide to Threads
by Jim Beveridge (Author), Robert Wiener (Author)

Y este que habla de las posiblidades en diferentes sistemas operativos (ojo,
no sirve para aprender)
Multithreading Programming Techniques (J. Ranade Workstation Series)
by Shashi Prasad, Shshi Prasad, Shashi Prashad

Si estas interesado en programar con hilos en el mundo .net no te pierdas el curso que un servidor imparte en Campus MVP

Para evitarlo lo que tienes que hacer es crear un hilo de ejecución para
realizar la tarea que deja bloqueada la ventana.

Si no quieres complicarte con hilos y la tarea que realizas es de tipo iterativo puedes poner en cada paso de bucle llamadas a la siguiente función, que permite que se procesen los mensajes de ventana de manera que esta no se quede muerta, de todos modos te recomiento que uses los hilos, ya que este método consume mucha CPU. El efecto logrado con el código siguiente es similar al DoEvents de Visual Basic.

void CApplication::DoEvents()
{
 MSG msg;
    while ( ::PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
    {
        if ( !PumpMessage( ) )
        {
            ::PostQuitMessage(0);
            break;
        }
    }
    // let MFC do its idle processing
    for (long lIdle = 0; OnIdle(lIdle); lIdle++ ){;}
}

Hay que usar el api SetWindowPos de la siguente manera:

Para hacer la ventan siempre visible

SetWindowPos(hwnd, HWND_TOPMOST, 0,  0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE |WP_NOSIZE);

Para devolverle el comportamiento normal

SetWindowPos(hwnd, HWND_NOTOPMOST, 0,  0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE| WP_NOSIZE);

Si estas trabajando en MFC la función SetWindowPos sera miembro de la clase
que representa tu ventana.

La técnica aquí descrita tambien se aplica a Visual Basic (anterior a VB.Net), solo habra que llamar a las mismas funciones mediante «declares», como se llama habitualmente a las API desde Visual Basic. Sin quereís ver el código completo para poner una ventana siempre visible sobre todas las otras en Visual Basic podeís consultar este artículo de la KB: How To Create a Form That Always Stays on Top.

MFC (Microsoft Fundation Classes): Libreria basada en jeraquia de clases, basicamente encapsula el API de windows en una forma orientada a objetos.

ATL (Active Template Library): Es una libreria basada en templates, que se creo para relizar controles y librerias ActiveX (COM) de bajo peso. El motivo fue el excesivo peso que MFC añadia a los ActiveX que perjidicaba su distribución desde internet.

WTL (Windows Template Library): Es una libreria en cierto modo similar a MFC solo que basada en templates y menos extensa, por ejemplo carece de clases para sockets, o bases de datos. Esta muy relacionada con ATL, a la que añade la posibilidad de trabajar con ventanas. WTL ha sido liberado bajo licencia GPL por Microsoft.

STL (Standar Template Libary): Es la libreria estandar de C++, se puede encontrar en practicamente cualquier compilador de C++. Contiene clases para multiples propositos como porejemplo trabajar con cadenas, algoritmos, clases de colecciones (listas,mapas…), los streams de C++ y muchas consas mas. Puedes mirar:
http://www.sgi.com/tech/stl/
http://www.stlport.org/

La mejor opción es usar ADO mediante la directiva #import. Y el mejor comienzo leer el siguiente articulo para saber como hacerlo:

Artículo de Microsoft Knowledge Base – 169496 INFO: Using ActiveX Data Objects (ADO) via #import in VC++

Otra fuente interesante de información es: Visual C++ ADO Programming

Sin embargo, si estas programando en C++ manejado, bien sea Managed C++ o C++/CLI el camino a seguir es ADO.net

Hechadle un vistazo a:
Aplicación de ejemplo de ADO.NET 
Learning ADO.NET

Otra situación es estar mezclando código manejado y no manejado y que tengas que manejar recordset de ADO y dataset de ADO.net. En este caso lee: How to use ADO RecordSet objects in Visual C++ .NET or in Visual C++ 2005

La forma más habitual de hacerlo es creando un objeto mutex global (con nombre) y verificar su estado. El siguiente fragmente de código Win32 muestra cómo hacerlo:

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    MSG msg;
    HACCEL hAccelTable;
    // Codigo previo… 
    // Controlar instancias previas
    HANDLE hMtx = CreateMutex( NULL, FALSE, «{FA531CC1-0497-11d3-A180-001052276C3E}» );
    if( GetLastError() == ERROR_ALREADY_EXISTS ) return FALSE;
    // Resto de código…
    return msg.wParam;
}

Un mutex con nombre es un objeto Kernel que puede ser verificado desde cualquier proceso. La primera aplicación lo creará sin problema, pero al intentar crearlo desde un segundo proceso, retornará ERROR_ALREADY_EXISTS. Retornando FALSE desde el WinMain provocamos la salida del programa.

Otro enfoque que tambien que se utiliza en ocasiones es buscar la ventana principal de tu aplicación con la función FindWindow. La ventaja es que una vez localizada la ventana puedes traer esta a primer plano, en lugar de simplemente informar al usuario de que no puede arracar otra instancia de la aplicación.

TCHAR szPath[MAX_PATH];
GetModuleFileName(NULL, szPath, MAX_PATH);
//Quitamos el nombre del ejecutable
//Tambien puedes usar PathRemoveFileSpec o splitpath si no estamos usando MFC o ATL
CString strAppPath(szPath);
strAppPath = strAppPath.Left(strAppPath.ReverseFind(‘\’));

Basicamente tienes que crear una DLL COM. y tener en cuenta que las interfaces de los objetos que exporten deben de ser duales y debes marcarlas como oleautomation.

La manera más simple de crear objetos COM en VC++ es usar ATL.

Este link te sera de utilidad:
Building COM Components That Take Full Advantage of Visual Basic and Scripting

Eso si, si no estas familiarizado con el desarrollo COM en VC++, bien mediante MFC o ATL la tarea no es simple.