Hace un tiempo que no escribo nada Nuevo en el blog, mucho trabajo estas semanas y una familia que atender es lo que tienen.

Peeero, para que la espera valga la pena, he estado estos últimos días preparando un custom control en .Net 3.5 y VB.NET 2008, sencillito pero útil. Se trata de un control que nos permitirá listar todos los monitores conectados a nuestro sistema y poder especificar por formulario (o a toda la aplicación) cual queremos usar en cada momento.

No entrare a los pasos de diseño y creación de un Control, pues son los mismos que los de una aplicación tradicional, la única diferencia es que la salida es un ensamblado .dll y no un ejecutable.

La clase de vb.net que usamos para saber los monitores del sistema es la screens. Muy util para obtener mucha información de la configuración de pantalla en la que se ejecuta nuestra aplicación o, como en este caso, para añadir soporte multi monitor a nuestro programa.

En nuestro caso, quería cumplir 3 funciones con este control:

Poder reutilizar el código de monitores en cualquier aplicación con la implementación mas sencilla posible.

Abstraer todo el código y funcionalidad de nuestra aplicación y que fuese el control el que se encargase de realizar todo el trabajo.

Poder obtener un objeto con todos los datos de pantallas del sistema de forma sencilla y sin tener que escribir código.

Para todo esto el control cuenta con 3 variables internas privadas:

  Y para acceder a cada una de una forma correcta publica 3 propiedades públicas, 1 de ellas de tipo read only, al usar properties en vez de variables públicas estas apareceran en la ventana de propiedades del control cuando lo insertemos en un formulario, por lo que cumpliremos nuestro objetivo de no tener que escribir más código.

La primera propiedad es de tipo form y nos servira para controlar el formulario sobre el que queramos trabajar, al ser tan genérico, si nuestra aplicación es mdi y movemos el formulario principal moveremos toda la aplicación.

  La segunda propiedad es un array de solo lectura, de tipo STR_Monitores, una estructura propia que contiene todos los parámatros necesarios para trabajar con un monitor:

 Por medio de la propiedad pública nuestra aplicación podra obtener este array con todos los datos de pantallas conectadas al sistema y podremos usarlas de forma independiente al control, otra vez usando 0 código para obtener los datos.

Por último la tercera propiedad pública nos permitira definir un poco en concreto el comportamiento de nuestro control, pues permite definir si queremos mover el formulario de pantalla, ocupando todo el espacio de la nueva pantalla ó tan solo moverlo sin modificar su tamaño.

El resto del código del control es muy sencillo, obviando el código de los botones para avanzar y retroceder en el array de mvarMonitores, el código del Form_load que inicializa todos los objetos y obtiene los datos necesarios:

Este código es muy sencillo, simplemente redimensiona el array mvarMonitores al número de monitores presentes en el sistema (restandole 1, hay que recordar que la propiedad count devuelve el número de elementos en un array, empezando desde 1 y que los arrays tienen base 0), despues recorre la lista AllScreens dentro de la clase Screens para guardar los datos en nuestra estructura, usando una variable int indiceArray para recorrer el array mvarMonitores. Después selecciona el primer elemento del array y lo muestra en nuestra label de información.

Con esto, solo con colocar el control en nuestro formulario, obtendremos una estructura STR_monitores rellena y lista para usar.

Y por último el código del botón que hace que nuestro formulario (el indicado en la propiedad) se mueva de pantalla, es en este momento en el que se tiene en cuenta la propiedad MoverYMaximizar, para tener en cuenta si solo debe moverse o también hay que cambiar el tamaño: 

El código es muy sencillo como veis, si le hemos indicado que mueva y maximice el formulario, simplemente asignara el tamaño del area de trabajo de la pantalla seleccionada a nuestro formulario, y después le asignara la nueva ubicación a nuestro formulario a traves de la propiedad Locatión del mismo.

Esto es así por que windows trata las pantallas como extensiones de nuestro escritorio, es decir, si tenemos 2 pantallas con una resolución de 1024×768, situada la secundaria a la derecha de la primaria, la esquina superior izquierda de nuestro primer monitor tendría las coordenadas x=0, y=0 y la misma esquina de nuestro segundo monitor tendría las cordenadas x=1024, y=0.

Como extra os dejo una función muy util, que en mi caso no está incluida dentro del control pues no me era necesaria, pero que puede ser muy ventajosa, Con estas funciones podremos ejecutar un proceso y asignarlo automáticamente al monitor que elijamos (que lo hemos podido obtener con nuestro control):

Y el código para ejecutar un proceso y moverlo a la pantalla que deseemos.

 La parta más importante es el x.WaitForInputIdle, esta línea detiene la ejecución hasta que nuestro proceso esta listo para recibir ordenes, y entonces le asignamos el nuevo tamaño y la nueva posición.

 Bien, esto es todo, espero que os sea de ayuda y os divertais tanto como yo realizando este control, os dejo el codigo fuente y el ensamblado compilado para que lo useis libremente, si os es util, no olvideis decir donde lo encontrasteis.

Descargar NetMultiMonitor.zip

Un saludo.

Happy coding!

Muchas veces usamos parametros opcionales en nuestras funciones o procedimientos de Visual Basic, y como sabemos es bastante sencillo, pues debemos saber que es practicamente igual de sencillo usarlo en nuestros procedimientos almacenados de SQL

Pasemos a la práctica:

Imaginaos que tenemos un procedimiento almacenado que lee clientes de nuestra base de datos:

CREATE PROCEDURE LeeClientes
AS
	SELECT IDCliente, RazonSocial
	FROM MyProgram_Clientes
	
	--EXEC LeeCLientes Devuelve todos los clientes de la base de datos

