No trabajo para ninguna empresa ni tengo intención de ello, ni creo que pueda.
No te preocupes, la mayoría de usuarios (y moderadores) tampoco trabajamos para empresas, si lo hicieramos probablemente no tendriamos tiempo para pasarnos a ayudar por aquí a los demás, cómo es el caso de algún que otro moderador que si se dedica a la programación profesional y que ya no se le ve el pelo por el foro...
B. Acabo de empezar con VB.NET hace como un par de meses o tres, más o menos.
Empecé tonteando un poco para adaptarme al entorno, del cual solo he usado seguramente como el 2% de lo que tiene.
Si acabas de empezar hace unos meses entonces no has podido llegar a tocar ni un 0,2% en ese tiempo. No exagero, creeme, la librería de classes de .Net Framework es colosalmente extensa, más de lo que te puedes imaginar, igual que todos los conceptos que se pueden aprender.
Estas cosas:
AddHandler, Task, WithEvents, RaiseEvent ,IsNullOrWhiteSpace, InvokeRequired
todavía no se como van, es nuevo para mí, tendré que mirar uno por uno para poder entender el código y conseguir lo que busco.
La declaración
AddHandler asocia un evento a un método.
La declaración
RemoveHandler desaasocia un evento de un método.
La declaración
RaiseEvent dispara un evento.
El keyword
WithEvents indica que el objeto declarado puede disparar eventos, por ende, esto posibilita que se pueda usar directamente el keyword
Handles para declarar el evento que controla un método (ej:
sub metodo() Handles evento; Esto así mismo evita la necesitad de llenar el código con las sentencias
AddHandler y
RemoveHandler, queda muy feo cuando no es necesario hacerlo.
La extensión o función
String.IsNullOrWhiteSpace determina si un string es nulo, vacío, o solo contiene espacios en blanco.
El método
Threading.Tasks.Task.Factory.StartNew invoka un método encapsulado en un delegado o expresión
Lambda, en un nuevo hilo (thread).
La propiedad
Control.InvokeRequired determina si un control debe ser invocado, esto será así siempre que se intente llamar al control desde un hilo distinto al hilo donde se creó el control, de lo contrario, si no se invoca en dicha condición, se producirá una excepción de tipo
Cross-Thread Exception.
buscando información sobre GDI, que siempre aparecen ejemplo de programas completos y bastante complejos.
Bueno, ese argumento es discutible, por que GDI/GDI+ de por si ya es algo complejo según se mire, hay características muy sencillas pero también otras muchas que se dificultan.
Hace poco modifiqué un programa de Leandro (no se qué) que semitransparenta un Form de modo que se vean nítidamente los controlos y demás pero el fondo del form sea semitransparente.
Pero tengo que decir que no comprendo el código completo. Tuve que modificarlo porque su código degradaba el form en dos colores sin opción o propiedad 'set' para cambiar dichos colores o ponerlo todo a un solo color.
Un consejo:
Olvida todos esos hacks para hacer transparente o semi-transparente un Form, WinForms no fue pensado ni está capacitado (de forma natural) para ese tipo de cosas, la transparencia y WinForms se llevan muy mal.
Todo ese tipo de códigos "transparentes" provocan un efecto muy negativo en la app, ya que ralentizan el form (todo lo que compone el form, sus controles), y mucho más si en dicho código se ua el hack de suplantar la función CreateParams para reducir el flickering. Si hicieses cualquier tipo de test de rendimiento en una app "transparente" (el tiempo que tarda un RichTextBox en mostrar X cantidad de caracteres por ejemplo) te dará resultados nefastos, y, si eres tan meticuloso (o tiquismiquis) cómo yo en ese sentido, entonces no querrás volver a hacer transparente una app utilzando ese tipo de técnicas esotéricas.
Confórmate con la manera natural de hacer transparente las cosas, ajustando la propiedad TransparencyKey.
Si quieres hacer algo más del estilo de ese tipo de códigos que mencionas, entonces olvida WinForms y ponte a programar en tecnología WPF, que está considerablemente más extendido en ese sentido, y en todos los demás sentidos también, ya que WPF es el sucesor de WinForms, y WPF sigue estando en desarrollo/actualización por parte de Microsoft, cosa que WinForms no.
porque en el momento que se me ocurre algo y quiero hacer una modificación, puede resultar o bien que la modificación produzca un error que me obliga a modificar todo o empezar casi desde el principio por incompatibilidad o bien haya pasado tanto tiempo desde que revisé el código que ya no recuerdo ni lo que hice y no se lo que hacía esto o aquello, sobre todo con códigos muy grandes.
Y por supuesto mi me memoria es pésima, cuando dejo de usar algo se me olvida, y es muy práctico tener un código de ejemplo para cuando lo necesite.
Existe algo llamado
lineas de comentario (o documentación), aplícalo a tus códigos y no deberías tener problemas de memoria en el futuro
, preferiblemente la documentación XML de .Net + la característica
IntelliSense en la IDE o unas llamadas al
Object Inspector, con eso es imposible perderte en códios grandes que estén XML-documentados.
En el código de ejemplo que publiqué arriba puedes ver un ejemplo de documentación XML para un método y sus parámetros:
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Releases unmanaged and - optionally - managed resources.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
''' <param name="isDisposing">
''' <c>True</c> to release both managed and unmanaged resources;
''' <c>False</c> to release only unmanaged resources.
''' </param>
''' ----------------------------------------------------------------------------------------------------
Protected Sub Dispose(ByVal isDisposing As Boolean)
...
End Sub
La documentación XML además también te permite añadir ejemplos de código con los tags:
<example><code>CÓDIGO AQUÍ
</code></example>, y muchas cosas más.
No se si lo he dejado del todo claro, pero por si no lo has pillado lo diré con otras palabras:
Cuando pasas el puntero del mouse por el nombre de un miembro en la IDE y te sale un tooltip con una descripción del miembro y de sus parámetros y tal, pues eso es lo que se consigue con la documentación XML, además la misma documentación también sirve para crear el archivo de referencia de una API, es decir, se documenta con XML los miembros de una librería .dll y se refleja toda esa información al compilar la dll en un archivo de ayuda (.chm, .html, pdf, etc).
Tengo cientos de plantillas de código simple y ejemplos sólo de VB, los cuales hacen lo básico y lo importante. Por supuesto son modificables y ajustables a la necesidades del programa.
Quizás te pueda interesar este hilo:
➢
Librería de Snippets para VB.Net !! (Compartan aquí sus snippets)
Tan sólo quiero:
Form1 (o cualquier otro, o módulo)
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
-Llama a la función y la URL
-Recibir información de descarga mientras se produce
-Opción cancelar
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▲
•
•
•
▼
Bloque de código aparte
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
- Función de descarga con la URL
- Obtener información de descarga
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
Por lo tanto como ejemplo y como base, tan solo necesito un label el cual va a recibir la información del porcentaje, todo lo demás es irrelevante.
Bien, ¿pero hay algún problema con eso?, ¿el código que te mostré no te ha servido?.
Saludos!