Mes: mayo 2006

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.

Las DLL construidas con VB exportan objetos COM.

La manera más simple de usar objetos COM desde VC++ es usando la directiva #import y los smart pointers de COM que genera esta directiva.

El mecanismo sería algo como:

#import «tuDLL.DLL»
using namespace tuDLL
…
//Crear un objeto
_TuClaseVBPtr tuClase(__uuidof(TuClaseVB));
tuClase->MetodoDeTuClaseVB();

Hace poco el gran Steve McConnell autor de algunos de los libros que más han influido en mi carrera profesional, y algunos de los más vendidos sobre desarrollo de software, defendia en una conferencia que las metodologias ágiles se han quedado cortas. Yo no comparto su visión, sino que creo que las personas que han intentado implementar estas metodologías son la que se han quedado cortas.

En cuarquier caso, aquí podeís leer las ideas sobre el tema que tiene Steve.

Por cierto, leed los libros de McConnell si no lo habies hecho, expecialmente Code Complete y Software Project Survival Guide. Si quereís profundizar Rapid Application Development es un copendio de todo los publicado sobre gestión ‘clásica’ de proyectos de software.