Si por el motivo que sea, se alinean Marte y Júpiter con el Sol por ejemplo   y necesitamos que nuestro procedimiento en un momento dado, no solo lea clientes sino que se capaz de filtrar por el identificador del cliente, tenemos dos opciones, añadir el parámetro @IDCliente y cambiar todas nuestras llamadas desde nuestro código añadiendo el nuevo parámetro o crear un nuevo procedimiento almacenado que se llame LeeCliente y cambiar las llamadas del código donde necesitemos; O  (si ya se que dije dos opciones pero ahí esta la gracia) añadir el parámetro como un parámetro opcional de nuestro procedimiento, lo que es tan sencillo como:

CREATE PROCEDURE LeeClientes
	@IDCliente AS int = 0    --Igualando el parámetro a un valor inicial conseguimos que el parámetro se convierta en opcional
AS
	SELECT IDCliente, RazonSocial
	FROM MyProgram_Clientes
	WHERE (MyProgram_Clientes.IDCliente = @IDCliente) OR (@IDCliente = 0)

	--EXEC LeeCLientes Devuelve todos los clientes de la base de datos
	--EXEC LeeCLientes @IDCliente Devuelve el cliente indicado en el parámtreo @IDCliente

Como veis es bastante sencillo y bastante útil o espero que así os haya sido

NOTA: Como no todo puede ser color de rosa, la única pega a esto es que si estamos accediendo desde nuestro programa al SQL mediante OLEBDB no podremos usar esta característica del SQL, necesitaremos otro proveedor de base de datos (SQLClient, SQL Native Client,…)

Resulta que de vez en cuando, la luna y marte se alinean y nosotros los programadores tenemos que arremangarnos para resolver los líos en que nos metemos….

Uno de estos líos inocentes puede ser que “alguien” te pase un string que contiene el nombre de un control que tienes en tu formulario y te dice: “haz visible ese control que te pase….. ahh se me olvidaba, el control puede estar metido dentro de tabpanels, panels o group panels…. por lo que eso de Form.Controls(“nombredelcontrol”) no va….” -_-!

Como si fuese tan facil…. pues sip, si que lo es, 2 linea de codigo, gracias a nuestro siempre querido reflection!!!

Dim obj As Object
obj = Owner.GetType().GetField(“_” & name,Reflection.BindingFlags.NonPublic Or _
                                                          Reflection.BindingFlags.Instance Or _
                                                          Reflection.BindingFlags.IgnoreCase).GetValue(Owner)

El primer parámetro de la función GetField es el nombre de control, se le pasa “_” porque el nombre en el ensamblado está precedido de “_”, sin este no encontrará el control.!
Con esto obj contendra nuestro objeto y podremos modificar, eliminar o cambiar todo lo que queramos, quedando reflejado en nuestro objeto real. Solo con algunas lineas más de código dejaremos nuestro código mucho más reusable….

Public Function EncontrarControl(ByVal name As String, ByVal Owner As Form) As Control
      Dim obj As Object
      Try
            obj = Owner.GetType().GetField(“_” & name,Reflection.BindingFlags.NonPublic Or _
                                                                      Reflection.BindingFlags.Instance Or _
                                                                      Reflection.BindingFlags.IgnoreCase).GetValue(Owner)
            Owner.GetType().GetFiel()
            Return (CType(obj, Control))
      Catch ex As Exception
            Return Nothing
      End Try
End Function

Y listo! solo con invocar nuestra función podemos acceder directamente a las propiedades de nuestro control y modificarlo y usarlo:

 

EncontrarControl(“Nombredelcontrol”, Form1).Visible = True

 

 

 

 Hasta la próxima.

Happy Coding!

Uno de estos problemas es el “Problem generating manifest. Insufficient memory to continue” que aparece al depurar un proyecto “un poco gordito”, sobretodo si tenemos winforms abiertos o varias páginas de codigo.

La forma de “mitigarlo” en sistemas operativos de 32bits es haciendo que visual studio se “coma” mas memoria:

Windows XP:

-Hacemos una copia de boot.ini y en el original editamos y añadimos la opción /3GB al final de la linea del S.O. que queramos adaptar a usar más de 2Gb de memoria.

Windows Vista:

- Ejecutamos el simbolo de sistema como Admin (de otra forma fallara) y ejecutamos lo siguiente en la linea de comandos:

BCDEDIT /Set IncreaseUserVa 3072

Bien, de esta forma con reiniciar nuestro pequeñin empezara a comerse ese giga extra de memoria que andaba suelto, ahora el objetivo es darselo enterito a visual studio (o por lo menos que pueda acceder a el) Por defecto los ejecutables de 32bits no pueden consumir más de 2Gb de memoria ni acceder a la memoria por encima de 2Gb, por lo que hay que modificar la cabecera de devenv.exe para que al ejecutarse haga lo correcto, tranquilos que no hay que buscar ningun editor hexadecimal…..

- Primero copia de seguridad a devenv.exe, por si acaso.

- En el Directorio VC\Bin encontraremos los archivos editbin y link que debemos copiar a Common7\IDE (donde se encuentra devenv.exe)

- Segundo desde linea de comandos ejecutar:

editbin /LARGEADDRESSAWARE devenv.exe

Y Listo nuestro amado, y querido VSTS2008 SP1 empezara a trabajar aprovechando toda la memoria disponible sin limitaciones (salvo las lógicas), damos un reinicio y ha trabajar, esto puede no reparar definitivamente el problema, pero por lo menos lo soluciona bastante.

Un saludo!

Happy coding!