Índice de la sección dedicada a .NET (en el Guille) - Migrar de VB6 a .NET

Equivalencias con el API de Windows

Declaraciones para VB6, VB .NET y C#
Publicado el 12/Ene/2005
Actualizado el 08/Jul/2008
Autor: Guillermo 'guille' Som

Nota:
Las añadidas en la última actualización están en negrita y marcadas con un asterisco rojo (*)
Las que tienen solo el asterisco (o están en negrita sin el asterisco), pero no están en negrita, es que he actualizado el contenido.
Algunos links apuntan a páginas en las que están las declaraciones y es posible que solo estén las declaraciones de Visual Basic .NET y las de C#.

Nota del 30/Nov/07:
La nueva página para las Equivalencias del API ha cambiado, pero dejo esta porque todavía no están operativos todos los links.

En esta página encontrarás las declaraciones tanto para VB .NET como para C# de algunas de las funciones del API de Windows, además de las constantes y tipos de datos usados habitualmente por el API de Windows.
Si viene al caso, también te pondré un link al artículo en el que se utiliza dicha API, para que tengas un ejemplo práctico y "realista" de cómo usarla, ya que aquí simplemente te mostraré la forma de declarar la función, constante o tipo de datos, sin ningún ejemplo de cómo usarla.
En el caso de que no exista un artículo publicado que la utilice, procuraré añadir un link a una página con un ejemplo "práctico" para usar la función del API y, si es posible o viene al caso, también te indicaré la clase de .NET que podemos usar para realizar la misma tarea.

En cada función del API de Windows he incluido la definición de la misma que aparece en la documentación del SDK de Windows, así como las declaraciones para VB6, VB .NET y C#.

Estas son las declaraciones de funciones del API de Windows equivalentes para Visual Basic .NET y C# (y la misma declaración para Visual Basic 6.0 -clásico-).

En la nueva página/sección hay más funciones y tipos del API de Windows y la forma de usarlo.

 

Nota:
En las declaraciones aquí mostradas, salvo descuido, he usado la forma "recomendada" de .NET, es decir: aplicando el atributo DllImport, (definido en System.Runtime.InteropServices) en caso de que usemos la forma "clásica" de VB6, el compilador de VB creará una declaración "parecida" a la de DllImport, pero usando los valores predeterminados.

A continuación te muestro la forma de usar el atributo DllImport y los campos que puedes indicar. En su versión simple, funciona de la siguiente forma (según los parámetros usados):

DllImport(String) Se indica el nombre de la Librería de Windows que contiene la función, esta es la forma "recomendable" de usar este atributo si queremos usar lo valores predeterminados del resto de campos.

DllImport(String, EntryPoint := String) Se indica el nombre de la librería en el primer parámetro, en el segundo se indicará el nombre de la función tal y como está definida en el fichero de cabecera (.H) correspondiente.

Habitualmente existen dos nombres de para cada función del API, una acabada con W y otra acabada con A, según se utilice un sistema operativo Unicode (Windows NT/2000/XP/2003/CE) o no (Win95/98/ME). Ver más abajo la descripción de CharSet, EntryPoint y ExactSpelling.

Los otros parámetros de este atributo, que podemos indicar (usando la forma: nombre_campo := valor en VB o nombre_campo = valor en C#) son:

  • CharSet:
    El tipo de juego de caracteres a usar.
    Puede ser:
    --Auto, se elegirá el juego de caracteres adecuado según el sistema operativo.
    --Ansi para sistemas Windows 98 / ME o
    --Unicode para sistemas Windows NT / 2000/ XP / 2003 / CE

    El valor predeterminado es Auto, por tanto si no se indica ningún valor especial en EntryPoint, se elegirá la función que mejor se adecue al sistema operativo.
     
  • EntryPoint:
    El valor del campo EntryPoint indica el nombre "exacto" de la función del API que queremos usar.
    Si el nombre de la función del API tiene el mismo nombre que el usado en la declaración, no es necesario indicar este valor.
    Como he indicado antes, ese nombre puede acabar con A o W, según el tipo de función a usar: ANSI o UNICODE respectivamente.
    Si no indicamos en EntryPoint el nombre de la función, se usará la que "coincida" con el nombre de la función indicada en la declaración y según el valor asignado al campo CharSet (o ExactSpelling) se añadirá la letra A o W (si es que existen dos versiones diferentes).
    Si no se indica ningún valor específico en CharSet, (el valor realmente será Auto), se usará la versión ANSI (acabada en A) o UNICODE (acabada en W) según el sistema operativo en el que se esté ejecutando la aplicación.
     
  • ExactSpelling:
    Indica si el nombre de la función se ha escrito de la misma forma que en la librería del API. Esto es para cuando no se usa EntryPoint, ya que en caso de que el valor de este campo sea False, se añadirá una A al nombre de la función si CharSet es Ansi y una W si el valor de Charset es Unicode.
    El valor predeterminado para C# es false.
    El valor predeterminado para VB dependerá del valor de CharSet, para Ansi y Unicode es True, para Auto es False.
     
  • SetLastError:
    Ver la documentación en línea para más información.
    El valor predeterminado para VB y C# es False.
    Si en VB utilizamos Declare en lugar de DllImport para declarar la función, el valor de SetLastError es True.
     
  • PreserveSig:
    Ver la documentación en línea para más información.
    El valor predeterminado es True.
     
  • CallingConvention:
    Ver la documentación en línea para más información.
    El valor predeterminado es WinAPI que se convertirá en una llamada StdCall para plataformas Windows o en Cdecl para CE.
     
  • BestFitMapping:
    Ver la documentación en línea para más información.
    El valor predeterminado es True.
     

 

Si quieres ver las declaraciones para .NET de muchas de las funciones del API de Windows, no debes dejar de visitar este sitio: PINVOKE.NET.

Equivalencias en los tipos de datos

Los tipos de datos equivalentes entre el API de Windows y los tipos de .NET, los podríamos resumir según la siguiente tabla, en la que se muestran también los de VB6.

Nota:
Debido a que prácticamente todos los tipos del API, salvo excepciones, se corresponden con un entero de .NET (Int32), para que la tabla no sea demasiado monótona, de los tipos de .NET sólo mostraré los tipos definidos en el CTS (Common Type System), sistema de tipos comunes de .NET, es decir los tipos de datos del propio .NET Framework, ya que no creo que te resulte difícil saber a que tipo de VB o C# equivale.

Como podrás comprobar, básicamente con saber que el tipo Int32 (Integer en VB, int en C#) de .NET equivale a un LONG del API de Windows, tendríamos más que suficiente, ya que ese es el tipo de datos (incluso camuflado) es el que se suele usar en las librerías del API que están escritas en C "normal".

También comprobarás que .NET dispone de "tipos" para lo que en el API de Windows se soluciona con "apaños de andar por casa", tal es el caso de los punteros de C, que en .NET se solucionan mediante delegados.

Algunos tipos, como el UINT se podrían cambiar por el "específico", pero también funcionará si se cambia por un Int32. El caso de HWND que es el "handle" de una ventana, se puede cambiar indistintamente por un Int32 o preferiblemente por System.IntPtr.

 

Tipo del API Descripción .NET VB6
HWND Handle de la ventana de destino Int32
System.IntPtr (4)		 Long
UINT   Int32 Long
WPARAM Cuando se usa en Send/PeekMessage, el primer mensaje a enviar a la ventana Int32 Long
LPARAM El segundo mensaje a enviar a la ventana Int32 Long
DWORD   Int32 Long
BOOL   Boolean Long/Boolean
HRESULT   Int32 Long
LPCTSTR Dirección de una cadena (no modificable) String o StringBuilder (2) ByVal String
LPTSTR Dirección de una cadena (modificable) String o StringBuilder (2) ByVal String
       
LPMSG Puntero a una estructura del tipo MSG (1)   --
LPDEVMODE Puntero a una estructura del tipo DEVMODE (1)   --
       
WNDENUMPROC Puntero a una función CallBack (3) Llamada a una función definida por un delegado Long (AddressOf)
CALLBACK Definición de la función CallBack (3) Definición de un delegado --
       
  1. Los punteros a estructuras normalmente se definen usando la estructura como parámetro por referencia (ByRef en VB, ref en C#)
  2. Cuando enviamos cadenas al API de Windows, es preferible indicar un tipo StringBuilder ya que de esta forma evitamos la recreación de una nueva cadena, que es lo que ocurriría si usamos un tipo de datos String.
  3. Las funciones CallBack son punteros a otras funciones, en .NET todo esto se maneja usando delegados (en VB .NET en los punteros a funciones se usará AddressOf para realizar la llamada al delegado).
  4. Es recomendable que para los manejadores de las ventanas utilices un tipo IntPtr en lugar de un Int32, ya que la propiedad Handle de los controles de Windows.Forms es del tipo IntPtr, y esa propiedad precisamente se puede usar para casi todas las funciones del API de Windows.

.

 

SendMessage

Esta función del API se utiliza para muchísimas cosas diferentes y dependiendo del uso, puede que los parámetros empleados sean de diferentes tipos, pero gracias a que los lenguajes de .NET permiten la sobrecarga de funciones, podremos usar el mismo nombre de función sin necesidad de que importe de que tipos son dichos parámetros.
Sin embargo en VB6 al no permitir el mismo nombre de función, en ocasiones teníamos que definirla usando nombres diferentes para usos diferentes, esa es la razón principal de que los dos últimos parámetros de esta función se definieran con As Any, que es la declaración que con más frecuencia se utiliza en VB6, pero que en otros casos se puede utilizar con parámetros diferentes, según el uso que le fuésemos a dar.

Ejemplo (usando una estructura como último parámetro)

 

Declaración en el API de Windows:

LRESULT SendMessage(
  HWND hWnd,      // handle of destination window
  UINT Msg,       // message to send
  WPARAM wParam,  // first message parameter
  LPARAM lParam   // second message parameter
);

 

VB6 genérico:

Private Declare Function SendMessage Lib "user32" Alias "SendMessageA" _
    (ByVal hWnd As Long, ByVal wMsg As Long, _
    ByVal wParam As Long, ByRef lParam As Any) As Long

Si queremos indicar un valor de tipo Long en el último parámetro (para que se "iguale" la declaración con las dos de .NET, habría que declararla de esta forma:

Private Declare Function SendMessage Lib "user32" Alias "SendMessageA" _
    (ByVal hWnd As Long, ByVal wMsg As Long, _
    ByVal wParam As Long, ByVal lParam As Long) As Long

Si en el último parámetro queremos usar un String y queremos usarlo al mismo tiempo que la anterior:

Private Declare Function SendMessageStr Lib "user32" Alias "SendMessageA" _
    (ByVal hWnd As Long, ByVal wMsg As Long, _
    ByVal wParam As Long, ByVal lParam As String) As Long

 

VB .NET:

<System.Runtime.InteropServices.DllImport("user32.DLL")> _
Private Shared Function SendMessage( _
        ByVal hWnd As System.IntPtr, ByVal wMsg As Integer, _
        ByVal wParam As Integer, ByVal lParam As Integer _
        ) As Integer
End Sub

Si queremos usar un String en el último parámetro y queremos usarla al mismo tiempo que la anterior, sólo hay que declararla nuevamente con los parámetros diferentes, (sin necesidad de cambiar el nombre, tal como se hace en VB6):

<System.Runtime.InteropServices.DllImport("user32.DLL")> _
Private Shared Function SendMessage( _
        ByVal hWnd As System.IntPtr, ByVal wMsg As Integer, _
        ByVal wParam As Integer, ByVal lParam As String _
        ) As Integer
End Sub

 

C#:

[System.Runtime.InteropServices.DllImport("user32.DLL")]
private extern static int SendMessage( 
	System.IntPtr hWnd, int wMsg, 
	int wParam, int lParam);
[System.Runtime.InteropServices.DllImport("user32.DLL")]
private extern static int SendMessage( 
	System.IntPtr hWnd, int wMsg, 
	int wParam, string lParam);

 

GetLongPathName

Esta función la podemos usar para convertir un nombre corto (tipo MS-DOS 8.3) en uno largo.

Declaración en el API de Windows:

DWORD GetLongPathName(
  LPCTSTR lpszShortPath,  // Pointer to a null-terminated path to be converted
  LPTSTR lpszLongPath,    // Pointer to the buffer to receive the long path.
                          // You can use the same buffer you used for the lpszShortPath parameter
  DWORD cchBuffer         // Specifies the size of the buffer, in characters
);

 

Declaración para VB6:

Private Declare Function GetLongPathName Lib "kernel32" Alias "GetLongPathNameA" _
        (ByVal lpszShortPath As String, _
        ByVal lpszLongPath As String, _
        ByVal cchBuffer As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("kernel32.dll")> _
Private Shared Function GetLongPathName( _
        ByVal lpszShortPath As String, _
        ByVal lpszLongPath As System.Text.StringBuilder, _
        ByVal cchBuffer As Integer) As Integer
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("kernel32.dll")] 
private extern static int GetLongPathName( 
        string lpszShortPath, 
        System.Text.StringBuilder lpszLongPath, 
        int cchBuffer);

 

GetShortPathName

Esta función la podemos usar para convertir un nombre largo en uno corto (tipo MS-DOS 8.3).

Declaración en el API de Windows:

DWORD GetShortPathName(
  LPCTSTR lpszLongPath,  // pointer to a null-terminated path string
  LPTSTR lpszShortPath,  // pointer to a buffer to receive the 
                         // null-terminated short form of the path
  DWORD cchBuffer        // specifies the size of the buffer pointed 
                         // to by lpszShortPath
);

 

Declaración para VB6:

Private Declare Function GetShortPathName Lib "kernel32" Alias "GetShortPathNameA" _
        (ByVal lpszLongPath As String, _
        ByVal lpszShortPath As String, _
        ByVal cchBuffer As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("kernel32.dll")> _
Private Shared Function GetShortPathName( _
        ByVal lpszLongPath As String, _
        ByVal lpszShortPath As System.Text.StringBuilder, _
        ByVal cchBuffer As Integer) As Integer
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("kernel32.dll")] 
private extern static int GetShortPathName( 
        string lpszLongPath, 
        System.Text.StringBuilder lpszShortPath, 
        int cchBuffer);

 

SetForegroundWindow

Trae la ventana indicada al frente y la activa.
Si se pudo traer al frente, devolverá un valor Verdadero (<>0 en VB6).

En ocasiones podríamos sustituir esta función del API usando el método BringToFront que todos los controles (y/o clases derivadas de Control) tienen.

Declaración en el API de Windows:

BOOL SetForegroundWindow(
  HWND hWnd   // handle to window to bring to foreground
);

 

Declaración para VB6:

Private Declare Function SetForegroundWindow Lib "user32" (ByVal hWnd As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Public Shared Function SetForegroundWindow(ByVal hWnd As System.IntPtr) As Boolean
End Function

 

Declaración para C#:

{System.Runtime.InteropServices.DllImport("user32.dll")] 
public extern static bool SetForegroundWindow(System.IntPtr hWnd);

 

FindWindow

Devuelve el "handle" de la ventana que coincida con la clase y nombre indicados.
Normalmente el primer parámetro se puede omitir.

Ejemplos: VB6, .NET (VB y C#)

 

Declaración en el API de Windows:

HWND FindWindow(
  LPCTSTR lpClassName,  // pointer to class name
  LPCTSTR lpWindowName  // pointer to window name
);

 

Declaración para VB6:

Private Declare Function FindWindow Lib "user32" Alias "FindWindowA" _
        (ByVal lpClassName As String, _
        ByVal lpWindowName As String) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function FindWindow( _
    ByVal lpClassName As String, _
    ByVal lpWindowName As String) As System.IntPtr
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")] 
private extern static System.IntPtr FindWindow( 
    string lpClassName, 
    string lpWindowName);

 

ShowWindow

Muestra (cambia) la ventana actual al estado indicado.
Si la ventana ya estaba visible devuelve un valor distinto de cero.
El estado puede ser: maximizada, minimizada, etc.
En .NET sería el equivalente a asignar un valor a la propiedad WindowState de un formulario.

 

Declaración en el API de Windows:

BOOL ShowWindow(
  HWND hWnd,     // handle to window
  int nCmdShow   // show state of window
);

 

Declaración para VB6:

Private Declare Function ShowWindow Lib "user32" _
	(ByVal hWnd As Long, ByVal nCmdShow As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function ShowWindow( _
        ByVal hWnd As System.IntPtr, _
        ByVal nCmdShow As Integer) As Integer
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static int ShowWindow(
        System.IntPtr hWnd, 
        int nCmdShow);

 

IsWindowVisible

Utilizada para saber si una ventana está visible.

 

Declaración en el API de Windows:

BOOL IsWindowVisible(
  HWND hWnd   // handle to window
);

 

Declaración para VB6:

Private Declare Function IsWindowVisible Lib "user32" (ByVal hWnd As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Public Shared Function IsWindowVisible(ByVal hWnd As System.IntPtr) As Boolean
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
public extern static bool IsWindowVisible(System.IntPtr hWnd);

 

GetWindowText

Recupera el texto de la barra de títulos de una ventana o el texto de un control.
Devuelve el número de caracteres copiados en el segundo parámetro o cero si la ventana o el control no tienen texto que copiar.

Ejemplos:
Con EnumWindows,
con GetForegroundWindow

 

Declaración en el API de Windows:

int GetWindowText(
  HWND hWnd,        // handle to window or control with text
  LPTSTR lpString,  // address of buffer for text
  int nMaxCount     // maximum number of characters to copy
);

 

Declaración para VB6:

Private Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" _
        (ByVal hWnd As Long, ByVal lpString As String, ByVal cch As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function GetWindowText( _
        ByVal hWnd As System.IntPtr, _
        ByVal lpString As System.Text.StringBuilder, _
        ByVal cch As Integer) As Integer
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static int GetWindowText(
        System.IntPtr hWnd, 
        System.Text.StringBuilder lpString, 
        int cch);

 

SetWindowText

Cambia el texto de la barra de títulos de una ventana o el texto de un control.
Devuelve un valor verdadero (distinto de cero) si todo funcionó bien.

 

Declaración en el API de Windows:

BOOL SetWindowText(
  HWND hWnd,         // handle to window or control
  LPCTSTR lpString   // address of string
);

 

Declaración para VB6:

Private Declare Function SetWindowText Lib "user32" Alias "SetWindowTextA" _
        (ByVal hWnd As Long, ByVal lpString As String) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function SetWindowText( _
        ByVal hWnd As System.IntPtr, _
        ByVal lpString As String) As Boolean
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static bool SetWindowText(
        System.IntPtr hWnd, 
        string lpString);

 

EnumWindows

Se usa para iniciar la enumeración de ventanas de "mayor" nivel (top level).
En el primer parámetro se indicará un "puntero a una función", (ver EnumWindowsProc), que en .NET se declara como un delegado.
 

Ejemplo

 

Declaración en el API de Windows:

BOOL EnumWindows(
  WNDENUMPROC lpEnumFunc,  // pointer to callback function
  LPARAM lParam            // application-defined value
);
 

Declaración para VB6:

Private Declare Function EnumWindows Lib "user32" _
	(ByVal lpEnumFunc As Long, ByVal lParam As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function EnumWindows( _
        ByVal lpfn As EnumWindowsDelegate, _
        ByVal lParam As Integer) As Boolean
End Function
 
Private Delegate Function EnumWindowsDelegate _
	(ByVal hWnd As System.IntPtr, ByVal parametro As Integer) As Boolean

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static bool EnumWindows(EnumWindowsDelegate lpfn, int lParam);

 

private delegate bool EnumWindowsDelegate (System.IntPtr hWnd, int parametro);

 

EnumChildWindows

Enumera las "ventanas" de una ventana "top-level". Es decir las ventanas pertenecientes a una ventana, por ejemplo los controles que contiene una ventana... hay que recordar que para Windows todo lo que se muestra es una ventana (o casi).
En el segundo parámetro se indicará un "puntero a una función", (ver EnumChildProc), que en .NET se declara como un delegado.
 

Ejemplo

 

Declaración en el API de Windows:

BOOL EnumChildWindows(
  HWND hWndParent,         // handle to parent window
  WNDENUMPROC lpEnumFunc,  // pointer to callback function
  LPARAM lParam            // application-defined value
);

 

Declaración para VB6:

Private Declare Function EnumChildWindows Lib "user32" _
    (ByVal hWndParent As Long, ByVal lpEnumFunc As Long, ByVal lParam As Long) As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function EnumChildWindows _
        (ByVal hWndParent As System.IntPtr, _
        ByVal lpEnumFunc As EnumWindowsDelegate, _
        ByVal lParam As Integer) As Integer
End Function

 

Private Delegate Function EnumWindowsDelegate _
	(ByVal hWnd As System.IntPtr, ByVal parametro As Integer) As Boolean

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static int EnumChildWindows( 
        System.IntPtr hWndParent, 
        EnumWindowsDelegate lpEnumFunc, 
        int lParam);

 

private delegate bool EnumWindowsDelegate (System.IntPtr hWnd, int parametro);

 

EnumWindowsProc, EnumChildProc

Estas funciones son funciones callback, es decir "un puntero a una función". Realmente no es que se use para "crear" ventanas "callback", sino que es la "definición" de cómo debe ser la función callback usada con las dos primeras funciones. Sería el equivalente a un delegado de .NET.

Para usar estos delegados habría que usar las funciones EnumWindows o EnumChildWindows de la siguiente forma, suponiendo que tenemos un método con la misma firma del delegado llamado EnumWindowsProc:

En VB .NET:

EnumWindows(AddressOf EnumWindowsProc, 0)

EnumChildWindows(handleParent, AddressOf EnumWindowsProc, 0)

 

En C#:

EnumWindows(new EnumWindowsDelegate(EnumWindowsProc), 0)

EnumChildWindows(handleParent, new EnumWindowsDelegate(EnumWindowsProc), 0)

 

Ejemplo

 

Declaración en el API de Windows:

BOOL CALLBACK EnumWindowsProc(
  HWND hwnd,     // handle to parent window
  LPARAM lParam     // application-defined value
);
BOOL CALLBACK EnumChildProc(
  HWND hwnd,           // handle to child window
  LPARAM lParam     // application-defined value
);

 

Declaración para VB6:

La función "callback" se debería declarar (en un módulo BAS) como:

Public Function EnumWindowsProc(ByVal hWnd As Long, ByVal parametro As Long) As Long
   
    '...
End Function

 

Declaración para VB .NET:

Private Delegate Function EnumWindowsDelegate _
	(ByVal hWnd As System.IntPtr, ByVal parametro As Integer) As Boolean

 

Declaración para C#:

private delegate bool EnumWindowsDelegate (System.IntPtr hWnd, int parametro);

 

ExtractIcon y ExtractIconEx

Extraer iconos de una aplicación o fichero (.exe, .dll,. etc.)

Ejemplos: .NET (VB y C#) y VB6

 

Declaración en el API de Windows:

.

 

Declaración para VB6:

Private Declare Function ExtractIcon Lib "shell32.dll" Alias "ExtractIconA" _
    (ByVal hInst As Long, ByVal lpszExeFileName As String, _
    ByVal nIconIndex As Long) As Long

 

Declaración para VB .NET:

 

' Declaraciones para extraer iconos de los programas
<DllImport("shell32.dll")> _
Private Shared Function ExtractIconEx( _
        ByVal lpszFile As String, ByVal nIconIndex As Integer, _
        ByRef phiconLarge As Integer, ByRef phiconSmall As Integer, _
        ByVal nIcons As UInteger) As Integer
End Function

<DllImport("shell32.dll")> _
Private Shared Function ExtractIcon( _
        ByVal hInst As Integer, ByVal lpszExeFileName As String, _
        ByVal nIconIndex As Integer) As IntPtr
End Function

 

Declaración para C#:

[DllImport("shell32.dll")]
private extern static int ExtractIconEx(string lpszFile, int nIconIndex, 
            ref int phiconLarge, ref int phiconSmall, uint nIcons);

[DllImport("shell32.dll")]
private extern static IntPtr ExtractIcon(int hInst,
                string lpszExeFileName, int nIconIndex);

 

GetClassLong

Devuelve un valor de 32 bits (long) de la ventana indicada por el handle del primer parámetro.

Ejemplo para .NET (VB y C#)

 

Declaración en el API de Windows:

DWORD GetClassLong(
    HWND hWnd,
    int nIndex
);

 

Declaración para VB6:

.

 

Declaración para VB .NET:

<DllImport("user32.dll")> _
Private Shared Function GetClassLong( _
        ByVal hWnd As IntPtr, ByVal nIndex As Integer) As Integer
End Function

 

Declaración para C#:

[DllImport("user32.dll")]
private extern static int GetClassLong(IntPtr hWnd, int nIndex);

 

GetForegroundWindow

Esta función devuelve el Handle de la venta que está actualmente activa, (la que el usuario está usando en ese momento).
GetForegroundWindow no es lo mismo que GetActiveWindow, ya que esta última devuelve la relacionada con el mismo thread (hilo) de la aplicación actual (la nuestra).

Ejemplo

 

Declaración en el API de Windows:

HWND GetForegroundWindow(VOID);

 

Declaración para VB6:

Private Declare Function GetForegroundWindow Lib "user32" () As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function GetForegroundWindow() As System.IntPtr
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static System.IntPtr GetForegroundWindow();

 

GetActiveWindow

GetActiveWindow devuelve el Handle de la venta activa de nuestra aplicación, sería el equivalente a ActiveForm de VB6.
Si quieres averiguar cual es la ventana que actualmente está activa (no necesariamente de nuestra aplicación), puedes usar GetForegroundWindow.

Ejemplo

 

Declaración en el API de Windows:

HWND GetActiveWindow(VOID);

 

Declaración para VB6:

Private Declare Function GetActiveWindow Lib "user32" () As Long

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Shared Function GetActiveWindow() As System.IntPtr
End Function

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private extern static System.IntPtr GetActiveWindow();

 

GetVersion

Ejemplo para Visual Basic 6.0, ejemplo para Visual Basic .NET y C#

Devuelve la versión actual del sistema operativo.

 

Declaración en el API de Windows:

DWORD GetVersion(void);

 

Declaración para VB6:

Private Declare Function GetVersion Lib "kernel32" () As Long

 

Declaración para VB .NET:

<DllImport("kernel32.dll")> _
Public Function GetVersion() As Integer
End Function

 

Declaración para C#:

[DllImport("kernel32.dll")]
static extern public int GetVersion();

 

 

GetVersionEx

Nota:
En los ejemplos anteriores se explica cómo usar la función y se muestra el código de la declaración, tanto de la función como de los tipos usados para obtener la información.

Breve descripción.

 

Declaración en el API de Windows:

.

 

Declaración para VB6:

.

 

Declaración para VB .NET:

.

 

Declaración para C#:

.

 

 

OSVERSIONINFO y OSVERSIONINFOEX

Nota:
En los ejemplos anteriores se explica cómo usar la función y se muestra el código de la declaración, tanto de la función como de los tipos usados para obtener la información.

 

Breve descripción.

 

Declaración en el API de Windows:

.

 

Declaración para VB6:

.

 

Declaración para VB .NET:

.

 

Declaración para C#:

.

 

 

  MoveWindow

Esta función la usaremos para cambiar el tamaño y la posición de una ventana de la que conocemos el handle.
Si esa ventana está contenida en otra, la posición será relativa a la ventana que la contiene, no al escritorio.

 

Ejemplos: VB6, .NET (VB y C#)

 

Declaración en el API de Windows:

BOOL MoveWindow(
    HWND hWnd,       // handle to window
    int X,               // horizontal position
    int Y,               // vertical position 
    int nWidth,     // width 
    int nHeight,   // height 
    BOOL bRepaint // repaint flag 
);

 

 

Declaración para VB6:

Private Declare Function MoveWindow Lib "user32" _
    (ByVal hWnd As Long, ByVal x As Long, ByVal y As Long, _
    ByVal nWidth As Long, ByVal nHeight As Long, ByVal bRepaint As Long) As Long

 

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Function MoveWindow(ByVal hWnd As IntPtr, ByVal x As Integer, ByVal y As Integer, _
                            ByVal nWidth As Integer, ByVal nHeight As Integer, _
                            ByVal bRepaint As Integer) As Integer
End Function

 

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
public static int MoveWindow(IntPtr hWnd, int x, int y, int nWidth, int nHeight, int bRepaint);

 

 

  SetParent

Asigna a una ventana el padre o contenedor.

 

Ejemplos: VB6, .NET (VB y C#)

 

 

Declaración en el API de Windows:

HWND SetParent(
  HWND hWndChild,           // handle to window whose parent is changing
  HWND hWndNewParent     // handle to new parent window
);

 

 

Declaración para VB6:

Private Declare Function SetParent Lib "user32" _
    (ByVal hWndChild As Long, ByVal hWndNewParent As Long) As Long

 

 

Declaración para VB .NET:

<System.Runtime.InteropServices.DllImport("user32.dll")> _
Private Function SetParent(ByVal hWndChild As IntPtr, ByVal hWndNewParent As IntPtr) As IntPtr
End Function

 

 

Declaración para C#:

[System.Runtime.InteropServices.DllImport("user32.dll")]
private IntPtr SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

 

 

SetWindowPos

Esta función sirve para cambiar el tamaño y posición de una ventana (la indicada por el handle del primer parámetro), pero también se usa para poner esa venta encima (o debajo) del resto de ventanas.

Ejemplos: .NET (VB y C#) (para poner siempre encima) y VB6

 

Declaración en el API de Windows:

BOOL SetWindowPos(
    HWND hWnd,
    HWND hWndInsertAfter,
    int X,
    int Y,
    int cx,
    int cy,
    UINT uFlags
);

 

Declaración para VB6:

Private Declare Function SetWindowPos Lib "user32" _
    (ByVal hWnd As Long, ByVal hWndInsertAfter As Long, _
    ByVal X As Long, ByVal Y As Long, ByVal cX As Long, ByVal cY As Long, _
    ByVal wFlags As Long) As Long

 

Declaración para VB .NET:

La declaración se puede hacer como Sub (void en C#) o como Function, devolviendo un Integer o un Boolean, pero normalmente no se utiliza el valor devuelto.

<DllImport("user32.DLL")> _
Private Shared Sub SetWindowPos( _
    ByVal hWnd As Integer, ByVal hWndInsertAfter As Integer, _
    ByVal X As Integer, ByVal Y As Integer, _
    ByVal cx As Integer, ByVal cy As Integer, _
    ByVal wFlags As Integer)
End Sub

 

Declaración para C#:

[DllImport("user32.DLL", EntryPoint="SetWindowPos")]
static extern bool SetWindowPos(
    int hWnd,                             // handle to window
    int hWndInsertAfter,       // placement-order handle
    int X,                                   // horizontal position
    int Y,                                   // vertical position
    int cx,                                 // width
    int cy,                                 // height
    uint uFlags                         // window-positioning options
);

 

ir arriba

GetLogicalDrives

The GetLogicalDrives function retrieves a bitmask representing the currently available disk drives.
Que más o menos quieres decir que devuelve una máscara de bits con los discos disponibles.

Nota:
Existe un método con el mismo nombre definido en la clase Environment que sirve para casi lo mismo, bueno, en realidad es parecido a la función del API GetLogicalDriveStrings.

 

Ejemplos:

 

Declaración en el API de Windows:

DWORD GetLogicalDrives(void);

 

vb6 Declaración para VB6:

Private Declare Function GetLogicalDrives Lib "kernel32" () As Long

 

vb .netDeclaración para VB .NET:

<DllImport("kernel32.dll")> _
Private Function GetLogicalDrives() As Integer
End Function

 

c#Declaración para C#:

[DllImport("kernel32.dll")]
private extern static int GetLogicalDrives();

 

 

ir arriba

GetDriveType

The GetDriveType function determines whether a disk drive is a removable, fixed, CD-ROM, RAM disk, or network drive.
Pues eso, que esta función nos indica el tipo de disco.

Nota:
El valor devuelto por esta función usa los valores de las enumeración indicada en el ejemplo de VB.NET y C#.

Si quieres más detalle sobre los tipos de discos USB, busca info sobre SetupDiGetDeviceRegistryProperty (yo aún no lo he probado, si lo hago, pues te lo pondré por esta página o sección)

 

Ejemplos:

 

Declaración en el API de Windows:

UINT GetDriveType(
  LPCTSTR lpRootPathName
);

 

vb6 Declaración para VB6:

Private Declare Function GetDriveType Lib "kernel32" Alias "GetDriveTypeA" _
        (ByVal nDrive As String) As Long

 

vb .netDeclaración para VB .NET:

<DllImport("kernel32.dll")> _
Private Function GetDriveType(ByVal nDrive As String) As TipoUnidades
End Function

 

La declaración de la enumeración TipoUnidades:

Enum TipoUnidades As Integer
    ' Indico también los valores del API (empiezan por cero y van de uno en uno)
    Desconocido     ' 0 DRIVE_UNKNOWN       The drive type cannot be determined.
    No_montado      ' 1 DRIVE_NO_ROOT_DIR   The root path is invalid;
    '                                       for example, there is no volume mounted at the path.
    Extraible       ' 2 DRIVE_REMOVABLE     The drive has removable media;
    '                                       for example, a floppy drive or flash card reader.
    '                                       Las llaves USB los da como extraibles.
    Fijo            ' 3 DRIVE_FIXED         The drive has fixed media;
    '                                       for example, a hard drive, flash drive, or thumb drive.
    '                                       Los discos duros normales enchufados por USB son fijos.
    Remoto          ' 4 DRIVE_REMOTE        The drive is a remote (network) drive. 
    CDROM           ' 5 DRIVE_CDROM         The drive is a CD-ROM drive.
    RAMDISK         ' 6 DRIVE_RAMDISK       The drive is a RAM disk.
End Enum

 

c#Declaración para C#:

[DllImport("kernel32.dll")]
private extern static TipoUnidades GetDriveType(string nDrive);

 

La declaración de la enumeración TipoUnidades:

enum TipoUnidades : int
{
    // Indico también los valores del API (empiezan por cero y van de uno en uno)
    Desconocido,    // 0 DRIVE_UNKNOWN       The drive type cannot be determined.
    No_montado,     // 1 DRIVE_NO_ROOT_DIR   The root path is invalid;
    //                                       for example, there is no volume mounted at the path.
    Extraible,      // 2 DRIVE_REMOVABLE     The drive has removable media;
    //                                       for example, a floppy drive or flash card reader.
    //                                       Las llaves USB los da como extraibles.
    Fijo,           // 3 DRIVE_FIXED         The drive has fixed media;
    //                                       for example, a hard drive, flash drive, or thumb drive.
    //                                       Los discos duros normales enchufados por USB son fijos.
    Remoto,         // 4 DRIVE_REMOTE        The drive is a remote (network) drive.
    CDROM,          // 5 DRIVE_CDROM         The drive is a CD-ROM drive.
    RAMDISK,        // 6 DRIVE_RAMDISK       The drive is a RAM disk.
};

 

 

ir arriba

Función del API

Breve descripción.

 

Declaración en el API de Windows:

.

 

vb6 Declaración para VB6:

.

 

vb .netDeclaración para VB .NET:

.

 

c#Declaración para C#:

.

 

 

ir arriba

la Luna del Guille o... el Guille que está en la Luna... tanto monta...