software interactiu de simulació de camps elèctrics generats per...

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals

TITULACIÓ: Enginyeria Tècnica Industrial en Electrònica Industrial

AUTOR: Juan Ramón Rodríguez Sánchez . DIRECTOR: Roger Cabré Rodon .

DATA: Setembre del 2008.

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 1.Índex

2

1 Índex

1 Índex............................................................................................................................................ 2 2 Memòria Descriptiva ................................................................................................................... 4

2.1 Objecte del Projecte .......................................................................................................................... 4 2.2 Titular ................................................................................................................................................ 5 2.3 Destinataris ........................................................................................................................................ 5 2.4 Antecedents........................................................................................................................................ 5 2.5 Programació Orientada a Objectes ................................................................................................. 7

2.5.1 Classes a OOP ........................................................................................................................... 7 2.5.2 Les Propietats a les Classes ....................................................................................................... 7 2.5.3 Mètodes a les Classes ................................................................................................................ 8 2.5.4 Objectes a OOP ......................................................................................................................... 8 2.5.5 Estats a Objectes........................................................................................................................ 8 2.5.6 Missatges a Objectes ................................................................................................................. 8 2.5.7 Herència..................................................................................................................................... 9 2.5.8 Polimorfisme ............................................................................................................................. 9 2.5.9 Resum........................................................................................................................................ 9

2.6 Descripció General .......................................................................................................................... 10 2.6.1 Procés de Realització del Programa......................................................................................... 10 2.6.2 Introducció............................................................................................................................... 12 2.6.3 Requeriments ........................................................................................................................... 12 2.6.4 Diagrama de Flux .................................................................................................................... 13 2.6.5 Descripció Funcional del Programa......................................................................................... 15

3 Memòria de Càlcul .................................................................................................................... 41 3.1 Dibuixar Vector d’Intensitat de Camp Elèctric ........................................................................... 41 3.2 Dibuixar Vector d’Intensitat de Camp Elèctric Discret .............................................................. 44 3.3 Dibuixar Línia de Força Individual............................................................................................... 45 3.4 Dibuixar Línies de Força Inicials................................................................................................... 48 3.5 Dibuixar Línia Equipotencial Individual ...................................................................................... 50 3.6 Dibuixar Línies Equipotencial Inicials .......................................................................................... 53 3.7 Representació 3D............................................................................................................................. 57 3.8 Comprovació Teorema de Gauss ................................................................................................... 62

4 Pressupost ................................................................................................................................ 69 4.1 Preus Unitaris .................................................................................................................................. 69 4.2 Descomposició de Partides ............................................................................................................. 69 4.3 Amidaments..................................................................................................................................... 73 4.4 Aplicació de Preus - Pressupost ..................................................................................................... 73 4.5 Resum del Pressupost ..................................................................................................................... 74

5 Plec de Condicions ................................................................................................................... 75 5.1 Condicions Generals ....................................................................................................................... 75 5.2 Condicions Econòmiques................................................................................................................ 75

Títol del Projecte Universitat Rovira i Virgili 1.Índex

3

5.3 Condicions Tècniques ..................................................................................................................... 75 5.4 Condicions Facultatives .................................................................................................................. 76

6 Annexos .................................................................................................................................... 77 6.1 Bibliografia ...................................................................................................................................... 77

6.1.1 Teoria de física (Camps Elèctrics, Teorema de Gauss, etc...).................................................. 77 6.1.2 Visual Basic.net ....................................................................................................................... 77 6.1.3 Altres ....................................................................................................................................... 77

6.2 Codi .................................................................................................................................................. 78 6.2.1 Codi Pantalla Principal (“Campelec”) ..................................................................................... 78 6.2.2 Codi Pantalla Comprovació Teorema de Gauss (“Gauss”) ................................................... 119 6.2.3 Codi Pantalla Representació Potencial en 3D (“Gràfica”)..................................................... 136

6.3 Manual d’Introducció a Microsoft Visual Basic 2005 Express Edition.................................... 144

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 2.Memòria Descriptiva

4

2 Memòria Descriptiva

2.1 Objecte del Projecte El projecte consisteix en un programa informàtic de suport docent, el qual,

mitjançant diferents presentacions gràfiques interactives, intenta fer més comprensible, per a l’estudiant, la teoria de camps elèctrics generats per càrregues puntuals. El camp elèctric és en realitat tridimensional, però és obvi que una representació mitjanament clara sobre la pantalla d’un ordinador només es pot fer en dues dimensions. Per tant, per a poder representar-lo en dues dimensions, hem de fer una sèrie de consideracions i rectificacions al càlcul, tal i com veurem més endavant.

Pricipalment, tenim:

- Una pantalla principal, amb una graella on col·locarem càrregues que generen un camp elèctric. Les càrregues les introduirem de nou, o podem obrir un arxiu d’extensió txt, prèviament creat, on s’emmagatzemen els valors de les càrregues i llurs posicions. Aquestes càrregues podrem desplaçar-les, esborrar-les i afegir-ne d’altres. A la graella hi podem representar els vectors d’intensitat de camp elèctric, les línies de força i les línies equipotencials. Si volem, podrem imprimir la graella amb el que hi hagi representat. També podem guardar el valor de les càrregues i les posicions en un arxiu d’extensió .txt, per a poder recuperar-ho posteriorment, si ens interessa.

- En una altra pantalla, podrem comprovar el teorema de Gauss per a una superfície de 2D. Com és conegut, el teorema de Gauss diu que la integral de flux del camp a través d'una superfície tancada al voltant d'algunes de les càrregues, és proporcional amb un factor 4π·ke (ke la constant elèctrica de la llei de Coulomb ke≈9x109 N·m2/C2 ) a la suma de les càrregues tancades dins la superfície.Com que ara treballarem en un espai de dues dimensions, no té sentit parlar de superficies tancades sinó de línies tancades dins el pla de treball, que envolten algunes de les càrregues i llavors el concepte de flux s'ha de redefinir per a línies, és el que en direm flux-2D. Igualment l’eqüació del Teorema de Gauss mateix s'haurà d'adaptar en el sentit que ja direm més endevant. Aquí tindrem la graella amb les càrregues introduïdes, clicarem una sèrie de punts que formaran una àrea a la graella, i hi calcularem el flux-2D resultant en aquesta àrea degut al camp elèctric existent. Aplicarem el teorema de Gauss (adaptat a 2D), i calcularem el flux teòric per l’àrea definida abans. Compararem tots dos resultats per a comprovar que hem realitzat bé els càlcul. Les dades d’aquests càlculs s’emmagatzemen en una taula que, si volem, podem passar i guardar en un arxiu Excel.

- En una tercera pantalla hi podem veure una representació en perspectiva 3D del potencial elèctric del camp existent. Aquesta representació s’aconsegueix considerant que les coordenades X i Y són les dels punts de la graella, i la coordenada Z el potencial del camp elèctric en aquests punts. Per a aconseguir la impressió de tridimensionalitat, s’han passat les coordenades cartesianes a coordenades esfèriques, i mitjançant la variació del angles de posició, podrem veure la representació del potencial des de diferents punts de vista.


5

És un software interactiu perquè ens permet introduir les càrregues que volguem, moure-les, afegir-ne, treure’n, etc...

2.2 Titular El titular del projecte és el DEEEA (Departament d’Enginyeria Electrònica, Elèctrica

i Automàtica). Amb adreça:

Escola Tècnica Superior d’Enginyeria

Avda. Països Catalans, 26 (Campus Sescelades)

43007 Tarragona

2.3 Destinataris Els destinataris seran principalment estudiants de primer curs de l’assignatura

Fonaments Físics de l’Enginyeria que es cursa als ensenyaments de: Enginyeria Tècnica en Telecomunicacions especialitat en Telemàtica, Enginyeria Tècnica Industrial especialitat en Electricitat i Enginyeria Tècnica Industrial especialitat en Electrònica Industrial. Així mateix, podrà anar dirigit als estudiants dels nous graus d’Electrònica, Electricitat, Informàtica, Telecomunicacions i Química que segurament cursaran una assignatura comú de Física. També es pot considerar destinatari qualsevol persona de l’ETSE o aliena que estigui interessada en complementar la teoria dels camps elèctrics generats per càrregues puntuals amb exemples gràfics. Les persones de fora de l’ETSE podran accedir a l’aplicació respectant les condicions que imposi el DEEEA..

2.4 Antecedents Durant l’estudi de la teoria de camps elèctrics, quan intentem fer-nos una imatge

mental que ens ajudi a entendre-ho millor, hem de fer un esforç per a poder visualitzar conceptes que de vegades, malgrat ser prou clars, al mateix temps tenen un grau d’abstracció que ens dificulta plasmar-los en imatge. En un tema bastant bàsic, com en el cas que ens pertoca del camp elèctric creat per partícules puntuals, la teoria és bastant clara, però imaginar-se, per exemple, que en un punt les línees de força i les equipotencials són perpendiculars, és molt més fàcil si podem veure-ho representat en una gràfica. És aquest el motiu pel que s’ha fet aquesta aplicació, ajudar als alumnes a entendre més clarament la teoria de camps elèctrics creats per càrregues puntuals, mitjançant representacions gràfiques dels conceptes que s’hi veuen involucrats.

L’aplicació a desenvolupar és essencialment un software interactiu que representarà línies en una graella. Així que, la funcionalitat que bàsicament haurà d’implementar és:

- Capacitat per a tractar events de teclat i ratolí.

- Capacitat gràfica per a representar línies.

- Càrrega de fitxers d’imatge.

- Lectura / escriptura de fitxers de text.

- Escriptura de fitxers Excel per emmagatzemar taules de dades (no era imprescindible).


6

És obvi que, es disposa de diverses eines comercials de programació que satisfan les necessitats requerides per a implementar l’aplicació del projecte. Entre aquestes eines, podríem posar com exemple el Visual C, el Java o el Visual Basic (que és per la que finalment s’ha optat).

Donat que l’aplicació no conté cap element clarament diferenciador a favor de cap de les eines abans esmentades, la que finalment s’ha triat per a la realització del projecte és el Visual Basic.Net (VB.Net). Les raons per haver escollit aquest llenguatge i no un altre són diverses, a continuació enumeraré alguna d’elles:

- El VB.Net té un entorn de treball bastant amigable (al contrari de per exemple el Visual C++, malgrat que aquest compta amb llibreries gràfiques).

- El VB.Net pertany a la plataforma de Microsoft, la qual cosa assegurava la seva compatibilitat amb una sèrie de programes molt utilitzats (per exemple, a l’aplicació, es guarda un document en format Excel).

- L’ús del VB.Net està molt estès, i es pot trobar una gran quantitat d’informació a Internet, tant de manuals com de solucions als possibles problemes o dubtes que poguessin sorgir durant l’elaboració del programa.

- El VB es tractar d’un llenguatge “derivat” del Basic, la qual cosa fa que resulti familiar al programador, tot i que la filosofia de l’un i l’altre és totalment diferent.

- Una altra raó de pes, és que Microsoft proporciona a la seva pàgina Web, de manera gratuïta, una versió del programa anomenada Visual Basic 2005 Express Edition, que potser no té totes les prestacions de la versió Professional, però que permet desenvolupar programes sense cap tipus de problema (l’enllaç on es pot trobar aquest programa és el següent: http://www.microsoft.com/spanish/msdn/vstudio/express/VB/default.mspx. Ara ja han llençat la versió 2008, la qual accepta qualsevol programa escrit en la versió 2005).


7

2.5 Programació Orientada a Objectes El VB.Net és un llenguatge dels anomenats de Programació Orientada a Objectes

(OOP de les sigles en anglès Object Oriented Programming)., i com que aquest és un tret diferenciador important entre uns llenguatges i altres, és adient fer una petita explicació de què es tracta.

La programació OOP és una evolució de la programació procedural basada en funcions, que permeten agrupar elements de codi (rutines i dades) amb funcionalitats similars, sota un sistema unificat de manipulació i accés a aquests elements.

La motivació del sorgiment de la OOP va ser que durant anys, els programadors es van dedicar a construir aplicacions molt semblants que resolien un els mateixos problemes. Per aconseguir que els esforços dels programadors poguessin ser utilitzats per altres persones es va crear la OOP. O sigui, que consisteix en una sèrie de normes de realitzar el codi, de manera que aquest es pugui reutilitzar.

Pensar en termes d’objecte és molt semblant a com ho faríem a la vida real. Per exemple, pensarem en un vehicle i tractarem de fer un model en un esquema de OOP. Diríem que el Vehicle és l’element principal que té una sèrie de característiques, com podrien ser el color, el model o la marca. A més té una sèrie de funcionalitats associades, como poden ser engegar, parar o aparcar.

En un esquema OOP el Vehicle seria l’objecte, les propietats serien les característiques com el color o el model i els mètodes serien les funcionalitats associades como engegar o parar.

Un altre exemple, modelitzarem en un esquema OOP una fracció (3/2, 1/5, etc...). La Fracció serà l’objecte i tindrà dues propietats, el numerador i el denominador. Podrà tenir diversos mètodes com simplificar-se, sumar-se amb una altra fracció o número, restar-se, etc...

Aquest dos objectes anteriors es podrien utilitzar a un programa de matemàtiques i a un programa que gestioni un taller de vehicles respectivament, per exemple. Al mateix temps, el taller de vehicles podria ser també un objecte que fa servir altres objectes (vehicles, eines, mecànics, etc...).

2.5.1 Classes a OOP

Les classes són declaracions d’objectes, també es podrien definir como abstraccions d’objectes. Això vol dir que la definició d’un objecte és la classe. Quan es programa un objecte i es defineixen les seves característiques i funcionalitats, el que realment s’està fent és programar una classe. Als exemples anteriors, estaríem parlant de la classe Vehicle i de la classe Fracció.

2.5.2 Les Propietats a les Classes

Les propietats o atributs són les característiques dels objectes. Quan es defineix una propietat, normalment, s’especifiquen el seu nom i el seu tipus. Podríem pensar que les propietats són com variables a on s’emmagatzemen dades relacionades amb els objectes.


8

2.5.3 Mètodes a les Classes

Són les funcionalitats associades als objectes. Els mètodes són com funcions que estan associades a un objecte.

2.5.4 Objectes a OOP

Els objectes són exemplars d’una classe qualsevol. Quan es crea un exemplar, s’ha d’especificar la classe a partir de la qual es crearà. Aquesta acció de crear un objecte a partir d’una classe s’anomena instanciar (que ve d’una traducció mal feta de la paraula instace que en anglès significa exemplar). Per exemple, 3/5 és un objecte de la classe fracció. El concepte o definició de fracció seria la classe, però quan parlem d’una fracció en concret (1/3, 2/5, etc...) l’anomenem objecte.

Per a crear un objecte s’ha d’escriure una instrucció especial que pot ser diferent depenent del llenguatge de programació, però serà quelcom semblant a:

meuVehicle = new Vehicle()

Amb la paraula new especifiquem que s’ha de crear una instància de la classe que la segueix. Al parèntesi hi podríem posar, per exemple, paràmetres d’inicialització de l’objecte.

2.5.5 Estats a Objectes

Quan tenim un objecte, les seves propietats prenen valors. Per exemple, quan tenim un objecte Vehicle, la propietat color prendrà un valor en concret (vermell, gris, etc...). Del valor concret d’una propietat d’un objecte se’n diu estat.

Per accedir a un estat d’un objecte, per veure el seu valor o canviar-lo, s’utilitza l’operador punt (.).

meuVehicle.Color = Vermell

L’objecte és meuVehicle, seguidament posem l’operador punt i per últim el nom de la propietat a la que volem accedir. En aquest exemple estem canviant el valor de l’estat de la propietat de l’objecte a vermell, amb una simple assignació.

2.5.6 Missatges a Objectes

Un missatge a un objecte és l’acció d’efectuar una crida a un mètode. Per exemple, quan li diem a un objecte Vehicle que s’engegui, estem passant-li el missatge “engega’t”.

Per enviar un missatge als objectes, utilitzarem l’operador punt (.) seguit del mètode que vulguem cridar (invocar).

meuVehicle.Engegar()

En aquest exemple, passem el missatge Engegar(). S’ha de posar parèntesi, i a l’igual que qualsevol crida a una funció, dins aniran els paràmetres que passem.


9

2.5.7 Herència

A la OOP existeix la possibilitat de “extendre” el comportament d’ una classe, afegint atributs i mètodes. El mecanisme utilitzat per a fer això s’anomena herència.

Continuant amb l’exemple de la classe Vehicle, podríem voler definir una classe Camió. Bàsicament un Camió té totes les característiques d’un Vehicle (marca, model, color, etc...), però a més tindrà altres atributs (com per exemple, la càrrega que pot transportar, si el remolc és articulat, etc...) i altres mètodes (carregar, descarregar, etc...). És per això que podrem definir la classe Camió heretant de la classe Vehicle (en OOP s’utilitza l’expressió “un Camió és un Vehicle”), i afegint el nou comportament (mètodes i atributs)

En resum, l’herència serveix per a crear objectes que incorporen propietats i mètodes d’altres objectes. Així podem construir uns objectes a partir d’altres sense haver de reescriure-ho tot novament.

2.5.8 Polimorfisme El polimorfisme determina que el mateix nom de mètode, realitzarà diferents accions

segons sigui l’objecte sobre el que s’aplica. Per exemple, si tenim dos objectes Pilota i GotdeVidre, i executem sobre ambdós el mètode Llençar, el resultat en cada cas serà molt diferent (la Pilota rebotarà i el GotdeVidre es trencarà). El programador que faci ús de l’objecte, no necessita conèixer els detalls de la implementació dels mètodes, tan sols es limita a utilitzar-los i a obtenir-ne els resultats.

2.5.9 Resum

La programació orientada a objectes expressa un programa com un conjunt d’aquest objectes, que col·laboren entre ells per a realitzar tasques. Això permet fer els programes i mòduls més fàcils d’escriure, mantenir i reutilitzar.

Els mètodes (comportament) i atributs (estat) estan estretament relacionats per la propietat de conjunt. Aquesta propietat destaca que una classe necessita de mètodes per a poder tractar els atributs que té. Això difereix de la programació estructurada tradicional on les dades i els procediments estan separats i sense cap relació, ja que l’única cosa que es busca és el processament d’unes dades d’entrada per a obtenir unes altres de sortida. A la programació estructurada només s’escriuen funcions que processen dades. A la OOP primer es defineixen objectes per a després enviar-los missatges sol·licitant que realitzin els seus mètodes per sí mateixos.

A lo que abans en dèiem tipus, referint-nos a estructures de dades, ara en diem classe, entenent como a tal no només les estructures, sinó també el comportament associat (les acciones i funcions associades directament amb l’estructura de dades)

A lo que abans en dèiem variable ara en diem objecte. Així com les variables són de determinat tipus, els objectes són de determinada classe.

Els procediments i funcions definits dins d’una classe es diuen mètodes, en tant que els camps es denominen atributs.


10

2.6 Descripció General

2.6.1 Procés de Realització del Programa Activitats a considerar per la creació del projecte:

Nº Activitat Designació de l’activitat Duració (dies)

1 Plantejament d’objectius i decisió del llenguatge a utilitzar

2

2 Investigació i estudis previs de la teoria 2

3 Estudi del llenguatge emprat per escriure el programa

30

4 Realització del programa 60

5 Disseny i realització de la memòria i el manual d’usuari

15

Duració total d’activitats... 1091

El diagrama de Gantt de la Figura 1 mostra la distribució de les tasques en què es va dividir en un principi el projecte i sobre les quals es va realitzar una planificació temporal per a dur-les a terme. S’hi poden veure la planificació inicial i el desenvolupament real de les tasques realitzades.

Òbviament, com tota planificació, aquesta a patit canvis i modificacions al llarg del desenvolupament del projecte. Observant la Figura 1, es pot apreciar que existeixen diferències substancials entre la planificació prevista i la final. Això és degut a varies causes:

- A una planificació excessivament optimista pel que fa a la distribució de les tasques durant el projecte.

- A la inversió de més temps del desitjat en algunes tasques degut a la compaginació d’activitats laborals.

- A què algunes tasques han tingut uns requeriments de temps superiors als previstos, ja sigui causat per la metodologia o per la insuficient inversió d’hores de treball durant el temps assignat a elles.

- A què hi ha tasques que sorgeixen a mida que s’avança en el projecte, a l’igual que d’altres que es suprimeixen o canvien

1 Es considera com activitat diària l’execució de 8 hores de treball efectives


11

Figura 1. Diagrama de Gantt. Planificació de Tasques


12

2.6.2 Introducció Aquesta aplicació consta d’una pàgina principal amb una graella on es podran

col·locar càrregues per a veure la representació del camp elèctric, línies equipotencials, etc... i de dues pàgines secundàries, una on es podrà veure una representació tridimensional del potencial elèctric i una altra on es podrà comprovar el teorema de Gauss per a una superfície de 2D.

La present memòria s’acompanya d’un CD que conté l’arxiu d’instal·lació del programa.

2.6.3 Requeriments Els requeriments mínims per a executar l’aplicació són els següents:

- Sistema Operatiu Windows 2000 o superior.

- Lector de CD ROM, Port USB o algun tipus de comunicació amb altres ordinadors, per a poder copiar els arxius necessaris a la unitat C: de l’ordinador on es vol treballar.

- Tenir instal·lat el .Net Framework 2.0 de Microsoft. El programa d’instal·lació o porta incorporat, sense necessitat de connectar-se a Internet

- Tenir instal·lat el programa Microsoft Office Excel 2003 o superior (si no és així, el programa funciona igualment, però l’opció de guardar les dades en Excel no funcionarà, i aquesta tasca s’haurà de fer a mà, seleccionant, copiant i després pegant.

La resolució de pantalla recomanada per veure tots els recursos que ofereix el programa de forma idònia és de 1280x800 píxels, ja que és la resolució del monitor on s’ha desenvolupat el programa, però no és problema tenir una altra configuració, sempre i quan la resolució de les Y sigui més gran de 600 píxels (720, 768,.etc..).


13

2.6.4 Diagrama de Flux A continuació es presenta el diagrama de flux del programa, per a mostrar, d’una

manera senzilla, quin és el seu funcionament bàsic.

Figura 2. Diagrama de Flux. Pantalla Principal


14

Figura 3. Diagrama de Flux. Pantalles: Gràfica 3D i Comprovació Teorema de Gauss


15

2.6.5 Descripció Funcional del Programa A continuació es descriurà quin és el funcionament del programa. Per a què sigui

més comprensible, es farà amb un parell d’exemples. Per tant aquest apartat podríem entendre’l també com una mena de manual d’usuari.

Un cop iniciem el programa amb l’arxiu executable, se’ns mostrarà la pantalla principal que veiem a la Figura 3.

Figura 3. Pantalla Principal

Les diferents parts que clarament podem distingir són:

- La Graella. Situada al centre de la imatge, és on col·locarem les càrregues i on es representaran les diferents gràfiques.

- La Barra d’Eines. Situada dalt de tot a l’esquerra. Conté quatre botons. A continuació s’explicarà per a què serveix cadascun.

- La Llegenda. Situada a la part esquerra de la pantalla. Hi veiem el codi de colors, etc...

- Etiquetes. Situades a la part esquerra de la pantalla, sota la llegenda.

- Els Botons. Situats a sobre de la graella.


16

A continuació s’explicarà què és cada element d’aquesta pàgina principal, i més endavant, amb un exemple, anirem veient per a què serveixen:

Nova Presentació. Serveix per iniciar una nova presentació.

Obrir Arxiu. Serveix per recuperar una presentació guardada amb anterioritat. S’obre un

Guardar Arxiu. Serveix per guardar la presentació en curs. Guarda el valor de les càrregues i la posició de cadascuna d’elles, ho fa en format .txt.

Imprimir. Serveix per imprimir la graella de la presentació actual amb lo que hi hagi dibuixat dins. Abans d’imprimir, s’obre una previsualització

Iniciar. Serveix per iniciar una nova presentació.

Sortir. Serveix per sortir del programa.

Reiniciar Serveix per iniciar una nova presentació, descartant l’actual.

Afegir Càrrega. Serveix per afegir una càrrega a la presentació en curs.

Esborrar Càrrega. Serveix per esborrar una càrrega a la presentació en curs.

Moure Càrrega. Serveix per moure les càrregues de la presentació en curs

Netejar. Serveix per a esborrar totes les línies que hi hagi a la graella.


17

Dibuixar Vectors d’Intensitat de Camp Elèctric. Serveix per dibuixar els vectors d’intensitat de camp elèctric creat per les càrregues de la presentació. Es representa a mòdul constant, per a què es distingeixi bé. Al clicar aquí apareix dues barres “lliscants” (trackbars) amb la que es poden variar el mòdul dels vectors i la distància entre vectors dibuixats. Al fer click en aquest botó, s’esborraran totes les línies anteriorment dibuixades.

Dibuixar Vector d’Intensitat de Camp Elèctric Discret. Serveix per mostrar el vector d’intensitat de camp elèctric al punt de la graella per on passa el cursor, també mostra una etiqueta amb les coordenades del punt per on passa i el valor del mòdul en aquest punt. Si fem click a la graella, tant l’etiqueta com el vector es quedaran dibuixats a la graella.

Dibuixar Línies de Força. Serveix per dibuixar una sèrie de línies de força creades per les càrregues de la presentació.

Les línies de força tenen una sèrie de propietats definitòries:

1. Les línies de força són trajectòries que en cada punt per on passen són tangents al vector d'intensitat de camp en aquell punt.

2. Les línies de força tenen sempre un sentit tal que surten de les càrregues positives o de l'infinit i van a para a les càrregues negatives o a l'infinit.

3. Igualment és cert que, si dibuixéssim un número de línies de força sortints de cada càrrega positiva o entrants a cada càrrega negativa, directament proporcional al valor d'aquesta càrrega, i distribuides angularment de forma homogènia al voltant d'ella; llavors en cada punt la densitat de línies de força seria proporcional al valor del camp.

El software automàticament ja realitza la distribució de la propietat 3. Crea automàticament un número de línies de força entrants i sortints, proporcionals al valor de la càrrega i a més les distribueix homogèniament al seu voltant.

Al fer click en aquest botó, s’esborraran totes les línies anteriorment dibuixades.

Dibuixar Línia de Força Individual. Serveix per dibuixar el la línia de força que passa pel punt de la graella on es faci click amb el ratolí. Serveix per si l'usuari vol afegir línies que passin per llocs on l'algorisme automàtic del botó anterior no ha creat.

Dibuixar Línies Equipotencials. És evident, que a causa de la reducció de la dimensionalitat, ara no parlarem de superfícies equipotencials tal i com es fa de


18

forma usual en teoria del camp elèctric 3D, sinó que ho reduirem a línies equipotencials.

El botó serveix per dibuixar una sèrie de línies equipotencials creades per les càrregues de la presentació de forma automàtica.

Les línies que automàticament es dibuixen corresponen a valors del potencial homogèniament distribuït entre dos valors extrems de màxim i de mínim, dels qual ja parlarem. Per això: la quantitat de línies que observem més a prop de cada càrrega creix a mesura que creix el valor de la càrrega en comparació a les altres. Al fer click en aquest botó, s’esborraran totes les línies anteriorment dibuixades.

Dibuixar Línia Equipotencial Individual. Serveix per dibuixar la línia equipotencial que passa pel punt de la graella on es faci click amb el ratolí.

Igualment que abans, serveix per si l'usuari vol afegir línies que passin per llocs on l'algorisme automàtic del botó anterior no ha creat.

Representació 3D. Al clicar el botó, s’obre una altra pantalla on hi veurem una representació en perspectiva tridimensional del potencial elèctric a la graella, creat per les càrregues de la presentació en curs.

Comprovació T. Gauss. Al clicar el botó, s’obre una altra pantalla on hi podrem comprovar el Teorema de Gauss per a una línia tancada en 2D.


19

Per a entendre millor el funcionament del programa, anem a desenvolupar un exemple, seguint una sèrie de passos:

1. Hem de col·locar càrregues a la graella. Això ho podem fer de dues maneres:

- Obrint un arxiu prèviament guardat, amb el botó Obrir Arxiu ( ), que conté la informació dels valors de les càrregues amb llurs posicions. Al clicar aquest botó s’obrirà un quadre de diàleg on es pot escollir l’arxiu a obrir que ha de tenir extensió .txt (Figura 4).

Figura 4. Valor de les Càrregues

En aquest cas, les càrregues ja estan introduïdes, doncs anteriorment hem guardat aquesta disposició.

- Clicant a la Graella, al botó Nova Presentació ( ) o al botó Iniciar ( ). S’obrirà una finestra emergent que ens preguntarà quantes càrregues volem introduir (amb un màxim de 10, ja que pel tamany de la graella i pel que necessitem és un número més que suficient), i posteriorment haurem d’introduir el valor de cada una (Figura 5 i Figura 6). Anem amb compte ja que les unitats per defecte són Coulombs (C) i els valors usuals de les càrregues haurien de ser fraccions molt petites del coulomb (μC, mC).

Figura 5. Nº de Càrregues


20

Figura 6. Valor de les Càrregues

Un cop haguem introduït el valor de les càrregues, les veurem aparèixer a la graella, i les podrem moure a on vulguem arrossegant-les amb el ratolí. A la part dreta de la pantalla es faran visibles unes etiquetes amb el valor i la posició de cada una d’elles (Figura 7). A la posició on situem una Càrrega Negativa veurem el símbol , i a on situem una Càrrega Positiva veurem aquest altre .

Figura 7. Etiquetes Valor i Posició de les Càrregues

2. Un cop introduïdes les càrregues, si cliquem novament els botons Nova Presentació o Iniciar, tornarà a demanar-nos que introduïm les càrregues. I si cliquem al botó Reiniciar ( ), tornarem a la pantalla inicial.

3. Si en qualsevol moment cliquem el botó Sortir ( ), es tancarà l’aplicació.

4. Si en qualsevol moment cliquem el botó Guardar Arxiu ( ), s’obrirà un quadre de diàleg que ens preguntarà on i amb quin nom volem guardar l’arxiu (que tindrà extensió txt). Aquest arxiu emmagatzemarà els valors de les càrregues i llurs posicions (Figura 8).

Figura 8. Guardar Arxiu


21

5. Si en qualsevol moment volem imprimir el contingut de la graella, hem de clicar el botó Imprimir ( ), primer s’obrirà una previsualització (Figura 9) i posteriorment un quadre de diàleg on hem d’escollir la impressora per on volem treure la impressió (Figura 10).

Figura 9. Imprimir. Vista Preliminar

Figura 10. Imprimir. Elecció d’Impressora

6. Al desplaçar el cursor sobre la graella, podem veure com les etiquetes Posició

Cursor, ens indiquen a cada moment sobre quin punt de la graella ens trobem i el valor del potencial elèctric i el mòdul del vector intensitat de camp en aquest punt (Figura 11).


22

Figura 11. Etiquetes Posició Cursor

7. Al clicar amb el ratolí sobre la graella, veurem com les etiquetes Click al Panel ens

mostren el valor de la X, de la Y del punt clicat, el potencial elèctric, i les components X,Y i el mòdul, del vector intensitat de camp elèctric en aquest punt (Figura 12).

Figura 12. Etiquetes Click al Panel

8. Si en qualsevol moment, volem moure les càrregues del lloc on es troben, hem

d’activar el botó Moure Càrrega ( ), i arrossegar-les allà on vulguem. En quan cliquem qualsevol altre botó, aquest es desactivarà.

9. Si en qualsevol moment volem afegir una càrrega, hem de clicar al botó Afegir Càrrega ( ). S’obrirà una finestra com la de la Figura 6 que ens demanarà que introduïm el valor de la càrrega. Un cop fet, apareixerà la càrrega, així com les etiquetes corresponents de valor i posició.

10. Si en qualsevol moment volem esborrar una de les càrregues que tenim a la graella, només hem de clicar el botó Esborrar Càrrega ( ). S’obrirà una finestra que ens demanarà quina és la càrrega que volem esborrar (Figura 13).

Figura 13. Esborrar Càrrega


23

11. Si en qualsevol moment cliquem el botó Netejar ( ), s’esborraran totes les línies de la graella, quedant tan sols les càrregues situades al mateix lloc on estaven.

12. Si activem el botó Dibuixar Vectors d’Intensitat de Camp Elèctric ( ), veurem que com es representen a la graella els Vectors d’Intensitat de Camp Elèctric a mòdul constant (Figura 14). Al fer click en aquest botó, s’esborraran totes les línies anteriorment dibuixades.

Recordem que La Intensitat de Camp Elèctric (E) en un punt, es defineix com la força exercida per un camp elèctric sobre la unitat de càrrega positiva situada en aquest punt. Si el camp elèctric estigués creat per n càrregues, la fórmula per a calcular el vector d’intensitat de camp en un punt r, seria, segons la Llei de Coulomb:

∑=

−−

=n

ii

i

i rrrr

qkE

13 )·(

·

On k ≈ 9 x 109 Nm2/C2 és la constant elèctrica, ri és la posició de la càrrega qi, r la del punt on volem calcular el camp. Com podem veure, cada càrrega introdueix una contribució al camp que va en la direcció radial del vector r-ri que uneix la càrrega amb el punt r; és proporcional a la càrrega qi i inversament proporcional al quadrat de la distància radial |r-ri| entre la càrrega i el punt.

La raó de dibuixar-los a mòdul constant, és per poder apreciar amb claredat quina direcció i sentit prenen aquests vectors a cada punt, ja que si els dibuixéssim amb el valor del seu mòdul real, simplement podríem veure un garbuix de línies que es creuen i que es tapen les unes a les altres. Això és així perquè quan ens apropem a les càrregues, els vectors d’intensitat de camp creixen molt pronunciadament, inversament al quadrat de la distància exponencialment. Això vol dir que quan més a prop d’una càrrega està el punt (o sigui, la unitat de càrrega positiva), amb més força o intensitat és atreta (o repel·lida, segons sigui la càrrega positiva o negativa).

Figura 14. Dibuixar Vectors d’Intensitat de Camp Elèctric


24

També per a poder apreciar bé aquests vectors, no hem dibuixat un per a cada punt (o píxel), la distància que s’ha agafat inicialment entre punt i punt és de 25 píxels. De qualsevol manera, s’han afegit dues “trackbar”, que només apareixen quan s’activa aquest botó, amb les que podem augmentar i disminuir tant el mòdul dels vectors d’intensitat de camp, com la distància entre els punts per als que els dibuixem(Figura 15).

Figura 15. TrackBars per a Distància i Mòdul de Vectors

Si augmentem el mòdul dels vectors veurem quelcom semblant a la Figura 16, i si augmentem la distància entre els punts pels que hem dibuixat els vectors, quelcom semblant a la Figura 17.

Figura 16. Augmentem el Mòdul dels Vectors


25

Figura 17. Augmentem la Distància entre Vectors Dibuixats

Podem apreciar clarament la direcció i sentit dels vectors, i els vectors dibuixats deixen entreveure com seran les línies de força, o línies de camp que veurem més endavant. Això no és estrany, ja que hem de recordar que el vector d’intensitat de camp en un punt, i la línia de força en aquest punt, són tangents (Figura 18).

Figura 18. Com els Vectors d’Intensitat de Camp deixen entreveure la trajectòria de les

Línies de Força

13. Si cliquem a Dibuixar Vector d’Intensitat de Camp Elèctric Discret ( ), se’ns mostrarà el vector d’intensitat de camp elèctric al punt de la graella per on passa el cursor. Si fem click amb el ratolí, tant el vector com també una etiqueta amb les


26

coordenades del punt i el valor del mòdul en aquest punt, es quedaran dibuixats a la graella (Figura 20). Al fer click en aquest botó, no s’esborraran les línies anteriorment dibuixades a la graella, la qual cosa és molt útil.

Al representar aquests vectors, veurem clar perquè amb l’altre botó els dibuixem a mòdul constant. Aquí no veurem els vectors a mòdul constant, però tampoc els representarem amb la seva magnitud real. Això és així perquè, quan les càrregues són molt grans, els vectors surten dels límits del dibuix i quan són molt petites, molts vectors són tan petits que ni es veuen. Per aquesta raó, escalarem el mòdul dels vectors, de manera que encara que no siguin el valors reals, sí que es mantindran les relacions de mòduls d’uns vectors respecte als altres. Amb la finalitat de que sigui més clar, els vectors de mòdul inferior a un cert valor ordre, s’han dibuixat amb aquest valor mínim. Malgrat tenir els mòduls escalats, si ens interessa, tenim el valor real de les components Ex i Ey i del mòdul al punt clicat a les etiquetes de Click al Panel. , tal i com hem vist anteriorment.

Figura 20. Dibuixar Vector d’Intensitat de Camp Discret

14. Si activem el botó Dibuixar Línies de Força ( ),veurem que com es representen a la graella els una sèrie de línies de força o línies de camp (Figura 21 i Figura 22). Al fer click en aquest botó, s’esborraran totes les línies anteriorment dibuixades.

Recordem que les Línies de Força o Línies de Camp són la trajectòria que seguiria la unitat elèctrica positiva abandonada a l’acció del camp elèctric, i sense acceleració i que a cada punt de l’espai, les línies de força són tangents als vectors d’intensitat de camp elèctric. És a dir, les línies de força indiquen a cada punt la direcció que té el camp elèctric. Aquestes línies mai es creuen entre elles, i quants més properes estiguin entre elles, significa que tan més intens és el camp elèctric.


27

Figura 21. Dibuixar Línies de Força (3 Càrregues)

Figura 22. Dibuixar Línies de Força (2 Càrregues)

Al activar aquest botó, el que es pretén és dibuixar una sèrie de línies de força que donin una idea de com és el camp elèctric creat per les càrregues que hem introduït. I per representar-les hem de tenir en compte que:

- Les línies de força han de partir de càrregues positives i acabar en càrregues negatives, i en absència d’unes o altres han de partir o acabar a l’infinit (Figura 23).

- En una representació normalitzada, el número de línies de força que surten d’una càrrega positiva o arriben a una càrrega negativa hauria de ser proporcional a la quantitat de càrrega respectiva.

- La intensitat del camp elèctric es visualitza mitjançant l’apropament entre les línies de força, a major densitat de línies, major intensitat de camp elèctric

- Les línies de força mai es poden creuar. Si es creuessin en un punt, significaria que en aquest punt el camp elèctric tindria dues direccions


28

diferents, és a dir, que tindria més d’un valor d’intensitat de camp. Això no és possible doncs la teoria ens diu que per definició a cada punt li correspon un únic valor d’intensitat de camp.

Figura 23. Dibuixar Línies de Força (1 Càrrega)

Per a aconseguir això, l’algorisme de representació s’ha resolt de la següent forma:

- Les línies dibuixades surten (o arriben) de les càrregues de signe “predominant”, és a dir, de les positives si el valor de la suma de les càrregues positives és major que el valor de la suma de les càrregues negatives, o a l’inrevés.

- Les línies estan repartides entre les càrregues, proporcionalment al seu valor, per exemple si d’una càrrega de 1 μC surten N línies, d’una altra de 2 μC sortiran 2N línies, ja que, com ja sabem, quant més gran sigui la càrrega, major és la intensitat de camp, i per representar això es dibuixen més línies de força per unitat de superfície.

- Depenent del número de càrregues, es dibuixen més o menys línies de força. Realment hi ha infinites línies de força, però lògicament no es dibuixen totes per claredat.

- Un cop determinades el número de línies que surten o entren a la càrrega, aquestes es reparteixen de forma homogènia en totes direccions al voltant d'elles.

No es tracta de fer una representació exacta, si no de donar una idea aproximada que ajudi a entendre el concepte

Si el camp elèctric està compensat, en teoria, cada línia de camp que surt d’una càrrega positiva ha d’arribar a una càrrega negativa. Com que la graella és com una “finestra” finita i petita des de la que observem el camp elèctric generat per les càrregues, és possible que, a la nostra representació, no totes les línies que surten de les càrregues positives vagin a parar a les negatives. Això és així perquè les línies que surten dels límits de la nostra “finestra”, i teòricament “donen el tomb” i retornen


29

per anar a parar a una càrrega negativa, des de el nostre finit punt de vista, marxen massa lluny. En aquests casos ens és impossible representar-les sortint d’una càrrega positiva i arribant a una negativa, solsament veurem com la línia surt d’una càrrega positiva i se’n va fora dels límits de la graella, o com la línia arriba a una càrrega negativa sorgint dels límits de la graella (Figura 24)

Si el camp elèctric no està compensat (ja sigui perquè només hi ha càrregues del mateix signe o el valor de les d’un signe és molt més gran que el valor de les de signe oposat), no totes les línies de força que surten d’una càrrega positiva acaben a una de negativa. En aquest cas, la falta de compensació la veurem reflexada en línies de força que realment van o venen de l'infinit (Figura 25).

Figura 24. Línies que des de el nostre punt de vista van a parar a l’infinit.

Figura 25. Línies que realment van a parar a l’infinit.


30

Si es volgués veure com és la línia de força que passa per un punt en concret, o per a completar el dibuix inicial que es dóna, s’ha d’activar el botó Dibuixar Línia de Força Individual ( ) i clicar a la graella el punt escollit.

15. Si activem el botó de Dibuixar Línia de Força Individual ( ), es dibuixarà al punt de la graella on es faci click la línia de força que passa per aquest punt.

Al fer click en aquest botó, no s’esborraran les línies anteriorment dibuixades a la graella. A la Figura 26, podem observar la Figura 24 completada amb línies de força individuals, clicant en punts de la graella de la regió que havia quedat més buida. Es pot apreciar que el color de les línies és més fort que a les pintades inicialment.

Figura 26. Dibuixar Línia de Força Individual

16. Si activem el botó Dibuixar Línies Equipotencials ( ), veurem que com es representen a la graella una sèrie de línies equipotencials (Figura 27 i Figura 28). Les línies equipotencials amb valor positiu es pintaran de color blau, i les negatives de color vermell. Al fer click en aquest botó, s’esborraran totes les línies anteriorment dibuixades.

Per a representar-les hem de tenir en compte que:

- Recordem que el potencial elèctric sobre en un punt r, creat per una càrrega q1 a l'orígen de coordenades, és el treball W que ha de realitzar una força

elèctrica (llei de Coulomb: rr·

rq·q·kF 2

21= ) per a moure una càrrega unitària

positiva (q2=1 C) des de l’infinit (on el potencial és zero) fins aquest punt r

(1q

WV = ).


31

- Fent el càlcul pertinent d'aquest treball surt l' energia potencial electrostàtica

mútua que és: r

q·q·kU 12= ; i per unitat de càrrega elèctrica q0 = 1 C, surt el

potencial elèctric que és 0q

UV = => rq·kV 1=

Com és obvi, el potencial elèctric és un escalar. - Les línies equipotencials uneixen punts amb el mateix potencial elèctric.

- Si dibuixem línies equipotencials separades per un increment igual de potencial, observarem que quant més a prop de les càrregues, les línies equipotencials estaran més juntes (mirant la fórmula veiem que el potencial és inversament proporcional a la distància de separació a la càrrega).

La representació s’ha resolt dibuixant 20 línies equipotencials entre la càrrega de valor més gran i la de valor més petit. Aquestes 20 línies corresponen a increments constants de potencial. Es podrien haver dibuixat més línies, però amb aquestes ja tenim una idea de com serà la distribució de línies equipotencials. Es pot observar que quan més gran és la càrrega, les línies estan més juntes al apropar-nos a ella (a les figues 27 i 28, fixeu-vos també en el valor de les càrregues representades per apreciar millor això).

Si volguéssim veure com es la línia equipotencial que passa per un punt en concret, s’ha d’activar el botó Dibuixar Línia Equipotencial Individual ( ) i clicar a la graella el punt escollit.

Figura 27. Dibuixar Línies Equipotencials (3 Càrregues)


32

Figura 28. Dibuixar Línies Equipotencials (2 Càrregues)

17. Si activem el botó Dibuixar Línia Equipotencial Individual ( ), tal i com hem dit abans, es representarà la línia equipotencial que passa pel punt de la graella on cliquem amb el ratolí. Si la línia equipotencial té valor positiu es pintarà de color blau, i si és de valor negatiu de color vermell.

Al fer click en aquest botó, no s’esborraran les línies anteriorment dibuixades a la graella. A la Figura 29 podem veure la representació de la Figura 27 completada amb línies equipotencials dibuixades a la zona de la graella que havia. quedat més buida. Es pot apreciar que el color de les línies és més fort que a les pintades inicialment.

Figura 29. Dibuixar Línia Equipotencial Individual


33

18. Si activem el botó Representació 3D ( ), s’obrirà una altra pantalla on hi veurem una representació en perspectiva 3D del potencial elèctric creat per les càrregues de la presentació en curs. La posició dels punts de la graella seran les components X i Y de la perspectiva, i el potencial d’aquests punts en serà la component Z. Serà quelcom semblant a la Figura 30.

Figura 30. Pantalla Perspectiva 3D

Hi trobem els següents elements:

- Sortir. Serveix per tancar la pantalla.

- Reiniciar. Serveix per tornar a mostrar aquesta pantalla inicial en qualsevol moment

- La Gràfica. Situada al centre de la pantalla. Ens mostra la distribució del potencial elèctric a la graella. Veiem de color vermell els punts amb potencial negatiu, i en color blau els de potencial positiu.


34

- Desplaçar Origen. Desplacen la gràfica horitzontalment i verticalment. Per si en algun moment la gràfica surt dels límits de la pantalla, o queda tapada per algun control.

- Modificar Punt de Vista de la Gràfica. Mitjançant els botons de les fletxes, es poden variar l’orientació dels eixos de coordenades i dels angles de posició dels punts, per tal d’obtenir una perspectiva diferent de la gràfica. Actuant sobre aquestes fletxes podrem veure quelcom semblant a la Figura 31.

Figura 31. Perspectiva del Potencial

S’ha limitat el valor màxim del potencial, ja que a mida que ens apropem a les

càrregues, aquest creix fins a l’infinit (rqkV 1·

= ). Observant, també veurem que les

càrregues quan més grans siguin, més “ampla” serà la base, ja que extendran la seva influència més lluny.


35

19. Si activem el botó Comprovació Teorema de Gauss ( ), s’obrirà una altra pantalla on hi podrem comprovar el Teorema de Gauss per a una superfície de 2D. Serà quelcom semblant a la Figura 32.

En el cas típic de camps en distribució 3D podríem dir que el Flux del Camp Elèctric és proporcional al número de línies de força que travessen un element d’àrea perpendicular al camp elèctric. O sigui, si considerem una determinada superfície S perpendicular al camp elèctric E definim el Flux de Camp Elèctric com el producte del mòdul del camp per l’àrea de la superfície perpendicular al camp:

SEE ·=φ

Com que el camp és proporcional al número de línies de força per unitat d’àrea, el flux és proporcional al número de línies de força que travessen la superfície. Si la superfície no fos perpendicular en tots els punts al camp, el flux seria definit pel producte escalar:

αφ ·cos···· SEsdEnSEE ===

On n és un vector unitari perpendicular a la superfície a cada punt, i α l’angle entre E i n .

Si ens interessa conèixer el flux del camp elèctric a través d’una superfície tancada, i només es considera a cada punt de la superfície la component del camp elèctric que li és perpendicular.:

∫ ∫==S SE sdESnE ···φ

D’aquesta manera podem trobar la quantitat de línies de força que surten de la superfície tancada menys la quantitat de línies de força que hi entren. Llavors, recordem que el Teorema de Gauss diu que: el flux de camp elèctric que travessa una superfície tancada és:

∑=

π=φn

1i

qi·k··4

Això és per una superfície en 3D, però com que estem treballant en 2D, el Teorema de Gauss queda així:

∑=

π=φn

1i

qi·k··2

On qi són les càrregues internes a la superfície i k és la constant elèctrica.

A més s'ha de canviar la superfície tancada S per una línia tancada C, i els elements de flux s'han de calcular no amb superfícies sinó amb línies: E·dl enlloc de E·ds

∫=cE ldE·φ

La comprovació del Teorema de Gauss anirà de la següent manera:

- Activarem el botó Marcar Punts ( ), i llavors anirem clicant una sèrie de punts a la graella que conformaran una superfície tancada.

- Un cop marcats els punts que volguem, cliquem el botó Calcular ( )


36

- El programa calcula el flux, generat per les càrregues de la graella, que travessa cada segment que uneix els punts que hem introduït.

- Es calcula el sumatori dels fluxos anteriors, i amb això tindrem el flux entrant/sortint a l’àrea tancada que hem creat amb els punts.

- Es troben les càrregues interiors a l’àrea.

- Es calcula el flux teòric, segons el Teorema de Gauss.

- A més el programa crea entre els punts clicats bastants punts intermedis i repeteix els passos anteriors per atots aquest nous punts, trobant un altre flux calculat.

- Ara podrem comparar, per comprovar si es compleix el Teorema de Gauss:

o El flux entrant/sortint a l’àrea definida, calculat amb els punts clicats.(a)

o El flux entrant/sortint a l’àrea definida, calculat amb els punts clicats completats pels punts generats automàticament pel programa.(b)

o El flux teòric, calculat amb la fórmula del Teorema de Gauss.(c)

- El programa també ens mostra l’error comès al calcular el flux, de les dues maneres exposades, respecte al flux teòric. Aquí podrem observar que la diferència entre (a) i (c) és bastant gran, mentres que entre (b) i (c) és ínfima.

- Si volem podem guardar aquestes dades, es presenten en dues taules (la de Punts Clicats (Figura 33) i la de Punts Calculats Automàticament) (Figura 34)en documents Excel, clicant als botons Guardar Taula i Guardar Taula (Punts Calculats Automàticament) ( )

Alhora de procedir hem de tenir en comptea una sèrie de consideracions:

- Si introduïm els punts en sentit horari o anti-horari, el flux calculat tindrà signe positiu o negatiu, ja que al ser resultat d’un producte escalar, l’ordre en què introduïm els punts compta.

- Quant més punts cliquem, i més a prop estiguin entre ells, més s’assemblarà el valor del flux calculat amb els punts clicats, al valor del flux teòric. Això és degut a què quant més punts formin la superfície i emprem per calcular el flux, més ens acostarem a la realitat, ja que els segments que formen la superfície estan més a prop de ser “diferencials”.


37

Figura 32. Pantalla Comprovació T. Gauss

En aquesta pantalla hi trobem els següents elements:

- La Graella. És la mateixa graella que trobem a la pàgina principal, hi estaran dibuixades les càrregues i lo que hi hagués quan s’ha clicat el botó que ens ha portat a aquesta pantalla.

- Marcar Punts. Serveix per a definir una àrea a la graella. Després d’activar aquest botó, hem d’anar marcant a la graella, fent click amb el ratolí, una sèrie de punts. Aquets punts són els que conformaran l’àrea que utilitzarem per a comprovar el teorema de Gauss. Quan creguem que ja hem introduït prou punts, hem d’activar el botó Calcular.

- Calcular. Serveix per, un cop definida l’àrea, calcular les càrregues que s’hi troben a l’interior i el flux sortint/entrant a la superfície, provocat per aquestes càrregues.

- Etiqueta Sumatori de Flux. Mostra el flux entrant/sortint, a la superfície definida, degut a les càrregues internes. Apareix després d’activar el botó Calcular. Realment aquest valor és el calculat amb tots els punts introduïts automàticament

- Etiqueta Càrregues Interiors. Ens mostra les càrregues que han quedat dins de l’àrea que s’ha definit. Apareixen després d’activar el botó Calcular.


38

- Etiquetes Teorema de Gauss. Ens mostra la suma de càrregues internes a la superfície definida, i quin seria el flux teòric, segons el Teorema de Gauss, generat per aquestes càrregues.

- Sortir. Serveix per tancar la pantalla.

- Taula de Dades (Punts Clicats). La podem veure a la Figura 29. Ens mostra:

o Les coordenades X i Y dels punts amb els que hem definit la superfície.

o Les components X i Y del camp elèctric promig entre un punt i el següent (dels que hem introduït).

o El flux, generat per totes les càrregues de la graella, que travessa el segment definit entre un punt i el següent.

o El sumatori dels fluxos anteriors.

o El flux teòric calculat segons el teorema de Gauss.

o L’error comès al calcular el flux (prenent com a model el flux teòric (segons el teorema de Gauss).

o El sumatori dels fluxos calculats amb els punts creats automàticament.

o El flux teòric calculat segons el teorema de Gauss.

o L’error comès al calcular el flux (prenent com a model el flux teòric (segons el teorema de Gauss).

Les dades d’aquesta taula les podem guardar seleccionant les cel·les, i copiant-les en algun document, o mitjançant el botó Guardar Taula.

Figura 33. Taula de Dades


39

- Guardar Taula. Serveix per exportar la Taula de Dades a un arxiu de format Excel.

Si ens desplacem cap a la dreta de la pantalla, veurem una altra taula (Figura 30):

- Taula de Dades (Punts Calculats Automàticament). Ens mostra lo mateix que la Taula de Dades, però ara entre els punts clicats a la graella, s’han afegit més punts automàticament. Quan més gran és la distància entre els punts clicats, més punts s’han afegit entre un punt i el següent. Això s’ha fet per a què el càlcul del flux surti més exacte, més semblant al teòric.

Aquesta taula també es pot exportar a Excel, amb el botó:

- Guardar Taula (Punts Calculats Automàticament).

Figura 34. Taula de Dades (Punts Calculats Automàticament)

20. Ara ja hem vist tots els botons sobre els que podem actuar al programa. A la pantalla principal podem anar activant uns i altres per a estudiar els resultats. Per exemple, podem activar el botó Dibuixar Línies Equipotencials Inicials i a continuació Dibuixar Línia de Força Individual i Dibuixar Vector d’Intensitat de Camp Elèctric Discret (Figura 35 i Figura 36). En aquestes representacions podem observar com les línies equipotencials sempre que es


40

creuen amb una línia de força, ho fan perpendicularment, que si col·loquem el vector intensitat de camp a sobre d’un punt d’una línia equipotencial, és també ortogonal en aquest punt, que en canvi si el col·loquem a sobre d’una línia de força, és tangent, etc...

Figura 35. Exemple

Figura 36. Exemple

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 3.Memòria de Càlculs

41

3 Memòria de Càlcul

Un cop donada una visió general de quines són les funcionalitats del programa, seguidament es descriuran com s’han fet els càlculs per a obtenir les diferents representacions gràfiques, resultats, etc...

Pels càlculs, tindrem tres variables principals:

NQi. Que serà el número de càrregues introduïdes per a cada presentació (n).

ArrayNQ(). Que serà una matriu unidimensional amb els valors de les càrregues (q1, q2,..., qn).

ArrayPosQ(). Que serà una matriu unidimensional de punts. amb les posicions de les càrregues ((x1, y1), (x2, y2),..., (xn, yn)).

3.1 Dibuixar Vector d’Intensitat de Camp Elèctric La Llei de Coulomb ens diu que la força d’atracció entre dues càrregues (Figura 37)

és la següent:

Figura 37. Llei de Coulomb

1

12

1 rrrr·

rr

2q·1q·kF−

−

−= = ( )13

1

rr·rr

2q·1q·k−

−

On k ≈ 9 x 109 Nm2/C2 és la constant elèctrica, r és la posició de la càrrega q2 i r1 la

de q1

Una sèrie de càrregues, com les que situem a la graella, conformen un Camp Elèctric. La Intensitat de Camp Elèctric (E) en un punt, es defineix com la força exercida per un camp elèctric, sobre la unitat de càrrega positiva q2 situada en aquest punt. Si el camp elèctric estigués format per una càrrega q1, tindríem:

( )131

rr·rr

1q·kE −−

=

Orígen

q1(r1)

q2(r)

r1

r

r- r1


42

Si tinguéssim n càrregues:

( )∑=

−−

=n

ii

i

i rrrr

qkE

13 ·

·

Així, a cada punt de l’espai li associem un vector d’intensitat de camp elèctric, amb el que tenim un camp vectorial.

Per a representar a la graella el camp elèctric degut a les càrregues que hem introduït, ho farem de la següent manera:

- Unirem cada punt de la graella (punts inicials Pi) amb l’extrem del vector d’intensitat de camp elèctric per aquest punt (punt final Pf).Per trobar aquest extrem, només haurem de calcular les components X i Y del vector d’intensitat de camp elèctric (Ex, Ey).

- Representarem els vectors a mòdul constant.

A la Figura 38 podem veure com trobar el vector d’intensitat de camp (e1).

q1 (xq1 , yq1)

Pi (xp, yp)

Pf (xf , yf)

r1

e1

Ex

Ey

α

α

Figura 38. Dibuixar vector d’intensitat de camp elèctric

Per dibuixar el vector e1, només necessitem tenir el punt Pi i el punt Pf. El punt Pi (xp, yp) és conegut (són els diferents punts de la graella), i tal i com veiem a la Figura 6, per trobar Pf només hem de fer:

EyypyfExxpxf

+=+=

Així que tan sols haurem de calcular les components X i Y del vector intensitat de camp pel punt Pi, i fer la suma.

Per aconseguir que els vectors tinguin mòdul constant fem:

.)()()(

··

22 cteNEyExE

EyypyfExxpxf

=+=

+=+=

λλ

λλ

⇒+=⇒ 222 )()( EyExN λλ


43

EN

EyExN

=+

=⇒22

λ

El codi corresponent a aquest càlcul és el següent: While xp < 701 'ample de la graella While yp < 501'alçada de la graella 'assignem tots els punts inicials arrayPi(IndArray) = New Point(xp, yp) 'assignem els punts finals xf = Calcular_Ex(New Point(xp, yp))'calculem Ex per al punt (xp,yp)(cridem la rutina corresponent) yf = Calcular_Ey(New Point(xp, yp))'idem per Ey xft = xp + xf'Aquesta serà la componet X de l’extrem del vector yft = yp + yf'Aquesta serà la component Y Et = (xf ^ 2 + yf ^ 2) ^ 0.5 'módul (el farem servir per dibuixar els vectors amb módul constant) If Et = 0 Then L = N Else L = N / Et 'calculem L per despres convertir els vectors a mòdul constant; L varia de valor, depèn de la trackbar1 xfesc = xp + L * xf 'Component X de l’extrem del vector a mòdul constant yfesc = yp + L * yf 'idem Y arrayPf(IndArray) = New PointF(xft, yft) 'punts finals sense módul constant arrayPfesc(IndArray) = New PointF(xfesc, yfesc) 'punts finals amb módul constant GraficaCampelec.DrawLine(PenCampelecEsc, arrayPi(IndArray), arrayPfesc(IndArray)) 'Unim amb una línea els punts inicials amb els punts finals (a módul constant) yp += D 'fem que la separació entre punts calculats sigui D que depèn de la trackbar2 IndArray += D End While yp = 0 xp += D End While La rutina per calcular la Ex és: Public Function Calcular_Ex(ByVal Punt As PointF) As Double Dim Ex_punt As Double Dim Ex_puntQ As Double Dim ex1 As Integer = 0 For ex1 = 0 To VG.ArrayNQ.Length – 1 'ho calculem per a cada una de les càrregues If (Punt.X = VG.ArrayPosQ(ex1).X And Punt.Y = VG.ArrayPosQ(ex1).Y) Then 'si el punt coincideix amb la càrrega Ex_puntQ = 0 Else 'Si no coincideix 'Ex=k*q1*(x-xq1)/r1^3 +...+ k*qn*(x-xqn)/rn^3 Ex_puntQ = 9 * 10 ^ 9 * (VG.ArrayNQ(ex1) * (Punt.X - VG.ArrayPosQ(ex1).X) / ((Punt.X - VG.ArrayPosQ(ex1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(ex1).Y) ^ 2) ^ 1.5) End If Ex_punt = Ex_punt + Ex_puntQ Next Return Ex_punt


44

End Function Exactament igual es calcula la component Ey.

3.2 Dibuixar Vector d’Intensitat de Camp Elèctric Discret Aquí no dibuixarem els vectors a mòdul constant, però tampoc els representarem

amb la seva magnitud real. Escalem el mòdul dels vectors, de manera que, encara que no siguin el valors reals, sí que es mantindran les relacions de mòduls d’un vectors respecte als altres. Amb la finalitat de que sigui més didàctic, els vectors de mòdul inferior a un cert ordre, s’han dibuixat amb un mòdul determinat per a què es pugui apreciar la direcció i sentit de cada un d’ells. El codi és el següent: PinicDib = New PointF(xi, yi) 'punt des d'on comencem a dibuixar (on cliquem) VG.ArrayNQ.CopyTo(ArrayNQ_esc, 0) ' Copiem l'array de Q al de Q escalades For i = 0 To VG.NQi ArrayNQ_esc(i) = Escalar_Q(ArrayNQ_esc(i)) ' Anem a la rutina d'escalar les Càrregues Next exf = Calcular_ExEsc(PinicDib) 'Anem a larutina de calcular la Ex escalada eyf = Calcular_EyEsc(PinicDib) 'Id. Ey escalada Epi = (exf ^ 2 + eyf ^ 2) ^ 0.5 'mòdul al punt clicat Dim Op As Integer = 10 Dim EpiEscalat As Double EpiEscalat = (exf ^ 2 + eyf ^ 2) ^ 0.5 P = Op / EpiEscalat If EpiEscalat < 20 Then 'si el vector té un módul<20 pixels, dibuixarem un vector de 20, no més petit, per a què es vegi exf = P * exf eyf = P * eyf End If PfinDib = New PointF(PinicDib.X + exf, PinicDib.Y + eyf) ' Creem el GraphicsPath per definir la fletxa del vector Dim E_path As New Drawing2D.GraphicsPath E_path.AddLine(0, 0, 4, -4) E_path.AddLine(0, 0, -4, -4) Dim E_cap As New Drawing2D.CustomLineCap(Nothing, E_path) ' Creem el pen que farà servir aquest inici de linea Dim penE As Pen penE = penVector penE.CustomEndCap = E_cap Dim puntRect As Point Dim rectangle1 As Rectangle Dim sizeRect As Size PicBox0.Refresh() sizeRect = New Size(53, 19) 'dimensions de l’etiqueta rectangle1 = New Rectangle(puntRect, sizeRect) grafVector.FillRectangle(Brushes.Aqua, rectangle1) 'pintem el fons de l’etiqueta grafVector.DrawString(PuntCursor.ToString & Chr(10) & "|E|=" & Eptxt, fontA, Brushes.DarkSlateBlue, puntRect) 'dibuixem l’etiqueta amb les coordenades I el valor del mòdul de E grafVector.DrawLine(penE, PinicDib, PfinDib) 'dibuixem el vector, desde el punt inicial al final, amb la fletxa


45

La rutina per escalar les càrregues és la següent: Public Function Escalar_Q(ByVal Qi As Double) As Double 'Aquí escalem les càrregues deixant les més grans de l'ordre dels microcoulombs Dim Qinic As Double = Qi Dim Qnew As Double Dim maxim = Math.Abs(VG.ArrayNQ(0)) 'trobem el màxim Dim im As Integer = 0 For im = 0 To VG.NQi If Math.Abs(VG.ArrayNQ(im)) > maxim Then maxim = Math.Abs(VG.ArrayNQ(im)) End If Next Qnew = Qi * 10 ^ (-5) / maxim Return Qnew End Function La rutina per calcular la Ex escalada és: Public Function Calcular_ExEsc(ByVal Punt As PointF) As Double Dim Ex_punt As Double Dim Ex_puntQ As Double Dim ex1 As Integer = 0 For ex1 = 0 To ArrayNQ_esc.Length - 1 If (Punt.X = VG.ArrayPosQ(ex1).X And Punt.Y = VG.ArrayPosQ(ex1).Y) Then 'si coincideixen amb les càrregues Ex_puntQ = 0 Else 'Ex=k*q1*(x-xq1)/r1^3 +...+ k*qn*(x-xqn)/rn^3 Ex_puntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(ex1) * (Punt.X - VG.ArrayPosQ(ex1).X) / ((Punt.X - VG.ArrayPosQ(ex1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(ex1).Y) ^ 2) ^ 1.5) End If Ex_punt = Ex_punt + Ex_puntQ Next Return Ex_punt End Function Exactament igual es calcula la component Ey escalada.

3.3 Dibuixar Línia de Força Individual En activar aquest botó, s’ha de dibuixar la línia de força que passa pel punt de la

graella on cliquem amb el ratolí. Per poder dibuixar la línia de força fem lo següent:

- Partim del punt inicial on hem clicat Pi (xi, yi), que òbviament pertany a la línia de força que passa per ell.

- Suposant que ens desplacem sobre la línia de força un increment d’espai molt petit (Dl), arribarem al punt Pf (xi+Dx, yi+Dy) que també pertany a la línia de força.

- Sabent que, com hem dit abans, en un punt la línia de força i el vector d’intensitat de camp són tangents, i que Dl és tant petit com vulguem, observarem la Figura 39.


46

Figura 39. Dibuixar Línies de Força

- De la Figura 39, per triangles semblants, podem treure les següents

conclusions:

22

·

·

EyExEEExlx

EEx

lx

EEyly

EEy

ly

+=

Δ=Δ⇒=ΔΔ

Δ=Δ⇒=ΔΔ

- Amb aquestes fórmules trobem el punt Pf, que pertany a la línea de força.

- Ara Pf passa a ser el punt inicial Pi’

- Igual que abans, trobem un Pf’ que també pertany a la línia de força.

- Repetim aquest procés tant com sigui necessari per trobar tots els punts de la línia de força.

- En el nostre cas, hi ha dues condicions per deixar de buscar punts:

o Que arribem fins a una càrrega.

o Que realitzi a un determinat número de repeticions. Com hem vist abans, totes les línies de força haurien de sortir d’una càrrega positiva i acabar en una càrrega negativa. Però de vegades, per aconseguir dibuixar aquestes línies, ens veuríem obligats a realitzar el procés anterior una quantitat immensa de cops, la qual cosa ralentitzaria molt el programa, o fins i tot desbordaria la capacitat de càlcul de l’ordinador.

- Realment hem de fer aquest procés partint de Pi, amb Dl positius i amb Dl negatius, ja que uns increments seguiran la línia fins una càrrega positiva i els altres fins la càrrega negativa. O potser, sortiran dels límits del dibuix i no les veurem tornar degut a què s’han realitzats les reiteracions de càlcul establertes.

El codi és el següent: Dim array_linF(30000) As PointF 'array punts de la línia de força trobats donant increments positius Dim array_linFatras(30000) As PointF 'id. Per increments negatius


47

Dim indice2 As Integer = 0 Dim indice21 As Integer = 0 Do 'línies de força Ex = Calcular_Ex(PInic) 'cridem la rutina per calcular Ex Ey = Calcular_Ey(PInic) 'id. Ey Dx = calcular_Dx(Ex, Ey) 'cridem la rutina per calcular Dx (component x de l’increment positiu) Dy = calcular_Dy(Ex, Ey) 'id. Dy array_linF(indice2) = PInic indice2 += 1 PInic = New PointF(PInic.X + Dx, PInic.Y + Dy) Dim iter2 As Integer = 0 For iter2 = 0 To VG.ArrayNQ.Length - 1 'una condicio per sortir del bucle es que el punt inicial coincideixi amb una Q If PInic.X = VG.ArrayPosQ(iter2).X And PInic.Y <> VG.ArrayPosQ(iter2).Y Then Exit Do End If Next Loop While indice2 < 30000'nº de vegades que repetim el procediment de trobar un punt de la línia de força amb increment positiu Do 'línies de força part de "darrera" / id. Que abans però per increments negatius Ex = Calcular_Ex(PInic_atras) Ey = Calcular_Ey(PInic_atras) Dx = calcular_Dx(Ex, Ey) Dy = calcular_Dy(Ex, Ey) array_linFatras(indice21) = PInic_atras indice21 += 1 PInic_atras = New PointF(PInic_atras.X - Dx, PInic_atras.Y - Dy) Dim iter2 As Integer = 0 For iter2 = 0 To VG.ArrayNQ.Length - 1 If PInic_atras.X = VG.ArrayPosQ(iter2).X And PInic_atras.Y <> VG.ArrayPosQ(iter2).Y Then Exit Do End If Next Loop While indice21 < 30000'nº de vegades que repetim el procediment de trobar un punt de la línia de força amb increment negatiu Graf.DrawCurve(PenlineasCam, array_linF) 'dibuixem la línia de força trobada amb increments positius Graf.DrawCurve(PenlineasCamAtras, array_linFatras) 'dibuixem la línia de força trobada amb increments negatius

El codi de les rutines pel càlcul dels increments és el següent: Public Function calcular_Dx(ByVal E_x As Double, ByVal E_y As Double) As Single Dim IncX As Single IncX = Increment * E_x / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncX End Function


48

Public Function calcular_Dy(ByVal E_x As Double, ByVal E_y As Double) As Single Dim IncY As Single IncY = Increment * E_y / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncY End Function

3.4 Dibuixar Línies de Força Inicials Es pretén dibuixar una sèrie de línies de força que donin una idea de com és el camp elèctric creat per les càrregues que hem introduït. Per tal d’aconseguir això, s’ha fet:

- Les línies dibuixades surten (o arriben) de les càrregues de signe “predominant”, és a dir, de les positives si el valor de la suma de les càrregues positives és major que el valor de la suma de les càrregues negatives, o a l’inrevés.

- Les línies estan repartides entre les càrregues, proporcionalment al seu valor, per exemple si d’una càrrega de 1C surten dues línies, d’una altra de 2C sortiran 4 línies, ja que, com ja sabem, quant més gran sigui la càrrega, major és la intensitat de camp, i per representar això es dibuixen més línees de força per unitat de superfície.

- Depenent del número de càrregues, es dibuixen més o menys línies de força. Realment hi ha infinites línies de força, però lògicament no es dibuixen totes per claredat.

El codi és el següent: Sub linees_força_inicials() Dim NLF As Integer 'nº de linees a dibuixar, variarà segons el nº de càrregues Dim ArrayNumLin(VG.NQi) As Integer 'array nº linees per càrrega Dim valtotal As Double = 0 Dim xiF As Single = 0 Dim yiF As Single = 0 Dim ximaxF As Single = 0 Dim yimaxF As Single = 0 Dim puntinicialF As PointF Dim tF As Integer = 0 Dim alfa As Double 'angle a cada quant dibuixarem uma línia Dim R As Single = 200 ' distancia desde la càrrega a la que començarem a dibuixar les línias de força '---------------------------------------------------------'mirem quin signe domina Dim ArrayNQPosit(VG.NQi) As Double 'Q’s positives Dim ArrayPosPosit(VG.NQi) As PointF 'Posicions Dim ArrayNQNeg(VG.NQi) As Double 'Q’s negatives Dim ArrayPosNeg(VG.NQi) As PointF 'Posicions Dim ArrayNQDom(VG.NQi) As Double 'Q dominants Dim ArrayPosDom(VG.NQi) As PointF 'Posicions Dim SumTotal As Double = 0 Dim NQdom As Integer = 0 Dim nn As Integer = 0 For nn = 0 To VG.NQi'Passem les Q positives a um array i les neg a um altre If VG.ArrayNQ(nn) > 0 Then ArrayNQPosit(NQdom) = VG.ArrayNQ(nn)


49

ArrayPosPosit(NQdom) = VG.ArrayPosQ(nn) Else ArrayNQNeg(NQdom) = VG.ArrayNQ(nn) ArrayPosNeg(NQdom) = VG.ArrayPosQ(nn) End If NQdom += 1 SumTotal += VG.ArrayNQ(nn) 'Veiem si predominen les posit o les neg Next ReDim Preserve ArrayNQPosit(NQdom - 1) ReDim Preserve ArrayPosPosit(NQdom - 1) ReDim Preserve ArrayNQNeg(NQdom - 1) ReDim Preserve ArrayPosNeg(NQdom - 1) 'Copiem les Q que dominen al array corresponent If SumTotal >= 0 Then ArrayNQPosit.CopyTo(ArrayNQDom, 0) ArrayPosPosit.CopyTo(ArrayPosDom, 0) Else ArrayNQNeg.CopyTo(ArrayNQDom, 0) ArrayPosNeg.CopyTo(ArrayPosDom, 0) End If ReDim Preserve ArrayNQDom(NQdom - 1) ReDim Preserve ArrayPosDom(NQdom - 1) '--------------------------------------------------------- ‘Calculem el valor total de les Q dominants, per repartir les línies Dim sF As Integer = 0 Dim rF As Integer = 0 For rF = 0 To ArrayNQDom.Length - 1 valtotal += Math.Abs(ArrayNQDom(rF)) Next Select Case NQdom - 1 'seleccionem quantes línees es dibuixaran inicialment, depenent del numero de Q Case 1 To 3 NLF = 12 Case 4 To 7 NLF = 18 Case 8 To 10 NLF = 20 End Select For sF = 0 To ArrayNQDom.Length - 1 'per saber el nº de línies a dibuixar desde cada Q del signe dominant ArrayNumLin(sF) = Math.Ceiling((NLF) * Math.Abs(ArrayNQDom(sF) / valtotal)) Next If VG.NQi = 0 Then 'Quan només hi ha una Q Dim n1 As Integer For n1 = 1 To 8 xiF = VG.ArrayPosQ(VG.NQi).X + 100 * Math.Cos(0.78 * n1) yiF = VG.ArrayPosQ(VG.NQi).Y + 100 * Math.Sin(0.78 * n1) puntinicialF = New PointF(xiF, yiF) Call dibujar_lineasF(puntinicialF, puntinicialF) Next Exit Sub End If Dim u As Integer = 0 For tF = 0 To NQdom - 1


50

alfa = 2 * Math.PI / ArrayNumLin(tF) 'dividim els 360 graus en el nº de línees corresponents For u = 1 To ArrayNumLin(tF) xiF = ArrayPosDom(tF).X + R * Math.Cos(u * alfa) yiF = ArrayPosDom(tF).Y + R * Math.Sin(u * alfa) puntinicialF = New PointF(xiF, yiF) 'Enviarem a la rutina de dibuixar les línies de força individuals, tants punts inicials per càrrega, com línies li hagin correspós, situats i repartits al llarg dels 360º d’una circunferència imaginària de radi R (abans li hem donat valor 50) i de centre la posició de la càrrega Call dibujar_lineasF(puntinicialF, puntinicialF) 'Cridem la rutina de dibuixar les línies individuals. Next Next End Sub

3.5 Dibuixar Línia Equipotencial Individual

Les línies equipotencials uneixen punts amb el mateix potencial elèctric.

En activar aquest botó, s’ha de dibuixar la línia equipotencial que passa pel punt de la graella on cliquem amb el ratolí. Per poder representar les línies equipotencials, seguirem el mateix procés que per les línees de força.

- Partim del punt inicial on hem clicat Pi (xi, yi), que òbviament pertany a la línia equipotencial que passa per ell.

- Suposant que ens desplacem sobre la línia equipotencial un increment d’espai molt petit (Dl), arribarem al punt Pf (xi+Dx, yi+Dy) que també pertany a la línia equipotencial.

- Trobem el punt Pf. Ara Pf passa a ser el punt inicial, i de la mateixa manera que abans, trobem un nou Pf’ que també pertany a la línia equipotencial. Repetint aquest procés, trobarem tots els punts de la línia equipotencial.

La diferència està en el càlcul de Pf. Hem de saber que a cada punt de l’espai, les línies equipotencials són tangents als vectors d’intensitat de camp elèctric i per tant també a les línees de força.

A les línies de força teníem:

EEyly

EExlx ·;· Δ=ΔΔ=Δ

Del punt inicial al següent de la línia de força teníem un Dl (Dx, Dy), si la pendent d’aquesta recta és m, llavors teníem Dl (Dx, mDx)

A la línia equipotencial tenim Dl’ (Dx’, Dy’)

Com que en aquest punt les dues línies són perpendiculars, el producte escalar dels dos vectors ha de ser zero, així que tenim:

'·1'

0'·'0'··'·0''

)(

xm

y

ymxyxmxxyx

xmx

Δ−=Δ⇒

⇒=Δ+Δ⇒=ΔΔ+ΔΔ⇒=⎟⎟⎠

⎞⎜⎜⎝

⎛ΔΔ

ΔΔ


51

Ara la pendent és -1/m. Per tant: Dl’ (Dx’, -1/m·Dx’)

Observarem la Figura 40:

Figura 40. Dibuixar Línies Equipotencials

De la Figura 40, per triangles semblants, podem treure les següents conclusions:

22

'·'''

'·'''

EyExEEEylx

EEy

lx

EExly

EEx

ly

+=

Δ−=Δ⇒=ΔΔ

−

Δ=Δ⇒=ΔΔ

- Amb aquestes fórmules trobem el punt Pf, que pertany a la línea equipotencial.

- Ara Pf passa a ser el punt inicial Pi’

- Igual que abans, trobem un Pf’ que també pertany a la línia equipotencial.

- Repetim aquest procés tant com sigui necessari per trobar tots els punts de la línia equipotencial.

- En el nostre cas, hi ha dues condicions per deixar de buscar punts:

o Que coincideixi el punt inicial de la següent iteració, amb el punt original on hem començat a dibuixar al línia. Com que això és molt difícil que succeeixi degut a què és un mètode aproximatiu, als errors en els càlculs de la màquina, etc..Pararà quan la distància que separa aquest dos punts sigui menor a un número establert.

o Que realitzi a un determinat número de repeticions. Les línies equipotencials són tancades. Però de vegades, per aconseguir dibuixar aquestes línies, ens veuríem obligats a realitzar el procés anterior una quantitat immensa de cops, la qual cosa ralentitzaria molt el programa, o fins i tot desbordaria la capacitat de càlcul de l’ordinador.


52

El codi és el següent: Public Sub dib_linEquipot(ByVal PuntInicial As PointF) ' passem la variable del punt on hem clicat ' dibuixem la línia equipotencial Dim indice3 As Integer 'comptador pel nº d'iteracions que farem Dim array_equip(200000) As PointF 'array de punts de la línia equipotencial Dim xi As Single = PuntInicial.X 'Punt original de la graella on cliquem Dim yi As Single = PuntInicial.Y Dim GrafEquip As Graphics = Me.PicBox0.CreateGraphics() 'Crrem la tela on dibuixarem Dim PenlineasEquip As New Pen(Color.Transparent, 1) 'creem el pincell amb el que pintarem If Calcular_Pot(PuntInicial) > 0 Then 'calculem el potencial al punt, i mirem és positiu If bool_linEquip_Inic = True Then 'si són les línees inicials, les pintarem més tènues PenlineasEquip.Color = Color.FromArgb(100, Color.Blue) Else PenlineasEquip.Color = Color.Blue End If Else 'si el potencial és negatiu If bool_linEquip_Inic = True Then 'si són les línees inicials, les pintarem més tènues PenlineasEquip.Color = Color.FromArgb(100, Color.Red) Else PenlineasEquip.Color = Color.Red End If End If Do 'Comencem les iteracions ExEquip = Calcular_Ex(PuntInicial) EyEquip = Calcular_Ey(PuntInicial) DxEquip = calcular_DxEquip(ExEquip, EyEquip) 'calculem `l'increment DyEquip = calcular_DyEquip(ExEquip, EyEquip) array_equip(indice3) = PuntInicial 'afegim el punt a l'array de punts de la línia equip indice3 += 1 'ara el punt final passa a ser el punt inicial PuntInicial = New PointF(PuntInicial.X + DxEquip, PuntInicial.Y + DyEquip) 'el següent condicional és el de parar quan es "tanca" la línia If (indice3 > 1000 And ((PuntInicial.X - xi) ^ 2 + (PuntInicial.Y - yi) ^ 2) ^ 0.5 < 10) Then GrafEquip.DrawLine(PenlineasEquip, New PointF(PuntInicial.X + DxEquip, PuntInicial.Y + DyEquip), New PointF(xi, yi)) Exit Do End If Loop While indice3 < (200000) 'Nº d'iteracions a realitzar ReDim Preserve array_equip(indice3 - 1) 'Dibuixem la línia GrafEquip.DrawLines(PenlineasEquip, array_equip) ' Netegem PenlineasEquip.Dispose()

End Sub


53

El codi de la rutina pel càlcul del potencial ja l’hem vist en apartats anteriors.

El codi de les rutines pel càlcul dels increments és el següent: Public Function calcular_DxEquip(ByVal E_x As Double, ByVal E_y As Double) As Single Dim IncX As Single IncX = -1 * Increment * E_y / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncX End Function Public Function calcular_DyEquip(ByVal E_x As Double, ByVal E_y As Double) As Single Dim IncY As Single IncY = Increment * E_x / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncY End Function

3.6 Dibuixar Línies Equipotencial Inicials Al activar aquest botó, el que es pretén és dibuixar una sèrie de línies equipotencials que donin una idea de com és la distribució del potencial elèctric a la graella.

Per aconseguir-ho es dibuixen 20 línies equipotencials entre la càrrega de valor més gran i la de valor més petit. Aquestes 20 línies corresponen a increments constants de potencial. El càlcul per dibuixar-les és:

- Calculem els 20 potencials que volem dibuixar (v1, v2,..., v20)

- Dividim el segment que uneix la càrrega màxima i la mínima en 200 parts (Figura 41).

Figura 41. Dividir el segment en 200 parts iguals.

- Calculem el potencial per cada un dels 199 punts intermedis.

- Busquem on coincideixen els potencials dels 199 punts amb v1,...,v20

o Partint del màxim.

o Comparem v1 amb el potencial de p1.

o Si v1 és més gran, dibuixarem la primera línea al punt mig entre p1 i la càrrega màxima.

o Si és més petit, comparem v1 amb el potencial de p2.

o si v1 és més gran, dibuixarem la línia al punt mig de p1 i p2,etc...

o Fem lo mateix amb cada un del 20 potencials que volem dibuixar.


54

Està clar que quant més punts busquem entre la càrrega màxima i la mínima, més exacte serà el punt que trobem amb el que realment té el potencial que volem dibuixar.

- Un cop tenim els 20 punts, els passem a la rutina de Dibuixar Línia Equipotencial Individual.

El codi és aquest: Sub linees_equip_inicials() Dim xi As Single = 0 Dim yi As Single = 0 Dim puntinicial As PointF 'punt on comencem a dibuixar la lín equipot Dim indexmax As Integer = 0 Dim indexmin As Integer = 0 Dim minim As Double = VG.ArrayNQ(0) 'Trobem la Q mínima Dim imi As Integer = 0 For imi = 0 To VG.NQi If VG.ArrayNQ(imi) < minim Then minim = VG.ArrayNQ(imi) indexmin = imi End If Next Dim maxim As Double = VG.ArrayNQ(0) 'Trobem la Q máxima Dim ima As Integer = 0 For ima = 0 To VG.NQi If VG.ArrayNQ(ima) > maxim Then maxim = VG.ArrayNQ(ima) indexmax = ima End If Next 'mirem cap a on s'han de fer els increments de distància per unir les dues càrregues (max i min) Dim Pcalcmax As PointF Dim pcalcmin As PointF If VG.ArrayPosQ(indexmin).X > VG.ArrayPosQ(indexmax).X Then Pcalcmax.X = VG.ArrayPosQ(indexmax).X + 10 'comencem a dibuixar a partir d'una distància de 10 de la Q pcalcmin.X = VG.ArrayPosQ(indexmin).X - 10 Else Pcalcmax.X = VG.ArrayPosQ(indexmax).X - 10 'Al calcul li he dit que el V a les carregues és 0 pcalcmin.X = VG.ArrayPosQ(indexmin).X + 10 End If If VG.ArrayPosQ(indexmin).Y > VG.ArrayPosQ(indexmax).Y Then Pcalcmax.Y = VG.ArrayPosQ(indexmax).Y + 10 pcalcmin.Y = VG.ArrayPosQ(indexmin).Y - 10 Else Pcalcmax.Y = VG.ArrayPosQ(indexmax).Y - 10 pcalcmin.Y = VG.ArrayPosQ(indexmin).Y + 10 End If Dim max As Double = Calcular_Pot(Pcalcmax) 'Calculem V per la Qmax Dim min As Double = Calcular_Pot(pcalcmin) ' id. Qmin Dim incV As Double = 0


55

If Math.Sign(max) <> Math.Sign(min) Then ' Si la Qmax i la Qmin són de signe diferent 'Trobem la diferència de V, i l'increment de V si volem dibuixar 20 línies incV = (max - min) / 20 Dim arrayVdibE(20) As Double 'array dels diferents V que representarem Dim arrayPosVdibE(20) As PointF 'array dels punts de la recta que uneix les dues Q 'amb aquests valors de V arrayVdibE(0) = max arrayPosVdibE(0) = VG.ArrayPosQ(indexmax) Dim ii As Integer = 0 For ii = 1 To 20 'Creem l'array pels diferents V de cada línia que volem dibuixar arrayVdibE(ii) = arrayVdibE(ii - 1) - incV Next '----------Fins aquí tenim l'array dels potencials de les línies que volem dibuixar Dim Pn As PointF Dim pnX As Single = 0 Dim pnY As Single = 0 Dim incX As Single = 0 Dim incY As Single = 0 Dim jj As Integer = 0 incX = (VG.ArrayPosQ(indexmin).X - VG.ArrayPosQ(indexmax).X) / 200 'trobem l'increment de X per si volem dividir el segment en 200 parts incY = (VG.ArrayPosQ(indexmin).Y - VG.ArrayPosQ(indexmax).Y) / 200 'id (Y) pnX = Pcalcmax.X pnY = Pcalcmax.Y Dim arrayVdif(200) As Double 'array del valor de V a cada punt de la divisió del segment en 200 parts Dim arrayPdif(200) As PointF ' array del punts arrayPdif(0) = New PointF(pnX, pnY) arrayVdif(0) = (Calcular_Pot(arrayPdif(0))) Dim zz As Integer For zz = 1 To 200 'creem l'array de dels 100 punts, i l'array del V d'aquests 200 punts pnX += incX pnY += incY Pn = New PointF(pnX, pnY) arrayPdif(zz) = Pn 'array dels punts que hi ha entre min i max (en aquest cas 200) arrayVdif(zz) = (Calcular_Pot(Pn)) 'array del V dels punts anterios Next '-------Fins aquí trobem els punts intermedis i els valors de V d'aquests punts 'ara hem de veure a on coincideixen els V (20) que hem de dibuixar amb els V (200) dels punts de l'array Dim nn As Integer = 0 Dim xx As Integer = 0 Dim dif As Double = 0 For nn = 1 To 20 If arrayVdibE(nn) > 0 Then For xx = 1 To 200


56

If arrayVdibE(nn) = arrayVdif(xx) Then Call dib_linEquipot(arrayPdif(xx)) Exit For Else If arrayVdibE(nn) > arrayVdif(xx) Then Dim point As PointF = New PointF(arrayPdif(xx).X - incX / 2, arrayPdif(xx).Y - incY / 2) Call dib_linEquipot(point) Exit For Else Continue For End If End If Next Else For xx = 1 To 200 If arrayVdibE(nn) = arrayVdif(xx) Then Call dib_linEquipot(arrayPdif(xx)) Exit For Else If arrayVdibE(nn) < arrayVdif(xx) Then Continue For Else Dim point As PointF = New PointF(arrayPdif(xx).X - incX / 2, arrayPdif(xx).Y - incY / 2) Call dib_linEquipot(point) Exit For End If End If Next End If Next Else 'si les Q max i min són del mateix signe (o si només hi hagués una Q) If max > 0 Then Dim n1 As Integer For n1 = 0 To 20 xi = VG.ArrayPosQ(indexmax).X + 10 + Math.Exp(n1 / 4) yi = VG.ArrayPosQ(indexmax).Y + 10 + Math.Exp(n1 / 4) puntinicial = New PointF(xi, yi) Call dib_linEquipot(puntinicial) Next Else Dim n1 As Integer For n1 = 0 To 20 xi = VG.ArrayPosQ(indexmin).X + 10 + Math.Exp(n1 / 4) yi = VG.ArrayPosQ(indexmin).Y + 10 + Math.Exp(n1 / 4) puntinicial = New PointF(xi, yi) Call dib_linEquipot(puntinicial) Next End If End If

End Sub

Els codis de les rutines pel càlcul del potencial i pel dibuix de la línea equipotencial, ja els hem vist en apartats anteriors.


57

3.7 Representació 3D Aquí volem fer una perspectiva en 3D del potencial elèctric creat per les càrregues de

la graella. Per a això, suposarem inicialment les coordenades dels punts de la següent manera:

- Component X: Serà la X de la graella.

- Component Y: Serà la Y de la graella.

- Component Z: Serà el valor del potencial en el punt (x,y) de la graella.

Això genera d'entrada un diagrama tridimensional del potencial. Però el dibuix a la pantalla ha de ser en 2D i per això necessitem fixar un eix unitari n que anomenem punt de vista i que representa que és la direcció des de la qual ens mirem el diagrama per tal de plasmar-lo en el dibuix en perspectiva.

Per aconseguir-ho, transformarem el sistema de coordenades tridimensionals ortogonals i els seus vector unitaris i, j i k on el punt P és descrit per les 3 coordenades x , y i z :

P= x·i +y·j + z·k

Essent i , j , k els vectors unitaris (mòdul 1) a llarg dels eixos x, y i z respectivament (Figura 42).

y

z

x

r

θ

ϕ

n

ji

k θ

ϕ

Figura 42. Sistema de Coordenades Tridimensionals Ortogonals comparat amb sistema de

coordenades (esfèriques) definides pel vector punt de vista n.

Considerem fixat un eix n unitari en aquest diagrama 3D que marca una direcció a l'espai. Aquest eix unitari l'expressarem per mitjà de les dues coordenades angulars θ i ϕ; on θ és l'angle polar que n forma amb l'eix z i ϕ és l'angle atzimutal que la projecció de n sobre el pla de base (x-y) forma amb l'eix x. El mateix eix n defineix una coordenada r (no angular) que va en la mateixa direcció que ell.


58

Aquestes 3 noves coordenades θ, ϕ i r, (també anomenades coordenades esfèriques definides per la direcció n) defineixen sengles vectors unitaris, que són r, θ i ϕ i que també formen un sistema ortogonal (perpendiculars entre sí) igual com ho feien i , j i k

Si es vol transformar el punt P de les coordenades definides per i , j i k a les noves coordenades esfèriques definides per n (r, θ i ϕ) , d'alguna manera això és equivalent a aplicar una típic canvi de base o transformació de coordenades. Com que es passa d'un sistema ortogonal a un altre que també ho és la transformació de coordenades s'anomena rotació, les rotacions formen una classe de transformacions de coordenades que estan molt ben catalogades i són relativament senzilles.

Les lleis bàsiques de qualsevol transformació de coordenades parteixen de les equacions lineals que dónen les noves bases en funció de les antigues. En el nostre cas i fixant-nos només amb relacions geomètriques de la Figura 42 resulta:

r = sin θ · cos ϕ · i + sin θ · sin ϕ · j + sin θ ·k

θ = cos θ · cos ϕ · i + cos θ · sin ϕ · j - sin θ ·k

ϕ = -sin ϕ · i + cos ϕ · j

Que és una típica relació matricial.

El punt P=x·i +y·j + z·k es transforma a les noves bases per mitjà de projeccions amb els vectors unitaris r, θ i ϕ

Pr=(P·r) r

Pθ = (P·θ) θ

Pϕ = (P·ϕ) ϕ on el producte · és el producte escalar.

Per tant,

Pr = (P·r) = x·sin θ·cos ϕ + y·sin θ·sin ϕ + z·cos θ

P= (P·θ) = x·cos θ·cos ϕ + y·cos θ·sin ϕ - z·sin θ

Pϕ = (P·ϕ) = - x·sin ϕ + y·cos ϕ

La projecció en 2D d'un diagrama en 3D usant una perspectiva la basarem en aquestes transformacions.

En efecte, la perspectiva en 2D la defineix la direcció n , que és la direcció normal al pla del dibuix en 2D, és a dir aquella que segueix tots els punts que quedarien confosos en un únic punt al dibuixar-los, ja que estan alineats en la mateixa direcció en la que ens mirem el dibuix. Per tant a aquesta direcció n li direm visual.

La component d'un punt en la mateixa direció que la visual n, és a dir Pr, no queda representada en el dibuix.


59

Les úniques que queden representades són les altres dues Pθ i Pϕ que són perpendiculars a la visual.

Generalment es fa de manera que l'eix z quedi dibuixat en la mateixa direcció que l'eix vertical del dibuix, per tant hem de canviar de signe la component Pθ .

Per tant, finalment les coordenades x' i y' sobre el pla del dibuix en en 2D quedaran així:

- Pθ = - x·cos θ·cos ϕ - y·cos θ·sin ϕ + z·sin θ ≡ y'

Pϕ = - x·sin ϕ + y·cos ϕ ≡ x'

i la tercera coordenada anomenada n' en la direcció de la visual

Pr= x·sin θ·cos ϕ + y·sin θ·sin ϕ + z·cos θ ≡ n'

Queda exclosa del dibuix ja que en variar-la no es mou el punt del dibuix, però que de totes maneres ens indica de forma oculta quina és la "profunditat" del punt.

Si es volgués es podria complementar aquesta perspectiva aconseguida passant a un

sistema de coordenades esfèriques, amb unes variacions sobre els eixos de coordenades. Aquestes variacions seran:

- Girar el pla XZ un angle a sobre l’eix Y que queda fix (Figura 43).

- Girant el pla YZ un angle β sobre l’eix X que queda fix (Figura 44).

Figura 43. Rotar sobre l’eix Y


60

Figura 44. Rotar sobre l’eix X

Observant les dues figures anteriors, per geometria, arriben a la conclusió que les coordenades x' i y' sobre el pla del dibuix en 2D combinant totes dues variacions, seran:

x’ = x·(1 + cosβ) – y·sina + z·sinβ

y’ = x·sinβ + y·(1+cosa) + z· sina

Si volem combinar la primera transformació i la segona, no tenim més que substituir la x i la y per la x’’ i la y’’ trobades.

Per tal de que la gràfica es pugui representar dins dels límits de la pantalla, s’han escalat tant la graella com les càrregues (sempre mantenint la proporció de valor d’unes amb les altres).

El codi és el següent: Public Sub Punts() Me.Refresh() 'Aquí calculem els punts que hem d'unir per dibuixar la gràfica Dim ii As Integer Dim jj As Integer For ii = 0 To 70 For jj = 0 To 50 'variació coord esferiques xf = PGrill(ii, jj).X * Math.Cos(angTheta) * Math.Cos(angPhi) + PGrill(ii, jj).Y * Math.Cos(angTheta) * Math.Sin(angPhi) yf = -PGrill(ii, jj).X * Math.Sin(angPhi) + PGrill(ii, jj).Y * Math.Cos(angPhi) - VPGrill(ii, jj) * Math.Sin(angTheta) 'rotació sobre Y i rotació sobre X PGrillF(ii, jj).X = xO + (xf * (1 + Math.Cos(angY)) - yf * Math.Sin(angX) + VPGrill(ii, jj) * Math.Sin(angY)) / 2


61

PGrillF(ii, jj).Y = yO + (yf * (1 + Math.Cos(angX)) + xf * Math.Sin(angY) + VPGrill(ii, jj) * Math.Sin(angX)) / 2 'xo i yo és el punt de la pantalla on comencem a dibuixar la gràfica 'dividim per 2 perque la graella l'hem fet la meitat de gran Next Next Call dibuixar()'cridem la rutina de dibuixar els punts End Sub El codi de la rutina d’escalar les càrregues és aquest: Public Function Escalar_Q(ByVal Qi As Double) As Double 'Aquí escalem les càrregues. Les deixem de l'ordre dels microcoulombs per a què la rpepresntació surti ``bé`` Dim Qinic As Double = Qi Dim Qnew As Double Dim maxim = Math.Abs(Form1.VG.ArrayNQ(0)) 'Trobem la més gran. Comencem supossant que és la primera. Dim im As Integer = 0 For im = 0 To Form1.VG.NQi If Math.Abs(Form1.VG.ArrayNQ(im)) > maxim Then maxim = Math.Abs(Form1.VG.ArrayNQ(im)) End If Next Qnew = Qi * 10 ^ (-6) / maxim Return Qnew End Function El codi de la rutina de calcular el potencial és aquest: Public Function Calcular_Potencial(ByVal Punt As PointF) As Double Dim Vpunt As Double Dim VpuntQ As Double Dim v1 As Integer = 0 For v1 = 0 To ArrayNQ_esc.Length - 1 Dim dist As Double = ((ArrayPosQ_esc(v1).X - Punt.X) ^ 2 + (ArrayPosQ_esc(v1).Y - Punt.Y) ^ 2) ^ 0.5 If dist < 5 Then ' Quan els punts estiguin a aquesta distància, com a màxim dibuixarà una z de 500, si dibuixèssim la realitat, es dispararia el valor VpuntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(v1) / dist) Vpunt = Vpunt + VpuntQ If Math.Abs(Vpunt) > 500 Then If Vpunt > 0 Then Vpunt = 500 Else Vpunt = -500 End If End If Else VpuntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(v1) / dist) Vpunt = Vpunt + VpuntQ End If Next FormatNumber(Vpunt, 4) ' deixem el potencial amb 4 decimals Return Vpunt End Function


62

3.8 Comprovació Teorema de Gauss Aquí es tracta de comprovar el Teorema de Gauss, que com hem vist a l’apartat 2.6.5

en 3D diu que:

∑=

=n

iqik

1···4 πφ

On el flux Φ s'ha calculat en una suferfície tancada que envolta part de les càrregues de la distribució, qi són les càrregues internes a la superfície i com sempre k és la constant elèctrica.

En haver de fer-ho en 2D, resulta que el flux s'ha de calcular al llarg d'una línia

tancada, de manera que els elements de flux a través d'un petit tram de línia es calculen fent el producte escalar entre els camp i l'element de línia representat per un vector perpendicular al tram, anàlogament a com el vector perpendicular representava a l'element de superfície.

A causa d'aquesta variació important en el càlcul del flux, el teorema de Gauss no es

compliria. Per a que es compleixi hem de fer dues variacions: 1. El camp elèctric s'ha de calcular de manera "falsa" tot dividint per la

distància en un grau menys (serà proporcional a l'invers de la distància i no a l'invers del quadrat de la distància com el camp veritable en 3D), en definitiva la cosa queda així:

Un càlcul diferent del camp elèctric implica un valor diferent en el flux que ara anomenarem Φ'

2. Per altra banda el teorema de Gauss s'ha de reformular multiplicant per 2π

enlloc dels 4π del teorema en 3D:

∑=

=n

iqik

1···2' πφ

Això és el que fa el programa, i per tant la comprovació del Teorema de Gauss anirà de la següent manera:

- Clicarem una sèrie de punts a la graella que conformaran una superfície tancada (Figura 45).

( )∑=

−−

=n

1ii2

i

i rr·rr

q·kE


63

Figura 45. Introduir Punts

- Es calcula el flux, generat per les càrregues de la graella, que travessa cada segment que uneix els punts que hem introduït (Figura 46).

Figura 46. Calcular Flux Segments

On:

21ppL és el vector que uneix un punt clicat i el següent.

21ppE és el vector intensitat de camp promig entre els dos punts.

2;

221

2121

21pp

pppp

pp

EyEyEy

ExExEx

+=

+=

12211221 ; yyLyxxLx pppp −=−=

Així que el flux que travessa aquest segment és:

2121 pppp EL ×=φ => 21212121 ·· pppppppp ExLyEyLx −=φ

Que equival al producte escalar entre el camp E i un vector perpendicular al tram de linia L, amb mòdul igual al tram.

- Es calcula el sumatori dels fluxos anteriors, i amb això tindrem el flux entrant/sortint a l’àrea tancada que hem creat amb els punts.

- Es troben les càrregues interiors a l’àrea.

- Es calcula el flux teòric, segons el Teorema de Gauss.


64

- Comparem el flux calculat i el flux teòric per veure si coincideixen i es compleix el Teorema de Gauss.

Per a obtenir uns resultats més exactes, a més de fer aquests càlculs pels punts clicats, els farem per una sèrie de punts generats automàticament. Aquests punts seran més o menys nombrosos, depenent de la distància que separi els dos punts clicats entre els que els hi afegim.

Per trobar les càrregues interiors a l’àrea determinada, s’ha utilitzat un algorisme denominat “Radial”.

El procediment consisteix en recórrer ordenadament tots els costats del polígon, calculant l’angle (més curt) format pels seus extrems i les rectes que els uneixen al punt que volem determinar si està o no dins del polígon (en el nostre cas, la posició de la càrrega. Figura 47). El signe de l’angle serà positiu, si el sentit de creixement de l’angle és antihorari, i negatiu en cas contrari (o a l’inrevés).

Figura 47. Algorisme Radial

- Sumem els angles: atot = a1-a2-a3-a4-a5+a6+a7

- Només es poden obtenir 2 valors, 2π o zero. Si el valor de atot és 2π o múltiple, el punt està dins del polígon. Si el valor és zero, el punt està fora.

Pensant en una possible imprecisió per la falta d’ exactitud en el càlcul dels angles, pensarem que si atot és menor que π, el considerarem zero, i si és major que π, el considerarem 2π.

Per trobar el valor dels angles, numèricament, farem servir el producte escalar:

yqyprxqxpr

yqyprxqxpr

y

x

y

x

122122

111111

−=−=

−=−=

; yyxx rrrrrr

rrrr

2·12·121

1·cos2·121

+=×

=× α => )

2·12·12·1

cos(1rr

rrrrar yyxx +

=α


65

Per saber si aquest angle és positiu o negatiu, numèricament, utilitzarem el mòdul del producte vectorial:

xyyx rrrrrr 2·12·121 −=∧

Per conveni, acceptem que mòdul positiu implica angle positiu, i el mòdul negatiu angle negatiu.

El codi per trobar les càrregues internes és el següent:

Dim indexsQ(Form1.VG.NQi) As Integer 'guardarem els índexs de les Q internes per a poder posar-los a les etiquetes 'Trobarem quines són les càrregues que es troben a l'interior de l'àrea 'Ho farem pel métode "radial"----------------------------- Dim Vectors(ArrayPunts.Length - 1) As PointF Dim angles(ArrayPunts.Length - 1) As Double Dim k As Integer = 0 Dim angle As Double Dim signe As Integer Dim angleTot As Double Dim m As Integer Dim s As Integer Dim i As Integer For m = 0 To Form1.VG.NQi For s = 0 To ArrayPunts.Length - 1 'vectors que uneixen cada càrrega amb els punts clicats Vectors(s).X = ArrayPunts(s).X - Form1.VG.ArrayPosQ(m).X Vectors(s).Y = ArrayPunts(s).Y - Form1.VG.ArrayPosQ(m).Y Next For i = 0 To ArrayPunts.Length - 1 If i < ArrayPunts.Length - 1 Then 'càlcul de l'angle de cada vector amb el següent angle = Calcul_Angle_Vectors(Vectors(i), Vectors(i + 1)) signe = Calcul_signe_angle(Vectors(i), Vectors(i + 1)) Else angle = Calcul_Angle_Vectors(Vectors(i), Vectors(0)) signe = Calcul_signe_angle(Vectors(i), Vectors(0)) End If angles(i) = signe * angle angleTot = angleTot + angles(i) Next If Math.PI < Math.Abs(angleTot) Then 'si és més gran de 180º està dins de l'àrea, i si és menor, fora Qinteriors(k) = Form1.VG.ArrayNQ(m) indexsQ(k) = m k = k + 1 End If angleTot = 0 'inicialitzem l'angle Next


66

El codi de les rutines per trobar els angles i els seus signes és el següent:

'Per tobar l'angle entre dos vectors, farem servir el producte escalar entre ells Public Shared Function Calcul_Angle_Vectors(ByVal v1 As PointF, ByVal v2 As PointF) As Double Dim angle As Double angle = Math.Acos((v1.X * v2.X + v1.Y * v2.Y) / ((v1.X ^ 2 + v1.Y ^ 2) ^ 0.5 * (v2.X ^ 2 + v2.Y ^ 2) ^ 0.5)) Return angle End Function 'per saber si l'angle entre aquests vestors és positiu o negatiu, utilitzarem el producte vectorial entre ells Public Shared Function Calcul_signe_angle(ByVal v1 As PointF, ByVal v2 As PointF) As Integer Dim signe As Integer ' si el módul del prod vect és positiu => angle positiu If ((v1.X * v2.Y) - (v1.Y * v2.X)) > 0 Then signe = 1 Else signe = -1 End If Return signe End Function

El codi per trobar calcular el flux total, tant amb els punts clicats com amb els punts generats automàticament, és el següent:

'---------Ara calcularem Ex, Ey i Flux correponents només als punts clicats--- Dim ArrayExInic(comptadorP - 1) Dim ArrayEyInic(comptadorP - 1) Dim d As Integer = 0 For d = 0 To comptadorP - 1 ArrayExInic(d) = Calcular_Ex(ArrayPunts(d)) ArrayEyInic(d) = Calcular_Ey(ArrayPunts(d)) Next Dim dlxInic(comptadorP - 1) As Double 'array de components x del vector que uneix un punt amb el següent Dim dlyInic(comptadorP - 1) As Double 'id. y Dim E_xInic(comptadorP - 1) As Double 'array de components x del vector camp "promig" entre un punt i el següent Dim E_yInic(comptadorP - 1) As Double 'id. y ReDim Preserve arrayfluxInic(comptadorP - 1) Dim f As Integer For f = 0 To comptadorP - 1 'calculem el flux que travessa cada segment de l'àrea dels punts clicats If f = comptadorP - 1 Then dlxInic(f) = ArrayPunts(0).X - ArrayPunts(f).X dlyInic(f) = ArrayPunts(0).Y - ArrayPunts(f).Y E_xInic(f) = (ArrayExInic(f) + ArrayExInic(0)) / 2 E_yInic(f) = (ArrayEyInic(f) + ArrayEyInic(0)) / 2 arrayfluxInic(f) = dlxInic(f) * E_yInic(f) - dlyInic(f) * E_xInic(f) Else


67

dlxInic(f) = ArrayPunts(f + 1).X - ArrayPunts(f).X 'components del vector que uneix un punt amb el següent dlyInic(f) = ArrayPunts(f + 1).Y - ArrayPunts(f).Y E_xInic(f) = (ArrayExInic(f + 1) + ArrayExInic(f)) / 2 'component x del vector camp "promig" entre un punt i el següent E_yInic(f) = (ArrayEyInic(f + 1) + ArrayEyInic(f)) / 2 ' id. y arrayfluxInic(f) = dlxInic(f) * E_yInic(f) - dlyInic(f) * E_xInic(f) 'flux = módul del producte vectorial End If Next '------------------------------------------------------------- 'Ara afegim més punts que els clicats, per a què el resultat sigui més exacte ------- Dim k As Integer = 0 Dim j As Integer = 0 Dim i As Integer = 0 Dim L As Integer Dim dl(comptadorP - 1) As Integer Dim Pnx As Single Dim Pny As Single For i = 0 To comptadorP - 1 'mirem quina és la distància entre els punts clicats arrayNewP(k) = ArrayPunts(i) 'al nou array de punts, també hi afegim els clicats k = k + 1 If i = comptadorP - 1 Then dl(i) = ((ArrayPunts(0).X - ArrayPunts(i).X) ^ 2 + (ArrayPunts(0).Y - ArrayPunts(i).Y) ^ 2) ^ 0.5 Else dl(i) = ((ArrayPunts(i + 1).X - ArrayPunts(i).X) ^ 2 + (ArrayPunts(i + 1).Y - ArrayPunts(i).Y) ^ 2) ^ 0.5 End If Select Case dl(i) 'depenent de la dist entre els punts clicats, buscarem més o menys punts intermedis Case 2 To 10 L = 50 ' L és el nº de punts intermitjos que possarem entre el punts clicats Case 10 To 20 L = 100 Case 20 To 40 L = 200 Case Is > 40 L = 300 End Select 'L = 100 Dim incX As Double = 0 Dim incY As Double = 0 If i = comptadorP - 1 Then 'Pnx i Pny són les components dels nous punts incX = (ArrayPunts(0).X - ArrayPunts(i).X) / L incY = (ArrayPunts(0).Y - ArrayPunts(i).Y) / L Else If j = L Then incX = (ArrayPunts(0).X - ArrayPunts(i).X) / L incY = (ArrayPunts(0).Y - ArrayPunts(i).Y) / L Else


68

incX = (ArrayPunts(i + 1).X - ArrayPunts(i).X) / L incY = (ArrayPunts(i + 1).Y - ArrayPunts(i).Y) / L End If End If Pnx = ArrayPunts(i).X Pny = ArrayPunts(i).Y For j = 1 To L Pnx += incX Pny += incY arrayNewP(k) = New PointF(Pnx, Pny) k = k + 1 ReDim Preserve arrayNewP(k + 1) Next Next ReDim Preserve arrayNewP(k - 1) ComptAutom = k - 1 'para crear la tabla2 'Fins aquí hem afegit els punts -------------------------- 'Ara calcularem el flux per aquests punts creats automàticament ReDim Preserve ArrayEx(k - 1) ReDim Preserve ArrayEy(k - 1) ReDim Preserve ArrayFlux(k - 1) ReDim Preserve E_x(k - 1) ReDim Preserve E_y(k - 1) Dim dlx(k - 1) As Double Dim dly(k - 1) As Double Dim jj As Integer For jj = 0 To k - 1 ArrayEx(jj) = Calcular_Ex(arrayNewP(jj)) ArrayEy(jj) = Calcular_Ey(arrayNewP(jj)) Next Dim ii As Integer For ii = 0 To k - 1 If ii = k - 1 Then dlx(ii) = arrayNewP(0).X - arrayNewP(ii).X dly(ii) = arrayNewP(0).Y - arrayNewP(ii).Y E_x(ii) = (ArrayEx(ii) + ArrayEx(0)) / 2 E_y(ii) = (ArrayEy(ii) + ArrayEy(0)) / 2 ArrayFlux(ii) = dlx(ii) * E_y(ii) - dly(ii) * E_x(ii) Else dlx(ii) = arrayNewP(ii + 1).X - arrayNewP(ii).X 'components del vector que uneix un punt amb el següent dly(ii) = arrayNewP(ii + 1).Y - arrayNewP(ii).Y E_x(ii) = (ArrayEx(ii + 1) + ArrayEx(ii)) / 2 'components del vector camp "promig" entre un punt i el següent E_y(ii) = (ArrayEy(ii + 1) + ArrayEy(ii)) / 2 ArrayFlux(ii) = dlx(ii) * E_y(ii) - dly(ii) * E_x(ii) 'flux = módul del producte vectorial End If Next 'Fins aquí hem calculat el flux pels punts creats automàticament

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 4.Pressupost

69

4 Pressupost

4.1 Preus Unitaris

Material

Codi Unitat Designació Preu(€)

101 un. Disc Compacte CD-ROM 0,50

102 un. Dispositiu de Memòria USB 9,00

103 h Amortització Equipament Hardware 1,00

104 h Amortització Equipament Software 1,00

Mà d’obra

Codi Unitat Designació Preu(€)

M1 h Investigació i recopilació d’informació 6,00

M2 h Càlculs Tècnics i realització d’algorismes 10,00

M3 h Programació 8,00

4.2 Descomposició de Partides

Realització Programa

Codi Partida Designació Unitat

P-001 Recopilació d’informació. un.

Unitat Quantitat Preu Unitari Total (€)

Material:

103-Amortització equipament Hardware h 2,00 1,00 2,00

Subtotal Material: 2,00

Mà d’obra

M1-Investigació i recopilació d’informació h 4,00 6,00 24,00

Subtotal Mà d’Obra 24,00

Cost Directe: 26,00

Despeses Indirectes 2,00%: 0,52

Cost Execució: 26,52

Són VINT-I-SIS AMB CINQUANTA-DOS €/un.


70


P-002 Decisió del llenguatge informàtic a utilitzar i del planin a seguir. un.


Material:



Mà d’obra

M1- Investigació i recopilació d’informació h 1,00 6,00 6,00

M2-Càlculs Tècnics i realització d’algorismes h 1,00 10,00 6,00

Subtotal Mà d’Obra 12

Cost Directe: 14,00



Són CATORZE AMB VINT-I-VUIT €/un.


P-003 Estudi del llenguatge informàtic utilitzat. un.


Material:



Mà d’obra

M1-Investigació i recopilació d’informació h 8,00 6,00 48,00


Cost Directe: 55,00



Són CINQUANTA-SIS AMB DEU €/un.


71


P-004 Realització del software un.


Material:



Mà d’obra

M2- Càlculs Tècnics i realització d’algorismes h 0,50 10,00 5,00

M3- Programació h 3,50 8,00 28,00


Cost Directe: 36,50



Són TRENTA-SET AMB VINT-I-TRES €/un.


P-005 Modificacions i resolucions de problemes. un.


Material:



Mà d’obra


M2- Càlculs Tècnics i realització d’algorismes h 0,50 10,00 5,00

M3- Programació h 1,00 8,00 8,00


Cost Directe: 18,00



Són DIVUIT AMB TRENTA-SIS €/un.


72


P-006 Gravació i presentació del programa en disc compacte. un.


Material:

101-Disc Compacte CD-ROM un. 1,00 0,50 0,50

102-Dispositiu de Memòria USB un. 1,00 9,00 9,00



Mà d’obra



Cost Directe: 11,20



Són ONZE AMB QUARANTA-DOS €/un.

Documentació


P-007 Realització de la documentació. un.


Material:

101-Disc Compacte CD-ROM un. 1,00 0,50 0,50



Mà d’obra



Cost Directe: 68,50



Són SEIXANTA NOU AMB VUITANTA-SET €/un.


73

4.3 Amidaments

Codi Partida Unitat Designació Total

P-001 un. Recopilació d’informació. 2

P-002 un. Decisió del llenguatge informàtic a utilitzar i del planin a seguir. 1

P-003 h Estudi del llenguatge informàtic utilitzat. 12

P-004 h Realització del software 25

P-005 h Modificacions i resolucions de problemes. 10

P-006 h Gravació i presentació del programa en disc compacte. 3

P-007 h Realització de la documentació. 1

4.4 Aplicació de Preus - Pressupost

Capítol 1. Realització Programa

Codi Partida Unitat Designació Quantitat Preu

Unitari Total

P-001 un. Recopilació d’informació. 2 26,52 53,04

P-002 un. Decisió del llenguatge informàtic a utilitzar i del planin a seguir.

1 14,28 14,28

P-003 un. Estudi del llenguatge informàtic utilitzat. 12 56,10 673,20

P-004 un. Realització del software 25 37,23 930,75

P-005 un. Modificacions i resolucions de problemes. 10 18,36 183,36

P-006 un. Gravació i presentació del programa en disc compacte. 3 11,42 34,26

Total Capítol 1: 1888,89

Són MIL VUIT-CENTS VUITANTA-VUIT AMB VUITANTA-NOU €/un.

Capítol 2. Documentació

Codi Partida Unitat Designació Quantitat Preu

Unitari Total

P-007 un. Realització de la documentació. 1 69,87 69,87

Total Capítol 2: 69,87

Són SEIXANTA-NOU AMB VUITANTA-SET €/un.


74

4.5 Resum del Pressupost

Capítols Import

Capítol 1: Realització Programa 1888,89

Capítol 2: Documentació 69,87

TOTAL PRESSUPOST D’EXECUCIÓ MATERIAL (€) 1958,76

Despeses Generals 13% 254,64

Benefici Industrial 6% 117,52

TOTAL PRESSUPOST PER CONTRACTAR (€) 2330,92

IVA 16% 372,95

TOTAL PRESSUPOST D’EXECUCIÓ (€) 2703,87

EL PRESSUPOST ASCENDEIX A LA QUANTITAT DE DOS MIL SET-CENTS TRES AMB VUITANTA-SET EUROS

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 5.Plec de Condicions

75

5 Plec de Condicions

5.1 Condicions Generals

El DEEEA de l’ETSE de la URV é propietària i titular del drets d’explotació del programa, així com de la documentació tècnica necessària per al seu funcionament.

Pel present contracte, el DEEEA pot concedir a qualsevol estudiant de l’ETSE una llicència, intransferible i no exclusiva, per l’ús d’aquest Programa en un sistema informàtic que compleixi les especificacions que es descriu en la memòria descriptiva, destinant-lo el beneficiari (en aquest cas l’estudiant de l’ETSE) a la satisfacció de les seves necessitats informàtiques.

5.2 Condicions Econòmiques No existeix cap mena de compensació econòmica per tal d’establir el lliurament del

Programa i de la corresponent documentació, així com dels drets d’explotació, per part del dissenyador i programador del software. El DEEEA, per la seva part, es reservarà el dret de demanar contraprestació econòmica per l’ús del programa si el beneficiari no pertany a l’ETSE de la URV. De la mateixa manera, el DEEEA tindrà total llibertat per establir les normes que cregui oportunes per al control i utilització del programa.

5.3 Condicions Tècniques El present Software, amb el seu suport magnètic i manual d’usuari, està garantit

contra qualsevol defecte de fabricació durant un període de dos mesos a partir de la data de lliurament per part del dissenyador programador del software. Aquesta garantia inclou la modificació per part del programador, dels errors de fabricació en el programa que beneficiari o propietari pogués detectar durant aquest temps. La correcció de qualsevol error o defecte en el suport magnètic serà lliure de càrrec durant aquest període.

El DEEEA no quedarà vinculada pels compromisos o promeses realitzades per persones alienes al Departament o equip projectista, ni per expectatives errònies respecte al funcionament del programa.

En qualsevol cas, el beneficiari accepta que aquest programa constitueix una eina de treball destinada a complementar, però no a substituir la tasca humana, per tant la responsabilitat del DEEEA pels danys imputables directament al Programa, es limitaran als indicats prèviament pel coordinador i director de l’assignatura.

El beneficiari haurà d’utilitzar el Programa exclusivament en un sistema informàtic que compleixi totes les especificacions tècniques descrites a l’apartat de característiques mínimes del Hardware de la memòria descriptiva. El DEEEA no es fa responsable del mal funcionament del Programa en cas que s’utilitzi en qualsevol tipus de configuració diferent a la requerida, sense haver deanat assessorament previ.

El DEEEA no serà responsable pels retards, interrupcions o falta de prestació dels serveis previstos, quan això succeeixi per causa major o aliena a la seva voluntat.

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 5.Plec de Condicions

76

5.4 Condicions Facultatives El beneficiari reconeix els drets de Propietat Intel·lectual del DEEA sobre el

Programa, comprometent-se a no suprimir cap indicació sobre aquests drets en el Software. Aquests drets protegeixen el Programa, i tot el material que es proporcioni amb ell.

El beneficiari està autoritzat a efectuar una sola còpia de seguretat del Software, que en cap cas podrà ser utilitzada i que quedarà sota la custòdia del beneficiari, amb l’única finalitat de guardar i conservar la informació. El beneficiari s’abstindrà de copiar total o parcialment la documentació subministrada pel DEEEA per l’ús del Software, així com qualsevol materia imprès lliurat pel mateix. Si el beneficiari necessités còpies addicionals d’aquest material, haurà de demanar permís al DEEEA o al director de l’assignatura, acceptant les mesures que es creguin oportunes en cada cas.

El beneficiari reconeix que aquest Software li és cedit per al seu ús i no per a la seva reproducció, modificació, cessió, venda, lloguer o préstec, i es compromet a no cedir el seu ús total o parcial de cap forma i a no transmetre cap dret que tingui sobre ell, així com no divulgar-lo, publicar-lo, ni posar-lo de cap altra manera a disposició d’altres persones.

El DEEEA tindrà dret a l’obertura d’expedient si el beneficiari incomplís qualsevol de les estipulacions pactades; en aquest cas ho hauria de notificar al beneficiari, procedint-ne a la immediata devolució del Programa (en cas de cessió en disc compacte).

El beneficiari estarà obligat a donar les seves dades personals per aprofitar-se d’aquest Programa. En cas que el DEEEA observés qualsevol irregularitat en les dades del beneficiari, tindrà la capacitat per desestimar la petició si així ho cregués oportú.

En cas de sorgir qualsevol divergència de la interpretació o aplicació d’aquests punts, serà la Universitat Rovira i Virgili la que, a través dels seus òrgans competents, resolgui el cas que es doni a confusió o disputa.

En cas que alguns punts anteriors fossin invalidats, il·legals o inexcusables en virtut d’alguna norma jurídica, es consideraran ineficaços en la mesura que correspongui, però en la resta es conservarà la seva validesa.

No s’han efectuat acords verbals i el present document, amb totes les seves estipulacions, conforma la totalitat del conveni inter-parts, substituint qualsevol altra comunicació anterior verbal o escrita.

Signat:

Juan Ramón Rodríguez Sánchez

Setembre 2008

Software Interactiu de Simulació de Camps Elèctrics Generats per Càrregues Puntuals Universitat Rovira i Virgili 6.Annexos

77

6 Annexos

6.1 Bibliografia

6.1.1 Teoria de física (Camps Elèctrics, Teorema de Gauss, etc...) - Física Preuniversitaria; Tripler, Paul A.; Editorial Reverte.

- Pàgina Web http://es.wikipedia.org

- Pàgina Web http://www.sc.ehu.es/sbweb/fisica/elecmagnet/electrico

- Pàgina Web http://www.fisica-facil.com/Temario

6.1.2 Visual Basic.net - Programación enVisual Basic Net; Luis Miguel Blanco; Grupo Eidos

- Manual de Introducción a Microsoft Visual Basic 2005 Express Edition; Jorge Serrano Pérez

- Programación con Visual Basic.Net; Francisco Charte; Anaya Multimedia

- Visual Basic 2005 express edition for dummies; Richard Mansfield; Wiley Publishing, Inc.

- Pàgina Web http://www.canalvisualbasic.net

- Pàgina Web http://forums.microsoft.com/MSDN-ES

- Pàgina Web http://www.programatium.com/vbnet.htm

- Pàgina Web http://www.elguille.info/

- Pàgina Web http://www.elquintero.net

- Pàgina Web http://foros.solocodigo.com

- Pàgina Web http://www.codeproject.com/

- Pàgina Web http://www.developerfusion.co.uk/vbnet/

- Pàgina Web http://www.netveloper.com/

6.1.3 Altres

- Pàgina Web http://www.mappinginteractivo.com

- Pàgina Web http://www.proyectosfindecarrera.com

- Pàgina Web http://www.google.es


78

6.2 Codi

A continuació s’adjunta el codi font del programa en tres parts, el codi corresponent

a la pantalla principal, el codi corresponent a la pantalla on es comprova el teorema de Gauss per a 2D, i el codi corresponent a la pantalla on es mostra una representació en 3D del potencial elèctric.

6.2.1 Codi Pantalla Principal (“Campelec”)

Imports System.Drawing.Drawing2D Imports System.IO Imports System.Drawing.Printing Public Class Form1 #Region "VARIABLES" Public Class VG ' VARIABLES GLOBALS (emprades també als altres formularis) Public Shared ArrayNQ(0) As Double 'array de càrregues, més tard ja el redimensionarem Public Shared ArrayPosQ(0) As PointF ' posició de les càrregues Public Shared NQi As Integer 'nº de càrregues (possem 10 com a màxim) End Class Dim Ex As Double ' Component X del camp elèctric a un punt Dim Ey As Double ' Componente Y del camp elèctric a un punt Dim ExEquip As Double ' id. per calcular les lin equipotencials Dim EyEquip As Double Dim Increment As Single = 0.05 'increment que donarem per trobar les línies de força i equipotencials Dim Dx As Single Dim Dy As Single Dim DxEquip As Single Dim DyEquip As Single Dim xp As Single = 0 Dim yp As Single = 0 Dim Indice As Integer = 0 Dim NQtxt As String 'auxiliar pel nº cargas Dim PBox As New ControlArray("PBox") 'Representaran les càrregues Dim lblQ As New ControlArray("lblQ") 'Etiquetes amb els noms de les càrregues Dim lblPosQ As New ControlArray("lblPosQ") 'Posicions Dim txtQ As New ControlArray("txtQ") ' Noms de les càrregues Dim txtPosQ As New ControlArray("txtPosQ") ' Posicions Dim bool_dib_lequip As Boolean = False 'per controlar si btn_dib_lequip està premut Dim bool_linEquip_Inic As Boolean 'id


79

Dim bool_dib_lf As Boolean = False 'per controlar si btn_dib_lf està premut Dim bool_linF_Inic As Boolean 'id Dim bool_btn_Campelec As Boolean = False 'id Dim bool_btn_ECamp As Boolean = False 'id Dim contador As Integer = 0 'Comptador per a controlar que no pinti un vector E a la graella quan cliquem el botó Ecamp Dim bool_Iniciar As Boolean Dim bool_btn_AddQ As Boolean Dim bool_btn_delQ As Boolean = False Dim bool_openF As Boolean Dim bool_moureQ As Boolean = False ' per controlar si el btn_mov està premut (habilita moure els picbox's) Dim dragging As Boolean 'var per controlar el moviment dels Picbox's Dim mousex As Single Dim mousey As Single Dim a As Cursor = New Cursor("C:\campelec\hmove.cur") 'Pel moviment dels picbox de les carregues Dim puntmovi(9) As Point Dim puntmovf(9) As Point Dim N As Double = 15 ' escala per a què els vectors E tinguin igual mòdul Dim D As Integer = 25 ' distància entre vectors d'intensitat de camp Dim ArrayNQ_esc(0) As Double ' array de Q escalades Dim FotoGraella As String 'var per anar a les pantalles 3D i Gauss #End Region #Region "CLASE ARRAY DE CONTROLS" ' Colecció d'objetes de tipus Control Public Class ControlArray Inherits CollectionBase Private mNombre As String Public Sub New() MyBase.New() End Sub Public Sub New(ByVal elNombre As String) MyBase.New() mNombre = elNombre End Sub Public Function Add(ByVal ctrl As Control) As Integer Return MyBase.List.Add(ctrl) End Function ' Assignar els controls que contindrà aquesta colecció Public Sub AsignarControles(ByVal ctrls As Control.ControlCollection, Optional ByVal elNombre As String = "") ' Assignar els controls als arrays, per a que funci automàticament els noms dels ' controls han de tenir el format: nom_índex If elNombre = "" Then


80

elNombre = mNombre End If ' si no s'indica el nom dels controls a afegir, llençar una excepció If elNombre = "" Then Throw New ArgumentException("No se ha indicado el nombre base de los controles") Exit Sub End If Me.Clear() asignarLosControles(ctrls, elNombre) Me.Reorganizar() End Sub Private Sub asignarLosControles( _ ByVal ctrls As Control.ControlCollection, ByVal elNombre As String) Dim ctr As Control For Each ctr In ctrls ' Fer una crida recursiva por si aquest control "conté" d'altres asignarLosControles(ctr.Controls, elNombre) If ctr.Name.IndexOf(elNombre) > -1 Then Me.Add(ctr) End If Next End Sub Public Function Contains(ByVal ctrl As Control) As Boolean List.Contains(ctrl) End Function Public Function IndexOf(ByVal ctrl As Control) As Integer Return List.IndexOf(ctrl) End Function Public Function Index(ByVal name As String) As Integer Dim ctrl As Control Dim i As Integer Dim hallado As Integer = -1 For i = 0 To List.Count - 1 ctrl = CType(List(i), Control) If StrComp(ctrl.Name, name, CompareMethod.Text) = 0 Then hallado = i Exit For End If Next Return hallado End Function Public Function Index(ByVal ctrl As Control) As Integer Dim i As Integer i = ctrl.Name.LastIndexOf("_") ' Si el nom té el signe _ If i = -1 Then i = List.IndexOf(ctrl)


81

Else i = CInt(ctrl.Name.Substring(i + 1)) End If Return i End Function Public Sub Insert(ByVal index As Integer, ByVal ctrl As Control) List.Insert(index, ctrl) End Sub Default Public Property Item(ByVal index As Integer) As Control Get Return CType(List.Item(index), Control) End Get Set(ByVal Value As Control) List.Item(index) = Value End Set End Property Default Public Property Item(ByVal name As String) As Control Get Dim index As Integer = Me.Index(name) ' Si existeix, tornar-lo, si no, crear-ne un de nou If index = -1 Then 'index = Me.Add(ctrl) End If Return CType(List.Item(index), Control) End Get Set(ByVal Value As Control) Dim index As Integer = Me.Index(name) If index = -1 Then index = Me.Add(Value) End If List.Item(index) = Value End Set End Property Default Public Property Item(ByVal ctrl As Control) As Control Get Return CType(List(Me.IndexOf(ctrl)), Control) End Get Set(ByVal Value As Control) List(Me.IndexOf(ctrl)) = Value End Set End Property Public Property Nombre() As String Get Return mNombre End Get Set(ByVal Value As String) mNombre = Value End Set End Property Public Sub Remove(ByVal ctrl As Control) List.Remove(ctrl) End Sub ' Reorganitzar el contingut de la colecció i ordenar per índex Public Sub Reorganizar()


82

Dim ca As New ControlArray() Dim ctr As Control Dim i As Integer For i = 0 To Me.Count For Each ctr In Me If i = Me.Index(ctr) Then ca.Add(ctr) Exit For End If Next Next Me.Clear() For Each ctr In ca Me.Add(ctr) Next End Sub End Class #End Region #Region "FORM1 LOAD & PAINT" Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load Call Colors_btn() Dim PB As PictureBox PBox.AsignarControles(Me.Controls) 'creem l'array de picbox's Dim i As Integer = 0 For Each PB In PBox 'al carregar el formulari, introduim els picbox's al PicBox0 PicBox0.Controls.Add(PBox(i)) i = i + 1 Next 'Assignem la imatge de la quadricula al picbox0 Me.PicBox0.Image = Image.FromFile("c:\campelec\quadricula.png") PicBox0.Refresh() 'creem els arrays de labels i textboxs lblQ.AsignarControles(Me.Controls) lblPosQ.AsignarControles(Me.Controls) txtQ.AsignarControles(Me.Controls) txtPosQ.AsignarControles(Me.Controls) 'no podem cambiar el readonly amb un bucle txtPosQ_1.ReadOnly = True txtPosQ_2.ReadOnly = True txtPosQ_3.ReadOnly = True txtPosQ_4.ReadOnly = True txtPosQ_5.ReadOnly = True txtPosQ_6.ReadOnly = True txtPosQ_7.ReadOnly = True txtPosQ_8.ReadOnly = True txtPosQ_9.ReadOnly = True txtPosQ_10.ReadOnly = True txtQ_1.ReadOnly = True


83

txtQ_2.ReadOnly = True txtQ_3.ReadOnly = True txtQ_4.ReadOnly = True txtQ_5.ReadOnly = True txtQ_6.ReadOnly = True txtQ_7.ReadOnly = True txtQ_8.ReadOnly = True txtQ_9.ReadOnly = True txtQ_10.ReadOnly = True Potencial.ReadOnly = True CampElecY.ReadOnly = True Xbox.ReadOnly = True YBox.ReadOnly = True txtPosCursor.ReadOnly = True txtVposCursor.ReadOnly = True Dim k As Integer = 0 For k = 0 To 9 PBox(k).Visible = False PBox(k).BackgroundImageLayout = ImageLayout.Stretch lblQ(k).Visible = False lblPosQ(k).Visible = False txtQ(k).Visible = False txtQ(k).BackColor = Color.White txtPosQ(k).Visible = False txtPosQ(k).BackColor = Color.White Next DataHora.Text = Format(Date.Now, "dd/MM/yy; hh:mm tt") lblVCamp.Visible = False 'trackbar pel modul de E TrackBar1.Visible = False lblDVCamp.Visible = False 'trackbar per la distància entre punts TrackBar2.Visible = False contador = 0 'var per que no pinti l'etiqueta quan cliquem al btn_E End Sub Private Sub form1_paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles Me.Paint Dim grafica As Graphics = Me.CreateGraphics 'dibuixem la part exterior de la gràfica Dim penGrafica As New Pen(Color.Black, 2) Dim penEixos As New Pen(Color.Black, 5) penEixos.EndCap = LineCap.DiamondAnchor Dim fontA As Font = New Font("Arial", 8, FontStyle.Regular) Dim fontB As Font = New Font("Arial", 12, FontStyle.Regular) Dim i As Integer For i = 0 To 10 grafica.DrawLine(penGrafica, PicBox0.Location.X, PicBox0.Location.Y + i * 50, PicBox0.Location.X - 10, PicBox0.Location.Y + i * 50) grafica.DrawLine(penGrafica, PicBox0.Location.X + 700, PicBox0.Location.Y + i * 50, PicBox0.Location.X + 710, PicBox0.Location.Y + i * 50) grafica.DrawString(i * 50, fontA, Brushes.Black, PicBox0.Location.X - 40, PicBox0.Location.Y + i * 50 - 10) Next Dim j As Integer For j = 0 To 14


84

grafica.DrawLine(penGrafica, PicBox0.Location.X + j * 50, PicBox0.Location.Y, PicBox0.Location.X + j * 50, PicBox0.Location.Y - 10) grafica.DrawLine(penGrafica, PicBox0.Location.X + j * 50, PicBox0.Location.Y + 500, PicBox0.Location.X + j * 50, PicBox0.Location.Y + 510) grafica.DrawString(j * 50, fontA, Brushes.Black, PicBox0.Location.X + j * 50 - 10, PicBox0.Location.Y - 30) Next grafica.DrawString("[m]", fontA, Brushes.Black, PicBox0.Location.X - 40, PicBox0.Location.Y - 30) grafica.DrawLine(penEixos, PicBox0.Location.X - 50, PicBox0.Location.Y - 40, PicBox0.Location.X - 50, PicBox0.Location.Y + 60) grafica.DrawLine(penEixos, PicBox0.Location.X - 50, PicBox0.Location.Y - 40, PicBox0.Location.X + 60, PicBox0.Location.Y - 40) grafica.DrawString("X", fontB, Brushes.Black, PicBox0.Location.X + 50, PicBox0.Location.Y - 60) grafica.DrawString("Y", fontB, Brushes.Black, PicBox0.Location.X - 70, PicBox0.Location.Y + 50) grafica.DrawRectangle(Pens.Black, PicBox0.Location.X - 1, PicBox0.Location.Y - 1, 701, 501) penEixos.Dispose() penGrafica.Dispose() fontA.Dispose() fontB.Dispose() End Sub #End Region #Region "CÀRREGUES" Public Sub Carregues() Dim qvalor As String PicBox0.Refresh() Array.Clear(VG.ArrayNQ, 0, VG.ArrayNQ.Length) 'per netejar els valors i les posicions de les càrregues Array.Clear(VG.ArrayPosQ, 0, VG.ArrayNQ.Length) Dim k As Integer = 0 For k = 0 To 9 PBox(k).Visible = False lblQ(k).Visible = False lblPosQ(k).Visible = False txtQ(k).Visible = False txtQ(k).BackColor = Color.White txtPosQ(k).Visible = False txtPosQ(k).BackColor = Color.White Next Do NQtxt = (InputBox("INTRODUEIX EL NOMBRE DE CÀRREGUES" & Chr(13) & Chr(13) & "QUE VOLS (MÀXIM 10 CÀRREGUES)", "Nº DE CÀRREGUES", 1, 200, 500)) If NQtxt = "" Then bool_Iniciar = False : Exit Sub 'per si cliquen Cancelar Loop While IsNumeric(NQtxt) = False 'per si no és un nº


85

VG.NQi = CInt(NQtxt) - 1 While VG.NQi < 0 Or VG.NQi > 9 MessageBox.Show("EL VALOR DE NQ HA D'ESTAR ENTRE 1 i 10", "ERROR AL INTRODUIR LES DADES", MessageBoxButtons.OK, MessageBoxIcon.Stop) Do NQtxt = (InputBox("INTRODUEIX EL NOMBRE DE CÀRREGUES" & Chr(13) & Chr(13) & "QUE VOLS (MÀXIM 10 CÀRREGUES)", "Nº DE CÀRREGUES", 1, 200, 500)) If NQtxt = "" Then bool_Iniciar = False : Exit Sub ''per si cliquen Cancelar Loop While IsNumeric(NQtxt) = False ' per si no és un nº VG.NQi = CInt(NQtxt) - 1 End While ReDim Preserve VG.ArrayNQ(VG.NQi) 'si li dono d'inici dim 10, quedaven elements de valor 0 ReDim Preserve VG.ArrayPosQ(VG.NQi) 'id Dim i As Integer = 0 For i = 0 To VG.NQi Step 1 'introduim els valors de Q i la seva posició Do qvalor = InputBox("INTRODUEIX EL VALOR DE Q" & (i + 1) & ":" & " (en Coulombs)" & Chr(13) & Chr(13) & "ATENCIÓ!!! SI INTRODUEIXES DECIMALS, HAS DE FER SERVIR LA COMMA EN LLOC DEL PUNT!!!", "VALORS DE LES CÀRREGUES", "-1", 200, 500) If qvalor = "" Then ''per si cliquen Cancelar, per netejar els valors i les posicions de las càrregues bool_Iniciar = False NQtxt = 0 VG.NQi = 0 Array.Clear(VG.ArrayNQ, 0, VG.ArrayNQ.Length) Array.Clear(VG.ArrayPosQ, 0, VG.ArrayNQ.Length) BtnReinici.PerformClick() Exit Sub End If Loop While IsNumeric(qvalor) = False ' per si no és un nº If qvalor = 0 Then MessageBox.Show("ÉS ABSURD QUE EL VALOR DE LA CÀRREGA SIGUI ZERO", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Exclamation) bool_Iniciar = False NQtxt = 0 VG.NQi = 0 Array.Clear(VG.ArrayNQ, 0, VG.ArrayNQ.Length) Array.Clear(VG.ArrayPosQ, 0, VG.ArrayNQ.Length) BtnReinici.PerformClick() Exit Sub End If VG.ArrayNQ(i) = CDbl(qvalor) If VG.ArrayNQ(i) <> 0 Then VG.ArrayPosQ(i) = New Point(15, 30 * i + 20) PBox(i).Visible = True PBox(i).Location = New Point(5, 30 * i + 10) End If


86

lblQ(i).Visible = True lblPosQ(i).Visible = True txtQ(i).Visible = True txtPosQ(i).Visible = True txtQ(i).Text = VG.ArrayNQ(i).ToString & " C" txtPosQ(i).Text = VG.ArrayPosQ(i).ToString Next Call dib_cargas() MessageBox.Show("COL·LOCA LES CÀRREGUES ON VULGUIS") Me.PicBox0.Image = Nothing Me.PicBox0.Image = Image.FromFile("c:\Campelec\quadricula.png") 'tornem a càrregar la imatge pq se quedaba 'al picbox la foto del messagebox i de les posicions inicials de les càrregues bool_moureQ = True End Sub Public Sub dib_cargas() Dim cq As Integer = 0 For cq = 0 To VG.ArrayNQ.Length - 1 If VG.ArrayNQ(cq) = 0 Then PBox(cq).Visible = False Else PBox(cq).Visible = True If VG.ArrayNQ(cq) < 0 Then PBox(cq).BackgroundImage = Image.FromFile("c:\Campelec\cargaNeg.png") 'COMPTE!!! s'han de posar en aquest directori End If If VG.ArrayNQ(cq) > 0 Then PBox(cq).BackgroundImage = Image.FromFile("c:\Campelec\cargaPos.png") End If End If PBox(cq).Location = New Point(VG.ArrayPosQ(cq).X - 10, VG.ArrayPosQ(cq).Y - 10) Next '--------------això ja està a sub carregues(), però si no ho posso també aquí, ' no surt quan entrem els valors desde un arxiu ToolTip1.InitialDelay = 50 ToolTip1.BackColor = Color.Aquamarine ToolTip1.IsBalloon = True Dim i As Integer For i = 0 To VG.NQi If VG.ArrayNQ(i) <> 0 Then lblQ(i).Visible = True lblPosQ(i).Visible = True txtQ(i).Visible = True txtPosQ(i).Visible = True txtQ(i).Text = VG.ArrayNQ(i).ToString("0.#E+00") & " C" 'li donem el format científic txtPosQ(i).Text = VG.ArrayPosQ(i).ToString End If ToolTip1.SetToolTip(PBox(i), "CARGA " & i + 1 & Chr(13) & VG.ArrayNQ(i).ToString & " C") Next


87

'------------------------------------------------------repetit End Sub Public Sub DeleteQ(ByVal NumIndex) 'per esborrar una càrrega PicBox0.Refresh() Dim Index As Integer = NumIndex Dim i As Integer = 0 'movem els elements del array, a partir de l'índex que volem esborrar, una posició cap a baix For i = Index To VG.NQi - 1 VG.ArrayNQ(i) = VG.ArrayNQ(i + 1) VG.ArrayPosQ(i) = VG.ArrayPosQ(i + 1) Next VG.ArrayNQ(VG.NQi) = 0 VG.ArrayPosQ(VG.NQi) = New PointF(0, 0) 'Ho fem invisible tot, per després tornar-ho a dibuixar correctament cridant el sub dib_cargas Dim k As Integer For k = 0 To 9 PBox(k).Visible = False PBox(k).BackgroundImageLayout = ImageLayout.Stretch lblQ(k).Visible = False lblPosQ(k).Visible = False txtQ(k).Visible = False txtQ(k).BackColor = Color.White txtPosQ(k).Visible = False txtPosQ(k).BackColor = Color.White Next VG.NQi -= 1 ReDim Preserve VG.ArrayNQ(VG.NQi) ReDim Preserve VG.ArrayPosQ(VG.NQi) Call dib_cargas() End Sub #End Region #Region "CAMP ELÈCTRIC" Public Sub Camp_electric() Dim L As Double ' L=N/|Et| Dim arrayPi(701 * 501) As PointF 'array punts inicials Dim arrayPf(701 * 501) As PointF 'array punts finals Dim arrayPfesc(701 * 501) As PointF 'array punts finals amb módul constant Dim xp As Integer = 0 Dim yp As Integer = 0 Dim IndArray As Integer = 0 Dim modCampelec(701 * 501) As Double 'array de modul de camp electric Dim Indexmax As Integer 'calculem en quin index esta el major modul Dim Et As Double 'modul del camp electric a cada punt Dim GraficaCampelec As Graphics = PicBox0.CreateGraphics Dim PenCampelecEsc As New Pen(Color.Black, 1) ' per a les linies que uneixen els punts d'igual modul 'creem l'extrem de la línia com una fletxa


88

PenCampelecEsc.EndCap = Drawing2D.LineCap.ArrowAnchor Dim xf, yf, xfesc, yfesc, xft, yft As Double While xp < 701 While yp < 501 'assignem tots els punts inicials arrayPi(IndArray) = New Point(xp, yp) 'asignemos els punts finals xf = Calcular_Ex(New Point(xp, yp)) yf = Calcular_Ey(New Point(xp, yp)) xft = xp + xf yft = yp + yf Et = (xf ^ 2 + yf ^ 2) ^ 0.5 'módul If Et = 0 Then L = N Else L = N / Et 'calculem L per despres convertir los vectors a modul constant xfesc = xp + L * xf yfesc = yp + L * yf arrayPf(IndArray) = New PointF(xft, yft) 'punts finals sense módul constant arrayPfesc(IndArray) = New PointF(xfesc, yfesc) 'punts finals amb módul constant 'donem valors a l'array de modul de camp electric i mirem en quin index esta el mes gran modCampelec(IndArray) = ((arrayPf(IndArray).X - arrayPi(IndArray).X) ^ 2 + (arrayPf(IndArray).Y - arrayPi(IndArray).Y) ^ 2) ^ 0.5 Dim maxim = Math.Abs(modCampelec(0)) 'trobem el màxim. Inicialment supossem que es el primer número. If Math.Abs(modCampelec(IndArray)) > maxim Then maxim = Math.Abs(modCampelec(IndArray)) Indexmax = IndArray End If GraficaCampelec.DrawLine(PenCampelecEsc, arrayPi(IndArray), arrayPfesc(IndArray)) yp += D 'fem que la separació entre vectors calculats sea 25, inicialment IndArray += D End While yp = 0 xp += D End While PenCampelecEsc.Dispose() End Sub Private Sub TrackBar1_ValueChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles TrackBar1.ValueChanged N = TrackBar1.Value * 10 'trackbar per controlar el tamany del mòdul dels vectors E btn_Campelec.PerformClick() End Sub Private Sub TrackBar2_Scroll(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TrackBar2.ValueChanged


89

D = TrackBar2.Value * 5 'trackbar per controlar la distància entre els vectors E btn_Campelec.PerformClick() End Sub #End Region #Region "DIBUIX LÍNEES EQUIPOTENCIALS" Public Sub dib_linEquipot(ByVal PuntInicial As PointF) ' passem la variable del punt on hem clicat ' dibuixem la línia equipotencial Dim indice3 As Integer 'comptador pel nº d'iteracions que farem Dim array_equip(200000) As PointF 'array de punts de la línia equipotencial Dim xi As Single = PuntInicial.X 'Punt original de la graella on cliquem Dim yi As Single = PuntInicial.Y Dim GrafEquip As Graphics = Me.PicBox0.CreateGraphics() 'Creem la tela on dibuixarem Dim PenlineasEquip As New Pen(Color.Transparent, 1) 'creem el pincell amb el que pintarem If Calcular_Pot(PuntInicial) > 0 Then 'calculem el potencial al punt, i mirem és positiu If bool_linEquip_Inic = True Then 'si són les línees inicials, les pintarem més tènues PenlineasEquip.Color = Color.FromArgb(100, Color.Blue) Else PenlineasEquip.Color = Color.Blue End If Else 'si el potencial és negatiu If bool_linEquip_Inic = True Then 'si són les línees inicials, les pintarem més tènues PenlineasEquip.Color = Color.FromArgb(100, Color.Red) Else PenlineasEquip.Color = Color.Red End If End If Do 'Comencem les iteracions ExEquip = Calcular_Ex(PuntInicial) EyEquip = Calcular_Ey(PuntInicial) DxEquip = calcular_DxEquip(ExEquip, EyEquip) 'calculem l'increment DyEquip = calcular_DyEquip(ExEquip, EyEquip) array_equip(indice3) = PuntInicial 'afegim el punt a l'array de punts de la línia equip indice3 += 1 'ara el punt final passa a ser el punt inicial PuntInicial = New PointF(PuntInicial.X + DxEquip, PuntInicial.Y + DyEquip) 'el següent condicional és el de parar quan es "tanca" la línia If (indice3 > 1000 And ((PuntInicial.X - xi) ^ 2 + (PuntInicial.Y - yi) ^ 2) ^ 0.5 < 10) Then GrafEquip.DrawLine(PenlineasEquip, New PointF(PuntInicial.X + DxEquip, PuntInicial.Y + DyEquip), New PointF(xi, yi)) Exit Do End If Loop While indice3 < (200000) 'Nº d'iteracions a realitzar ReDim Preserve array_equip(indice3 - 1)


90

'Dibuixem la línia GrafEquip.DrawLines(PenlineasEquip, array_equip) ' Netegem PenlineasEquip.Dispose() End Sub #End Region #Region "DIBUIX DE LÍNEES EQUIPOTENCIALS INICIALS" Sub linees_equip_inicials() Dim xi As Single = 0 Dim yi As Single = 0 Dim puntinicial As PointF 'punt on comencem a dibuixar la lín equipot Dim indexmax As Integer = 0 Dim indexmin As Integer = 0 Dim minim As Double = VG.ArrayNQ(0) 'Trobem la Q mínima Dim imi As Integer = 0 For imi = 0 To VG.NQi If VG.ArrayNQ(imi) < minim Then minim = VG.ArrayNQ(imi) indexmin = imi End If Next Dim maxim As Double = VG.ArrayNQ(0) 'Trobem la Q máxima Dim ima As Integer = 0 For ima = 0 To VG.NQi If VG.ArrayNQ(ima) > maxim Then maxim = VG.ArrayNQ(ima) indexmax = ima End If Next 'mirem cap a on s'han de fer els increments de distància per unir les dues càrregues (max i min) Dim Pcalcmax As PointF Dim pcalcmin As PointF If VG.ArrayPosQ(indexmin).X > VG.ArrayPosQ(indexmax).X Then Pcalcmax.X = VG.ArrayPosQ(indexmax).X + 10 'comencem a dibuixar a partir d'una distància de 10 de la Q pcalcmin.X = VG.ArrayPosQ(indexmin).X - 10 Else Pcalcmax.X = VG.ArrayPosQ(indexmax).X - 10 'Al calcul li he dit que el V a les carregues és 0 pcalcmin.X = VG.ArrayPosQ(indexmin).X + 10 End If If VG.ArrayPosQ(indexmin).Y > VG.ArrayPosQ(indexmax).Y Then Pcalcmax.Y = VG.ArrayPosQ(indexmax).Y + 10 pcalcmin.Y = VG.ArrayPosQ(indexmin).Y - 10 Else Pcalcmax.Y = VG.ArrayPosQ(indexmax).Y - 10 pcalcmin.Y = VG.ArrayPosQ(indexmin).Y + 10 End If Dim max As Double = Calcular_Pot(Pcalcmax) 'Calculem V per la Qmax Dim min As Double = Calcular_Pot(pcalcmin) ' id. Qmin Dim incV As Double = 0 If Math.Sign(max) <> Math.Sign(min) Then ' Si la Qmax i la Qmin són de signe diferent


91

'Trobem la diferència de V, i l'increment de V si volem dibuixar 20 línies incV = (max - min) / 20 Dim arrayVdibE(20) As Double 'array dels diferents V que representarem Dim arrayPosVdibE(20) As PointF 'array dels punts de la recta que uneix les dues Q 'amb aquests valors de V arrayVdibE(0) = max arrayPosVdibE(0) = VG.ArrayPosQ(indexmax) Dim ii As Integer = 0 For ii = 1 To 20 'Creem l'array pels diferents V de cada línia que volem dibuixar arrayVdibE(ii) = arrayVdibE(ii - 1) - incV Next '----------Fins aquí tenim l'array dels potencials de les línies que volem dibuixar Dim Pn As PointF Dim pnX As Single = 0 Dim pnY As Single = 0 Dim incX As Single = 0 Dim incY As Single = 0 Dim jj As Integer = 0 incX = (VG.ArrayPosQ(indexmin).X - VG.ArrayPosQ(indexmax).X) / 200 'trobem l'increment de X per si volem dividir el segment en 200 parts incY = (VG.ArrayPosQ(indexmin).Y - VG.ArrayPosQ(indexmax).Y) / 200 'id (Y) pnX = Pcalcmax.X pnY = Pcalcmax.Y Dim arrayVdif(200) As Double 'array del valor de V a cada punt de la divisió del segment en 200 parts Dim arrayPdif(200) As PointF ' array del punts arrayPdif(0) = New PointF(pnX, pnY) arrayVdif(0) = (Calcular_Pot(arrayPdif(0))) Dim zz As Integer For zz = 1 To 200 'creem l'array de dels 100 punts, i l'array del V d'aquests 200 punts pnX += incX pnY += incY Pn = New PointF(pnX, pnY) arrayPdif(zz) = Pn 'array dels punts que hi ha entre min i max (en aquest cas 200) arrayVdif(zz) = (Calcular_Pot(Pn)) 'array del V dels punts anterios Next '-------Fins aquí trobem els punts intermedis i els valors de V d'aquests punts 'ara hem de veure a on coincideixen els V (20) que hem de dibuixar amb els V (200) dels punts de l'array Dim nn As Integer = 0 Dim xx As Integer = 0 Dim dif As Double = 0 For nn = 1 To 20 If arrayVdibE(nn) > 0 Then For xx = 1 To 200 If arrayVdibE(nn) = arrayVdif(xx) Then Call dib_linEquipot(arrayPdif(xx))


92

Exit For Else If arrayVdibE(nn) > arrayVdif(xx) Then Dim point As PointF = New PointF(arrayPdif(xx).X - incX / 2, arrayPdif(xx).Y - incY / 2) Call dib_linEquipot(point) Exit For Else Continue For End If End If Next Else For xx = 1 To 200 If arrayVdibE(nn) = arrayVdif(xx) Then Call dib_linEquipot(arrayPdif(xx)) Exit For Else If arrayVdibE(nn) < arrayVdif(xx) Then Continue For Else Dim point As PointF = New PointF(arrayPdif(xx).X - incX / 2, arrayPdif(xx).Y - incY / 2) Call dib_linEquipot(point) Exit For End If End If Next End If Next Else 'si les Q max i min són del mateix signe (o si només hi hagués una Q) If max > 0 Then Dim n1 As Integer For n1 = 0 To 20 xi = VG.ArrayPosQ(indexmax).X + 10 + Math.Exp(n1 / 4) yi = VG.ArrayPosQ(indexmax).Y + 10 + Math.Exp(n1 / 4) puntinicial = New PointF(xi, yi) Call dib_linEquipot(puntinicial) Next Else Dim n1 As Integer For n1 = 0 To 20 xi = VG.ArrayPosQ(indexmin).X + 10 + Math.Exp(n1 / 4) yi = VG.ArrayPosQ(indexmin).Y + 10 + Math.Exp(n1 / 4) puntinicial = New PointF(xi, yi) Call dib_linEquipot(puntinicial) Next End If End If End Sub #End Region #Region "DIBUIX LÍNEES DE FORÇA" Public Sub dibujar_lineasF(ByVal PInic As PointF, ByVal PInic_atras As PointF) Dim array_linF(30000) As PointF 'array línies de força Dim array_linFatras(30000) As PointF 'array línies de força "cap a enrera"


93

Dim indice2 As Integer = 0 Dim indice21 As Integer = 0 Do 'línies de força Ex = Calcular_Ex(PInic) Ey = Calcular_Ey(PInic) Dx = calcular_Dx(Ex, Ey) Dy = calcular_Dy(Ex, Ey) array_linF(indice2) = PInic indice2 += 1 PInic = New PointF(PInic.X + Dx, PInic.Y + Dy) Dim iter2 As Integer = 0 For iter2 = 0 To VG.ArrayNQ.Length - 1 'una condicio per sortir del bucle es que el punt inicial coincideixi amb una Q If PInic.X = VG.ArrayPosQ(iter2).X And PInic.Y <> VG.ArrayPosQ(iter2).Y Then Exit Do End If Next Loop While indice2 < 30000 Do 'línies de força "cap a enrera"(fen id que "cap a endavant" Ex = Calcular_Ex(PInic_atras) Ey = Calcular_Ey(PInic_atras) Dx = calcular_Dx(Ex, Ey) Dy = calcular_Dy(Ex, Ey) array_linFatras(indice21) = PInic_atras indice21 += 1 PInic_atras = New PointF(PInic_atras.X - Dx, PInic_atras.Y - Dy) Dim iter2 As Integer = 0 For iter2 = 0 To VG.ArrayNQ.Length - 1 If PInic_atras.X = VG.ArrayPosQ(iter2).X And PInic_atras.Y <> VG.ArrayPosQ(iter2).Y Then Exit Do End If Next Loop While indice21 < 30000 ReDim Preserve array_linF(indice2 - 1) ReDim Preserve array_linFatras(indice21 - 1) Dim Graf As Graphics = Me.PicBox0.CreateGraphics() 'Creem la tela on dibuixarem (Picbox0) Dim PenlineasCam As Pen 'creem els llapis amb els que pintarem les línees de força Dim PenlineasCamAtras As Pen If bool_linF_Inic = True Then 'si són les línies inicials, les pintarem més tènues PenlineasCam = New Pen(Color.FromArgb(100, Color.Green)) PenlineasCamAtras = New Pen(Color.FromArgb(100, Color.Green)) Else ' si són les que pintem individualment, les pintem més fortes PenlineasCam = New Pen(Color.Green, 1) PenlineasCamAtras = New Pen(Color.Green, 1) End If


94

' Creem el GraphicsPath per definir l'inici de línea per marcar la direcció de la línea de força Dim InV_path As New Drawing2D.GraphicsPath InV_path.AddLine(0, 0, 5, 15) InV_path.AddLine(0, 0, -5, 15) InV_path.AddLine(5, 15, -5, 15) ' Creem l'inici de línea per marcar la direcció de la línea de força Dim InV_cap As New Drawing2D.CustomLineCap(Nothing, InV_path) ' Creem el pen que farà servir aquest inici de linea Dim penInV As Pen penInV = PenlineasCam penInV.CustomStartCap = InV_cap Graf.DrawLine(penInV, array_linF(0).X, array_linF(0).Y, array_linF(20).X, array_linF(20).Y) 'dibuixem una línea molt petita que té l'inici com li hem dit Graf.DrawCurve(PenlineasCam, array_linF) 'dibuixem les línees de força "cap a endavant" Graf.DrawCurve(PenlineasCamAtras, array_linFatras) ' dibuixem les línees de força "cap a endarrera" ' Netegem penInV.Dispose() InV_path.Dispose() InV_cap.Dispose() PenlineasCam.Dispose() PenlineasCamAtras.Dispose() End Sub #End Region #Region "DIBUIX DE LÍNEES DE FORÇA INICIALS" Sub linees_força_inicials() Dim NLF As Integer '= 20 'nº de linies a dibuixar, he de fer un if per que varii segons el nº de q Dim ArrayNumLin(VG.NQi) As Integer 'array nº linies per càrrega Dim valtotal As Double = 0 Dim xiF As Single = 0 Dim yiF As Single = 0 Dim ximaxF As Single = 0 Dim yimaxF As Single = 0 Dim puntinicialF As PointF Dim tF As Integer = 0 Dim alfa As Double 'angle a cada quant possarem un punt inicial de linia de força Dim R As Single = 200 ' distancia desde la Q a la que comencem a dibuixar les línies de força '---------------------------------------------------------'mirem qui signe domina Dim ArrayNQPosit(VG.NQi) As Double Dim ArrayPosPosit(VG.NQi) As PointF Dim ArrayNQNeg(VG.NQi) As Double Dim ArrayPosNeg(VG.NQi) As PointF Dim ArrayNQDom(VG.NQi) As Double


95

Dim ArrayPosDom(VG.NQi) As PointF Dim SumTotal As Double = 0 Dim NQdom As Integer = 0 Dim nn As Integer = 0 For nn = 0 To VG.NQi If VG.ArrayNQ(nn) > 0 Then ArrayNQPosit(NQdom) = VG.ArrayNQ(nn) ArrayPosPosit(NQdom) = VG.ArrayPosQ(nn) Else ArrayNQNeg(NQdom) = VG.ArrayNQ(nn) ArrayPosNeg(NQdom) = VG.ArrayPosQ(nn) End If NQdom += 1 SumTotal += VG.ArrayNQ(nn) Next ReDim Preserve ArrayNQPosit(NQdom - 1) ReDim Preserve ArrayPosPosit(NQdom - 1) ReDim Preserve ArrayNQNeg(NQdom - 1) ReDim Preserve ArrayPosNeg(NQdom - 1) If SumTotal >= 0 Then ArrayNQPosit.CopyTo(ArrayNQDom, 0) ArrayPosPosit.CopyTo(ArrayPosDom, 0) Else ArrayNQNeg.CopyTo(ArrayNQDom, 0) ArrayPosNeg.CopyTo(ArrayPosDom, 0) End If ReDim Preserve ArrayNQDom(NQdom - 1) ReDim Preserve ArrayPosDom(NQdom - 1) '--------------------------------------------------------- Dim sF As Integer = 0 Dim rF As Integer = 0 For rF = 0 To ArrayNQDom.Length - 1 valtotal += Math.Abs(ArrayNQDom(rF)) Next Select Case NQdom - 1 'seleccionem quantes línees es dibuixaran inicialment Case 1 To 3 NLF = 12 Case 4 To 7 NLF = 18 Case 8 To 10 NLF = 20 End Select For sF = 0 To ArrayNQDom.Length - 1 'per saber el num de linies que hems de dibuixar per cada Q ArrayNumLin(sF) = Math.Ceiling((NLF) * Math.Abs(ArrayNQDom(sF) / valtotal)) Next If VG.NQi = 0 Then 'per quan només hi ha una Q Dim n1 As Integer For n1 = 1 To 8 xiF = VG.ArrayPosQ(VG.NQi).X + 100 * Math.Cos(0.78 * n1) yiF = VG.ArrayPosQ(VG.NQi).Y + 100 * Math.Sin(0.78 * n1) puntinicialF = New PointF(xiF, yiF) Call dibujar_lineasF(puntinicialF, puntinicialF) Next


96

Exit Sub End If Dim u As Integer = 0 For tF = 0 To NQdom - 1 alfa = 2 * Math.PI / ArrayNumLin(tF) 'dividim els 360 graus en el nº de línees corresponents For u = 1 To ArrayNumLin(tF) xiF = ArrayPosDom(tF).X + R * Math.Cos(u * alfa) yiF = ArrayPosDom(tF).Y + R * Math.Sin(u * alfa) puntinicialF = New PointF(xiF, yiF) Call dibujar_lineasF(puntinicialF, puntinicialF) Next Next End Sub #End Region #Region "CÀLCULS" Public Function Calcular_Pot(ByVal Punt As PointF) As Double Dim Vpunt As Double Dim VpuntQ As Double Dim v1 As Integer = 0 For v1 = 0 To VG.ArrayNQ.Length - 1 If (Punt.X = VG.ArrayPosQ(v1).X And Punt.Y = VG.ArrayPosQ(v1).Y) Then 'si coincideixen amb les càrregues VpuntQ = 0 Else 'V=k*q1/r1+...+ k*qn/rn VpuntQ = 9 * 10 ^ 9 * (VG.ArrayNQ(v1) / ((Punt.X - VG.ArrayPosQ(v1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(v1).Y) ^ 2) ^ 0.5) End If Vpunt = Vpunt + VpuntQ Next FormatNumber(Vpunt, 4) ' deixem el Potencial amb 4 decimals Return Vpunt End Function Public Function Calcular_Ex(ByVal Punt As PointF) As Double Dim Ex_punt As Double Dim Ex_puntQ As Double Dim ex1 As Integer = 0 For ex1 = 0 To VG.ArrayNQ.Length - 1 If (Punt.X = VG.ArrayPosQ(ex1).X And Punt.Y = VG.ArrayPosQ(ex1).Y) Then 'si coincideixen amb les càrregues Ex_puntQ = 0 Else 'Ex=k*q1*(x-xq1)/r1^3 +...+ k*qn*(x-xqn)/rn^3 Ex_puntQ = 9 * 10 ^ 9 * (VG.ArrayNQ(ex1) * (Punt.X - VG.ArrayPosQ(ex1).X) / ((Punt.X - VG.ArrayPosQ(ex1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(ex1).Y) ^ 2) ^ 1.5) End If Ex_punt = Ex_punt + Ex_puntQ Next Return Ex_punt End Function Public Function Calcular_Ey(ByVal Punt As PointF) As Double Dim Ey_punt As Double


97

Dim Ey_puntQ As Double Dim ey1 As Integer = 0 For ey1 = 0 To VG.ArrayNQ.Length - 1 If (Punt.X = VG.ArrayPosQ(ey1).X And Punt.Y = VG.ArrayPosQ(ey1).Y) Then 'si coincideixen amb les càrregues Ey_puntQ = 0 Else 'Ex=k*q1*(x-xq1)/r1^3 +...+ k*qn*(x-xqn)/rn^3 Ey_puntQ = 9 * 10 ^ 9 * (VG.ArrayNQ(ey1) * (Punt.Y - VG.ArrayPosQ(ey1).Y) / ((Punt.X - VG.ArrayPosQ(ey1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(ey1).Y) ^ 2) ^ 1.5) End If Ey_punt = Ey_punt + Ey_puntQ Next Return Ey_punt End Function Public Function calcular_DxEquip(ByVal E_x As Double, ByVal E_y As Double) As Single 'increment X al càlcul de les línies equipot Dim IncX As Single IncX = -1 * Increment * E_y / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncX End Function Public Function calcular_DyEquip(ByVal E_x As Double, ByVal E_y As Double) As Single 'increment Y al càlcul de les línies equipot Dim IncY As Single IncY = Increment * E_x / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncY End Function Public Function calcular_Dx(ByVal E_x As Double, ByVal E_y As Double) As Single 'increment X al càlcul de les línies de força Dim IncX As Single IncX = Increment * E_x / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncX End Function Public Function calcular_Dy(ByVal E_x As Double, ByVal E_y As Double) As Single 'increment Y al càlcul de les línies de força Dim IncY As Single IncY = Increment * E_y / (E_x ^ 2 + E_y ^ 2) ^ 0.5 Return IncY End Function #End Region #Region "CALCULS CÀRREGUES ESCALADES" Public Function Escalar_Q(ByVal Qi As Double) As Double 'Aquí s'escalen les càrregues. Per a dibuixar els vectors d'intensitat de camp "bé", les deixem de l'ordre dels microcoulombs Dim Qinic As Double = Qi Dim Qnew As Double Dim maxim = Math.Abs(VG.ArrayNQ(0)) 'trobem el màxim.Comencem supossant que és el primer número. Dim im As Integer = 0 For im = 0 To VG.NQi If Math.Abs(VG.ArrayNQ(im)) > maxim Then maxim = Math.Abs(VG.ArrayNQ(im)) End If Next


98

Qnew = Qi * 10 ^ (-4.5) / maxim Return Qnew End Function Public Function Calcular_ExEsc(ByVal Punt As PointF) As Double Dim Ex_punt As Double Dim Ex_puntQ As Double Dim ex1 As Integer = 0 For ex1 = 0 To ArrayNQ_esc.Length - 1 If (Punt.X = VG.ArrayPosQ(ex1).X And Punt.Y = VG.ArrayPosQ(ex1).Y) Then 'si coincideixen amb les Q Ex_puntQ = 0 Else 'Ex=k*q1*(x-xq1)/r1^3 +...+ k*qn*(x-xqn)/rn^3 Ex_puntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(ex1) * (Punt.X - VG.ArrayPosQ(ex1).X) / ((Punt.X - VG.ArrayPosQ(ex1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(ex1).Y) ^ 2) ^ 1.5) End If Ex_punt = Ex_punt + Ex_puntQ Next Return Ex_punt End Function Public Function Calcular_EyEsc(ByVal Punt As PointF) As Double Dim Ey_punt As Double Dim Ey_puntQ As Double Dim ey1 As Integer = 0 For ey1 = 0 To ArrayNQ_esc.Length - 1 If (Punt.X = VG.ArrayPosQ(ey1).X And Punt.Y = VG.ArrayPosQ(ey1).Y) Then 'si coincideixen amb les Q Ey_puntQ = 0 Else 'Ex=k*q1*(x-xq1)/r1^3 +...+ k*qn*(x-xqn)/rn^3 Ey_puntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(ey1) * (Punt.Y - VG.ArrayPosQ(ey1).Y) / ((Punt.X - VG.ArrayPosQ(ey1).X) ^ 2 + (Punt.Y - VG.ArrayPosQ(ey1).Y) ^ 2) ^ 1.5) End If Ey_punt = Ey_punt + Ey_puntQ Next Return Ey_punt End Function #End Region #Region "EVENTS AL PICBOX0 (GRAELLA)" Private Sub PicBox0_MouseClick(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PicBox0.MouseClick 'Aquí veiem els events que es donaran al fer click a sobre del PicBox0 (graella) bool_moureQ = False CType(PicBox0, PictureBox).BringToFront() If VG.ArrayNQ(0) <> 0 Then Dim PinicDib As PointF 'punt des d'on comencem a dibuixar (on cliquem) Dim xi As Single = e.X Dim yi As Single = e.Y Dim VPi As Double 'Potencial al punt on es clica


99

Dim exf, eyf, ef As Single 'per trobar el valor del camp electric al punt PinicDib = New PointF(xi, yi) 'punt inicial (on cliquem, on passem) VPi = Calcular_Pot(PinicDib) Potencial.Text = VPi.ToString("0.####E+00") 'li donem el format científic ReDim ArrayNQ_esc(VG.NQi) VG.ArrayNQ.CopyTo(ArrayNQ_esc, 0) ' Copiem l'array de Q Dim i As Integer For i = 0 To VG.NQi ArrayNQ_esc(i) = Escalar_Q(ArrayNQ_esc(i)) ' Anem a la rutina d'escalar les Càrregues Next If VPi = 0 Then PinicDib.X = PinicDib.X + 0.001 'per a que no doni problemes quan V val 0 Else PinicDib.X = xi End If exf = Calcular_ExEsc(PinicDib) eyf = Calcular_EyEsc(PinicDib) ef = (exf ^ 2 + eyf ^ 2) ^ 0.5 'mòdul escalat CampElecX.Text = exf.ToString("0.####E+00") CampElecY.Text = eyf.ToString("0.####E+00") CampElec.Text = ef.ToString("0.####E+00") Xbox.Text = e.X 'mostra les coordenades del mouse quan es clica al pictureBox YBox.Text = e.Y If bool_dib_lequip = True Then 'si el botó está clicat Call dib_linEquipot(PinicDib) 'cridem el procediment de dibuixar les linies equipot, passant a la rutina el punt inicial Call Copiar_Imatge_Pbox() 'Fem una "foto" del picbox0 End If If bool_dib_lf = True Then ' id linias de força Call dibujar_lineasF(PinicDib, PinicDib) Call Copiar_Imatge_Pbox() End If If bool_btn_ECamp = True And contador <> 0 Then 'si el botó està activat, al fer click al panel 'dibuixarà el vector i l'etiqueta amb la posició i E Dim fontA As Font = New Font("Arial", 6, FontStyle.Bold) Cursor = Cursors.Cross Dim PfinDib As PointF 'punt extrem del vector Dim Eptxt As String Dim grafVector As Graphics = PicBox0.CreateGraphics 'tela on pintarem el vector Dim penVector As Pen = New Pen(Color.DarkOrange, 2) 'color del vector penVector.StartCap = System.Drawing.Drawing2D.LineCap.Flat 'fletxa del vector Eptxt = ef.ToString("0.###E+00") 'etiqueta amb el valor E Dim Op As Integer = 20 Dim P As Double P = Op / ef


100

If ef < 20 Then 'si el vector té un módul<15 pixels, ' dibuixarem un vector de 15, no més petit, per a què es vegi exf = P * exf eyf = P * eyf End If PfinDib = New PointF(PinicDib.X + exf, PinicDib.Y + eyf) ' Creem el GraphicsPath per definir la fletxa------- Dim E_path As New Drawing2D.GraphicsPath E_path.AddLine(0, 0, 4, -4) E_path.AddLine(0, 0, -4, -4) ' Creem l'inici de línea per marcar la direcció de la línea de força Dim E_cap As New Drawing2D.CustomLineCap(Nothing, E_path) ' Creem el pen que farà servir aquest inici de linea Dim penE As Pen penE = penVector penE.CustomEndCap = E_cap Dim puntRect As Point 'rectangle de fons blau on escriurem l'etiqueta Dim rectangle1 As Rectangle Dim sizeRect As Size sizeRect = New Size(55, 20) If PinicDib.X > 640 Then 'situació de l'etiqueta (hem de veure que no quedi fora de la graella) If PinicDib.Y > 480 Then puntRect = New Point(PinicDib.X - 55, PinicDib.Y - 20) Else puntRect = New Point(PinicDib.X - 55, PinicDib.Y + 5) End If Else If PinicDib.Y > 480 Then puntRect = New Point(PinicDib.X + 5, PinicDib.Y - 20) Else puntRect = New Point(PinicDib.X + 5, PinicDib.Y + 5) End If End If PicBox0.Refresh() rectangle1 = New Rectangle(puntRect, sizeRect) grafVector.FillRectangle(Brushes.Aqua, rectangle1) 'pintem el rectangle blau grafVector.DrawString(PinicDib.ToString & Chr(10) & "|E|=" & Eptxt, fontA, Brushes.DarkSlateBlue, puntRect) ' pintem l'etiqueta grafVector.DrawLine(penE, PinicDib, PfinDib) 'dibuixem el vector ' Netegem penE.Dispose() E_path.Dispose() E_cap.Dispose() penVector.Dispose() End If Call Copiar_Imatge_Pbox() 'Fem una "foto" Else


101

MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "TOT SEGUIT PROCEDIREM A FER-HO", "INICI", MessageBoxButtons.OK, MessageBoxIcon.Warning) btn_Iniciar.PerformClick() End If End Sub Private Sub PicBox0_Mousemove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PicBox0.MouseMove 'Aquí veiem els events que es donaran quan movem el cursor per sobre del PicBox0 Dim Vpunt As Double Dim PuntCursor As Point = New Point(e.X, e.Y) 'Assignem al PuntCursor el valor de la posició del cursor al PicBox0 txtPosCursor.Text = PuntCursor.ToString 'mostrem la posició del cursor al picbox0 Vpunt = Calcular_Pot(PuntCursor) 'calculem el potencial en cada punt por on passa el cursor txtVposCursor.Text = Vpunt.ToString("0.####E+00") 'li donem format científic per a què no surti un nº molt gran If bool_dib_lf = True Or bool_dib_lequip = True Then Cursor = Cursors.Cross End If If bool_btn_ECamp = True Then Cursor = Cursors.Cross Dim PinicDib As PointF 'punt des d'on comencem a dibuixar (on cliquem, on passem) Dim PfinDib As PointF 'punt extrem del vector Dim exf, eyf As Single 'per trobar el valor del camp electric al punt Dim Ep As Double Dim grafVector As Graphics = PicBox0.CreateGraphics Dim penVector As Pen = New Pen(Color.DarkOrange, 2) penVector.StartCap = System.Drawing.Drawing2D.LineCap.Flat PinicDib = (PuntCursor) exf = Calcular_ExEsc(PinicDib) eyf = Calcular_EyEsc(PinicDib) Ep = (exf ^ 2 + eyf ^ 2) ^ 0.5 'mòdul csmp elect al punt Dim Op As Integer = 20 Dim P As Double P = Op / Ep If Ep < 20 Then 'si el vector té un módul<15 pixels, ' dibuixarem un vector de 15, no més petit, per a què es vegi exf = P * exf eyf = P * eyf End If PfinDib = New PointF(PinicDib.X + exf, PinicDib.Y + eyf) ' Creem el GraphicsPath per definir la fletxa------- Dim E_path As New Drawing2D.GraphicsPath E_path.AddLine(0, 0, 4, -4) E_path.AddLine(0, 0, -4, -4) ' Creem l'inici de línea per marcar la direcció de la línea de força Dim E_cap As New Drawing2D.CustomLineCap(Nothing, E_path) ' Creem el pen que farà servir aquest inici de linea


102

Dim penE As Pen penE = penVector penE.CustomEndCap = E_cap PicBox0.Refresh() grafVector.DrawLine(penE, PinicDib, PfinDib) 'dibuixem el vector ' Netegem penE.Dispose() E_path.Dispose() E_cap.Dispose() penVector.Dispose() End If End Sub Private Sub PicBox0_MouseLeave(ByVal sender As Object, ByVal e As System.EventArgs) Handles PicBox0.MouseLeave 'El que passarà al sortir del picbox0 Cursor = Cursors.Default 'el cursor serà retornarà a ser normal End Sub #End Region #Region "EVENTS ALS PICBOX'S (CÀRREGUES)" Private Sub PicBox_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles PBox_1.MouseEnter, PBox_2.MouseEnter, PBox_3.MouseEnter, PBox_4.MouseEnter, PBox_5.MouseEnter, PBox_6.MouseEnter, PBox_7.MouseEnter, PBox_8.MouseEnter, PBox_9.MouseEnter, PBox_10.MouseEnter 'Quan el cursor passa per sobre, es transforma en una mà, si el botó de moure està activat If bool_moureQ = True Then Cursor = a Else Exit Sub End If End Sub Private Sub Picbox_MouseLeave(ByVal sender As Object, ByVal e As System.EventArgs) Handles PBox_1.MouseLeave, PBox_2.MouseLeave, PBox_3.MouseLeave, PBox_4.MouseLeave, PBox_5.MouseLeave, PBox_6.MouseLeave, PBox_7.MouseLeave, PBox_8.MouseLeave, PBox_9.MouseLeave, PBox_10.MouseLeave 'Quan el cursor abandona el picbox Cursor = Cursors.Default End Sub Private Sub Picbox_click(ByVal sender As Object, ByVal e As System.EventArgs) Handles PBox_1.Click, PBox_2.Click, PBox_3.Click, PBox_4.Click, PBox_5.Click, PBox_6.Click, PBox_7.Click, PBox_8.Click, PBox_9.Click, PBox_10.Click 'Si fem clic a sobre If bool_dib_lf = True Or bool_dib_lequip = True Then MessageBox.Show("NO ES CONVENIENT QUE CLIQUIS A SOBRE DE LES CÀRREGUES!!!" & Chr(13) & Chr(13) & "PODRÍA DONAR LLOC A ERRORS O INDETERMINACIONS DEL RESULTAT", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Warning)


103

End If End Sub Private Sub Picbox_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PBox_1.MouseDown, PBox_2.MouseDown, PBox_3.MouseDown, PBox_4.MouseDown, PBox_5.MouseDown, PBox_6.MouseDown, PBox_7.MouseDown, PBox_8.MouseDown, PBox_9.MouseDown, PBox_10.MouseDown 'Aquí "agafem" amb el cursor el picbox per moure'l PicBox0.Refresh() 'per a què s'esborrin les línias Dim indexPB As Integer indexPB = PBox.IndexOf(sender) ' per saber de quin dels 10 picbox es tracta If bool_moureQ = True Then If e.Button = Windows.Forms.MouseButtons.Left Then dragging = True If dragging = True Then Cursor = Cursors.Hand End If mousex = sender.Location.X 'posició x on estava el pbox mousey = sender.Location.Y 'id y 'delimitem l'àrea per on es pot moure: Windows.Forms.Cursor.Clip = Me.RectangleToScreen(New Rectangle(PicBox0.Location.X, PicBox0.Location.Y, PicBox0.Width - 20, PicBox0.Height - 20)) puntmovi(indexPB) = New Point(mousex, mousey) 'punt inicial del Pbox 'Compte!! s'han de sumar 10 a la x i a la y, ja que la Q està al centre End If Else Exit Sub End If txtPosQ(indexPB).Text = "" 'esborrem l'etiqueta de la posició End Sub Private Sub Picbox_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PBox_1.MouseMove, PBox_2.MouseMove, PBox_3.MouseMove, PBox_4.MouseMove, PBox_5.MouseMove, PBox_6.MouseMove, PBox_7.MouseMove, PBox_8.MouseMove, PBox_9.MouseMove, PBox_10.MouseMove 'Aquí movem el picbox amb el cursor Dim indexPB As Integer indexPB = PBox.IndexOf(sender) ' per saber de quin dels 10 picbox es tracta If bool_moureQ = True Then If dragging Then Cursor = Cursors.Hand 'mou el pbox a la nova posició Dim MPosition As New Point() MPosition = Me.PointToClient(MousePosition) - PicBox0.Location 'assegura que el control no surt del contenidor picbox0 sender.Location = MPosition puntmovf(indexPB) = New Point(MPosition.X, MPosition.Y) 'punt final del picbox (de la càrrega) End If Else Exit Sub End If


104

End Sub Private Sub Picbox_MouseUp(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PBox_1.MouseUp, PBox_2.MouseUp, PBox_3.MouseUp, PBox_4.MouseUp, PBox_5.MouseUp, PBox_6.MouseUp, PBox_7.MouseUp, PBox_8.MouseUp, PBox_9.MouseUp, PBox_10.MouseUp 'Aquí deisem anar el picbox a la seva nova posició Dim indexPB As Integer indexPB = PBox.IndexOf(sender) ' per saber de quin dels 10 picbox es tracta If bool_moureQ = True Then If dragging Then Cursor = Cursors.Hand 'acabem amb el "dragging"(arrastre) dragging = False Windows.Forms.Cursor.Clip = Nothing PBox(indexPB).Invalidate() End If Else Exit Sub End If Dim i As Integer = 0 'Per no deixar una càrrega sobre una altra existent For i = 0 To 9 If (PBox(i).Visible = True) And i <> indexPB And (Math.Abs(PBox(indexPB).Location.X - PBox(i).Location.X) < 20 And Math.Abs(PBox(indexPB).Location.Y - PBox(i).Location.Y) < 20) Then 'condició: que l'altra càrrega sigui visible i que estigui "solapada" MessageBox.Show("LES CÀRREGUES NO PODEN ESTAR TAN APROP") PBox(indexPB).Location = puntmovi(indexPB) puntmovf(indexPB) = puntmovi(indexPB) End If Next VG.ArrayPosQ(indexPB) = New Point(puntmovf(indexPB).X + 10, puntmovf(indexPB).Y + 10) bool_btn_AddQ = False txtPosQ(indexPB).Text = VG.ArrayPosQ(indexPB).ToString Colors_btn() End Sub #End Region #Region "BOTONS CLICK" Private Sub btn_Iniciar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_Iniciar.Click 'Botó Iniciar PicBox0.Refresh() bool_Iniciar = True bool_linF_Inic = False bool_linEquip_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_btn_Campelec = False bool_btn_ECamp = False bool_btn_AddQ = False bool_btn_delQ = False


105

Dim i As Integer = 0 For i = 0 To 9 PBox(i).Visible = False Next Call Carregues() Call dib_cargas() Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Dim j As Integer = 0 For j = 0 To VG.NQi PBox(j).Enabled = True Next contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btnReinici_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles BtnReinici.Click 'Botó Reiniciar Form1_Load(sender, e) If bool_Iniciar = True Then PicBox0.Refresh() bool_linF_Inic = False bool_linEquip_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_moureQ = False bool_Iniciar = False bool_btn_Campelec = False bool_btn_ECamp = False bool_btn_AddQ = False bool_btn_delQ = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Dim i As Integer = 0 For i = 0 To 9 PBox(i).Visible = False Next Array.Clear(VG.ArrayNQ, 0, VG.ArrayNQ.Length) 'para netejar els valors i les posicions de les càrregues Array.Clear(VG.ArrayPosQ, 0, VG.ArrayNQ.Length) 'id Else 'si no s'han introduit les càrregues: Exit Sub End If If bool_btn_ECamp = True Then lblVCamp.Visible = True TrackBar1.Visible = True lblDVCamp.Visible = True TrackBar2.Visible = True Else lblVCamp.Visible = False TrackBar1.Visible = False lblDVCamp.Visible = False TrackBar2.Visible = False End If contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella


106

End Sub Private Sub btn_mov_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_mov.Click 'Botó Moure Càrrega If bool_Iniciar = True Then 'mirem si ja s'han introduit les carregues bool_moureQ = True PicBox0.Refresh() 'borra las lineas bool_linF_Inic = False bool_linEquip_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_btn_Campelec = False bool_btn_ECamp = False bool_btn_AddQ = False bool_btn_delQ = False TrackBar1.Visible = False lblVCamp.Visible = False lblDVCamp.Visible = False TrackBar2.Visible = False Colors_btn() 'anem a la rutina que canvia els colors dels botons Cursor = Cursors.Default Me.Refresh() Me.PicBox0.Image = Image.FromFile("c:\campelec\quadricula.png") PicBox0.Refresh() 'esborra les línees Dim i As Integer = 0 For i = 0 To VG.NQi PBox(i).Enabled = True 'per a que pugui moure els picbox Next Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_limplin_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_limplin.Click 'Botó Netejar Línies Me.PicBox0.Image = Nothing Me.PicBox0.Image = Image.FromFile("c:\campelec\quadricula.png") PicBox0.Refresh() If bool_Iniciar = True Then bool_linEquip_Inic = False bool_linF_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_moureQ = False bool_btn_Campelec = False bool_btn_ECamp = False bool_btn_AddQ = False bool_btn_delQ = False Colors_btn() 'anem a la rutina que canvia els colors dels botons Call dib_cargas()


107

Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If Dim j As Integer = 0 For j = 0 To VG.NQi PBox(j).Enabled = True Next If bool_btn_ECamp = True Then lblVCamp.Visible = True TrackBar1.Visible = True lblDVCamp.Visible = True TrackBar2.Visible = True Else lblVCamp.Visible = False TrackBar1.Visible = False lblDVCamp.Visible = False TrackBar2.Visible = False End If contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_LinEquip_Inic_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_LinEquip_Inic.Click 'Botó Dibuixar Línies Equipotencials Inicials btn_limplin.PerformClick() 'aquí ja mirarà si encara no s'han introduit càrregues, i activarà els pbox If bool_Iniciar = True Then bool_linEquip_Inic = True bool_linF_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_moureQ = False bool_btn_Campelec = False bool_btn_ECamp = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Call linees_equip_inicials() 'comptador += 1 Call Copiar_Imatge_Pbox() 'li fem la foto al picbox Else : Exit Sub End If contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_dib_lequip_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_dib_lequip.Click 'Botó Dibuixar Línies Equipotencials Individuals If bool_Iniciar = True Then bool_dib_lequip = True bool_linF_Inic = False bool_linEquip_Inic = False bool_dib_lf = False bool_moureQ = False bool_btn_Campelec = False


108

bool_btn_ECamp = False lblVCamp.Visible = False TrackBar1.Visible = False lblDVCamp.Visible = False TrackBar2.Visible = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If Dim j As Integer = 0 For j = 0 To VG.NQi PBox(j).Enabled = True Next contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_LinF_Inic_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_LinF_Inic.Click 'Botó Dibuixar Línies de Força Inicials btn_limplin.PerformClick() 'aquí ja mirarà si encara no s'han introduit càrregues, i activarà els pbox If bool_Iniciar = True Then bool_linF_Inic = True bool_linEquip_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_moureQ = False bool_btn_Campelec = False bool_btn_ECamp = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Call linees_força_inicials() Call Copiar_Imatge_Pbox() Else : Exit Sub End If contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_dib_lf_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_dib_lf.Click 'Botó Dibuixar Línies de Força Individuals If bool_Iniciar = True Then bool_dib_lf = True bool_linF_Inic = False bool_dib_lequip = False bool_linEquip_Inic = False bool_moureQ = False bool_btn_Campelec = False bool_btn_ECamp = False lblVCamp.Visible = False TrackBar1.Visible = False


109

lblDVCamp.Visible = False TrackBar2.Visible = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If Dim j As Integer = 0 For j = 0 To VG.NQi PBox(j).Enabled = True Next contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_Campelec_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_Campelec.Click 'Botó Dibuixar Camp Elèctric Inicial btn_limplin.PerformClick() 'aquí ja mirarà si encara no s'han introduit càrregues, i activarà els pbox If bool_Iniciar = True Then bool_btn_Campelec = True bool_dib_lf = False bool_linF_Inic = False bool_dib_lequip = False bool_linEquip_Inic = False bool_moureQ = False bool_btn_ECamp = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Call Camp_electric() Copiar_Imatge_Pbox() 'comptador += 1 If bool_btn_Campelec = True Then 'per a què mostri la barra lblVCamp.Visible = True TrackBar1.Visible = True lblDVCamp.Visible = True TrackBar2.Visible = True Else lblVCamp.Visible = False TrackBar1.Visible = False lblDVCamp.Visible = False TrackBar2.Visible = False End If Else : Exit Sub End If contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_ECamp_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_ECamp.Click


110

'Botó Dibuixar Vectors de Camp Elèctric Individuals If bool_Iniciar = True Then bool_btn_ECamp = True bool_dib_lf = False bool_linF_Inic = False bool_dib_lequip = False bool_linEquip_Inic = False bool_moureQ = False bool_btn_Campelec = False lblVCamp.Visible = False TrackBar1.Visible = False lblDVCamp.Visible = False TrackBar2.Visible = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If Dim j As Integer = 0 For j = 0 To VG.NQi PBox(j).Enabled = False Next Call PicBox0_MouseClick(sender, e) 'per a que quan entrem ja ens mostri el vector per on passem (si no ho fem així, fins que no cliquem, no comença a mostrar-ho) contador += 1 'var per a que no pinti quan enviï aquest event End Sub Private Sub btn_AddQ_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_AddQ.Click 'Botó Afegir Càrrega If VG.NQi = 9 And VG.ArrayNQ(0) <> 0 Then MessageBox.Show("JA HAS ARRIBAT AL MÀXIM DE CÀRREGUES PERMESES (10)", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Information) ', MessageBoxDefaultButton.Button3, MessageBoxOptions.ServiceNotification, ) Exit Sub End If If VG.ArrayNQ(0) = 0 Then btn_limplin.PerformClick() 'Form1_Load(sender, e) 'Exit Sub End If If bool_Iniciar = True Then bool_btn_AddQ = True bool_btn_Campelec = False bool_dib_lf = False bool_linF_Inic = False bool_dib_lequip = False bool_linEquip_Inic = False bool_openF = False bool_btn_delQ = False


111

Call Colors_btn() 'anem a la rutina que canvia els colors dels botons Else 'si no s'han introduit les càrregues: Exit Sub End If Call btn_limplin.PerformClick() Dim valorQ As String Do valorQ = InputBox("INTRODUEIX EL VALOR DE Q" & (VG.NQi + 2) & ":" & " (en Coulombs)" & Chr(13) & Chr(13) & "ATENCIÓ!!! SI INTRODUEIXES DECIMALS, HAS DE FER SERVIR LA COMMA EN LLOC DEL PUNT!!!", "VALORS DE LES CÀRREGUES", "-1", 200, 500) If valorQ = "" Then bool_btn_AddQ = False : Call Colors_btn() : Exit Sub 'per si cancelen Loop While IsNumeric(valorQ) = False 'por si no entren un nº If valorQ = 0 Then MessageBox.Show("ÉS ABSURD QUE EL VALOR DE LA CÀRREGA SIGUI ZERO", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Exclamation) bool_btn_AddQ = False Call Colors_btn() Exit Sub End If VG.NQi += 1 ReDim Preserve VG.ArrayNQ(VG.NQi) ReDim Preserve VG.ArrayPosQ(VG.NQi) VG.ArrayNQ(VG.NQi) = CDbl(valorQ) Call dib_cargas() VG.ArrayPosQ(VG.NQi) = New Point(15, 30 * VG.NQi + 20) PBox(VG.NQi).Visible = True PBox(VG.NQi).Location = New Point(5, 30 * VG.NQi + 10) PBox(VG.NQi).BringToFront() lblQ(VG.NQi).Visible = True lblPosQ(VG.NQi).Visible = True txtQ(VG.NQi).Visible = True txtPosQ(VG.NQi).Visible = True txtQ(VG.NQi).Text = VG.ArrayNQ(VG.NQi).ToString & " C" txtPosQ(VG.NQi).Text = VG.ArrayPosQ(VG.NQi).ToString MessageBox.Show("COL·LOCA LA CÀRREGA ON VULGUIS") bool_moureQ = True 'per permetre moure la càrrega afegida contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btn_delQ_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_delQ.Click 'Botó Esborrar Càrrega If bool_Iniciar = True Then If VG.NQi = 0 Then MessageBox.Show("JA NOMÉS QUEDA UNA CÀRREGA, PER A QUÈ VOLS ESBORRAR-LA?", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub Else


112

bool_btn_delQ = True bool_btn_Campelec = False bool_dib_lf = False bool_linF_Inic = False bool_dib_lequip = False bool_linEquip_Inic = False bool_moureQ = False 'per permetre moure la càrrega afegida bool_openF = False bool_btn_AddQ = False Dim indextxt As String Dim index As Integer Do indextxt = InputBox("INTRODUEIX EL NÚMERO DE LA CÀRREGA QUE VOLS ESBORRAR?", "ESBORRAR CÀRREGA", VG.NQi + 1, 400, 500) If indextxt = "" Then bool_btn_delQ = False : Exit Sub Loop While IsNumeric(indextxt) = False 'per si cliquen cancelar o no és un número While indextxt < 1 Or indextxt > VG.NQi + 1 MessageBox.Show("EL NÚMERO HA DE COINCIDIR AMB L'ÍNDEX D'ALGUNA DE LES CÀRREGUES", "ERROR AL INTRODUIR EL NÚMERO", MessageBoxButtons.OK, MessageBoxIcon.Stop) Do indextxt = (InputBox("INTRODUEIX EL NÚMERO DE LA CÀRREGA QUE VOLS ESBORRAR?", "ESBORRAR CÀRREGA", VG.NQi + 1, 200, 500)) If indextxt = "" Then bool_btn_delQ = False : Exit Sub Loop While IsNumeric(indextxt) = False 'index = "" Or End While index = CInt(indextxt) - 1 btn_limplin.PerformClick() Call DeleteQ(index) End If Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If bool_btn_delQ = False Call Colors_btn() 'anem a la rutina que canvia els colors dels botons contador = 0 'var per que no pinti l'etiqueta quan cliquem a la graella End Sub Private Sub btnClose_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnClose.Click 'Botó Sortir Application.Exit() End Sub #End Region #Region "COLORS BOTONS"


113

Public Sub Colors_btn() 'Per a què els botons tinguin un color o un altre, depenent de si estan activats o no If bool_linF_Inic = True Then btn_LinF_Inic.BackColor = Color.Orange Else btn_LinF_Inic.BackColor = Color.Gainsboro End If If bool_linEquip_Inic = True Then btn_LinEquip_Inic.BackColor = Color.Orange Else btn_LinEquip_Inic.BackColor = Color.Gainsboro End If If bool_dib_lf = True Then btn_dib_lf.BackColor = Color.Orange Else btn_dib_lf.BackColor = Color.Gainsboro End If If bool_dib_lequip = True Then btn_dib_lequip.BackColor = Color.Orange Else btn_dib_lequip.BackColor = Color.Gainsboro End If If bool_moureQ = True Then btn_mov.BackColor = Color.Orange Else btn_mov.BackColor = Color.Gainsboro End If If bool_Iniciar = True Then btn_Iniciar.BackColor = Color.Orange Else btn_Iniciar.BackColor = Color.Gainsboro End If If bool_btn_Campelec = True Then btn_Campelec.BackColor = Color.Orange Else btn_Campelec.BackColor = Color.Gainsboro End If If bool_btn_AddQ = True Then btn_AddQ.BackColor = Color.Orange Else btn_AddQ.BackColor = Color.Gainsboro End If If bool_btn_delQ = True Then btn_delQ.BackColor = Color.Orange Else btn_delQ.BackColor = Color.Gainsboro End If If bool_btn_ECamp = True Then btn_ECamp.BackColor = Color.Orange Else btn_ECamp.BackColor = Color.Gainsboro End If End Sub


114

#End Region #Region "OBRIR / GUARDAR / IMPRIMIR" 'Botó Nova Presentació: per començar una nova presentació Private Sub NuevoToolStripButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles NuevoToolStripButton.Click Call btn_Iniciar.PerformClick() bool_moureQ = True End Sub 'Botó Guardar: per guardar en un arxiu de text les carregues (amb un dialeg) Private Sub GuardarToolStripButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles GuardarToolStripButton.Click If bool_Iniciar = True Then Dim dlAbrir As System.Windows.Forms.SaveFileDialog = SaveFDialog 'propietats del diàleg per obrir l'arxiu dlAbrir.Filter = "Arxius de Text (*.txt)|*.txt|" & "Tots els Arxius (*.*)|*.*" dlAbrir.CheckFileExists = False dlAbrir.OverwritePrompt = True dlAbrir.Title = "Guardar Arxiu" dlAbrir.InitialDirectory = "C:\Campelec" dlAbrir.ShowDialog() If dlAbrir.FileName <> "" Then Dim fichero As New System.IO.StreamWriter(dlAbrir.FileName) Dim i As Integer = 0 For i = 0 To VG.NQi fichero.WriteLine(VG.ArrayNQ(i).ToString) fichero.WriteLine(VG.ArrayPosQ(i).X.ToString) fichero.WriteLine(VG.ArrayPosQ(i).Y.ToString) Next fichero.Close() End If Else 'si no s'han introduit les càrregues: MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA!" & Chr(13) & Chr(13) & "PREM EL BOTÓ D'INICIAR O CLICA AL PANEL!", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning) Exit Sub End If End Sub 'Botó Obrir: per llegir el valor de les càrregues enmagatzemades Private Sub AbrirToolStripButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles AbrirToolStripButton.Click bool_openF = True Dim oOpenFileDialog As OpenFileDialog = OpenFDialog Dim oStreamReader As StreamReader Dim sCargas As String Dim sX As String Dim sY As String ReDim VG.ArrayNQ(9) ReDim VG.ArrayPosQ(9)


115

With oOpenFileDialog 'propietats del diàleg per obrir l'arxiu .DefaultExt = "txt" .Filter = "txt files (*.txt)|*.txt" .InitialDirectory = "C:\Campelec" End With If oOpenFileDialog.ShowDialog = Windows.Forms.DialogResult.Cancel Then Exit Sub oStreamReader = New StreamReader(oOpenFileDialog.FileName) Dim i, j, z As Integer 'variables per passar els valors de l'arxiu Dim cargas(29) As Double 'Qi Dim posX(9) As Single 'Qi.x Dim posY(9) As Single 'Qi.y For i = 0 To 27 Step 3 sCargas = oStreamReader.ReadLine() sX = oStreamReader.ReadLine() sY = oStreamReader.ReadLine() cargas(i) = sCargas cargas(i + 1) = sX cargas(i + 2) = sY Next z = 0 For j = 0 To 27 Step 3 If cargas(j) = 0 Then Exit For 'per a què surti quan ja no hagi més càrregues Else VG.ArrayNQ(z) = cargas(j) VG.ArrayPosQ(z) = New PointF(cargas(j + 1), cargas(j + 2)) z += 1 End If Next ReDim Preserve VG.ArrayNQ(z - 1) 'redimensionem els array de Q i posicions ReDim Preserve VG.ArrayPosQ(z - 1) oStreamReader.Close() 'tanquen l'objecte streamreader Form1_Load(sender, e) 'tornem a carregar el formulari bool_Iniciar = True ' per a què hagi constància de que s'ha iniciat i quan cliquem al panel no demani les Q bool_moureQ = False 'per poder moure les Q si volem bool_linF_Inic = False bool_linEquip_Inic = False bool_dib_lequip = False bool_dib_lf = False bool_btn_Campelec = False bool_btn_ECamp = False bool_btn_AddQ = False bool_btn_delQ = False VG.NQi = (z - 1) 'si no li donem el valor, compta que VG.NQi=0 Call Colors_btn() Call dib_cargas() 'demanem que pinti les càrregues


116

End Sub 'Botó Imprimir: Imprimirà la graella, amb una previsualitació (inclou les tres rutines següents) Private Sub ImprimirToolStripButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles ImprimirToolStripButton.Click Call guardar_imatge() 'Ara tenim a la variable bm una foto de la regió que li hem dit Dim oprintdoc As System.Drawing.Printing.PrintDocument = PrintDoc Dim PrintPrevisDialeg As System.Windows.Forms.PrintPreviewDialog = PrintPreviewDialogDoc 'li diem a aPresvisualitzador quin és el document que ha de mostrar PrintPrevisDialeg.Document = oprintdoc 'li diem quin nom li ha de donar al doc que imprimeix oprintdoc.DocumentName = "c:\Campelec\Grafic.png" ' Li indiquem a l'objecte PrintDocument (oprintdoc) l'event que s'executarà al ' previsualitzar la graella a l'objeto PrintPreviewDialog (PrintPrevisDialeg) ' L'event es PrintPage i està representat per ImprimirGrafica AddHandler oprintdoc.PrintPage, AddressOf Me.ImprimirGrafica PrintPrevisDialeg.ShowDialog() PrintPrevisDialeg.MinimizeBox = False PrintPrevisDialeg.MaximizeBox = False PrintPrevisDialeg.Height = Me.Height - 100 'estableix l'alt de la finestra que contindrà la previsualització PrintPrevisDialeg.Width = Me.Width - 100 'id. ample PrintPrevisDialeg.StartPosition = FormStartPosition.CenterScreen ' Indica al PrintPreviewDialog quin és el document que imprimirà PrintPrevisDialeg.PrintPreviewControl.Zoom = 0.5 ' Ara obrirà el diàleg d'impresió per a escollir la impresora 'i si acceptem, llavors imprimirà If PrintDocDialog.ShowDialog = Windows.Forms.DialogResult.OK Then If PrintPrevisDialeg.ShowDialog = Windows.Forms.DialogResult.Yes Then oprintdoc.Print() Else Exit Sub End If Else Exit Sub End If End Sub Private Sub ImprimirGrafica(ByVal sender As System.Object, ByVal ePrint As PrintPageEventArgs) ePrint.Graphics.DrawImage(Image.FromFile("c:\Campelec\grafic.png"), Me.PicBox0.Location.X - 270, Me.PicBox0.Location.Y) ePrint.HasMorePages = False End Sub Public Sub guardar_imatge() 'primer creem una imatge de lo que volem imprimir ' Capturar tota l'àrea del picbox0, i una mica més


117

Dim gr As Graphics = Me.PicBox0.CreateGraphics ' Creem el bitmap amb l'àrea (ample i alt) que anem a capturar ' Un objecte Graphics a partir del bitmap Dim bm As New Bitmap(PicBox0.Width + 300, PicBox0.Height + 90, gr) Dim gr2 As Graphics = Graphics.FromImage(bm) ' Copiar l'àrea de la pantalla del tamany que li hem dit, a partir del punt que li direm ara Dim fsize As Size = bm.Size Me.BackColor = Color.White Me.Refresh() gr2.CopyFromScreen(Me.PicBox0.Location.X - 270, Me.PicBox0.Location.Y - 40, 0, 0, fsize) bm.RotateFlip(RotateFlipType.Rotate270FlipNone) 'girem la imatge per a deixar-la vertical bm.Save("c:\Campelec\Grafic.png", Imaging.ImageFormat.Png) 'salvarà la selecció de pantalla que li hem dit en aquest arxiu gr.Dispose() gr2.Dispose() Me.BackColor = Color.Beige Me.Refresh() End Sub #End Region #Region "BOTONS GRÀFICA 3D I GAUSS" Private Sub btn_Gauss_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_Gauss.Click 'Botó Comprovació Teorema de Gauss If VG.ArrayNQ.Length = 0 Or VG.ArrayNQ(0) = 0 Then MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub Else Call EsborraArxiu("C:\Campelec\FotoGraella1.png") 'esborrem al imatge que hi havia pel fons de la graella FotoGraella = "C:\Campelec\FotoGraella1.png" ' creem la nova imatge pel fons de la graella de Gauss Call Imatge(FotoGraella) Gauss.Show() End If End Sub Private Sub btnGrafica_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnGrafica.Click 'Botó Obrir Gràfica 3D If VG.ArrayNQ.Length = 0 Or VG.ArrayNQ(0) = 0 Then MessageBox.Show("ENCARA NO HAS INTRODUIT CAP CÀRREGA", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub Else Call EsborraArxiu("C:\Campelec\FotoGraella2.png") FotoGraella = "C:\Campelec\FotoGraella2.png" Call Imatge(FotoGraella) Grafica.Show() End If End Sub


118

Public Sub EsborraArxiu(ByVal FilePath As String) Kill(FilePath) 'esborra l'arxiu que està al path que li passem End Sub Public Function Imatge(ByVal Path As String) As Image 'creem una imatge per a posar-la de fons al form gauss o al 3d Dim NomArxiu As String = Path ' Capturar l'àrea del picbox Dim gr As Graphics = Me.PicBox0.CreateGraphics ' Creamos el bitmap con el área (ancho y alto) que vamos a capturar ' Un objeto Graphics a partir del bitmap Dim fSize As Size = PicBox0.Bounds.Size 'area que vamos a capturar ' Creamos el bitmap con el área que vamos a capturar Dim bm As New Bitmap(fSize.Width, fSize.Height, gr) Dim gr2 As Graphics = Graphics.FromImage(bm) ' Copiar el área de la pantalla del tamaño que le hemos dicho, ' a partir del punto que le decimos ahora gr2.CopyFromScreen(Me.PicBox0.Location.X, Me.PicBox0.Location.Y + 26, 0, 0, fSize) bm.Save(NomArxiu, Imaging.ImageFormat.Png) 'salvarà la selecció de pantalla que li hem dit en aquest arxiu gr.Dispose() gr2.Dispose() Return bm End Function Public Sub Copiar_Imatge_Pbox() 'primer creem una imatge per a posar-la de fons al picbox0(graella) ' Capturar l'àrea del picbox Dim gr As Graphics = Me.PicBox0.CreateGraphics ' Creem el bitmap amb l'àrea (ample i alt) que anem a capturar ' Un objecte Graphics a partir del bitmap Dim fSize As Size = PicBox0.Bounds.Size 'area que vamos a capturar ' Creamos el bitmap con el área que vamos a capturar Dim bm As New Bitmap(fSize.Width, fSize.Height, gr) Dim gr2 As Graphics = Graphics.FromImage(bm) ' Copiar l'àrea de la pantalla del tamany que li hem dit, a partir del punt que li direm ara gr2.CopyFromScreen(Me.PicBox0.Location.X, Me.PicBox0.Location.Y + 26, 0, 0, fSize) ' Assignem la imatge al PictureBox Me.PicBox0.Image = bm gr.Dispose() gr2.Dispose() End Sub #End Region End Class


119

6.2.2 Codi Pantalla Comprovació Teorema de Gauss (“Gauss”)

Imports System.Drawing.Drawing2D Imports System.Data Public Class Gauss #Region "VARIABLES" Dim PuntP As PointF Dim comptadorP As Integer Dim ArrayPunts(300) As PointF Dim ArrayEx(300) As Double Dim ArrayEy(300) As Double Dim arrayfluxInic(300) As Double ' fluxes dels punts clicats Dim ArrayFlux(300) As Double 'id. punts creats automàtics Dim Qinteriors(9) As Double Dim QinteriorsTot As Double Dim fluxTotInic As Double 'sumatori dels fluxes calculats amb els punts clicats Dim fluxTot As Double 'id. punts creats automàtics Dim lblQ As New ControlArray("lblQ") Dim bool_btn_ClickPunts As Boolean = False Dim Tabla As New DataTable 'creem la taula on guardarem les dades que ens interessen Dim m_Excel As Excel.Application 'per a poder guardar les dades de la taula en un doc excel '--------------------------------------per la taula dels punts trobats automàticament Dim tabla2 As New DataTable Dim arrayNewP(100000) As PointF Dim E_x(100000) As Double Dim E_y(100000) As Double Dim ComptAutom As Integer = 0 '-------------------------------------- #End Region #Region "CLASE ARRAY DE CONTROLS" 'És la mateixa que al formular Campelec ' Colecció d'objectes de tipus Control Public Class ControlArray Inherits CollectionBase Private mNombre As String Public Sub New() MyBase.New() End Sub Public Sub New(ByVal elNombre As String) MyBase.New() mNombre = elNombre End Sub Public Function Add(ByVal ctrl As Control) As Integer Return MyBase.List.Add(ctrl)


120

End Function Public Sub AsignarControles(ByVal ctrls As Control.ControlCollection, _ Optional ByVal elNombre As String = "") If elNombre = "" Then elNombre = mNombre End If If elNombre = "" Then Throw New ArgumentException("No se ha indicado el nombre base de los controles") Exit Sub End If Me.Clear() asignarLosControles(ctrls, elNombre) Me.Reorganizar() End Sub Private Sub asignarLosControles( _ ByVal ctrls As Control.ControlCollection, _ ByVal elNombre As String) Dim ctr As Control For Each ctr In ctrls asignarLosControles(ctr.Controls, elNombre) If ctr.Name.IndexOf(elNombre) > -1 Then Me.Add(ctr) End If Next End Sub Public Function Contains(ByVal ctrl As Control) As Boolean List.Contains(ctrl) End Function Public Function IndexOf(ByVal ctrl As Control) As Integer Return List.IndexOf(ctrl) End Function Public Function Index(ByVal name As String) As Integer Dim ctrl As Control Dim i As Integer Dim hallado As Integer = -1 For i = 0 To List.Count - 1 ctrl = CType(List(i), Control) If StrComp(ctrl.Name, name, CompareMethod.Text) = 0 Then hallado = i Exit For End If Next Return hallado End Function Public Function Index(ByVal ctrl As Control) As Integer Dim i As Integer i = ctrl.Name.LastIndexOf("_") If i = -1 Then i = List.IndexOf(ctrl) Else i = CInt(ctrl.Name.Substring(i + 1)) End If Return i End Function Public Sub Insert(ByVal index As Integer, ByVal ctrl As Control) List.Insert(index, ctrl) End Sub Default Public Property Item(ByVal index As Integer) As Control


121

Get Return CType(List.Item(index), Control) End Get Set(ByVal Value As Control) List.Item(index) = Value End Set End Property Default Public Property Item(ByVal name As String) As Control Get Dim index As Integer = Me.Index(name) If index = -1 Then End If Return CType(List.Item(index), Control) End Get Set(ByVal Value As Control) Dim index As Integer = Me.Index(name) If index = -1 Then index = Me.Add(Value) End If List.Item(index) = Value End Set End Property Default Public Property Item(ByVal ctrl As Control) As Control Get Return CType(List(Me.IndexOf(ctrl)), Control) End Get Set(ByVal Value As Control) List(Me.IndexOf(ctrl)) = Value End Set End Property Public Property Nombre() As String Get Return mNombre End Get Set(ByVal Value As String) mNombre = Value End Set End Property Public Sub Remove(ByVal ctrl As Control) List.Remove(ctrl) End Sub Public Sub Reorganizar() Dim ca As New ControlArray() Dim ctr As Control Dim i As Integer For i = 0 To Me.Count For Each ctr In Me If i = Me.Index(ctr) Then ca.Add(ctr) Exit For End If Next Next Me.Clear() For Each ctr In ca Me.Add(ctr) Next End Sub End Class #End Region


122

#Region "INICIAR I PAINT" Private Sub Gauss_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Call reiniciar() End Sub Private Sub gauss_paint(ByVal sender As Object, ByVal e As System.Windows.Forms.PaintEventArgs) Handles Me.Paint Dim grafica As Graphics = Me.CreateGraphics 'dibuixem la part exterior de la gràfica Dim penGrafica As New Pen(Color.Black, 2) Dim penEixos As New Pen(Color.Black, 5) penEixos.EndCap = LineCap.DiamondAnchor Dim fontA As Font = New Font("Arial", 8, FontStyle.Regular) Dim fontB As Font = New Font("Arial", 12, FontStyle.Regular) Dim i As Integer For i = 0 To 10 grafica.DrawLine(penGrafica, PicBox0G.Location.X, PicBox0G.Location.Y + i * 50, PicBox0G.Location.X - 10, PicBox0G.Location.Y + i * 50) grafica.DrawLine(penGrafica, PicBox0G.Location.X + 700, PicBox0G.Location.Y + i * 50, PicBox0G.Location.X + 710, PicBox0G.Location.Y + i * 50) grafica.DrawString(i * 50, fontA, Brushes.Black, PicBox0G.Location.X - 40, PicBox0G.Location.Y + i * 50 - 10) Next Dim j As Integer For j = 0 To 14 grafica.DrawLine(penGrafica, PicBox0G.Location.X + j * 50, PicBox0G.Location.Y, PicBox0G.Location.X + j * 50, PicBox0G.Location.Y - 10) grafica.DrawLine(penGrafica, PicBox0G.Location.X + j * 50, PicBox0G.Location.Y + 500, PicBox0G.Location.X + j * 50, PicBox0G.Location.Y + 510) grafica.DrawString(j * 50, fontA, Brushes.Black, PicBox0G.Location.X + j * 50 - 10, PicBox0G.Location.Y - 30) Next grafica.DrawString("[m]", fontA, Brushes.Black, PicBox0G.Location.X - 40, PicBox0G.Location.Y - 30) grafica.DrawLine(penEixos, PicBox0G.Location.X - 50, PicBox0G.Location.Y - 40, PicBox0G.Location.X - 50, PicBox0G.Location.Y + 60) grafica.DrawLine(penEixos, PicBox0G.Location.X - 50, PicBox0G.Location.Y - 40, PicBox0G.Location.X + 60, PicBox0G.Location.Y - 40) grafica.DrawString("X", fontB, Brushes.Black, PicBox0G.Location.X + 50, PicBox0G.Location.Y - 60) grafica.DrawString("Y", fontB, Brushes.Black, PicBox0G.Location.X - 70, PicBox0G.Location.Y + 50) grafica.DrawRectangle(Pens.Black, PicBox0G.Location.X - 1, PicBox0G.Location.Y - 1, 701, 501) penEixos.Dispose() penGrafica.Dispose() fontA.Dispose() fontB.Dispose() End Sub


123

Public Sub reiniciar() PicBox0G.Image = Nothing PicBox0G.Refresh() PicBox0G.Image = Image.FromFile("C:\CAMPELEC\FotoGraella1.png") PicBox0G.Refresh() DataHora.Text = Format(Date.Now, "dd/MM/yy; hh:mm tt") ToolTip1G.InitialDelay = 50 ToolTip1G.BackColor = Color.Aquamarine ToolTip1G.IsBalloon = True lblQ.AsignarControles(Me.Controls) 'creem l'array de labels Dim labelQ As Label Dim i As Integer = 0 For Each labelQ In lblQ lblQ(i).Visible = False i = i + 1 Next lblTitolQ.Visible = False lblFlux.Visible = False lblFluxTeo.Visible = False lblSumaQi.Visible = False lblNoQi.Visible = False comptadorP = 0 'per tornar a comptar els punts que s'introdueixen QinteriorsTot = 0 'id per les Q interiors fluxTot = 0 ' bool_Stop_Punts = False bool_btn_ClickPunts = False Tabla.Columns.Clear() 'Netejem la taula, per a poder introduir nous punts Tabla.Rows.Clear() 'S'han d'esborrar també les columnes tabla2.Columns.Clear() 'Netejem la taula, per a poder introduir nous punts tabla2.Rows.Clear() 'S'han d'esborrar també les columnes Array.Clear(ArrayPunts, 0, ArrayPunts.Length) 'per netejar els valors i les posicions de les Q Array.Clear(ArrayEx, 0, ArrayEx.Length) Array.Clear(ArrayEy, 0, ArrayEy.Length) Array.Clear(ArrayFlux, 0, ArrayFlux.Length) Array.Clear(arrayNewP, 0, arrayNewP.Length) Array.Clear(E_x, 0, E_x.Length) Array.Clear(E_y, 0, E_y.Length) ComptAutom = 0 ReDim Qinteriors(9) End Sub #End Region #Region "BOTONS INTRODUIR PUNTS/CALCULAR I CLICAR ELS PUNTS A LA GRÀFICA" Private Sub btn_ClickPunts_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_ClickPunts.Click 'Botó introduir punts punts Call reiniciar() bool_btn_ClickPunts = True


124

comptadorP = 0 MessageBox.Show("INTRODUEIX ELS PUNTS QUE CONFORMARAN L'ÀREA CLICANT AL PANEL. TINGUES EN COMPTE QUE, PER A NO OBTENIR RESULTATS ERRONIS, HAS D'ANAR SEMPRE EN SENTIT HORARI", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) colors_botons() End Sub Private Sub Stop_Punts(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Calcular_Flux.Click 'Botó calcular 'parem d'introduir punts i comença a calcular If bool_btn_ClickPunts = False Then MessageBox.Show("ENCARA NO HAS DEFINIT UNA ÀREA PER A CALCULAR EL FLUX", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub Else If comptadorP < 3 Then MessageBox.Show("PER DEFINIR UNA ÀREA, NECESSITES ALMENYS TRES PUNTS...CONTINUA", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub End If End If bool_btn_ClickPunts = False Call Calculs_Arrays() Call colors_botons() End Sub Private Sub PicBox0G_MouseClick1(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles PicBox0G.MouseClick 'Cicar a la graella introduint els punts ReDim Preserve ArrayPunts(300) If bool_btn_ClickPunts = True Then PuntP = New PointF(e.X, e.Y) Dim Graf As Graphics = Me.PicBox0G.CreateGraphics() 'Creem la tela on dibuixarem (Picbox0) Dim PenPunts As Pen 'creem els llapis amb els que pintarem els punts PenPunts = New Pen(Color.Red, 3) Graf.DrawEllipse(PenPunts, PuntP.X - 1, PuntP.Y - 1, 2, 2) 'cada vegada que dibuixem un punt, fem una "foto" ArrayPunts(comptadorP) = PuntP Copiar_Imatge_PboxG() PicBox0G.Refresh() comptadorP += 1 If comptadorP > 299 Then MessageBox.Show("ENCARA NO T'HAS CANSAT D'INTRIDUIR PUNTS??? AMB 300 JA N'HIHA DE SOBRES!!!!", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) Call Calculs_Arrays() End If End If Call colors_botons() End Sub


125

#End Region #Region "CÀLCUL DEL FLUX QUE ATRAVESSA L'ÀREA CLICADA" Public Sub Calculs_Arrays() 'calculem el flux que atravessa l'àrea ReDim Preserve ArrayPunts(comptadorP - 1) ReDim Preserve ArrayEx(1000) ReDim Preserve ArrayEy(1000) ReDim Preserve ArrayFlux(1000) '---------Ara calcularem Ex, Ey i Flux correponents només als punts clicats--- Dim ArrayExInic(comptadorP - 1) Dim ArrayEyInic(comptadorP - 1) Dim d As Integer = 0 For d = 0 To comptadorP - 1 ArrayExInic(d) = Calcular_Ex(ArrayPunts(d)) ArrayEyInic(d) = Calcular_Ey(ArrayPunts(d)) Next Dim dlxInic(comptadorP - 1) As Double 'array de components x del vector que uneix un punt amb el següent Dim dlyInic(comptadorP - 1) As Double 'id. y Dim E_xInic(comptadorP - 1) As Double 'array de components x del vector camp "promig" entre un punt i el següent Dim E_yInic(comptadorP - 1) As Double 'id. y ReDim Preserve arrayfluxInic(comptadorP - 1) Dim f As Integer For f = 0 To comptadorP - 1 'calculem el flux que travessa cada segment de l'àrea dels punts clicats If f = comptadorP - 1 Then dlxInic(f) = ArrayPunts(0).X - ArrayPunts(f).X dlyInic(f) = ArrayPunts(0).Y - ArrayPunts(f).Y E_xInic(f) = (ArrayExInic(f) + ArrayExInic(0)) / 2 E_yInic(f) = (ArrayEyInic(f) + ArrayEyInic(0)) / 2 arrayfluxInic(f) = dlxInic(f) * E_yInic(f) - dlyInic(f) * E_xInic(f) Else dlxInic(f) = ArrayPunts(f + 1).X - ArrayPunts(f).X 'components del vector que uneix un punt amb el següent dlyInic(f) = ArrayPunts(f + 1).Y - ArrayPunts(f).Y E_xInic(f) = (ArrayExInic(f + 1) + ArrayExInic(f)) / 2 'component x del vector camp "promig" entre un punt i el següent E_yInic(f) = (ArrayEyInic(f + 1) + ArrayEyInic(f)) / 2 ' id. y arrayfluxInic(f) = dlxInic(f) * E_yInic(f) - dlyInic(f) * E_xInic(f) 'flux = módul del producte vectorial End If Next '------------------------------------------------------------------------------------ 'Ara afegim més punts que els clicats, per a què el resultat sigui més exacte ------- Dim k As Integer = 0 Dim j As Integer = 0 Dim i As Integer = 0 Dim L As Integer Dim dl(comptadorP - 1) As Integer Dim Pnx As Single Dim Pny As Single


126

For i = 0 To comptadorP - 1 'mirem quina és la distància entre els punts clicats arrayNewP(k) = ArrayPunts(i) 'al nou array de punts, també hi afegim els clicats k = k + 1 If i = comptadorP - 1 Then dl(i) = ((ArrayPunts(0).X - ArrayPunts(i).X) ^ 2 + (ArrayPunts(0).Y - ArrayPunts(i).Y) ^ 2) ^ 0.5 Else dl(i) = ((ArrayPunts(i + 1).X - ArrayPunts(i).X) ^ 2 + (ArrayPunts(i + 1).Y - ArrayPunts(i).Y) ^ 2) ^ 0.5 End If Select Case dl(i) 'depenent de la dist entre els punts clicats, buscarem més o menys punts intermedis Case 2 To 10 L = 50 ' L és el nº de punts intermitjos que possarem entre el punts clicats Case 10 To 20 L = 100 Case 20 To 40 L = 200 Case Is > 40 L = 300 End Select 'L = 100 Dim incX As Double = 0 Dim incY As Double = 0 If i = comptadorP - 1 Then 'Pnx i Pny són les components dels nous punts incX = (ArrayPunts(0).X - ArrayPunts(i).X) / L incY = (ArrayPunts(0).Y - ArrayPunts(i).Y) / L Else If j = L Then incX = (ArrayPunts(0).X - ArrayPunts(i).X) / L incY = (ArrayPunts(0).Y - ArrayPunts(i).Y) / L Else incX = (ArrayPunts(i + 1).X - ArrayPunts(i).X) / L incY = (ArrayPunts(i + 1).Y - ArrayPunts(i).Y) / L End If End If Pnx = ArrayPunts(i).X Pny = ArrayPunts(i).Y For j = 1 To L Pnx += incX Pny += incY arrayNewP(k) = New PointF(Pnx, Pny) k = k + 1 ReDim Preserve arrayNewP(k + 1) Next Next ReDim Preserve arrayNewP(k - 1) ComptAutom = k - 1 'per a crear la tabla2 'Fins aquí hem afegit els punts ------------------------------------------------------------- 'Ara calcularem el flux per aquests punts creats automàticament ----------------------------- ReDim Preserve ArrayEx(k - 1)


127

ReDim Preserve ArrayEy(k - 1) ReDim Preserve ArrayFlux(k - 1) ReDim Preserve E_x(k - 1) ReDim Preserve E_y(k - 1) Dim dlx(k - 1) As Double Dim dly(k - 1) As Double Dim jj As Integer For jj = 0 To k - 1 ArrayEx(jj) = Calcular_Ex(arrayNewP(jj)) ArrayEy(jj) = Calcular_Ey(arrayNewP(jj)) Next Dim ii As Integer For ii = 0 To k - 1 If ii = k - 1 Then dlx(ii) = arrayNewP(0).X - arrayNewP(ii).X dly(ii) = arrayNewP(0).Y - arrayNewP(ii).Y E_x(ii) = (ArrayEx(ii) + ArrayEx(0)) / 2 E_y(ii) = (ArrayEy(ii) + ArrayEy(0)) / 2 ArrayFlux(ii) = dlx(ii) * E_y(ii) - dly(ii) * E_x(ii) Else dlx(ii) = arrayNewP(ii + 1).X - arrayNewP(ii).X 'components del vector que uneix un punt amb el següent dly(ii) = arrayNewP(ii + 1).Y - arrayNewP(ii).Y E_x(ii) = (ArrayEx(ii + 1) + ArrayEx(ii)) / 2 'components del vector camp "promig" entre un punt i el següent E_y(ii) = (ArrayEy(ii + 1) + ArrayEy(ii)) / 2 ArrayFlux(ii) = dlx(ii) * E_y(ii) - dly(ii) * E_x(ii) 'flux = módul del producte vectorial End If Next '---------------------------------Fins aquí hem calculat el flux pels punts creats automàticament Call Omplir_Taula(ArrayPunts, E_xInic, E_yInic, arrayfluxInic) 'Creem un Datatable amb els valors dels punts clicats, ex, ey i flux Call Carregues_interiors() 'Trobem les càrregues interiors de l'àrea clicada, i el flux teòric(T.Gauss) End Sub #End Region #Region "OMPLIR TAULA I GUARDAR EN EXCEL" Public Sub Omplir_Taula(ByVal ArrPI() As PointF, ByVal ArrExI() As Double, ByVal ArrEyI() As Double, ByVal ArrFluxI() As Double) 'Ara omplirem la datagridview amb els punts clicats i els Ex, Ey, Flux correponents només als punts clicats--- Tabla.Columns.Add(New DataColumn("Nº")) 'creem les columnes Tabla.Columns.Add(New DataColumn("X")) Tabla.Columns.Add(New DataColumn("Y")) Tabla.Columns.Add(New DataColumn("Ex")) Tabla.Columns.Add(New DataColumn("Ey")) Tabla.Columns.Add(New DataColumn("Flux")) ' Dim fila(comptadorP) As DataRow 'creem les files Dim nf As Integer For nf = 0 To comptadorP - 1 Dim fila As DataRow = Tabla.NewRow


128

fila(0) = nf + 1 fila(1) = ArrPI(nf).X fila(2) = ArrPI(nf).Y fila(3) = ArrExI(nf) fila(4) = ArrEyI(nf) fila(5) = ArrFluxI(nf) Tabla.Rows.Add(fila) Next Me.DataGridView1.DataSource = Tabla ' li passem els valors de la datatable al datagridview, per veure'ls representats 'cridem la rutina on hem posat les característiques de la taula '--------id per la tabla2 (punts trobats automàticament) tabla2.Columns.Add(New DataColumn("Nº")) tabla2.Columns.Add(New DataColumn("X")) tabla2.Columns.Add(New DataColumn("Y")) tabla2.Columns.Add(New DataColumn("Ex")) tabla2.Columns.Add(New DataColumn("Ey")) tabla2.Columns.Add(New DataColumn("Flux")) Dim nf2 As Integer For nf2 = 0 To ComptAutom Dim fila2 As DataRow = tabla2.NewRow fila2(0) = nf2 + 1 fila2(1) = arrayNewP(nf2).X fila2(2) = arrayNewP(nf2).Y fila2(3) = E_x(nf2) fila2(4) = E_x(nf2) fila2(5) = ArrayFlux(nf2) tabla2.Rows.Add(fila2) Next Me.DataGridView2.DataSource = tabla2 '-------------------------------------------------------------------------------- 'cridem la rutina on hem posat les característiques de les taules Call Configuracio_DataGridView() End Sub Private Sub Configuracio_DataGridView() 'definim l'estil(style) de la datagridview With DataGridView1 'nom del datagridview 'Color general .DefaultCellStyle.BackColor = Color.LightSteelBlue 'Activació de autosize de l'ample de columnes .ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize .AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells 'Estil i color de les Columnes capçals .ColumnHeadersDefaultCellStyle.BackColor = Color.Navy .ColumnHeadersDefaultCellStyle.ForeColor = Color.White .ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.None .RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader 'Seleccionant tota la fila .SelectionMode = DataGridViewSelectionMode.FullRowSelect '.SelectionMode = DataGridViewSelectionMode.CellSelect 'seleccionem nomes la cel.la 'Color de fila seleccionada .DefaultCellStyle.SelectionBackColor = Color.Cyan .DefaultCellStyle.SelectionForeColor = Color.Red


129

'Color de la Fila Capçal Seleccionada .RowHeadersDefaultCellStyle.SelectionBackColor = Color.Goldenrod .RowHeadersDefaultCellStyle.SelectionForeColor = Color.White 'Propietats del DataGridView .EnableHeadersVisualStyles = False .AllowUserToAddRows = False 'L'usuari no pot addicionar una fila .MultiSelect = True 'L'usuari pot seleccionar més d'una fila .ReadOnly = True 'Tota la Datagridview és només de lectura, no és editable. 'establir el punter en una fila, en aquest cas estarà a la fila 1 .CurrentCell = Me.DataGridView1.Item(0, 0) .Rows(0).Selected = True 'Color general del datagridview .DefaultCellStyle.BackColor = Color.Yellow 'Color de cel·les alternades .AlternatingRowsDefaultCellStyle.BackColor = Color.White ' per permetre copiar les cel·les al portapapers .ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText End With With DataGridView2 'id amb l'altra taula .DefaultCellStyle.BackColor = Color.LightSteelBlue .AlternatingRowsDefaultCellStyle.BackColor = Color.White .ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize .AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells .ColumnHeadersDefaultCellStyle.BackColor = Color.Navy .ColumnHeadersDefaultCellStyle.ForeColor = Color.White .ColumnHeadersBorderStyle = DataGridViewHeaderBorderStyle.None .ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.DisableResizing .RowHeadersDefaultCellStyle.BackColor = Color.Navy .RowHeadersDefaultCellStyle.ForeColor = Color.White .RowHeadersBorderStyle = DataGridViewHeaderBorderStyle.None .RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.AutoSizeToFirstHeader .SelectionMode = DataGridViewSelectionMode.FullRowSelect .DefaultCellStyle.SelectionBackColor = Color.Cyan .DefaultCellStyle.SelectionForeColor = Color.Red .RowHeadersDefaultCellStyle.SelectionBackColor = Color.Goldenrod .RowHeadersDefaultCellStyle.SelectionForeColor = Color.White .EnableHeadersVisualStyles = False .AllowUserToAddRows = False .MultiSelect = True .ReadOnly = True .CurrentCell = Me.DataGridView1.Item(0, 0) .Rows(0).Selected = True .DefaultCellStyle.BackColor = Color.GreenYellow .AlternatingRowsDefaultCellStyle.BackColor = Color.White .ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText End With End Sub


130

Public Sub Save_Excel(ByVal Table As DataTable) 'Per poder fer això he hagut de agregar referència a la una llibreria de excel 'Obre un document Excel i guarda el contigut de la datatable Dim dt As DataTable = Table ' Creem un objecte WorkBook Dim objLibroExcel As Excel.Workbook ' Creem un objecte WorkSheet Dim objHojaExcel As Excel.Worksheet ' Iniciem una instància a Excel m_Excel = New Excel.Application m_Excel.Visible = True 'Ara creem un nou document Excel i seleccionem el primer full de treball del document que és on crearem el nostre informe objLibroExcel = m_Excel.Workbooks.Add() objHojaExcel = objLibroExcel.Worksheets(1) objHojaExcel.Visible = Excel.XlSheetVisibility.xlSheetVisible ' Fem aquest full visible en pantalla objHojaExcel.Activate() ' Creem l'encapçalat del full objHojaExcel.Range("A1:F1").Merge() objHojaExcel.Range("A1:F1").Value = "COMPROBACIÓ TEOREMA DE GAUSS" objHojaExcel.Range("A1:F1").Font.Bold = True objHojaExcel.Range("A1:F1").Font.Size = 15 ' Creem el subencapçalat del nostre informe objHojaExcel.Range("A2:F2").Merge() objHojaExcel.Range("A2:F2").Value = "TAULA DE DADES" objHojaExcel.Range("A2:F2").Font.Italic = True objHojaExcel.Range("A2:F2").Font.Size = 13 'afegim els valors de la taula al full excel Dim objCelda As Excel.Range = objHojaExcel.Range("A3", Type.Missing) objCelda.Value = "Punts" objCelda = objHojaExcel.Range("B3", Type.Missing) objCelda.Value = "X" objCelda = objHojaExcel.Range("C3", Type.Missing) objCelda.Value = "Y" objCelda = objHojaExcel.Range("D3", Type.Missing) objCelda.Value = "Ex" objCelda = objHojaExcel.Range("E3", Type.Missing) objCelda.Value = "Ey" objCelda = objHojaExcel.Range("F3", Type.Missing) objCelda.Value = "Flux" Dim i As Integer = 4 ' aquest serà el número de fila a on passarà el primer valor (hi ha l'encapçalat a sobre) 'Recorrem els registres de la taula i els hi assignem a les cel·les corresponents, a la fila corresponent For Each fila As DataRow In dt.Rows ' Assignar els valors dels registres a les cel·les objHojaExcel.Cells(i, "A") = fila.Item(0) objHojaExcel.Cells(i, "B") = fila.Item(1) objHojaExcel.Cells(i, "C") = fila.Item(2) objHojaExcel.Cells(i, "D") = fila.Item(3) objHojaExcel.Cells(i, "E") = fila.Item(4) objHojaExcel.Cells(i, "F") = fila.Item(5) 'Avancem una fila i += 1 Next End Sub


131

#End Region #Region "TROBAR CÀRREGUES INTERIORS I EL FLUX TEÓRIC" Public Sub Carregues_interiors() Call colors_botons() Dim indexsQ(Form1.VG.NQi) As Integer 'guardarem els índexs de les Q internes per a poder posar-los a les etiquetes 'Trobarem quines són les càrregues que es troben a l'interior de l'àrea 'Ho farem pel métode "radial"------------------------------------------------------------------------------------ Dim Vectors(ArrayPunts.Length - 1) As PointF Dim angles(ArrayPunts.Length - 1) As Double Dim k As Integer = 0 Dim angle As Double Dim signe As Integer Dim angleTot As Double Dim m As Integer Dim s As Integer Dim i As Integer For m = 0 To Form1.VG.NQi For s = 0 To ArrayPunts.Length - 1 'vectors que uneixen cada càrrega amb els punts clicats Vectors(s).X = ArrayPunts(s).X - Form1.VG.ArrayPosQ(m).X Vectors(s).Y = ArrayPunts(s).Y - Form1.VG.ArrayPosQ(m).Y Next For i = 0 To ArrayPunts.Length - 1 If i < ArrayPunts.Length - 1 Then 'càlcul de l'angle de cada vector amb el següent angle = Calcul_Angle_Vectors(Vectors(i), Vectors(i + 1)) signe = Calcul_signe_angle(Vectors(i), Vectors(i + 1)) Else angle = Calcul_Angle_Vectors(Vectors(i), Vectors(0)) signe = Calcul_signe_angle(Vectors(i), Vectors(0)) End If angles(i) = signe * angle angleTot = angleTot + angles(i) Next If Math.PI < Math.Abs(angleTot) Then 'si és més gran de 180º està dins de l'àrea, i si és menor, fora Qinteriors(k) = Form1.VG.ArrayNQ(m) indexsQ(k) = m k = k + 1 End If angleTot = 0 'inicialitzem l'angle Next ReDim Preserve indexsQ(k - 1) ReDim Preserve Qinteriors(k - 1) '--------------------------------------------------------------------------------------------------------- Dim j As Integer For j = 0 To k - 1


132

QinteriorsTot = QinteriorsTot + Qinteriors(j) 'sumatori de les càrregues interiors Next 'calculem el flux teòric pel T.Gauss Dim fluxTeoric As Double = 2 * Math.PI * 9000000000.0 * QinteriorsTot 'Flux teòric = 2*Pi*K*SUMATORI(Qi) lblFluxTeo.Text = fluxTeoric.ToString("0.####E+00") lblFluxTeo.Visible = True lblTitolQ.Visible = True If k = 0 Then 'Si no hi ha cap Q interior, ha de sortir escrit "no hi ha Qi" lblNoQi.Location = New Point(452, 681) lblNoQi.Visible = True Else Dim ii As Integer = 0 Do 'per fer visibles les etiquetes de les càrregues internes a l'àrea lblQ(ii).Text = "Q" & indexsQ(ii) + 1 & ": " & Qinteriors(ii).ToString("0.###E+00") ' lblQ(ii).Location = New Point(453, 629 * (ii + 1)) lblQ(ii).Visible = True ii = ii + 1 Loop While ii < Qinteriors.Length End If lblSuma.Visible = True lblSumaQi.Text = (QinteriorsTot.ToString("0.###E+00") & " C") lblSumaQi.Visible = True 'ara calcularem el flux total // hauria de coincidir amb el flux teòric, clar Dim ss As Integer = 0 For ss = 0 To ArrayFlux.Length - 1 fluxTot = fluxTot + ArrayFlux(ss) 'Flux total calculat amb els punts creats automàticament Next Dim tt As Integer = 0 For tt = 0 To arrayfluxInic.Length - 1 fluxTotInic = fluxTotInic + arrayfluxInic(tt) 'Flux total calculat amb els punts clicats Next If Math.Sign(fluxTot) = Math.Sign(fluxTeoric) Then MessageBox.Show("HAS INTRODUIT ELS PUNTS EN SENTIT ANTIHORAI, I PER AIXÒ EL SIGNE DEL FLUX SERÀ EL CONTRARI AL TEÒRIC", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) End If lblFlux.Text = (-1 * fluxTot).ToString("0.####E+00") Dim errFLPC As Double Dim errFLtPC As String If fluxTeoric <> 0 Then 'calculem l'error comès entre el flux teòric i el calculat amb els punts clicats errFLPC = 100 * Math.Abs((Math.Abs(fluxTeoric) - Math.Abs(fluxTotInic)) / Math.Abs(fluxTeoric)) errFLtPC = errFLPC.ToString Else errFLtPC = "" End If Dim errFL As Double


133

Dim errFLt As String If fluxTeoric <> 0 Then 'calculem l'error comès entre el flux teòric i el calculat amb els punts creats automàticament errFL = 100 * Math.Abs((Math.Abs(fluxTeoric) - Math.Abs(fluxTot)) / Math.Abs(fluxTeoric)) errFLt = errFL.ToString Else errFLt = "" End If '------ Afegim a la taula els fluxes teòrics i calculats 'afegim dues fileres buides per després adjuntar els fluxes totals i l'error comès Tabla.Rows.Add() Tabla.Rows.Add() Dim filaPC As DataRow = Tabla.NewRow filaPC(3) = "Punts clicats" filaPC(4) = "--------------" filaPC(5) = "--------------" Tabla.Rows.Add(filaPC) Dim filaFCPC As DataRow = Tabla.NewRow filaFCPC(4) = "Flux Calculat(m2/NC):" filaFCPC(5) = -1 * fluxTotInic Tabla.Rows.Add(filaFCPC) Dim filaFTPC As DataRow = Tabla.NewRow filaFTPC(4) = "Flux Teòric(m2/NC):" filaFTPC(5) = fluxTeoric Tabla.Rows.Add(filaFTPC) '-------------------- Dim filaErrPC As DataRow = Tabla.NewRow filaErrPC(4) = "Error comès(%):" filaErrPC(5) = errFLtPC Tabla.Rows.Add(filaErrPC) '-------------------- Dim filaPA As DataRow = Tabla.NewRow filaPA(3) = "Punts creats" filaPA(4) = "--------------" filaPA(5) = "--------------" Tabla.Rows.Add(filaPA) Dim filaFC As DataRow = Tabla.NewRow filaFC(4) = "Flux Calculat(m2/NC):" filaFC(5) = -1 * fluxTot Tabla.Rows.Add(filaFC) Dim filaFT As DataRow = Tabla.NewRow filaFT(4) = "Flux Teòric(m2/NC):" filaFT(5) = fluxTeoric Tabla.Rows.Add(filaFT) '-------------------- '-------------------- Afegim una filera a la taula amb l'error entreels fluxes Dim filaErr As DataRow = Tabla.NewRow filaErr(4) = "Error comès(%):" filaErr(5) = errFLt Tabla.Rows.Add(filaErr) '-------------------- lblFlux.Visible = True colors_botons() End Sub


134

'Per tobar l'angle entre dos vectors, farem servir el producte escalar entre ells Public Shared Function Calcul_Angle_Vectors(ByVal v1 As PointF, ByVal v2 As PointF) As Double Dim angle As Double angle = Math.Acos((v1.X * v2.X + v1.Y * v2.Y) / ((v1.X ^ 2 + v1.Y ^ 2) ^ 0.5 * (v2.X ^ 2 + v2.Y ^ 2) ^ 0.5)) Return angle End Function 'per saber si l'angle entre aquests vestors és positiu o negatiu, utilitzarem el producte vectorial entre ells Public Shared Function Calcul_signe_angle(ByVal v1 As PointF, ByVal v2 As PointF) As Integer Dim signe As Integer ' si el módul del prod vect és positiu => angle positiu If ((v1.X * v2.Y) - (v1.Y * v2.X)) > 0 Then signe = 1 Else signe = -1 End If Return signe End Function #End Region #Region "CÀLCUL DE EX I EY PER A 2D" Public Function Calcular_Ex(ByVal Punt As PointF) As Double Dim Ex_punt As Double Dim Ex_puntQ As Double Dim ex1 As Integer = 0 For ex1 = 0 To Form1.VG.ArrayNQ.Length - 1 If (Punt.X = Form1.VG.ArrayPosQ(ex1).X And Punt.Y = Form1.VG.ArrayPosQ(ex1).Y) Then 'si coinciden con las cargas Ex_puntQ = 0 'le doy valor 0, esto hay que mirarlo bien Else 'Ex=k*q1*(x-xq1)/r1^2 +...+ k*qn*(x-xqn)/rn^2; 'rn està elevat a 2 i no a 3, perque és un camp "falsejat" per a què es cumpleixi el teorema de gauss en 2D Ex_puntQ = 9000000000.0 * Form1.VG.ArrayNQ(ex1) * (Punt.X - Form1.VG.ArrayPosQ(ex1).X) / ((Punt.X - Form1.VG.ArrayPosQ(ex1).X) ^ 2 + (Punt.Y - Form1.VG.ArrayPosQ(ex1).Y) ^ 2) End If Ex_punt = Ex_punt + Ex_puntQ Next Return Ex_punt End Function Public Function Calcular_Ey(ByVal Punt As PointF) As Double Dim Ey_punt As Double Dim Ey_puntQ As Double Dim ey1 As Integer = 0 For ey1 = 0 To Form1.VG.ArrayNQ.Length - 1 If (Punt.X = Form1.VG.ArrayPosQ(ey1).X And Punt.Y = Form1.VG.ArrayPosQ(ey1).Y) Then 'si coinciden con las cargas Ey_puntQ = 0 'le doy valor 0, esto hay que mirerlo bien Else 'Ex=k*q1*(x-xq1)/r1^2 +...+ k*qn*(x-xqn)/rn^2;


135

' rn està elevat a 2 i no a 3, perque és un camp "falsejat" per a què es cumpleixi el teorema de gauss en 2D Ey_puntQ = 9000000000.0 * Form1.VG.ArrayNQ(ey1) * (Punt.Y - Form1.VG.ArrayPosQ(ey1).Y) / ((Punt.X - Form1.VG.ArrayPosQ(ey1).X) ^ 2 + (Punt.Y - Form1.VG.ArrayPosQ(ey1).Y) ^ 2) End If Ey_punt = Ey_punt + Ey_puntQ Next Return Ey_punt End Function #End Region #Region "DIVERSOS" Public Sub Copiar_Imatge_PboxG() 'primer creem una imatge ' Capturar l'àrea del picbox Dim grs As Graphics = Me.PicBox0G.CreateGraphics ' Creem el bitmap amb l'àrea (ample y alt) que anem a capturar ' Un objecte Graphics a partir del bitmap Dim fSize As Size = PicBox0G.Bounds.Size 'area que anem a capturar ' Creem el bitmap amb l'área que anem a capturar Dim cm As New Bitmap(fSize.Width, fSize.Height, grs) Dim gr3 As Graphics = Graphics.FromImage(cm) ' Copiar l'àrea de la pantalla del tamany que li hem dit, a partir del punt que li direm ara gr3.CopyFromScreen(Me.PicBox0G.Location.X, Me.PicBox0G.Location.Y + 26, 0, 0, fSize) ' Asignem la imatge al PictureBox Me.PicBox0G.Image = cm grs.Dispose() gr3.Dispose() End Sub Public Sub colors_botons() If bool_btn_ClickPunts = True Then btn_ClickPunts.BackColor = Color.Orange Else btn_ClickPunts.BackColor = Color.Gainsboro End If End Sub Private Sub Guardar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Guardar.Click 'Botó Guardar Document Excel If Tabla.Rows.Count = 0 Then MessageBox.Show("LA TAULA ENCARA ÉS BUIDA, NO HI HA RES A GUARDAR", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub Else Call Save_Excel(Tabla) End If End Sub Private Sub Guardar2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Guardar2.Click If tabla2.Rows.Count = 0 Then


136

MessageBox.Show("LA TAULA ENCARA ÉS BUIDA, NO HI HA RES A GUARDAR", "AVÍS", MessageBoxButtons.OK, MessageBoxIcon.Information) Exit Sub Else Call Save_Excel(tabla2) End If End Sub Private Sub btn_close_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_close.Click 'Botó Sortir comptadorP = 0 QinteriorsTot = 0 fluxTot = 0 bool_btn_ClickPunts = False Array.Clear(ArrayPunts, 0, ArrayPunts.Length) 'per a netejar els valorsi les posicions de les càrregues Array.Clear(ArrayEx, 0, ArrayEx.Length) Array.Clear(ArrayEy, 0, ArrayEy.Length) Array.Clear(ArrayFlux, 0, ArrayFlux.Length) Array.Clear(Qinteriors, 0, Qinteriors.Length) PicBox0G.Image = Nothing PicBox0G.Refresh() Me.Close() End Sub #End Region

End Class

6.2.3 Codi Pantalla Representació Potencial en 3D (“Gràfica”)

Imports System.Drawing.Drawing2D Public Class Grafica #Region "VARIABLES" Public Shared ArrayNQ_esc(Form1.VG.NQi) As Double 'array de càrregues escalades Public Shared ArrayPosQ_esc(Form1.VG.NQi) As PointF ' posició de les càrregues escalades Dim xf As Double = 0 Dim yf As Double = 0 Dim angX As Double = 0 'angles de rotació dels eixos Dim angY As Double = 0 Dim angPhi As Double = 0 Dim angTheta As Double = 0 Dim grill(351, 251) As Double Dim PGrill(70, 50) As PointF Dim VPGrill(70, 50) As Double Dim PGrillF(70, 50) As PointF Dim xO As Integer = 450 'origen gràfica Dim yO As Integer = 330


137

Dim cont As Integer = 0 'per fer parar el timer #End Region #Region "INICI" Private Sub Grafica_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load Me.Refresh() Me.BringToFront() ToolTip1_graf.InitialDelay = 50 ToolTip1_graf.BackColor = Color.Aquamarine ToolTip1_graf.IsBalloon = True ReDim ArrayNQ_esc(Form1.VG.NQi) ReDim ArrayPosQ_esc(Form1.VG.NQi) Form1.VG.ArrayNQ.CopyTo(ArrayNQ_esc, 0) Form1.VG.ArrayPosQ.CopyTo(ArrayPosQ_esc, 0) Dim i As Integer = 0 For i = 0 To Form1.VG.NQi 'Escalem les càrregues ArrayNQ_esc(i) = Escalar_Q(ArrayNQ_esc(i)) / 4 ArrayPosQ_esc(i).X = ArrayPosQ_esc(i).X / 2 ArrayPosQ_esc(i).Y = ArrayPosQ_esc(i).Y / 2 Next '--------------------------------------------------GRILL Dim gX As Integer = 0 Dim gY As Integer = 0 Dim PuntGrill As PointF Dim gXaux, gYaux As Integer While gX <= 350 While gY <= 250 PuntGrill = New Point(gX, gY) grill(gX, gY) = Calcular_Potencial(PuntGrill) If grill(gX, gY) <> 0 Then VPGrill(gXaux, gYaux) = grill(gX, gY) 'V als punts de la graella PGrill(gXaux, gYaux) = New PointF(gX, gY) 'punts de la graella gYaux += 1 End If gY += 5 End While gYaux = 0 gXaux += 1 gY = 0 gX += 5 End While Call Punts() End Sub #End Region #Region "CALCULS" Public Function Escalar_Q(ByVal Qi As Double) As Double


138

'Aquí escalem les càrregues. Les deixem de l'ordre dels microcoulombs Dim Qinic As Double = Qi Dim Qnew As Double Dim maxim = Math.Abs(Form1.VG.ArrayNQ(0)) 'Trobem la més gran. Comencem supossant que és la primera. Dim im As Integer = 0 For im = 0 To Form1.VG.NQi If Math.Abs(Form1.VG.ArrayNQ(im)) > maxim Then maxim = Math.Abs(Form1.VG.ArrayNQ(im)) End If Next Qnew = Qi * 10 ^ (-6) / maxim Return Qnew End Function Public Function Calcular_Potencial(ByVal Punt As PointF) As Double Dim Vpunt As Double Dim VpuntQ As Double Dim v1 As Integer = 0 For v1 = 0 To ArrayNQ_esc.Length - 1 Dim dist As Double = ((ArrayPosQ_esc(v1).X - Punt.X) ^ 2 + (ArrayPosQ_esc(v1).Y - Punt.Y) ^ 2) ^ 0.5 If dist < 5 Then ' Quan els punts estiguin a aquesta distància, com a màxim dibuixarà una z de 500 'Si dibuixèssim la realitat, marxaria a l'infinit VpuntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(v1) / dist) Vpunt = Vpunt + VpuntQ If Math.Abs(Vpunt) > 500 Then If Vpunt > 0 Then Vpunt = 500 Else Vpunt = -500 End If End If Else VpuntQ = 9 * 10 ^ 9 * (ArrayNQ_esc(v1) / dist) Vpunt = Vpunt + VpuntQ End If Next FormatNumber(Vpunt, 4) ' deixem el potencial amb 4 decimals Return Vpunt End Function Public Sub Punts() Me.Refresh() 'Aquí calculem els punts que hem d'unir per dibuixar la gràfica Dim ii As Integer Dim jj As Integer For ii = 0 To 70 For jj = 0 To 50 'variació coord esferiques xf = PGrill(ii, jj).X * Math.Cos(angTheta) * Math.Cos(angPhi) + PGrill(ii, jj).Y * Math.Cos(angTheta) * Math.Sin(angPhi) yf = -PGrill(ii, jj).X * Math.Sin(angPhi) + PGrill(ii, jj).Y * Math.Cos(angPhi) - VPGrill(ii, jj) * Math.Sin(angTheta) 'rotació sobre Y i rotació sobre X PGrillF(ii, jj).X = xO + (xf * (1 + Math.Cos(angY)) - yf * Math.Sin(angX) + VPGrill(ii, jj) * Math.Sin(angY)) / 2


139

PGrillF(ii, jj).Y = yO + (yf * (1 + Math.Cos(angX)) + xf * Math.Sin(angY) + VPGrill(ii, jj) * Math.Sin(angX)) / 2 'xo i yo és el punt de la pantalla on comencem a dibuixar la gràfica 'dividim per 2 perque la graella l'hem fet la meitat de gran Next Next Call dibuixar() End Sub #End Region #Region "DIBUIXAR" Public Sub dibuixar() Me.BackgroundImage = Nothing Me.Refresh() ' Creem el GraphicsPath per definir una línea amb cap triangular gran, per l'eix--------------------------------------------- Dim Graf As Graphics = Me.GroupBox1.CreateGraphics() 'Creem la tela on dibuixarem(tota la pantalla) Dim Imag As Image = Image.FromFile("c:\campelec\graficaesferiques02.png") 'imatges de les gràfiques i de la graella Dim Imag2 As Image = Image.FromFile("c:\campelec\graficacartesianes02.png") Dim Imag3 As Image = Image.FromFile("c:\Campelec\FotoGraella2.png") Graf.DrawImage(Imag, 0, 250, 250, 250) Graf.DrawImage(Imag2, 0, 530, 250, 250) Graf.DrawImage(Imag3, 0, 0, 350, 250) 'GroupBox1.BackgroundImage = Image.FromFile("c:\campelec\grafica 3d2dbis1.png") 'GroupBox1.BackgroundImageLayout = ImageLayout.Stretch Dim PeixY As PointF = New PointF(0, 250) Dim PeixX As PointF = New PointF(350, 0) Dim PeixZ As PointF = New PointF(0, 0) Dim fontA As Font = New Font("Arial", 12, FontStyle.Regular) '------calculem els punts Dim p1 As PointF Dim p2 As PointF Dim p3 As PointF Dim x1 As Double = 0 Dim y1 As Double = 0 Dim x2 As Double = 0 Dim y2 As Double = 0 Dim x3 As Double = 0 Dim y3 As Double = 0 x1 = PeixX.X * Math.Cos(angTheta) * Math.Cos(angPhi) + PeixX.Y * Math.Cos(angTheta) * Math.Sin(angPhi) y1 = -PeixX.X * Math.Sin(angPhi) + PeixX.Y * Math.Cos(angPhi) x2 = PeixY.X * Math.Cos(angTheta) * Math.Cos(angPhi) + PeixY.Y * Math.Cos(angTheta) * Math.Sin(angPhi) y2 = -PeixY.X * Math.Sin(angPhi) + PeixY.Y * Math.Cos(angPhi) x3 = 0


140

y3 = +300 * Math.Sin(angTheta) p1.X = xO + (x1 * (1 + Math.Cos(angY)) - y1 * Math.Sin(angX)) / 2 p1.Y = yO + (y1 * (1 + Math.Cos(angX)) + x1 * Math.Sin(angY)) / 2 p2.X = xO + (x2 * (1 + Math.Cos(angY)) - y2 * Math.Sin(angX)) / 2 p2.Y = yO + (y2 * (1 + Math.Cos(angX)) + x2 * Math.Sin(angY)) / 2 p3.X = xO + (x3 * (1 + Math.Cos(angY)) - y3 * Math.Sin(angX) - 300 * Math.Sin(angY)) / 2 p3.Y = yO + (y3 * (1 + Math.Cos(angX)) + x3 * Math.Sin(angY) - 300 * Math.Sin(angX)) / 2 '------------fins aqui hem calculat els punts '--------------------------------------------pintem els eixos Dim pnl As Pen = New Pen(Color.Gray, 3) Dim InV_path As New Drawing2D.GraphicsPath InV_path.AddLine(0, 0, -1, -5) InV_path.AddLine(0, 0, 1, -5) InV_path.AddLine(-1, -5, 1, -5) ' Creem l'inici de línea per marcar la direcció de la línea de força Dim InV_cap As New Drawing2D.CustomLineCap(Nothing, InV_path) ' Creem el pen que farà servir aquest inici de linea Dim penInV As Pen penInV = pnl penInV.CustomEndCap = InV_cap Graf.DrawLine(penInV, xO, yO, p1.X, p1.Y) 'eixos de la grafica "central Graf.DrawLine(penInV, xO, yO, p2.X, p2.Y) Graf.DrawLine(penInV, xO, yO, p3.X, p3.Y) Graf.DrawString("X", fontA, Brushes.DarkGreen, p1.X, p1.Y) Graf.DrawString("Y", fontA, Brushes.DarkGreen, p2.X, p2.Y) Graf.DrawString("Z", fontA, Brushes.DarkGreen, p3.X, p3.Y) Graf.DrawLine(penInV, 5, 5, 340, 5) 'Eixos de la imatge de la graella Graf.DrawLine(penInV, 5, 5, 5, 240) Graf.DrawString("X", fontA, Brushes.DarkGreen, 345, 5) Graf.DrawString("Y", fontA, Brushes.DarkGreen, 5, 245) Graf.DrawString("Z", fontA, Brushes.DarkGreen, 5, 5) pnl.Dispose() penInV.Dispose() '------------------------------------------------Hem dibuixat l'eix 'Abans de dibuixar la gràfica, activem un timer per a que "acabi de calcular" 'si no, molts cops desapareix la imatge Me.Timer1.Enabled = True Me.Timer1.Start() Me.Timer1.Interval = 100 Graf.Dispose() End Sub Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick 'Rutina que fa cada 100ms (només la farà 1 cop) Dim graf As Graphics = Me.CreateGraphics Dim penline As Pen = New Pen(Color.FromArgb(50, Color.Green))


141

'Dim PtosVista As Double Dim s1 As Integer 'dibuixa cuadrícula Dim s2 As Integer For s1 = 1 To 70 For s2 = 1 To 50 If VPGrill(s1, s2) > 0 Then penline = New Pen(Color.Blue) Else penline = New Pen(Color.Red) End If graf.DrawLine(penline, PGrillF(s1 - 1, s2), PGrillF(s1, s2)) graf.DrawLine(penline, PGrillF(s1, s2 - 1), PGrillF(s1, s2)) Next Next Copiar_Imatge() 'fa "la foto" If cont >= 1 Then Timer1.Stop() Timer1.Enabled = False Timer1.Dispose() cont = 0 Exit Sub End If graf.Dispose() End Sub Public Sub Copiar_Imatge() 'primer creem una imatge per a posar-la de fons a la pantalla ' Capturar l'àrea del picbox Dim gr As Graphics = Me.CreateGraphics ' Creem el bitmap amb l'àrea (ample i alt) que anem a capturar ' Un objecte Graphics a partir del bitmap Dim fSize As Size = Me.Bounds.Size 'area que anem a capturar Dim bm As New Bitmap(fSize.Width, fSize.Height, gr) Dim gr2 As Graphics = Graphics.FromImage(bm) ' Copiar l'àrea de la pantalla del tamany que li hem dit, a partir del punt que li direm ara gr2.CopyFromScreen(0, 0, 0, 0, fSize) Me.BackgroundImage = Nothing ' Asignem la imatge a la pantalla Me.BackgroundImage = bm Me.Refresh() cont += 1 'per a fer parar el timer gr.Dispose() gr2.Dispose() '------------------------------------------------------------------------------ End Sub #End Region #Region "ROTAR EIXOS" Dim increment As Integer = 5 Private Sub btnTheta_a_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnTheta_a.Click increment = CInt(IncAng.Text)


142

angPhi = angPhi + increment * 2 * Math.PI / 360 'cada cop que cliquem aumenta Increment graus Call Punts() End Sub Private Sub btnTheta_b_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnTheta_b.Click increment = CInt(IncAng.Text) angPhi = angPhi - increment * 2 * Math.PI / 360 Call Punts() End Sub Private Sub btnPhi_a_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnPhi_a.Click increment = CInt(IncAng.Text) angTheta = angTheta + increment * 2 * Math.PI / 360 Call Punts() End Sub Private Sub btnbtnPhi_b_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnPhi_b.Click increment = CInt(IncAng.Text) angTheta = angTheta - increment * 2 * Math.PI / 360 Call Punts() End Sub Private Sub Yu_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Yu.Click increment = CInt(IncAng.Text) angX = angX + increment * 2 * Math.PI / 360 Call Punts() End Sub Private Sub Yd_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Yd.Click increment = CInt(IncAng.Text) angX = angX - increment * 2 * Math.PI / 360 Call Punts() End Sub Private Sub Xu_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Xu.Click increment = CInt(IncAng.Text) angY = angY + increment * 2 * Math.PI / 360 Call Punts() End Sub Private Sub Xd_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Xd.Click increment = CInt(IncAng.Text) angY = angY - increment * 2 * Math.PI / 360 Call Punts() End Sub #End Region #Region "DIVERSOS" Private Sub TrackBarXO_Scroll(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TrackBarXO.Scroll 'per desplaçar la gràfica horitzontalment xO = TrackBarXO.Value * 100


143

Call Punts() End Sub Private Sub TrackBarYO_Scroll(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles TrackBarYO.Scroll 'per desplaçar la gràfica verticalment yO = 330 - TrackBarYO.Value * 66 Call Punts() End Sub Private Sub btn_Reiniciar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_Reiniciar.Click 'Botó reiniciar Me.BackgroundImage = Nothing angPhi = 0 angTheta = 0 angX = 0 angY = 0 Me.Refresh() Grafica_Load(sender, e) End Sub Private Sub btnClose_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnClose.Click 'Botó tancar Me.Close() End Sub #End Region

End Class


144

6.3 Manual d’Introducció a Microsoft Visual Basic 2005 Express Edition

Manual de Introducción a

Microsoft®

Visual Basic® 2005 Express Edition

por Jorge Serrano Pérez


145

Índice

CAPÍTULO 1: SOBRE VISUAL BASIC Y ESTE LIBRO 1.1.- ¿Visual Basic .NET 2005 ó Visual Basic 2005? 1.2.- ¿Visual Studio 2005 ó Visual Basic 2005 Express Edition? 1.3.- Microsoft .NET Framework 2.0 1.4.- ¿Es necesario utilizar un entorno de desarrollo rápido con Microsoft .NET? 1.5.- Cómo y por dónde empezar este manual 1.6.- POO, la base de .NET CAPÍTULO 2: MICROSOFT .NET FRAMEWORK 2.1.- SDK 2.2.- BCL o Base Class Library 2.3.- CLR o Common Language Runtime 2.4.- MSIL 2.5.- JIT CAPÍTULO 3: VISUAL BASIC 2005, EL LENGUAJE 3.1.- Tipos de datos

3.1.1.- Tipos primitivos 3.1.2.- Declaración de constantes, un tipo de declaración especial 3.1.3.- Declaración de variables 3.1.4.- Palabras clave 3.1.5.- Listas enumeradas 3.1.6.- Matrices

3.2.- Comentarios y organización de código 3.3.- Control de flujo

3.3.1.- Operadores lógicos y operadores relacionales 3.3.2.- If…Then…Else 3.3.3.- Select…Case

3.4.- Bucles 3.4.1.- Bucles de repetición o bucles For 3.4.2.- Bucles Do While…Loop y Do Until…Loop

3.5.- Estructuras 3.6.- Operadores aritméticos CAPÍTULO 4: VISUAL BASIC 2005, OTRAS CARACTERÍSTICAS DEL LENGUAJE 4.1.- Métodos 4.2.- Parámetros como valor y parámetros como referencia 4.3.- Funciones 4.4.- Propiedades 4.5.- Excepciones 4.6.- Colecciones 4.7.- Ámbito y visibilidad de las variables 4.8.- Clases

4.8.1.- Utilizando Namespace 4.8.2.- Utilizando el constructor de la clase 4.8.3.- Utilizando constructores múltiples 4.8.4.- Destruyendo la clase 4.8.5.- Clases parciales

4.9.- Estructuras CAPÍTULO 5: VISUAL BASIC 2005, OTROS ASPECTOS AVANZADOS DEL LENGUAJE 5.1.- Funciones recursivas 5.2.- Interfaces 5.3.- Eventos 5.4.- Multihebras o Multithreading 5.5.- Delegados 5.6.- Herencia


146

CAPÍTULO 6: VISUAL BASIC 2005, EL ENTORNO 6.1.- Visión general del entorno 6.2.- Creando una nueva aplicación 6.3.- El Cuadro de herramientas 6.4.- El Explorador de soluciones 6.5.- Los Orígenes de datos 6.6.- Ventana de propiedades 6.7.- Agregar elementos al proyecto 6.8.- Agregando elementos al proyecto

6.8.1.- Windows Forms 6.8.2.- Cuadro de diálogo 6.8.3.- Formulario del explorador 6.8.4.- Formulario primario MDI 6.8.5.- Cuadro Acerca de 6.8.6.- Pantalla de bienvenida 6.8.7.- Otras plantillas

CAPÍTULO 7: VISUAL BASIC 2005, TRABAJANDO CON EL ENTORNO 7.1.- Código vs Diseñador 7.2.- Ejecutando una aplicación 7.3.- Diferencias entre Iniciar depuración e Iniciar sin depurar 7.4.- Depurando una aplicación

7.4.1.- Puntos de interrupción 7.4.2.- Deteniendo la depuración 7.4.3.- Visión práctica de la depuración de un ejemplo 7.4.4.- Modificando el código en depuración

7.5.- Utilizando los recortes como solución a pequeños problemas 7.6.- Diseñando nuestras aplicaciones Windows

7.6.1.- Cuadro de herramientas 7.6.2.- Controles contenedores 7.6.3.- Posicionando los controles en nuestros formularios 7.6.4.- Tabulando los controles en nuestros formularios

7.7.- Las propiedades de un proyecto CAPÍTULO 8: MY, NAMESPACE PARA TODO 8.1.- ¿En qué consiste My? 8.2.- Funcionamiento de My 8.3.- Una primera toma de contacto con My 8.4.- El corazón de My CAPÍTULO 9: XML, LOS DOCUMENTOS EXTENSIBLES 9.1.- Agregando la referencia a System.Xml 9.2.- Leer XML con XmlTextReader 9.3.- Leer XML con XmlDocument 9.4.- Leer XML con XPathDocument 9.5.- Leer un XML como un DataSet 9.6.- Ejemplo práctico para escribir un documento XML CAPÍTULO 10: BREVE INTRODUCCIÓN AL ACCESO A DATOS 10.1.- Una pequeña introducción a ADO.NET 10.2.- ¿Acceso conectado o acceso desconectado? 10.3.- DataSet, DataView y DataTable 10.4.- Ejemplo de conectividad de datos con DataSet 10.5.- Recorriendo los datos de un DataSet 10.6.- Ejemplo de acceso conectado de datos


147

CAPÍTULO 1

SOBRE VISUAL BASIC Y ESTE LIBRO ESTE CAPÍTULO INTRODUCTORIO ACERCA AL LECTOR ALGUNOS ASPECTOS BÁSICOS QUE CONVIENE QUE CONOZCA ANTES DE EMPEZAR A LEER ESTE MANUAL. Visual Basic tiene el honor de haber sido el lenguaje de programación más extendido y utilizado en la historia de la informática. Pero lejos de haberse quedado anclado en el pasado, este lenguaje ha continuado evolucionando a lo largo de los últimos años. Con la aparición de la tecnología Microsoft .NET, Visual Basic sufrió la transformación más amplia que jamás haya tenido este lenguaje de programación. Microsoft elaboró entonces la primera especificación de esta evolución que ha tenido Visual Basic. Hablo de la especificación del lenguaje Visual Basic 7.0, y que sería la que se incorporaría a Visual Basic .NET 2002. Poco tiempo después, la especificación del lenguaje Visual Basic sufrió pequeños retoques que se incorporaron a la especificación del lenguaje Visual Basic 7.1 y que formaría parte de Visual Basic .NET 2003. Microsoft sin embargo, no se ha detenido aquí y así ha elaborado la especificación del lenguaje Visual Basic 8.0 que es la especificación que forma parte de Visual Basic 2005 y en la lógicamente, me he basado para escribir este manual. 1.1.- ¿Visual Basic .NET 2005 ó Visual Basic 2005? Con la última especificación añadida al lenguaje Visual Basic por Microsoft, el lenguaje pasa a denominarse Visual Basic 2005. La palabra .NET ya no acompaña al lenguaje Visual Basic como ha ocurrido con las versiones 2002 y 2003 de Visual Studio. De hecho, ahora Visual Studio en su nueva versión pasa a llamarse Visual Studio 2005. Por esa razón, en este libro haremos referencia solamente a Visual Basic 2005. Algo a lo que deberemos acostumbrarnos si hemos utilizado anteriormente términos como Visual Basic .NET 2002, Visual Basic .NET 2003, Visual Studio .NET 2002, etc. 1.2.- ¿Visual Studio 2005 ó Visual Basic 2005 Express Edition? Microsoft está haciendo un importante esfuerzo por acercar y llevar Visual Basic al mayor número de programadores posible. Microsoft pone a disposición de los desarrolladores un entorno integrado de desarrollo de aplicaciones con los lenguajes de programación que Microsoft incorpora a su entorno de desarrollo rápido. Este entorno de desarrollo se llama Visual Studio 2005, y con él podemos desarrollar prácticamente cualquier tipo de aplicación que necesitemos crear. Por otro lado, y con el objetivo principal de acercar la programación a los programadores, Microsoft ha desarrollado entornos de desarrollo rápido, económicamente más asequibles y sin todas las bondades que ofrece Visual Studio. Son entornos de desarrollo para programadores menos exigentes o con unos requerimientos menores, o un poder adquisitivo más bajo que no requiera de todas las posibilidades que ofrece un paquete como Visual Studio. De esta manera, aparecen los entornos de desarrollo denominados Express Edition y que en el caso de Visual Basic, se denomina Visual Basic 2005 Express Edition. Este manual está orientado precisamente a conocer Visual Basic 8.0 ó lo que es lo mismo, Visual Basic 2005, de la mano del entorno de desarrollo rápido Visual Basic 2005 Express Edition. 1.3.- Microsoft .NET Framework 2.0


148

El conjunto de librerías y el propio corazón de .NET que permite compilar, depurar y ejecutar aplicaciones .NET se denomina Microsoft .NET. Desde que apareció Microsoft .NET, han aparecido tres versiones de Microsoft .NET Framework. La versión Microsoft .NET Framework 1.0 apareció en primer lugar y fue la que se utiliza dentro de Visual Studio .NET 2002. Poco más tarde apareció Microsoft .NET Framework 1.1 que fue integrada en Visual Studio .NET 2003. Actualmente, Microsoft ha desarrollado la versión Microsoft .NET Framework 2.0 que es la versión que se utiliza en Visual Studio 2005 y en las versiones Express Edition de la nueva familia de entornos de desarrollo rápido de Microsoft. Adicionalmente, SQL Server 2005 utiliza también esta versión de .NET. 1.4.- ¿Es necesario utilizar un entorno de desarrollo rápido con Microsoft .NET? No, no es necesario utilizar un entorno de desarrollo rápido como Visual Studio 2005 ó Visual Basic 2005 Express Edition para poder desarrollar aplicaciones en Microsoft .NET. De hecho, hay otras alternativas algunas de ellas de carácter gratuito disponibles en Internet, para crear aplicaciones .NET de forma rápida y cómoda. Otra manera que tenemos de desarrollar y compilar aplicaciones de .NET es utilizando el SDK o Software Development Kit de .NET Framework y la línea de comandos para realizar todas las acciones de compilación, depuración y ejecución. Aún y así, Microsoft ha desarrollado en el entorno Visual Studio, el software de desarrollo rápido de aplicaciones .NET más robusto y completo del mercado para la tecnología de desarrollo de Microsoft. Microsoft .NET Framework se integra en el entorno de desarrollo de forma transparente al programador, y lo utiliza para ayudarnos a desarrollar de forma rápida, eficiente y segura, nuestras aplicaciones. Nos permite aumentar el rendimiento y disminuir la curva de tiempo de desarrollo enormemente, por lo que aunque el uso de un entorno de desarrollo rápido para programar aplicaciones .NET es algo que corresponde decidirlo al programador, la conclusión que podemos extraer de esto que comento, es que no es necesario utilizarlo, pero sí muy recomendable. 1.5.- Cómo y por dónde empezar este manual Este manual está enfocado a aquellos desarrolladores que quieren aprender a utilizar Visual Basic 2005. No se trata de un manual avanzado de Visual Basic 2005, sino de un manual enfocado a la toma de contacto del lenguaje con la base puesta en su introducción, y en el contacto del entorno de desarrollo Visual Basic 2005 Express Edition. Entre otras cosas, no se tendrá en cuenta si el lector viene del mundo Visual Basic o no. El objetivo de este manual es el de servir de base y guía para iniciarse en el desarrollo de aplicaciones con Visual Basic 2005. Lógicamente, lo primero que necesitaremos conocer son las nociones básicas y generales de Microsoft .NET Framework que nos permitirán familiarizarnos con esta tecnología. Si ya conoce cuales son las partes fundamentales de Microsoft .NET Framework y sabe como funciona, le sugiero pasar directamente al capítulo 3, pero si quiere conocer qué es y cómo funciona Microsoft .NET, entonces le sugiero continuar leyendo los capítulos de este manual de forma secuencial. 1.6.- POO, la base de .NET Todos los lenguajes de programación de la plataforma .NET, entre ellos Visual Basic 2005, son lenguajes de programación orientados a objetos, por lo que es ampliamente recomendable, tener nociones de programación orientada a objetos para sacar el máximo provecho a este manual y al lenguaje Visual Basic 2005.


149

CAPÍTULO 2

MICROSOFT .NET FRAMEWORK ESTE CAPÍTULO INTRODUCTORIO ACERCA AL LECTOR ALGUNOS ASPECTOS BÁSICOS QUE DEBE CONOCER ANTES DE EMPEZAR A LEER ESTE MANUAL. Microsoft .NET es un entorno integrado de ejecución, compilación, depuración, y desarrollo de aplicaciones. Los diferentes lenguajes de programación de la plataforma, comparten el mismo entorno, normas, reglas, y librerías de Microsoft .NET Framework. Las reglas sintácticas y algunas diferencias más, son las partes destacables entre un lenguaje de programación y otro dentro de .NET, pero la cantidad de cosas que comparten en común es una de las partes que ha hecho a .NET, un entorno moderno, robusto y eficiente que cubre las expectativas de los desarrolladores modernos y más exigentes. 2.1.- SDK El SDK es conocido también como Software Development Kit, y es el paquete con el cuál, podemos compilar, ejecutar, y depurar nuestras aplicaciones, y utilizar las bibliotecas de clases de .NET que nos facilita enormemente una enorme cantidad de trabajo. Adicionalmente, el SDK tiene también documentación, ayuda, y ejemplos, y viene preparado con varios compiladores, entre los que está Visual Basic. Con el SDK, seremos capaces de desarrollar cualquier tipo de aplicación, aunque lo ideal es disponer de un entorno de diseño rápido para poder potenciar la programación y sacar un mayor aprovechamiento y rendimiento a nuestro trabajo y a nuestro tiempo. 2.2.- BCL o Base Class Library El BCL o bibliotecas de clases de .NET son un enorme conjunto de clases -más de 4000- que poseen una amplia funcionalidad y que nos servirán para desarrollar cualquier tipo de aplicación que nos propongamos. Adicionalmente, podemos desarrollar nuestras propias clases y con eso, podemos contribuir con nuestra experiencia a nuestros desarrollos. Microsoft .NET Framework, no deja de ser por lo tanto en parte, un enorme repositorio de clases listas para usar desde que instalamos el entorno .NET. En .NET Framework, referenciamos a las BCL mediante lo que se ha denominado Namespace -Espacios de Nombres- y que se engloban dentro del Namespace System. 2.3.- CLR o Common Language Runtime Una de las partes fundamentales de Microsoft .NET Framework, es el CLR o Common Language Runtime, que no es otra cosa que el entorno o motor de ejecución de lenguaje común. Todo código escrito en .NET es ejecutado bajo el control del CLR como código administrado. Es aquí dónde encontramos una de las diferencias más notables entre las versiones de Visual Basic anteriores a .NET y las versiones de Visual Basic que tienen que ver con la plataforma .NET. Antes de .NET, las aplicaciones desarrolladas con Visual Basic se ejecutaban como código no administrado, mientras que las aplicaciones desarrolladas con Visual Basic bajo el entorno .NET, se ejecutan como código administrado, código administrado siempre por el CLR. El CLR es el centro neurálgico del .NET Framework encargado de gestionar la ejecución de nuestras aplicaciones, aplicar parámetros de seguridad y ejecutar el denominado recolector de basura entre otras cosas.


150

Dentro del CLR, encontraremos diferentes partes como ya hemos indicado, cada una responsable de su parcela o responsabilidad. Así podemos encontrar el CTS o Common Type Specification, o Especificación de Tipos de Datos Común. El CTS lo forma los tipos y definiciones de cada tipo de dato utilizable en una aplicación .NET. Cada tipo de dato, hereda su tipo del objeto System.Object. El CTS está por otro lado, relacionado con el CLS o Common Language Specification, o lo que es lo mismo, la Especificación Común de Lenguajes, que son las reglas que hay que seguir a la hora de trabajar con los tipos de datos. Por último, no quiero dejar de hablar brevemente del CLR sin haber mencionado al Garbage Collector o GC, que en su traducción más o menos exacta, lo definiremos como Recolector de Basura, y que tiene la función digna o indigna, de hacer la tarea más sucia de .NET, es decir, de hacer las funciones de gestor de limpieza de .NET eliminando de la memoria, todos aquellos objetos que no sean útiles en un momento dado, liberando al sistema de recursos no utilizables. La ejecución del GC es una ejecución desatendida y trasparente por el programador y por el usuario, pero si lo deseamos, podemos forzar como programadores, su ejecución bajo demanda. 2.4.- MSIL MSIL o IL es conocido como Microsoft Intermediate Language o simplemente Intermediate Language, o lo que es lo mismo, lenguaje intermedio. Todos los lenguajes administrados de la plataforma .NET, deben cumplir un conjunto de reglas y normas, y parte de este ajuste, es que una aplicación escrita en un lenguaje de programación determinado, debe ser compilada en un lenguaje intermedio, de manera tal, que una aplicación escrita por ejemplo en C# y otra igual en Visual Basic, se compilan al prácticamente el mismo lenguaje intermedio. El IL es un lenguaje muy similar al conocido ensamblador, y contiene instrucciones de bajo nivel. La particularidad del IL es que no está compilado teniendo en cuenta ningún tipo de sistema operativo ni ningún dispositivo hardware en particular, por lo que al final de este proceso, es necesario realizar un último ajuste, el correspondiente a la ejecución de la aplicación del código intermedio en la máquina final dónde se ejecuta. 2.5.- JIT JIT son las siglas de Just In Time, o lo que es lo mismo, el procedimiento de .NET mediante el cuál, una aplicación compilada en código intermedio, es compilada cuando se lanza y ejecutada en última instancia de acuerdo al compilador que transformará el IL en instrucciones de ensamblador específicas para el sistema operativo en el cuál se está ejecutando. Como particularidad de esto, mencionaré el funcionamiento del CLR de Mono, proyecto de acercar .NET al mundo Linux. Podemos escribir una pequeña aplicación de ejemplo que nos demuestre este funcionamiento, y compilarla en código intermedio. Copiaremos el resultado de esta compilación a código intermedio, y pondremos una copia en Windows bajo Microsoft .NET Framework y otra en Linux bajo Mono. Ejecutando nuestra aplicación en ambos sistemas y con las versiones correspondientes del entorno de ejecución, comprobaremos que ambas aplicaciones son ejecutadas en ambos sistemas operativos. La explicación es sencilla, el código intermedio es el mismo para la aplicación Windows que para la aplicación Linux. El CLR de .NET Framework para Windows se encargará de compilar en modo JIT la aplicación para este sistema operativo, mientras que el CLR para Linux, se encargará de hacer lo propio para ese sistema operativo.


151

CAPÍTULO 3

VISUAL BASIC 2005, EL LENGUAJE ESTE CAPÍTULO NOS ACERCA DE FORMA DIRECTA A LAS ESPECIFICACIONES GENÉRICAS DEL LENGUAJE VISUAL BASIC 2005. Ya hemos comentado que Visual Basic ha evolucionado en los últimos años de forma paulatina, y así, nos encontramos con la versión más reciente de Visual Basic hasta la fecha. Hablo claramente de Visual Basic 2005. En este capítulo, veremos las partes fundamentales de Visual Basic 2005 como lenguaje, para que sepamos realizar con él, cualquier trabajo que nos soliciten o que queramos desempeñar. Acompáñeme entonces en este capítulo y en los dos siguientes, para que juntos aprendamos las partes fundamentales y más interesantes de este lenguaje. 3.1.- Tipos de datos Ya hemos comentado algo acerca de los tipos de datos cuando en el capítulo anterior hablábamos de CTS, pero ¿cómo afecta esto en un lenguaje como Visual Basic 2005?. En realidad, para el programador, escribir una aplicación en .NET es una tarea fácil. A independencia de lo que ocurría antes de .NET, cuando una aplicación interactuaba con otra, compartía funciones, o compartía código, el programador tenía la obligación de conocer cómo estaba diseñada y desarrollada una para poder hacer la segunda y que interactuaran entre sí sin que hubiera problemas. En .NET, esta problemática ha desaparecido, y así, un programador que escriba una aplicación en C# por ejemplo con el fin de que interactúe con una aplicación desarrollada por otro programador en Visual Basic 2005, es independiente a la forma en la que se ha diseñado o escrito, ya que al compartir el mismo conjunto de tipos de datos de .NET, ambas aplicaciones se entenderán a la perfección. Este aspecto conviene tenerlo en cuenta y tenerlo muy claro, pues el avance es considerable, y pocos piensan en ello. .NET nos trae como vemos, muchos avances, como los mismos Servicios Web que en este manual no trataremos y que ha resultado ser otro de los avances más interesantes de la informática, aunque inexplicablemente aún hoy y quizás por falta de conocimiento y comprensión de lo que es y de lo que puede hacer por nosotros, aún no ha estallado como era de esperar. A continuación, veremos los tipos de datos que podemos encontrarnos en Visual Basic 2005, y como utilizarlos. 3.1.1.- Tipos primitivos Los tipos definidos en .NET Framework, tienen su equivalente al tipo definido en Visual Basic 2005. A continuación, se exponen los diferentes tipos de datos de .NET y su correspondiente equivalencia en Visual Basic 2005.

.NET Framework Visual Basic 2005

System.Boolean Bolean

System.Byte Byte

System.Int16 Short

System.Int32 Integer

System.Int64 Long

System.Single Single

System.Double Double

System.Decimal Decimal

System.Char Char


152

System.String String

System.Object Object

System.DateTime Date

System.SByte SByte

System.UInt16 UShort (valor sin signo -, sólo +)

System.UInt32 UInteger (valor sin signo -, sólo +)

System.UInt64 ULong (valor sin signo -, sólo +)

Tabla 3.1: tipos primitivos en .NET Aún y así, podemos escribir nuestras aplicaciones utilizando ambos tipos de datos obteniendo el mismo resultado. La declaración de cualquier tipo de datos en Visual Basic 2005, se realiza por lo general salvo excepciones que veremos más adelante, declarando la variable anteponiendo la palabra reservada Dim delante de la variable seguida de la palabra reservada As y del tipo de dato a declarar. Podemos obviar también el tipo de dato a declarar, pero lo más recomendable es indicar el tipo de dato para evitar errores o malas interpretaciones de los datos. Un ejemplo práctico de declaración y uso de variables dentro de un procedimiento, método o evento en Visual Basic 2005, es el que corresponde con el siguiente código de ejemplo:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intVar1 As Integer Dim intVar2 As Int32 intVar1 = 12345 intVar2 = intVar1 MessageBox.Show("intVar1: " & intVar1 & " " & _ intVar1.GetType.ToString() & vbCrLf & _ "intVar2: " & intVar2 & " " & _ intVar2.GetType.ToString()) End Sub

En este ejemplo podemos observar que hemos declarado dos variables, una de tipo Integer y otra de tipo Int32 que según la tabla 1, son dos tipos de declaraciones equivalentes. En este mismo ejemplo, mostramos un mensaje por pantalla con los resultados de las dos variables y con el tipo de variable que representa. En la figura 3.1 podemos observar este ejemplo en ejecución:

Figura 3.1: ejemplo de declaración de tipos de variables en ejecución.

Nota del código fuente: Si apreciamos el código fuente anterior, observaremos que hay líneas de código que aparecen con el carácter _ que indica a Visual Basic la continuación del código en la siguiente línea. La continuación de una instrucción de código en la línea siguiente, está formado por un espacio en blanco, seguido del carácter _.

Como vemos, .NET transforma el tipo de datos Integer de Visual Basic 2005 en un tipo de datos propio de .NET que es el tipo de datos Int32. Evidentemente,


153

podemos declarar una variable dentro de nuestra aplicación de ambas formas, aunque lo más frecuente será hacerlo mediante la palabra reservada Integer. Pero con todo y con esto, la declaración de variables en .NET puede hacerse más extensiva, ya que podemos declarar las variables también, utilizando unos símbolos o caracteres detrás de las variables, que indiquen el tipo de variable utilizada. La siguiente tabla aclarará en algo esto que comento, y el posterior ejemplo, terminará por explicarlo de forma práctica.

Tipo de Dato Símbolo Carácter

Short S

Integer % I

Long & L

Single ! F

Double # R

Decimal @ D

UShort US

UInteger UI

ULong UL

String $

Tabla 3.2: declaración explícita de los tipos de datos en .NET De esta manera, podemos declarar un objeto -Object- en un tipo de datos de forma implícita. El tipo de dato Object, es un tipo de dato que aún no hemos tratado y del cuál heredan el resto de tipos de datos. De hecho y por decirlo de alguna forma, es el comodín de los tipos de datos de .NET. A continuación, veremos un sencillo ejemplo que explique y aclare el funcionamiento de los tipos de datos indicados así implícita o explícitamente.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intVar1 As Integer Dim intVar2 As Int32 Dim intVar3, intVar4 As Object intVar1 = 12345 intVar2 = intVar1 intVar3 = 12345I intVar4 = 12345% MessageBox.Show("intVar1: " & intVar1 & " " & _ intVar1.GetType.ToString() & vbCrLf & _ "intVar2: " & intVar2 & " " & _ intVar2.GetType.ToString() & vbCrLf & _ "intVar3: " & intVar3 & " " & _ intVar3.GetType.ToString() & vbCrLf & _ "intVar4: " & intVar4 & " " & _ intVar4.GetType.ToString()) End Sub

Este ejemplo en ejecución es el que puede verse en la figura 3.2.


154

Figura 3.2: ejemplo de declaración implícita y explícita de tipos de datos en ejecución. Otro aspecto a tener en cuenta en Visual Basic 2005, es la posibilidad de trabajar con dígitos en formato Octal y en formato Hexadecimal. Para esto, trabajaremos con el carácter O y el carácter H anteponiendo a estos caracteres el símbolo &. El siguiente ejemplo práctico, nos muestra como trabajar con estos caracteres para indicar una cantidad en formato Octal o Hexadecimal.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim Oct As Integer Dim Hex As String Oct = &O3 Hex = &HA0 MessageBox.Show("Valor Octal: " & Oct & _ vbCrLf & _ "Valor Hexadecimal: " & Hex) End Sub

Otra significación con la asignación directa o indirecta de valores es el apartado referente al trabajo con fechas. Si queremos, podemos incluir una fecha entre los caracteres #, teniendo en cuenta que la fecha debe ir en formato MES/DIA/AÑO. Sirva el siguiente ejemplo como demostración de esto que estamos comentando:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim dateVar As Date dateVar = #12/17/2005# MessageBox.Show(dateVar) End Sub

3.1.2.- Declaración de constantes, un tipo de declaración especial Antes de continuar adentrándonos en la declaración de variables, vamos a explicar un tipo de declaración muy útil y frecuentemente usado, la declaración y uso de constantes. Dentro de una aplicación, puede ser adecuado e interesante la declaración y uso de variables constantes cuyo valor asignado, no sea modificable a lo largo de la aplicación y que se utilice para un caso o ejecución determinada. El típico valor constante de ejemplo en toda demostración del uso y declaración de variables constantes es el valor PI. Para declarar una variable de tipo constante, tendremos que declarar el tipo de variable con la palabra reservada Const delante de la variable. El siguiente ejemplo, facilitará la comprensión de la declaración y uso de este tipo de constantes.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Const PI As Double = 3.1416 Dim dValor As Decimal dValor = (2 * PI) ^ 2 MessageBox.Show(dValor) End Sub

Este pequeño ejemplo demostrativo en ejecución del uso de declaración de constantes es el que puede verse en la figura 3.3.


155

Figura 3.3: ejemplo demostrativo del uso de variables constantes. 3.1.3.- Declaración de variables Ya hemos adelantado y ya hemos visto, como declarar variables en Visual Basic 2005. Anteriormente, hemos visto que la declaración de una variable dentro de un procedimiento, se realiza anteponiendo la palabra reservada Dim al nombre de la variable, seguida de la palabra reservada As y el tipo de dato declarado. Un ejemplo sencillo sería:

Dim strMiVar As String Pero hay un aspecto en la declaración de variables que conviene conocer, ya que este aspecto, es el diferenciador más importante entre el Visual Basic de la plataforma .NET y el Visual Basic anterior a .NET. Si declaramos un conjunto de variables de un mismo tipo y las declaramos de la forma:

Dim strMiVar1, strMiVar2, strMiVar3 As String Estaremos declarando las tres variables strMiVar1, strMiVar2 y strMiVar3 como variables de tipo String. En versiones anteriores a .NET de Visual Basic, esta misma declarativa, hacía que las dos primeras variables se declararan de tipo Variant y la última de tipo String.

Ojo: El tipo de declaración Variant de versiones de Visual Basic anteriores a .NET, ya no existe. El tipo Object, es el tipo más adecuado para sustituir a este tipo de declaración.

De todas las maneras, en Visual Basic 2005, podemos declarar una variable y asignarla un valor inicial a la hora de declarar esta variable. El siguiente ejemplo, ayudará a comprender mejor esto:

Dim strMiVar As String = "Ejemplo en Visual Basic 2005" Inclusive podemos declarar variables de forma anidada y asignarle valores directamente, como por ejemplo:

Dim Val1 As Integer = 2, Val2 As Integer = 3, Val3 As Integer = Val1 + Val2 MessageBox.Show(Val3)

Este pequeño ejemplo nos mostrará el valor de la suma de las dos primeras variables declaradas e inicializadas como se indica en la figura 3.4.

Figura 3.4: ejecución del ejemplo de inicialización de variables declaradas.


156

Otro aspecto destacable en la declaración de variables en Visual Basic 2005, es el uso y gestión de variables de tipo String. Este tipo de variables se declaran como Nothing en su inicialización. Es decir, una variable String que se declara por primera vez, no se inicializa a "" -cadena vacía- sino que se inicializa a un valor Nothing. Como la teoría puede superar a veces a la práctica y sino tocamos no creemos, lo mejor es ver esto con un ejemplo que nos facilite la comprensión de todo lo que estamos explicando:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim strValor As String If strValor Is Nothing Then MessageBox.Show("Nothing") Else MessageBox.Show("Tiene datos") End If End Sub

Este primer ejemplo, mostrará en pantalla que el valor de la variable strValor es Nothing, y que por lo tanto, se trata de una variable no inicializada. Dentro del entorno de Visual Basic 2005 Express Edition, recibiremos una pequeña ayuda visual al observar que la palabra strValor aparece subrayada indicándonos que no se ha asignado un valor a la variable. Pero esto sólo es un aviso, no es un error, y de hecho, la aplicación de ejemplo se puede compilar y ejecutar sin ninguna complicación.

Figura 3.5: mensaje de advertencia de Visual Basic 2005 sobre la inicialización de variable. El segundo ejemplo sin embargo, es el mismo que el anterior con la salvedad de que la variable strValor es inicializada. En este segundo ejemplo, la variable ya no vale Nothing, sino que su valor ha cambiado al valor modificado en su asignación:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim strValor As String = "Visual Basic 2005" If strValor Is Nothing Then MessageBox.Show("Nothing") Else MessageBox.Show("Tiene datos") End If End Sub

Por último, mencionar un aspecto destacable sobre el carácter " en las cadenas de texto. Una cadena de texto debe de ser introducida entre caracteres ". Sin embargo, podemos encontrarnos con la posibilidad de que queremos escribir este mismo carácter dentro de la cadena de texto. Esto se hará duplicando siempre el carácter " que queremos escribir. Si por ejemplo queremos escribir la palabra Hola, declararemos nuestra variable como:

txtVar = "Hola"

Si por otro lado, deseamos escribir Hol"a, deberemos entonces escribir algo


157

similar a:

txtVar = "Hol""a"

De esta manera, aparecerá en pantalla el texto Hol"a. 3.1.4.- Palabras clave Las palabras clave, son palabras con un significado especial dentro de un lenguaje de programación, en nuestro caso, dentro de Visual Basic 2005. A las palabras clave, también se las conoce como palabras reservadas y no pueden ser utilizadas como identificadores excepto en casos en los cuales se puede forzar su uso. Esto último se consigue poniendo la definición del identificador entre los caracteres [ y ]. Un ejemplo práctico de este uso es el que se detalla a continuación:

Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim [String] As String [String] = "Hola Visual Basic 2005" MessageBox.Show([String]) End Sub End Class

Las palabras clave de Visual Basic 2005 son las siguientes:

AddHandler AddressOf Alias And

AndAlso As Boolean ByRef

Byte ByVal Call Case

Catch CBool CByte CChar

CDate CDbl CDec Char

CInt Class CLng CObj

Const Continue CSByte CShort

CSng CStr CType CUInt

CULng CUShort Date Decimal

Declare Default Delegate Dim

DirectCast Do Double Each

Else ElseIf End EndIf

Enum Erase Error Event

Exit False Finally For

Friend Function Get GetType

Global GoSub GoTo Handles

If Implements Imports In

Inherits Integer Interface Is

IsNot Let Lib Like

Long Loop Me Mod

Module MustInherit MustOverride MyBase

MyClass Namespace Narrowing New

Next Not Nothing NotInheritable

NotOverridable Object Of On

Operador Option Optional Or


158

OrElse Overloads Overridable Overrides

ParamArray Partial Private Property

Protected Public RaiseEvent ReadOnly

ReDim REM RemoveHandler Resume

Return SByte Select Set

Shadows Shared Short Single

Static Step Stop String

Structure Sub SyncLock Then

Throw To True Try

TryCast TypeOf UInteger ULong

UShort Using Variant Wend

When While Widening With

WithEvents WriteOnly Xor

3.1.5.- Listas enumeradas Otro tipo de declaración es la que se hace a las denominadas listas enumeradas. Las listas enumeradas son listas de variables o datos que hacen referencia a índices y que empieza desde el 0 en adelante, aunque estos valores pueden ser alterados según nuestra conveniencia. Para declarar una lista enumerada, tendremos que hacerlo utilizando la palabra reservada Enum. El siguiente ejemplo, demuestra como declarar una lista enumerada y como usar sus valores:

Private Enum Ejemplo Valor1 Valor2 Valor3 End Enum Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiEjemplo As Ejemplo MiEjemplo = Ejemplo.Valor1 MessageBox.Show(MiEjemplo) End Sub

Este pequeño ejemplo en ejecución es el que puede verse en la figura 3.6.

Figura 3.6: ejecución del ejemplo de inicialización de variables declaradas. Aún y así y como ya hemos adelantado brevemente, podemos forzar a que la lista enumerada posea valores forzosos según nuestros intereses. El siguiente ejemplo, demuestra esto que comento:


159

Private Enum Ejemplo Valor1 = 3 Valor2 = 5 Valor3 = 1 End Enum Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiEjemplo As Ejemplo MiEjemplo = Ejemplo.Valor1 MessageBox.Show(MiEjemplo) End Sub


Figura 3.7: ejecución del ejemplo de inicialización de variables declaradas forzando valores. Pero también podemos forzar el tipo de datos de una lista enumerada. Eso sí, el tipo de datos debe de pertenecer al grupo de tipos de datos entero. La figura 3.8 muestra dentro del entorno de desarrollo Visual Basic 2005, este grupo de tipos de datos.

Figura 3.8: declaración posible de tipos de datos dentro de una lista enumerada.

A tener en cuenta: No es nada relevante, pero sí es algo que debemos tener en cuenta por si en algún momento dado, deseamos conocer el tipo o nombre de variable seleccionado de la lista enumerada. Utilizando los ejemplos anteriores, observamos las siguientes líneas de código: Dim MiEjemplo As Ejemplo MiEjemplo = Ejemplo.Valor2 MessageBox.Show(MiEjemplo.ToString() & ": " & MiEjemplo) Esto dará como resultado el nombre de la lista enumerada seguida del valor, tal y como se indica en la siguiente figura.


160

En algunos momentos, este uso puede resultar especialmente útil. 3.1.6.- Matrices La declaración de matrices es otra de las declarativas en Visual Basic 2005 que debemos tener en cuenta y que en más ocasiones podemos utilizar. La declaración de una matriz se realiza anteponiendo al nombre de la variable dos paréntesis abierto y cerrado, e indicando si así lo queremos, la dimensión de la matriz. Por ejemplo, podemos declarar una matriz de estas dos maneras posibles:

Dim MiArray() As Byte Y de la forma:

Dim MiArray(10) As Byte En el primero de los casos, hemos declarado una matriz de tipo Byte sin dimensiones, es decir, no se ha reservado en memoria el tamaño de la matriz declarada. En el segundo de los casos, hemos declarado la misma matriz con el mismo tipo de datos, indicando además el tamaño que deberá ocupar en memoria. Hemos reservado su espacio lo utilicemos o no. Toda matriz declarada en Visual Basic 2005, empezará con el subíndice 0 y así en adelante. En el caso de la matriz declarada como MiArray(10), esta matriz no tendrá 10 posiciones en memoria reservadas para ser utilizadas, sino 11, es decir, la cantidad de posiciones reservadas en memoria para una matriz, oscila desde 0 hasta el número de posiciones indicada más 1. MiArray(10) = 10 +1 posiciones. Un ejemplo sencillo y que nos permita comprender esto de forma rápida es el que se detalla a continuación:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiArray(10), I As Byte For I = 0 To 10 MiArray(I) = I * 2 Next Dim strValores As String = "" For I = 0 To 10 strValores += MiArray(I) & " " Next MessageBox.Show(strValores.Trim) End Sub

Nuestro ejemplo de demostración en ejecución es el que se puede ver en la figura 3.10.

Figura 3.10: declaración posible de tipos de datos dentro de una lista enumerada.

Nota del código fuente: La línea strValores += MiArray(I) & " " es equivalente a escribir:


161

strValores = strValores + MiArray(I) & " " Se utiliza por lo tanto += en este caso, para concatenar un dato en otro.

Aviso: Los índices inferiores de una matriz en Visual Basic 2005, siempre deben empezar por 0.

Otra particularidad es utilizar la palabra reservada To para indicar las posiciones reservadas para nuestra matriz. En sí, es una equivalencia y por ello, podemos declarar una matriz de estas formas:

Dim MiArray(10) As Byte O bien:

Dim MiArray(0 To 10) As Byte Una particularidad dentro de las matrices, es la inicialización de estas dentro de nuestras aplicaciones. Para realizar esto, basta con introducir los valores entre llaves. Los siguientes breves ejemplos, nos enseñan y demuestran como llevar a cabo esto.

Dim MiArray1() As Byte = {2} Dim MiArray2() As String = {"Ejemplo"} MessageBox.Show(MiArray1(0) & " - " & MiArray2(0))

El único requisito para inicializar matrices es no indicar el número de posiciones que tendrá esta. Otra particularidad en el uso de matrices, son las matrices de más de una dimensión. Hasta ahora hemos visto como declarar y trabajar con matrices de una dimensión, pero en el caso de utilizar matrices de más de una dimensión, la forma es similar aunque no exactamente igual, ya que deberemos tener en cuenta que podemos movernos en dos direcciones dentro de la matriz, teniendo en este caso, tantas columnas como dimensiones haya. Un ejemplo práctico de esto que comentamos es el que se detalla a continuación:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiArray1(2, 1) As String MiArray1(0, 0) = "María" MiArray1(0, 1) = 28 MiArray1(1, 0) = "Juan" MiArray1(1, 1) = 33 MiArray1(2, 0) = "Lara" MiArray1(2, 1) = 23 Dim I As Integer Dim strCadena As String = "" For I = 0 To 2 strCadena += MiArray1(I, 0) & " " & MiArray1(I, 1) & vbCrLf Next MessageBox.Show(strCadena) End Sub

Este ejemplo en ejecución es el que se puede observar en la figura 3.11.


162

Figura 3.11: ejecución de una matriz de más de una dimensión. Otro aspecto a la hora de trabajar con matrices en Visual Basic 2005, es la capacidad de cambiar o modificar su tamaño o dimensión en memoria. Esto lo podemos lograr utilizando las palabras reservadas ReDim y ReDim Preserve. Un ejemplo práctico que demuestre esto que estamos comentando es el que se detalla a continuación:

Dim MiArray() As String ReDim MiArray(2) MiArray(0) = "Uno" : MiArray(1) = "Dos" : MiArray(2) = "Tres" ReDim Preserve MiArray(3) MiArray(3) = "Cuatro" MessageBox.Show(MiArray(0))

Nota del código fuente: Podemos concaternar varias líneas o instrucciones de código fuente separándolas con el carácter : como se puede observar en el código anterior.

Por último, hablaremos de otro aspecto relacionado con las matrices. Hablamos de sus tamaños o dimensiones. En muchos momentos, nos puede resultar muy útil recorrer los elementos de una matriz para trabajar o manipular los datos que contiene ésta, pero puede ocurrir también, que no conozcamos la dimensión de una matriz en un momento dado, por lo que lo más útil es utilizar algunos métodos de Visual Basic 2005 que nos facilite estas tareas. Esto se consigue utilizando la propiedad Lenght de la variable matriz declarada. Así nos dará el número de elementos que tiene la matriz. Un ejemplo del uso de este método sería:

Dim MiArray(2) As String MiArray(0) = "Uno" : MiArray(1) = "Dos" : MiArray(2) = "Tres" MessageBox.Show(MiArray.Length)

La única particularidad a tener en cuenta con el uso de este método, es que en nuestro ejemplo, MiArray.Lenght nos indicará 3 como resultado y no 2, ya que la información que nos está devolviendo esta propiedad es el número de elementos o dimensiones dentro de la matriz. Si por otro lado, lo que deseamos es eliminar todos los elementos de una matriz de forma rápida, lo mejor será utilizar la palabra reservada Nothing para quitar las referencias de los elementos de la matriz en memoria. Un ejemplo práctico de esto que comentamos es el que se detalla a continuación:


163

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiArray() As String ReDim MiArray(2) MiArray(0) = "Uno" : MiArray(1) = "Dos" : MiArray(2) = "Tres" MiArray = Nothing If MiArray Is Nothing Then MessageBox.Show("Nothing") Else MessageBox.Show(MiArray.Length) End If End Sub

De hecho, tenemos que tener cuidado a la hora de trabajar con una matriz y crear otra dependiendo de la cantidad de elementos de la primera. Esto lo veremos a continuación. Por eso y para casi concluir el completo apartado de las matrices diremos que en otras muchas ocasiones, consideraremos interesante el hecho de copiar una matriz en otra para manipular sus datos, ordenarlos o realizar cualquier otra acción que consideremos oportuna. El siguiente ejemplo demuestra esto:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim strMiArray() As String = {"Urano", "Neptuno", "Plutón", "Sol"} Dim strOtroArray() As String ReDim strOtroArray(strMiArray.Length - 1) strMiArray.CopyTo(strOtroArray, 0) MessageBox.Show(strOtroArray(0)) End Sub

Debemos notar la declaración de redimensionado de la segunda matriz utilizando para ello la propiedad Lenght para saber la dimensión de la matriz. Si observamos bien esto, veremos que estamos creando una segunda matriz con una dimensión igual a strMiArray.Length - 1. Recordemos que los elementos de la matriz empiezan por 0 y que esta propiedad informa del número total de elementos, siendo el índice 0 el primer elemento. Ya para finalizar este apartado del uso, gestión y manipulación de matrices, hablaremos de otra forma de recorrer una matriz, utilizando para ello, el bucle For Each, un bucle especialmente útil para el tratamiento de este tipo de situaciones. El uso de este bucle sería de la forma siguiente:

For Each <cadena> In <matriz> … Next

Quizás un ejemplo, nos facilite muchísimo la comprensión del uso de este tipo de bucles:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiArray() As String = {"Uno", "Dos", "Tres"} Dim strCadena As String Dim strMsg As String = "" For Each strCadena In MiArray strMsg += strCadena & " " Next MessageBox.Show(strMsg.Trim) End Sub

3.2.- Comentarios y organización de código


164

Cuando escribimos código en Visual Basic 2005 y también dentro del entorno Microsoft Visual Basic 2005 Express Edition, tenemos la posibilidad de añadir comentarios y organizar el código. Para añadir comentarios a nuestro código, lo podemos hacer utilizando el carácter ' o utilizando la palabra reservada REM. Un ejemplo del uso de comentarios sería por ejemplo:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load 'Esto es un comentario REM esto es otro comentario End Sub

Otra alternativa que tenemos a la hora de escribir el código de nuestras aplicaciones es la posibilidad de añadir pequeñas porciones o regiones de comentarios que nos facilite la organización, clasificación, y ordenación del código de nuestro código. Esto lo lograremos utilizando la instrucción:

#Region "<texto>" … #End Region

Un ejemplo del uso de esta instrucción es la que se detalla a continuación:

#Region "Ejemplo" Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load 'Esto es un comentario REM esto es otro comentario End Sub #End Region

Una particularidad de esta instrucción, es como hemos comentado ya, la posibilidad de organizar el código o instrucciones que quedan introducidas dentro de la instrucción #Region "…" ... #End Region. De hecho, en Visual Basic 2005 Express Edition, podemos contraer y expandir el contenido de estas instrucciones tal y como se muestra en las figuras 3.12 y 3.13.

Figura 3.12: código expandido en el entorno de Visual Basic 2005 Express Edition.

Figura 3.13: código contraído en el entorno de Visual Basic 2005 Express Edition. 3.3.- Control de flujo Cuando escribimos código, muchas veces tenemos uno o más caminos de realizar las tareas encomendadas, es decir, de elegir el flujo a través del cuál debe


165

discurrir nuestra aplicación. Eso es justamente lo que veremos a continuación. 3.3.1.- Operadores lógicos y operadores relacionales Uno de los aspectos a tener en cuenta a la hora de hacer comparaciones, utilizar o seleccionar un camino o flujo u otro, es el uso de operadores lógicos y operadores relacionales. En la tabla 3.3, podemos observar los operadores relacionales con su correspondiente descripción:

Operador relacional

Descripción

= Da como resultado verdadero si las expresiones comparadas sin iguales

< Da como resultado verdadero si la expresión de la izquierda es menor que la expresión de la derecha

> Da como resultado verdadero si la expresión de la izquierda es mayor que la expresión de la derecha

<> Da como resultado verdadero si la expresión de la izquierda es distinta que la expresión de la derecha

<= Da como resultado verdadero si la expresión de la izquierda es menor o igual que la expresión de la derecha

>= Da como resultado verdadero si la expresión de la izquierda es mayor o igual que la expresión de la derecha

Tabla 3.3: operadores relacionales en Visual Basic 2005 Por otro lado, en la tabla 3.4 podemos observar los operadores lógicos que en muchas ocasiones se utilizan junto a los operadores relacionales para combinar las diferentes acciones:

Operador lógico

Descripción

And Da como resultado verdadero si las dos expresiones comparadas son verdaderas

Or Da como resultado verdadero si una de las dos expresiones comparadas es verdadera

Not Invierte el valor de la expresión. Dos negaciones es una afirmación, y negar una afirmación es el valor contrario de la afirmación

Xor Da como resultado verdadero solamente si una de las dos expresiones comparadas es verdadera

AndAlso Da como resultado verdadero si las dos expresiones comparadas son verdaderas, con la particularidad de que evalúa la segunda parte de la expresión si la primera la cumple

OrElse Da como resultado verdadero si una de las dos expresiones comparadas es verdadera con la particularidad de que si cumple la primera expresión, no continúa con la siguiente dando por verdadera la comparación lógica

Tabla 3.4: operadores lógicos en Visual Basic 2005 3.3.2.- If…Then…Else La construcción If…Then…Else, nos permite ejecutar una o más condiciones que podemos comparar utilizando operadores relacionales y operadores lógicos.


166

En este tipo de comparaciones, podemos comparar las condiciones de forma anidada o tan compleja como lo deseemos. Lo mejor es ver esto con un ejemplo práctico:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 If intValor > 5 Then MessageBox.Show("Valor mayor que 5") Else MessageBox.Show("Valor menor que 6") End If End Sub


Figura 3.14: evaluación de la condición If…Then…Else. Una particularidad de este tipo de instrucciones es la que corresponde a la palabra reservada IIf que se utiliza para ejecutar la condición de forma anidada en una sola instrucción, siendo su sintaxis la siguiente:

IIf(<expresión>, True, False) Un ejemplo práctico del uso de esta claúsula que sólo corresponde a un tipo de uso especial de Visual Basic, es la siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 Dim strMsg As String = "" MessageBox.Show(IIf(intValor > 5, "Valor mayor que 5", "Valor menor que6")) End Sub

El resultado de ejecutar este ejemplo, es el mismo que el ejemplo anterior y que puede verse en la figura 14. En el caso de querer comparar condiciones de forma anidada, emplearemos tantas claúsulas Else o ElseIf como deseemos. Un breve ejemplo de demostración de este uso es el siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 If intValor > 5 Then MessageBox.Show("Valor mayor que 5") ElseIf intValor < 5 Then MessageBox.Show("Valor menor que 5") Else MessageBox.Show("Valor igual a 5") End If End Sub


167

También y en el caso de utilizar una única condición, podemos declarar la instrucción If dentro de la misma línea de código sin usar End If, como por ejemplo:

If intValor > 5 Then MessageBox.Show("Valor mayor que 5")

3.3.3.- Select…Case La sentencia Select…Case se utiliza por lo general, para evaluar varios grupos de sentencias e instrucciones dependiendo del valor de la expresión a evaluar. Hay diferentes formas de utilizar esta sentencia, las cuales veremos a continuación:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 Select Case intValor Case Is > 5 MessageBox.Show("Valor mayor que 5") Case Is = 5 MessageBox.Show("Valor igual a 5") Case Is < 5 MessageBox.Show("Valor menor que 5") End Select End Sub

Observamos en este ejemplo, que el valor de la expresión intValor se cumple en alguno de los casos dentro de la sentencia de evaluación. En el caso de que no ocurra esto, podemos utilizar la sentencia Case Else como veremos a continuación:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 Select Case intValor Case Is > 5 MessageBox.Show("Valor mayor que 5") Case Is < 5 MessageBox.Show("Valor menor que 5") Case Else MessageBox.Show("Valor igual a 5") End Select End Sub

Pero dentro de esta sentencia, podemos también utilizar la palabra reservada To en la claúsula Case como por ejemplo Case 1 To 5. Para comprender mejor esto, lo mejor es verlo con un ejemplo:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 Select Case intValor Case 1 To 3 MessageBox.Show("Valor entre 1 y 3") Case 4 To 6 MessageBox.Show("Valor entre 4 y 5") Case Else MessageBox.Show("Valor no comprendido entre 1 y 6") End Select End Sub

También podemos comparar el valor de la expresión con varios valores, como por


168

ejemplo:

Case 1, 2, 3 3.4.- Bucles En otras circunstancias a la hora de escribir nuestras aplicaciones, nos podemos ver interesados o incluso obligados a utilizar bucles en nuestro código, con el fin y objetivo de evaluar expresiones y sentencias. Esto es justamente lo que veremos a continuación. 3.4.1.- Bucles de repetición o bucles For Es uno de los bucles más extendidos para recorrer una determinada porción de código un número de veces limitado. Si ese número de veces se convierte en ilimitado, se denomina bucle infinito y la ejecución del proceso se volvería eterna, por lo que es un tipo de bucle a controlar en nuestras aplicaciones. La nomenclatura de uso de este tipo de bucle es de la siguiente manera:

For <variable> = <valor inicial> To <valor final> Step <salto> … Next

Un ejemplo nos ayudará a comprender esto de forma sencilla y práctica:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 Dim I As Integer, strCadena As String = "" For I = 1 To intValor strCadena += Chr(I + 64) Next MessageBox.Show(strCadena) End Sub

Este ejemplo en ejecución es el que puede observarse en la figura 3.15.

Figura 3.15: ejecución de un ejemplo de demostración del uso de un bucle For. Como vemos en el ejemplo anterior, no hemos utilizado la palabra reservada Step ya que no es necesario utilizarla. A continuación veremos un ejemplo del uso de esta palabra reservada.

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Integer = 5 Dim I As Integer, strCadena As String = "" For I = 1 To intValor Step 2 strCadena += Chr(I + 64) Next MessageBox.Show(strCadena) End Sub


169


Figura 3.16: ejecución de un ejemplo de demostración del uso de un bucle For con Step. 3.4.2.- Bucles Do While…Loop y Do Until…Loop El uso del bucle Do While...Loop es realmente útil en el caso de querer realizar una o varias tareas mientras se cumpla una determinada condición. De esta manera, este bucle se utiliza de la forma:

Do While <condición> … Loop

Un ejemplo práctico que nos aleccione en el uso de este bucle sería el siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Byte = 5 Dim intResultado As Byte Do While intValor > 0 intResultado += intValor intValor -= 1 Loop MessageBox.Show(intResultado) End Sub

Nuestro ejemplo en ejecución es el que puede verse en la figura 3.17.

Figura 3.17: ejecución de un ejemplo de uso del bucle Do While. Otra particularidad de este bucle es el uso del mismo mediante la siguiente forma:

Do … Loop While <condición>

De hecho, nuestro ejemplo anterior, quedaría de la forma:


170

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Byte = 5 Dim intResultado As Byte Do intResultado += intValor intValor -= 1 Loop While intValor > 0 MessageBox.Show(intResultado) End Sub

Pero también podemos utilizar otro bucle, el bucle Do Until...Loop que nos permite ejecutar una o más sentencias de código, hasta que se cumpla una determinada condición. En este caso, la estructura del bucle sería de la forma:

Do Until <condición> … Loop

Un ejemplo práctico del uso de este tipo de bucles sería el que se detalla a continuación:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Byte = 5 Dim intResultado As Byte Do Until intValor < 1 intResultado += intValor intValor -= 1 Loop MessageBox.Show(intResultado) End Sub

De igual manera, podemos hacer uso de este bucle utilizándolo de la forma:

Do … Loop Until <condición>

En este caso, el ejemplo práctico del uso de este bucle sería de la forma:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim intValor As Byte = 5 Dim intResultado As Byte Do intResultado += intValor intValor -= 1 Loop Until intValor < 1 MessageBox.Show(intResultado) End Sub

3.5.- Estructuras Las estructuras están formadas por uno ó más miembros y cada miembro puede ser de un tipo de datos determinado, pudiendo tener una estructura con varios miembros de diferentes tipos de datos. Por otro lado, las estructuras se definen de la forma siguiente:

Structure <nombre> Public <nombre> As <tipo> End Structure

Un ejemplo práctico del uso y declaración de estructuras sería el siguiente:


171

Private Structure Persona Public Nombre As String Public Edad As Byte End Structure Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiEst As Persona MiEst.Nombre = "Santiago" MiEst.Edad = "32" MessageBox.Show(MiEst.Nombre & " tiene " & MiEst.Edad & " años") End Sub

Este ejemplo en ejecución es el que se muestra en la figura 3.18.

Figura 3.18: ejecución de un ejemplo de uso estructuras. Visual Basic por otro lado, nos ofrece la posibilidad de trabajar con la palabra reservada With para realizar acciones repetitivas sin necesidad de escribir una porción de código muchas veces. En el caso de trabajar con estructuras, este uso es muy interesante, aunque su uso se puede extender a más situaciones. Un ejemplo práctico de este uso sería el siguiente:

Private Structure Persona Public Nombre As String Public Edad As Byte End Structure Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiEst As Persona With MiEst .Nombre = "Santiago" .Edad = 32 End With MessageBox.Show(MiEst.Nombre & " tiene " & MiEst.Edad & " años") End Sub

3.6.- Operadores aritméticos Los operadores aritméticos se utilizan en los lenguajes de programación para realizar operaciones matemáticas por lo general, aunque hay excepciones en las cuales utilizamos este tipo de operadores, para realizar operaciones con cadenas de texto. Los operadores aritméticos que podemos usar en Visual Basic 2005 son los que se detallan en la tabla 3.5:

Operador aritmético

Descripción

+ Operador para realizar la suma de dos elementos

- Operador para realizar la resta de dos elementos

* Operador para realizar el producto de dos


172

elementos

/ Operador para realizar la división de dos elementos

\ Operador para realizar la división entera (sin decimales) de dos elementos

^ Operador para elevar un número al exponente indicado

Mod Operador para extraer el resto de la división de dos elementos

Tabla 3.5: operadores aritméticos en Visual Basic 2005 Para ver como el funcionamiento de operadores aún utilizándose para operaciones matemáticas, se pueden utilizar también en operaciones entre caracteres, vamos a ver un ejemplo que nos demuestre este hecho:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim I, J As Integer Dim strI, strJ As String I = 2 : J = 3 strI = "Uno" : strJ = "Dos" MessageBox.Show(I + J & vbCrLf & strI + " " + strJ) End Sub


Figura 3.19: ejecución del ejemplo de demostración del uso de operadores aritméticos.


173

CAPÍTULO 4

VISUAL BASIC 2005, OTRAS CARACTERÍSTICAS DEL LENGUAJE ESTE CAPÍTULO AVANZA EN EL RECORRIDO DE LAS ESPECIFICACIONES GENÉRICAS DEL LENGUAJE VISUAL BASIC 2005. Ya hemos visto algunas de las partes más generales y necesarias para la comprensión de la programación con Visual Basic 2005. A continuación, veremos algunas de las partes de tipo avanzado correspondientes al lenguaje Visual Basic 2005 y que conviene que conozcamos, cosas como la creación de métodos, clases, propiedades, conocer genéricamente el ámbito de las variables de una aplicación, etc. 4.1.- Métodos Los métodos son las partes de código más cercanas a las funciones que se encargan de ejecutar una o varias instrucciones. El siguiente ejemplo, muestra la declaración y uso de un método sencillo:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MiMetodo() End Sub Private Sub MiMetodo() Dim strNombre As String strNombre = "Visual Basic 2005" MessageBox.Show(strNombre) End Sub

De todos los modos, los métodos pueden ser utilizados de manera tal, que podamos pasarlos argumentos con el fin de trabajar con ellos. Los argumentos pasados, pueden ser de cualquier tipo. Un ejemplo práctico sería el siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MiMetodo("Visual Basic 2005") End Sub Private Sub MiMetodo(ByVal strTxt As String) MessageBox.Show(strTxt) End Sub

Otra particularidad a tener en cuenta cuando trabajamos con métodos, es la posibilidad de llamarlos por el nombre. Esto se consigue utilizando la instrucción CallByName. Un ejemplo del uso en Visual Basic 2005 de esta instrucción es la siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MiMetodo() End Sub Private Sub MiMetodo() CallByName(Me, "Text", CallType.Set, "Mi Formulario") End Sub

Aún y así, podemos hacer un uso de parámetros mucho más avanzados al que hemos hecho hasta ahora, es decir, podemos utilizar y pasar parámetros como valor o como referencia. ¿Qué significa esto?. Es justamente lo que veremos en el siguiente apartado.


174

4.2.- Parámetros como valor y parámetros como referencia Cuando trabajamos con parámetros, podemos pasar un parámetro como valor ByVal o como referencia ByRef. El comportamiento de este tipo de valores es diferente. Los parámetros se pasan de la misma manera, pero el resultado puede ser completamente distinto. Digamos que un parámetro pasado como valor, es para entendernos, una copia del objeto en memoria que será utilizada por el método para trabajar con ese valor, manipularlo, etc., y una vez que el método se destruye de la memoria al finalizar su uso, el valor de este parámetro desaparece. Un parámetro pasado como referencia es ligeramente diferente, de hecho, en este caso se envía no una copia del elemento en memoria para que trabaje el método con él, sino un puntero al objeto original, por lo que todo lo que se realice con ese objeto, se está realizando directamente con él mismo, no con una copia de ese elemento. La mejor manera de ver esto en funcionamiento es con ejemplos. A continuación veremos un ejemplo de cómo utilizar un método con parámetros pasados como valores:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim strValor As String = "Visual Basic" MiMetodo(strValor) MessageBox.Show(strValor) End Sub Private Sub MiMetodo(ByVal strTxt As String) strTxt += " 2005" MessageBox.Show(strTxt) End Sub

En este caso, en pantalla el método nos devolverá el texto Visual Basic 2005 primero, y Visual Basic después. Pero este resultado cambia radicalmente cuando sobre el mismo código, modificamos el parámetro pasado como valor por un parámetro pasado como referencia. El código de ejemplo quedaría de la forma siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim strValor As String = "Visual Basic" MiMetodo(strValor) MessageBox.Show(strValor) End Sub Private Sub MiMetodo(ByRef strTxt As String) strTxt += " 2005" MessageBox.Show(strTxt) End Sub

El resultado que se obtiene en este segundo caso es diferente al anterior, de hecho, el método nos devolverá el texto Visual Basic 2005 primero, y Visual Basic 2005 después, lo cuál significa que hemos trabajado directamente con el parámetro inicial pasado como referencia dentro del método. Otra particularidad al usar parámetros, es el uso de los denominados parámetros opcionales que se usan con la palabra reservada Optional. Los parámetros opcionales se utilizan por lo general para ejecutar necesidades específicas, por lo que podemos pasar el parámetro marcado como opcional o no, es decir, no estamos obligados a pasarlos. Un ejemplo de uso de parámetros opcionales es el siguiente:


175

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MiMetodo(2) MiMetodo(2, "VB 2005") End Sub Private Sub MiMetodo(ByVal intVal As Integer, Optional ByVal strVal As String= "") MessageBox.Show(IIf(strVal.Trim <> "", intVal & " y " & strVal, intVal)) End Sub

Como podemos observar en el ejemplo anterior, podemos llamar al método utilizando el valor opcional o no. La única obligatoriedad que tenemos en Visual Basic 2005 a la hora de describir el método con el valor opcional, es que tenemos que darle un valor por defecto. A la hora de llamar al método, podemos obviar el uso de ese parámetro o no. Si lo obviamos, el método asignará al parámetro opcional el valor de inicialización indicado. Pero no sólo podemos usar parámetros opcionales como aspecto destacable en el uso de parámetros dentro de nuestros métodos, también podemos utilizar un conjunto de valores pasados como parámetros sin importarnos cuántos valores hay en la matriz de parámetros y cuántos valores lo forman. Esto se logra con el uso de ParamArray, el cuál veremos a continuación en un sencillo ejemplo:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim Matriz() = {"Uno", "Dos", "Tres"} MiMetodo(Matriz) End Sub Private Sub MiMetodo(ByVal ParamArray MiMatriz()) Dim Elemento As Object Dim strCadena As String = "" For Each Elemento In MiMatriz strCadena += Elemento & " " Next MessageBox.Show(strCadena.Trim) End Sub

En este ejemplo, se pasa como parámetro una matriz con un conjunto n de elementos y que podemos manipular dentro del método sin tener en cuenta cuántos elementos lo contiene. 4.3.- Funciones Las funciones son prácticamente idénticas a los métodos, con la salvedad de que devuelven valores para tratarlo en nuestras aplicaciones. De igual manera, podemos trabajar con funciones pasando parámetros por valor o parámetros por referencia. De hecho, vamos a ver también los dos ejemplos. En el caso de pasar parámetros por valor, lo haremos de una forma similar a la empleada anteriormente:


176

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MessageBox.Show(IIf(MiMetodo(128), "Valor > 100", "Valor <= 100")) End Sub Private Function MiMetodo(ByVal bteVal As Byte) As Boolean If bteVal < 101 Then Return False Else Return True End If End Function

Nuestro ejemplo en ejecución es el que se muestra en la figura 4.1.

Figura 4.1: ejecución de una función con parámetros por valor. Opuesto como ya hemos comentado, es el comportamiento de las funciones que tienen parámetros pasados como referencia, al igual que pasaba con los métodos. Un ejemplo nos facilitará muchísimo la comprensión:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MessageBox.Show(IIf(MiMetodo(128), "Valor > 100", "Valor <= 100")) End Sub Private Function MiMetodo(ByRef bteVal As Byte) As Boolean bteVal /= 2 If bteVal < 101 Then Return False Else Return True End If End Function

Nuestro ejemplo en ejecución de parámetros pasados como referencia es el que puede verse en la figura 4.2.

Figura 4.2: ejecución de una función con parámetros por valor. 4.4.- Propiedades Las propiedades tienen una similitud enorme con los métodos. De hecho, son casi iguales, con la salvedad de que se utilizan como una caja en la cuál puedo meter y sacar un objeto con el valor y el estado en el que se encuentre. Supongamos la propiedad Color. Imaginemos esta cualidad, el color, como una propiedad, es decir, sólo hay una y dependiendo de las modificaciones que podamos


177

hacer en un instante t, esta propiedad tendrá un valor u otro. Imaginemos por lo tanto, que podemos meter la mano en la caja de esta propiedad Color y manipular y conocer su estado. Este es el funcionamiento de las propiedades en Visual Basic 2005 y se declara de la siguiente forma:

Private <_variable> As <tipo> Property <variable> As <tipo> Get Return <_variable> End Get Set(ByVal <valor> As <tipo>) <_variable> = <valor> End Set End Property

Lo mejor es ver esto que comentamos con un ejemplo práctico que nos ayude a entenderlo mejor.

Private _color As String = "Blanco" Private Property Color() As String Get Return _color End Get Set(ByVal value As String) _color = value End Set End Property Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load MessageBox.Show(Color) Color = "Rojo" MessageBox.Show(Color) End Sub

4.5.- Excepciones Visual Basic 2005 es un lenguaje orientado a objetos y por lo tanto, la gestión de errores se realiza mediante excepciones. Cuando se produce un error se lanza una excepción. Si utilizamos las instrucciones de código necesarias para gestionar las excepciones, tendremos un control claro en todo momento, sobre la ejecución de nuestras aplicaciones. Las instrucciones para usar excepciones tienen una estructura como la que se detalla a continuación:

Try <sentencias> Catch <tipo_excepción> <control_excepción> Finally <sentencias> End Try

La claúsula Finally no es estrictamente necesaria, aunque dependiendo de la excepción o código a tratar, puede resultar muy interesante. Un ejemplo práctico del uso y gestión de excepciones sería el siguiente:


178

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim I As Integer = 1 Try I = I / 0 Catch ex As Exception MessageBox.Show(ex.Message) Finally I = 1 End Try End Sub

Este ejemplo en ejecución, es el que puede verse en la figura 4.3.

Figura 4.3: ejecución de un ejemplo del uso de excepciones. Sin embargo, podemos utilizar mensajes preparados ya para gestionar las excepciones o personalizar éstas con nuestras propias instrucciones de gestión y uso de excepciones. Un ejemplo del uso de excepciones con mensajes ya preparados en Visual Basic 2005 sería el siguiente:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim I As Integer = 1 Try I = I / 0 Catch ex As OverflowException MessageBox.Show("Se ha producido un error de desbordamiento") End Try End Sub

4.6.- Colecciones Las colecciones funcionan de forma muy parecida a las matrices con la salvedad de que sus elementos pueden ser manipulados y recorridos de forma ligeramente diferente. La nomenclatura de definición de una colección es mediante las instrucciones:

Dim <variable> As New Collection() Existen diferentes métodos que podemos utilizar para manipular los elementos de una colección. El método Add lo utilizaremos para añadir un elemento a la colección, mientras que el método Remove lo utilizaremos para eliminar un elemento dado de la colección. La particularidad entre colecciones y matrices, es que cuando se elimina un elemento de una colección, la lista de elementos se corre una posición a la izquierda ocupando el espacio del elemento eliminado. Lo mismo sucede para añadir un elemento a la colección. En el caso de las matrices sin embargo, podemos borrar el elemento que ocupa una posición determinada en una matriz, pero no podemos eliminar el elemento como en una colección. Y al añadir un elemento, lo añadiremos siempre al final de la matriz. Un ejemplo práctico del uso de colecciones que ponga en práctica esto que comentamos es el siguiente:


179

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiCol As New Collection() MiCol.Add("Uno") MiCol.Add("Dos") MiCol.Add("Tres") Dim I As Integer Dim strCadena As String = "" MiCol.Remove(2) For I = 1 To MiCol.Count strCadena += MiCol.Item(I) & " " Next MessageBox.Show(strCadena.Trim) End Sub

Este ejemplo en ejecución es el que se muestra en la figura 4.4.

Figura 4.4: ejecución de un ejemplo del uso de excepciones. 4.7.- Ámbito y visibilidad de las variables La declaración tipo de variables en Visual Basic 2005, es utilizando la palabra clave Dim. Cuando se declara una variable como Dim, se declara con el ámbito por defecto que es el ámbito de variable local. La declaración de una variable como Public es extender la visibilidad de la variable a todo el ámbito. Por otro lado, una variable declarada como Private extiende la visibilidad de la variable a un ámbito local. Pero también podemos declarar las variables como Protected que permite acceder a la variable dentro de la propia clase en la que está declarada o en una clase derivada. Por último, también podemos declarar las variables como Friend mediante la cuál, sólo podrán acceder a estas porciones de código dentro del mismo ensamblado. Adicionalmente, se pueden conjugar los permisos de ámbito utilizando combinaciones como Protected Friend. Sin embargo, existen otras formas de declarar variables como mediante la palabra reservada Shared que especifica que estas variables no están asociadas con una instancia específica de clase o de estructura. Otra particularidad de declaración de variables es el hecho de declararla mediante la palabra reservada Shadows que indica que el método o porción que está definiéndose, oculta al heredado de la clase base. Por otro lado, podemos utilizar la declarativa Static para procurar que la variable declarada como tal, exista desde que se inicia el programa hasta el final. Finalmente, podemos declarar las variables como ReadOnly, y en este caso, lo que estaremos indicando es que esta variable es de sólo lectura y no de escritura. Aún y así, debemos tener en cuenta que podemos definir también variables dentro de métodos, bucles, etc., y el ámbito de la variable en este caso, cambia radicalmente. Un ejemplo nos ayudará a entender esto que comento de una manera clara y meridiana:


180

Public Class Form1 Private I As Integer = 7 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim bolValor As Boolean = True If bolValor Then Dim I As Integer = 1 MessageBox.Show(I) Else Dim I As Integer = 0 MessageBox.Show(I) End If MessageBox.Show(I) End Sub End Class

Si observamos este código de ejemplo detenidamente, veremos que dentro de la clase Form1, que es la clase a la que pertenece el formulario Windows, hemos declarado una variable de tipo Integer a la cuál hemos dado un valor. En el evento Form1_Load, hemos declarado dos variables de tipo Integer que tienen el mismo nombre de declaración que la anterior variable declarada en la clase. Esto significa que la variable Integer definida en la clase, tiene un ámbito general privado dentro de toda la clase. Es por lo tanto, visible dentro de toda la clase, pero el código del evento Form1_Load nos indica que estas mismas variables, son declaradas y visibles dentro de la porción de código en la cuál se declara, en nuestro caso un bucle If. Dicho de otro modo, nuestro ejemplo, mostrará en pantalla el valor 1 primero, y el valor 7 después. El primer valor corresponderá al valor tomado dentro del bucle If y el segundo valor, al valor correspondiente al ámbito de visibilidad de la variable declarada en la clase, ya que en ese momento ya estamos fuera del bucle If. 4.8.- Clases Las clases en .NET y en Visual Basic 2005 por lo tanto, tienen la singularidad de poderse programar y agrupar en nombres de espacio. Para declarar una clase tipo, lo haremos de la forma:

Public Class <nombre_clase> ... End Class

4.8.1.- Utilizando Namespace El nombre de espacio o Namespace, es utilizado para organizar las clases e identificarlas de forma fácil. Esto se logra utilizando la siguiente instrucción:

Namespace <nombre> Public Class <nombre_clase> ... End Class End Namespace

De esta manera, para hacer referencia a la clase desde un formulario Windows por ejemplo, lo haremos de la forma:

Dim <variable> As New <nombre de espacio>.<clase> De hecho un ejemplo de definición y uso de una clase es el siguiente:


181

Namespace VB2005 Public Class clsPrueba Public Function MiFuncion() As Boolean If Now.TimeOfDay.Hours > 12 Then Return True Else Return False End If End Function End Class End Namespace

La siguiente porción de código, nos muestra como consumir la clase:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiClase As New VB2005.clsPrueba MessageBox.Show(IIf(MiClase.MiFuncion(), "P.M.", "A.M.")) End Sub

Sino hubiéramos codificado la clase utilizando la palabra clave Namespace, la declaración de uso de la clase sería de la forma Dim MiClase As New clsPrueba.

Interesante: Un formulario Windows no deja de ser una clase. Desde Visual Basic 2005 podemos crear nuestras propias clases, compilarlas y distribuirlas para reutilizarlas desde otros lenguajes de .NET como C# por ejemplo.

4.8.2.- Utilizando el constructor de la clase El constructor de una clase en Visual Basic 2005, permite ser utilizado al instanciar cualquier clase. El constructor en Visual Basic 2005, se identifica por medio del método New. Todas las clases se inicializan con este método si lo tiene y en nuestras clases, podemos crearlo con parámetros o sin ellos. Un ejemplo de uso de una clase con este método de inicialización sería el siguiente. Por un lado la definición de la clase de la forma:

Namespace VB2005 Public Class clsPrueba Private _horas As Byte Private Property Horas() As Byte Get Return _horas End Get Set(ByVal value As Byte) _horas = value End Set End Property Public Sub New(ByVal Tiempo As Byte) Horas = Tiempo End Sub Public Function MiFuncion() As Boolean If Horas > 12 Then Return True Else Return False End If End Function End Class End Namespace


182

Por otro lado, el uso de la parte consumidora de la clase, por ejemplo desde un formulario Windows, se realizaría de la forma:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e AsSystem.EventArgs) Handles MyBase.Load Dim MiClase As New VB2005.clsPrueba(Now.TimeOfDay.Hours) MessageBox.Show(IIf(MiClase.MiFuncion(), "P.M.", "A.M.")) End Sub

4.8.3.- Utilizando constructores múltiples Hemos visto en el apartado anterior como utilizar el constructor de una clase, pero lo que no hemos comentado aún es que se puede utilizar un constructor múltiple dentro de una clase. A continuación, se expone el ejemplo de una clase que utiliza más de un constructor:

Namespace VB2005 Public Class clsPrueba Private _horas As Byte Private Property Horas() As Byte Get Return _horas End Get Set(ByVal value As Byte) _horas = value End Set End Property Public Sub New() Horas = Now.TimeOfDay.Hours End Sub Public Sub New(ByVal Tiempo As Byte) Horas = Tiempo End Sub Public Function MiFuncion() As Boolean If Horas > 12 Then Return True Else Return False End If End Function End Class End Namespace

Así, llamar a una clase nos permite utilizar cualquiera de los constructores declarados, por lo que sería igualmente válido declarar la clase como Dim MiClase As New VB2005.clsPrueba(Now.TimeOfDay.Hours) o bien como Dim MiClase As New VB2005.clsPrueba(). Ambos casos de declaración son válidos.

Interesante: Sino se define un constructor en una clase, Visual Basic 2005 lo genera por nosotros siendo un constructor sin parámetros.

4.8.4.- Destruyendo la clase Una clase tiene un tiempo de vida determinado y cuando ya se finaliza su uso, se pone en marcha el recolector de basura o GC o Garbage Collector que hemos


183

comentado en los capítulos iniciales de este manual. Teóricamente sin embargo, una clase se debería eliminar al asignarle el valor Nothing a la clase, aunque esto no significa que el recolector de basura se ponga en marcha y se elimine la clase totalmente de la memoria del ordenador. 4.8.5.- Clases parciales Una nueva característica añadida a la especificación del lenguaje Visual Basic 2005 es lo que se denominan clases parciales, que son indicaciones de que la declaración de clase parcial forma parte de una clase principal. De esta manera, podemos romper una clase en varios ficheros perteneciendo todos ellos a la misma clase principal. De hecho y sin que nosotros lo sepamos, Visual Basic 2005 inicia los proyectos con clases parciales. Para comprobar esto, abriremos un nuevo proyecto de aplicación Windows dentro de Visual Basic 2005 Express Edition y haremos clic sobre el botón Mostrar todos los archivos del Explorador de soluciones tal y como se muestra en la figura 4.5.

Figura 4.5: opción para mostrar todos los archivos del proyecto. Al pulsar esta opción, observaremos que se muestran todos los archivos del proyecto, y entre ellos, observaremos que el formulario Form1 contiene dos archivos adicionales, del cuál nos interesa ahora el denominado Form1.Designer.vb como se muestra en la figura 4.6.

Figura 4.6: ficheros del formulario Form1. Observaremos que hay dos ficheros pertenecientes a Form1, el anteriormente comentado Form1.Designer.vb y el Form1.resx. El primero de ellos es el que nos interesa destacar y el segundo, es el correspondiente a los recursos propios del formulario Form1 y que no profundizaremos por no ser especialmente relevante en estos momentos. Si observamos el código del fichero Form1.Designer.vb, veremos que encontramos el siguiente texto o parecido en la cabecera del código:

Partial Public Class Form1

Aquí lo que se está indicando es que esta clase, es una clase parcial de la clase Form1. Como vemos, la definición de la clase parcial, se hace de la forma:


184

Partial Class <objeto>

Sin embargo, las clases parciales son clases, y por lo tanto, pueden ser utilizadas en formularios, clases propias, u otros objetos. A continuación veremos como utilizar una clase parcial en nuestro proyecto. Iniciaremos un nuevo proyecto e insertaremos dos elementos de tipo Clase o Class en nuestro proyecto. Para hacer esto, haga clic con el botón derecho del ratón sobre el proyecto y seleccione la opción Agregar > Nuevo elemento del menú emergente, tal y como se muestra en la figura 4.7.

Figura 4.7: opción para agregar un nuevo elemento en Visual Basic 2005 Express Edition. Dentro de la ventana que aparece correspondiente a la opción de Agregar un nuevo elemento, seleccione la plantilla de Clase y dele un nombre que considere apropiado como se muestra en la figura 4.8.

Figura 4.8: ventana para agregar un nuevo elemento de tipo clase al proyecto.


185

Repita esta operación otra vez más para añadir así, dos elementos de tipo Clase al proyecto. En mi caso, he dado los nombres de clsPrueba.vb y clsTest.vb. A continuación, tan sólo nos quedará ponernos manos a la obra y escribir la parte de código que nos permita construir una clase de tipo principal y otra u otras de tipo parcial. Tan sólo conviene puntualizar dos aspectos sobre el tratamiento de clases parciales. Por un lado, no nos importa para nada, el nombre del elemento de la clase sobre el cuál escribimos la parte principal de la clase y la parte parcial de la misma. Esto nos impide tener un mayor control de la parte principal de la clase, pero al mismo tiempo, permite que dentro de un equipo de desarrollo, haya multitud de desarrolladores trabajando con una clase principal y con métodos o funciones independientes. Por otro lado, el interfaz IntelliSense de Visual Basic 2005 Express Edition, es capaz de reconocer directamente los métodos, propiedades, funciones, etc., de las clases principal y parcial. Esto es lo lógico, pero integrarlo en el entorno no es tarea sencilla, algo que .NET hace perfectamente. Siguiendo con el ejemplo práctico de la creación y uso de clases parciales, vamos a crear la clase principal que podemos escribir dentro de cualquiera de los dos elementos de tipo Clase añadidos al proyecto anteriormente y que tendrá el siguiente código:

Public Class miClase Public Function Suma(ByVal Valor1 As Long, ByVal Valor2 As Long) As Long Return Valor1 + Valor2 End Function End Class

A continuación, añadiremos el código correspondiente al segundo elemento de tipo Clase y que corresponderá con la clase parcial. El código en este caso será el siguiente:

Partial Public Class miClase Public Function Resta(ByVal Valor1 As Long, ByVal Valor2 As Long) As Long Return Valor1 - Valor2 End Function End Class

A continuación consumiremos nuestra clase como si de una clase normal y corriente se tratara, por lo que haremos doble clic sobre el formulario Form1 y escribiremos el siguiente código:

Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim MiClase As New miClase() MessageBox.Show(MiClase.Suma(3, 2) & vbCrLf & MiClase.Resta(3, 2)) End Sub End Class

Si observamos la ayuda IntelliSense del entorno de trabajo, veremos que las funciones Suma y Resta están integradas en la clase, pese a pertenecer a una clase principal y una clase parcial, como se muestra en la figura 4.9.


186

Figura 4.9: funciones de la clase principal y parcial añadidas a la ayuda Intelli-Sense. Esta es la demostración fehaciente, de que ya trabajemos con clases principales o parciales, el entorno de .NET las trata a todas como partes de la misma clase. Como si fuera un mismo fichero de tipo Clase. 4.9.- Estructuras Las estructuras son tipos de valor definidos por el usuario. Las estructuras se definen mediante la palabra reservada Structure y tiene la siguiente forma:

Structure <nombre> <Public, Private, Friend,…> <nombre> As <tipo> End Structure

Un ejemplo práctico del uso de estructuras es el que se detalla a continuación:

Public Class Form1 Private Structure MiEs Public Nombre As String Public Num_Hijos As Byte Public F_Nac As Date End Structure Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim Est As MiEs Est.Nombre = "Juan López" Est.F_Nac = "02/08/1980" Est.Num_Hijos = 0 End Sub End Class

Como podemos observar, a la hora de definir la estructura, utilizamos una instrucción del tipo:

Dim <nombre> As <nombre_de_estructura> Sin embargo, también podríamos utilizar la instrucción de declaración de la estructura del modo:

Dim <nombre> As New <nombre_de_estructura> La diferencia es que al poner New lo que estamos indicando es que vaya al constructor de la estructura, algo que no existirá a no ser que lo creemos nosotros, por lo que no es necesario definir la estructura con New sin tener un constructor. Aún y así, y como podemos observar, es posible utilizar constructores dentro de nuestras estructuras como hicimos en el caso de las clases. Para hacer esto, deberemos utilizar la palabra reservada New en la definición de la estructura y en la declaración del uso de la estructura para de esta forma, ejecutar el constructor indicado. Un ejemplo práctico facilitará la comprensión de esto que


187

comentamos:

Public Class Form1 Private Structure MiEs Public Nombre As String Public Num_Hijos As Byte Public F_Nac As Date Sub New(ByVal strNombre As String, ByVal bte_Num_Hijos As Byte, ByVal date_F_Nac As Date) Nombre = strNombre Num_Hijos = bte_Num_Hijos F_Nac = date_F_Nac End Sub End Structure Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim Est As New MiEs("Juan López", 0, "02/08/1980") MessageBox.Show(Est.Nombre & vbCrLf & _ Est.F_Nac & vbCrLf & _ Est.Num_Hijos) End Sub End Class

Pero aún hay más. Quizás deseemos utilizar constructores múltiples en nuestras estructuras. Esto es igualmente posible. Para ello, deberemos usar varios constructores New dentro de la declaración de la estructura tal y como se muestra en el siguiente ejemplo:

Public Class Form1 Private Structure MiEs Public Nombre As String Public Shared Num_Hijos As Byte = 0 Public F_Nac As Date Sub New(ByVal strNombre As String, ByVal bte_Num_Hijos As Byte, ByVal date_F_Nac As Date) Nombre = strNombre Num_Hijos = bte_Num_Hijos F_Nac = date_F_Nac End Sub Sub New(ByVal strNombre As String, ByVal date_F_Nac As Date) Nombre = strNombre F_Nac = date_F_Nac End Sub End Structure Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim Est As New MiEs("Juan López", "02/08/1980") MessageBox.Show(Est.Nombre & vbCrLf & _ Est.F_Nac & vbCrLf & _ MiEs.Num_Hijos) End Sub End Class

Otra particularidad de las estructuras, es la posibilidad de utilizarlas como estructuras parciales, como en el caso de las clases parciales anteriormente comentadas. Para este caso, se utilizará las instrucciones de tipo:


188

Partial Structure <objeto> Un ejemplo práctico del uso de estructuras parciales es el que se detalla a continuación:

Public Class Form1 Private Structure MiEs Public Nombre As String End Structure Partial Structure MiEs Public Edad As Byte End Structure Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim Est As MiEs Est.Edad = 45 Est.Nombre = "Isabel Gómez" MessageBox.Show(Est.Nombre & vbCrLf & _ Est.Edad) End Sub End Class

Evidentemente, podemos conjugar con clases parciales y estructuras parciales combinadas en nuestros desarrollos según nuestras necesidades. Esto de la parcialidad, nos ofrece en .NET una gran flexibilidad, aunque nos fuerza también a perder parte del control sobre el código que escribimos sino tenemos una organización clara de lo que estamos haciendo en un proyecto.


189

CAPÍTULO 5

VISUAL BASIC 2005, OTROS ASPECTOS AVANZADOS DEL LENGUAJE ESTE CAPÍTULO NOS MUESTRA ALGUNOS DE LOS ASPECTOS AVANZADOS DEL LENGUAJE VISUAL BASIC 2005. El capítulo anterior ha sido el más denso de este manual. Quizás podríamos haber separado ese capítulo en varios o haber introducido en este capítulo parte del anterior, ya que el capítulo 4 contenía aspectos avanzados de la programación en Visual Basic 2005, aunque he preferido separar algunos de estos aspectos a este capítulo por ser acciones no de tan uso común como las anteriores. 5.1.- Funciones recursivas La definición más simple de funciones recursivas es aquella que dice que se llama así a toda función que se llama así misma, de ahí su nombre. El uso de este tipo de funciones es el habitual en cualquier lenguaje de programación, y por lo tanto, se indica aquí como ejemplo genérico del uso de este tipo de funciones en Visual Basic 2005. El ejemplo típico de función recursiva es el cálculo del factorial de un número. El siguiente código lanza la función del cálculo del factorial de un número tantas veces como sea necesario:

Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load MessageBox.Show(Factorial(4)) End Sub Public Function Factorial(ByVal N As Long) As Long If N = 1 Then Return 1 Else Return N * Factorial(N - 1) End If End Function End Class

Las funciones recursivas deben crearse solamente para facilitar o simplificar enormemente tareas repetitivas, recursivas, que permiten realizar una función general, como el cálculo del factorial de un número como el ejemplo que hemos visto. 5.2.- Interfaces Las interfaces son una forma especial de una clase que sólo define miembros, a diferencia de una clase que contiene código de ejecución. Al no existir herencia múltiple en Visual Basic 2005, debemos utilizar el concepto de Interface para implementar múltiples interfaces y hacer así, algo similar a la herencia múltiple. Para definir una interfaz, utilizaremos las instrucciones:

Interface <nombre> <...> End Interface

Como vemos, la forma de declarar una interfaz es de la misma manera que hacíamos para declarar una clase. De hecho, lo único que debemos hacer es sustituir la palabra reservada Class por Interface.


190

La implementación por lo tanto, de una interfaz, es realmente sencilla. Sirva el siguiente ejemplo para mostrar como hacerlo:

Public Class Form1 Implements Ejemplo Public Sub Saludo(ByVal strMensaje As String) Implements Ejemplo.Saludo MessageBox.Show(strMensaje) End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Saludo("Hola Mundo") End Sub Public Interface Ejemplo Sub Saludo(ByVal strMsg As String) End Interface End Class

5.3.- Eventos Los eventos nos permiten recoger cualquier interferencia o acción ocurrida en nuestra aplicación con el sistema, ya sea de manera forzada voluntariamente, como por ejemplo un clic de un usuario a un control como un botón, o de manera automáticamente al lanzarse una interrupción determinada como por ejemplo, saber cuando se refresca un control Grid. Lo primero que veremos es como lanzar un evento en Visual Basic 2005. Crearemos un nuevo proyecto e insertaremos en el formulario un control Button. Esto lo haremos desplegando la ventana Cuadro de herramientas que hay a la izquierda del entorno de desarrollo Visual Basic 2005 Express Edition y haciendo doble clic sobre el control Button de la solapa Controles comunes, tal y como se muestra en la figura 5.1.

Figura 5.1: control Button del Cuadro de herramientas. Repita la operación e inserte un segundo control Button en el formulario. De esta manera, tendremos dos controles Button insertados en el formulario como se muestra en la figura 5.2.


191

Figura 5.2: controles Button insertados en el formulario. A continuación escribiremos el siguiente código en nuestra aplicación de ejemplo:

Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click MessageBox.Show("Botón 1 pulsado") End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click Button1_Click(sender, e) End Sub End Class

Como podemos observar en este ejemplo, hemos querido lanzar un evento desde otro. Ahora bien, no sólo podemos usar o lanzar los eventos generados por Visual Basic 2005, también podemos generar nuestros propios eventos para que los utilicemos dentro de nuestras aplicaciones. Esto es justamente lo que haremos a continuación. Sin embargo, también podemos usar un evento en varios controles, esto se haría indicando el manejador del evento que queremos utilizar indicándole los controles que lo utilizará. Siguiendo con el ejemplo anterior, modificaremos el código de la siguiente manera:

Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click, Button2.Click MessageBox.Show("Botón 1 pulsado") End Sub End Class

Como podemos observar, al final de la palabra reservada Handles del evento Button1_Click, hemos añadido los eventos que queremos que formen parte de este código. Por otro lado, lo que podemos hacer también, es generar nuestros propios eventos los cuales irán casi siempre asociados a nuestras propias clases. Esto se logra utilizando las palabras reservadas Event y RaiseEvent. Adicionalmente, también podemos utilizar los comandos AddHandler y RemoveHandler para activar y desactivar el evento. El siguiente ejemplo, nos facilitará la comprensión del uso de eventos


192

personalizados. Para ello, escribiremos el siguiente código como clase de nuestra aplicación:

Public Class miClase Public Event MiEvento() Private _Valor As Integer = 0 Property Valor() As Integer Get Return _Valor End Get Set(ByVal value As Integer) _Valor = value End Set End Property Public Sub MiMetodo() MessageBox.Show(Valor) RaiseEvent MiEvento() End Sub End Class

Para ejecutar esta clase, escribiremos en nuestro formulario el siguiente código:

Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim Miclase As New miClase Miclase.Valor = 5 AddHandler Miclase.MiEvento, AddressOf TrataEvento Miclase.MiMetodo() End Sub Public Sub TrataEvento() MessageBox.Show("Evento lanzado") End Sub End Class

Si queremos en un momento dado forzar el no uso del evento, podemos utilizar la instrucción RemoveHandler. Un ejemplo adicional de la ejecución de la clase anterior, dónde forzamos en primer lugar el no uso del evento para forzar posteriormente su uso, sería el que se detalla a continuación:

Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim Miclase As New miClase Miclase.Valor = 5 RemoveHandler Miclase.MiEvento, AddressOf TrataEvento Miclase.MiMetodo() AddHandler Miclase.MiEvento, AddressOf TrataEvento Miclase.MiMetodo() End Sub Public Sub TrataEvento() MessageBox.Show("Evento lanzado") End Sub End Class

5.4.- Multihebras o Multithreading


193

Un aspecto a tener en cuenta en nuestras aplicaciones es el concepto de hebras múltiples, también conocido como Multithreading. Quizás también lo haya escuchado alguna vez como hilos, y es que en sí, este último concepto aclara aún más de que se trata. Podemos ejecutar una aplicación y querer por ejemplo, lanzar varias ejecuciones paralelas y recoger sus eventos para saber cuando han finalizado todas ellas. Por lo general, nuestra aplicación se va a comportar siempre como una aplicación de tipo lineal, es decir, entrará por un sitio, irá recorriendo el árbol lógico de la aplicación, y finalizará en un punto determinado. Sin embargo, en muchas ocasiones, podemos querer lanzar diferentes procesos que se lancen simultáneamente para recoger los resultados de toda la ejecución de estos procesos y muestre el resultado final en pantalla. Para utilizar esta técnica, utilizaremos en .NET el nombre de espacio System.Threading. Dentro de este nombre de espacio, encontraremos diferentes clases de la cuales, la que más nos interesa es la clase Thread. Un ejemplo práctico del uso de este nombre de espacio y de la ejecución de una aplicación multihilo sería el siguiente:

Imports System.Threading Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim MiHilo1 As New Thread(AddressOf Calculo_1) Dim MiHilo2 As New Thread(AddressOf Calculo_2) MiHilo1.Start() MiHilo2.Start() End Sub Public Sub Calculo_1() Dim res As Long For I As Integer = 0 To 100000 res += (IIf(I < 101, I, 0)) Next MessageBox.Show("Calculo_1 " & res) End Sub Public Sub Calculo_2() Dim res As Long For I As Integer = 0 To 500 res += (IIf(I < 51, I, 0)) Next MessageBox.Show("Calculo_2 " & res) End Sub End Class

Este simple ejemplo, nos enseña y demuestra que aunque lancemos varias hebras o hilos de un determinado método en ejecución, estos funcionan y se ejecutan paralelamente haciendo en este caso, que el segundo hilo lanzado termine antes que el primero. De todos los modos, lo más habitual es utilizar la gestión de hilos en nuestras aplicaciones con los eventos que hemos visto en el apartado anterior. Esto nos permite hacer aplicaciones mucho más robustas y fiables. 5.5.- Delegados Un delegado es un tipo de referencia asociada a un método compartido, o una instancia de un método de un objeto. Para declarar delegados, debemos utilizar la palabra reservada Delegate.


194

A la hora de trabajar con objetos, la forma más habitual es la de declarar un objeto como una clase y acceder a los métodos de esa clase. Ahora bien, podemos encontrarnos con situaciones muy singulares como por ejemplo la necesidad de que la clase acceda a un método del programa principal. En este caso, el uso de delegados es obligado porque de no ser así, no podremos utilizar ese método. Esto es lo que veremos a continuación con un ejemplo práctico. En primer lugar, escribiremos el código correspondiente a la clase de la aplicación de ejemplo, del uso de delegados y que es el siguiente:

Public Class miClase Public Sub MiMetodo(ByVal strMsg As String) strMsg += Now.Date MessageBox.Show(strMsg) End Sub End Class

Para consumir la clase y en este caso el delegado que permita ejecutar una parte de la clase, escribiremos el siguiente código:

Public Class Form1 Delegate Sub MiDelegado(ByVal strMensaje As String) Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim Clase As New miClase Dim Delegado As MiDelegado Delegado = AddressOf Clase.MiMetodo Delegado.Invoke("Hoy es día: ") End Sub End Class

5.6.- Herencia La palabra reservada utilizada en Visual Basic 2005 para trabajar con la herencia de clases que pertenece a la programación orientada a objetos, es Inherits. La herencia es a grandes rasgos, la relación en la cuál una clase derivada, deriva de otra clase base. Dicho de una manera más llana aún, es la relación de una clase que se basa en otra ya existente. De este modo, la nueva clase derivada, heredará todas las propiedades y métodos de la clase base de la cuál hereda. Para entender esto de una forma más clara, utilizaremos el siguiente ejemplo práctico:

Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim MiClase As New Clase_Derivada MiClase.strValor = "Ejemplo de herencia" MessageBox.Show(MiClase.strValor) End Sub End Class Public Class Clase_Base Public strValor As String End Class Public Class Clase_Derivada Inherits Clase_Base End Class

Nuestro ejemplo en ejecución, es el que se muestra en la figura 5.3.


195

Figura 5.3: ejemplo de ejecución del uso de clases heredadas. Por último, comentar que una clase, puede heredar de varias al mismo tiempo. Esto es lo que se denomina herencia múltiple.


196

CAPÍTULO 6

VISUAL BASIC 2005, EL ENTORNO ESTE CAPÍTULO NOS PERMITIRÁ INTRODUCIRNOS EN EL ENTORNO DE DESARROLLO DE VISUAL BASIC 2005 EXPRESS EDITION. Ya hemos visto las pinceladas generales del lenguaje Visual Basic 2005. Ahora lo que debemos hacer es familiarizarnos con el entorno de desarrollo, que es justamente lo que haremos en este capítulo. 6.1.- Visión general del entorno Con Visual Basic 2005 Express Edition podemos desarrollar aplicaciones de forma mucho más rápida y eficiente que sin un entorno de desarrollo de estas características. Con este entorno de desarrollo, podemos crear aplicaciones para Windows, biblioteca de clases, y aplicaciones de consola. El único pero es que no podemos desarrollar aplicaciones Web, Servicios Web, Servicios Windows y otro tipo de aplicaciones. Para este tipo de aplicaciones, existen otros productos de la familia Express Edition o de Visual Studio 2005. En este capítulo nos centraremos por ese motivo, en la creación de aplicaciones Windows principalmente, el conocimiento general del entorno de desarrollo, y posteriormente, el conocimiento avanzado del entorno para sacar el máximo provecho a la programación. 6.2.- Creando una nueva aplicación ¿Cómo crear una nueva aplicación Windows o cualquier otro tipo de proyecto en Visual Basic 2005 Express Edition?. Inicie el entorno de desarrollo y seleccione del menú la opción Archivo > Nuevo > Proyecto como se muestra en la figura 6.1.

Figura 6.1: opción para crear un nuevo proyecto en Visual Basic 2005 Express Edition. Aparecerá una nueva ventana como la que se muestra en la figura 6.2., en la cuál podremos seleccionar el tipo de proyecto que queremos crear. En nuestro caso, crearemos una nueva Aplicación para Windows.


197

Figura 6.2: plantilla de Aplicación para Windows seleccionada para una nueva aplicación. Seleccione esta opción y pulse el botón Aceptar. Con esto habremos creado la estructura principal de un nuevo proyecto vacío de tipo aplicación para Windows. 6.3.- El Cuadro de herramientas El Cuadro de herramientas está situado en la parte izquierda del entorno de desarrollo rápido, y engloba dentro de sí, todos los controles y componentes que tenemos activados en el entorno para poder utilizarlos, pero también podemos añadir los controles y componentes que creemos nosotros y los que podamos cargar en .NET y que hayan sido desarrollados por terceros. En la figura 6.3., podemos observar el Cuadro de herramientas del entorno.

Figura 6.3: Cuadro de herramientas del entorno de desarrollo. Para insertar un control o un componente dentro de un formulario Windows, deberemos seleccionar el objeto que queremos insertar y hacer doble clic sobre el control, o bien hacer clic en el control y arrastrarlo y soltarlo sobre el formulario Windows, o bien hacer clic en el control y luego hacer clic nuevamente en el formulario y dimensionar un espacio que será el que ocupe el control insertado. 6.4.- El Explorador de soluciones


198

El Explorador de soluciones está situado en la parte derecha del entorno de desarrollo rápido, y en él tenemos todos los proyectos de la solución, y los ficheros y recursos de cada proyecto. En la figura 6.4., podemos observar la ventana del Explorador de soluciones.

Figura 6.4: Explorador de soluciones del entorno de desarrollo. Si observamos esta ventana, veremos que en la parte inferior hay dos solapas. La segunda tiene que ver con los Orígenes de datos. 6.5.- Los Orígenes de datos Los Orígenes de datos nos permiten añadir conexiones en el entorno con fuentes de datos para agregarlas a un formulario u otro objeto de forma rápida y sencilla con una acción simple de arrastrar y soltar. Adicionalmente, podemos acceder a las fuentes de datos para modificar o gestionar esas fuentes de datos, ya sean tablas, vistas, procedimientos almacenados, etc. La ventana de Orígenes de datos del entorno, tendrá por lo tanto un aspecto similar al que se presenta en la figura 6.5.

Figura 6.5: Orígenes de datos del entorno de desarrollo.

Recordatorio: En el caso de .NET y en cuanto a los productos Microsoft, existen dos


199

versiones de Microsoft SQL Server 2005. Hay una versión comercial de pago y una versión Express Edition que es una versión gratuita del producto que se integra perfectamente con el entorno de desarrollo.

6.6.- Ventana de propiedades La ventana de Propiedades nos facilita el acceso a las propiedades del formulario y controles y componentes de la aplicación. En sí, nos posibilita acceder a las propiedades de todos los objetos utilizados dentro del proyecto. En la figura 6.6., podemos observar la ventana de Propiedades:

Figura 6.6: Propiedades en el entorno de desarrollo. 6.7.- Agregar elementos al proyecto Para agregar elementos al proyecto, tenemos tres alternativas. La primera de ellas, es hacer esta acción desde la barra de botones del entorno de desarrollo. La segunda posibilidad que tenemos es hacerlo desde la ventana del Explorador de soluciones. Aquí veremos estas dos alternativas para aprender a movernos en el entorno de desarrollo. La primera de estas alternativas para agregar un elemento al proyecto, es como hemos comentado, utilizando la barra de botones del entorno de desarrollo. Para ello, haremos clic sobre el botón de Agregar elemento, y dentro de esta opción, en el botón Agregar nuevo elemento… como se muestra en la figura 6.7.

Figura 6.7: opción de Agregar nuevo elemento… dentro del entorno de desarrollo. Como podemos observar, también podemos pulsar las teclas rápidas Ctrl+Mayús.+A


200

para acceder a esta misma acción. Adicionalmente, observamos en la figura 6.7. que podemos también añadir otros tipos de elementos al proyecto de forma directa, aunque lo habitual es abrir la ventana para agregar nuevos elementos al proyecto. La segunda de las opciones que tenemos para agregar un elemento al proyecto, es hacerlo desde la ventana del Explorador de soluciones. Para lograr esto, deberemos acudir a esta ventana y hacer clic con el botón derecho del ratón sobre el proyecto y seleccionar la opción Agregar > Nuevo elemento… del menú emergente, tal y como se muestra en la figura 6.8.

Figura 6.8: opción de agregar Nuevo elemento… dentro del entorno de desarrollo. Cuando seleccionamos esta opción de agregar un nuevo elemento al entorno, aparecerá una ventana como la que se muestra en la figura 6.9.

Figura 6.9: ventana para Agregar nuevo elemento en el entorno de desarrollo. Desde esta ventana, elegiremos la plantilla o elemento que deseamos añadir al proyecto, algo que veremos a continuación de forma más detallada. 6.8.- Agregando elementos al proyecto


201

Cuando seleccionamos la opción de agregar un nuevo elemento al proyecto, se abre una ventana con todas las plantillas disponibles, de las cuales, aquí veremos las más frecuentes. Las plantillas que podemos utilizar en el entorno son la de Windows Forms, Cuadro de diálogo, Formulario del explorador, Formulario primario MDI, Cuadro Acerca de, Pantalla de bienvenida, Clase, Módulo, Conjunto de datos, Base de datos SQL, Control de usuario y Archivo de texto. 6.8.1.- Windows Forms Poco podemos añadir ya sobre esta plantilla, pues es la plantilla utilizada por defecto en cualquier tipo de proyecto que iniciamos o con cualquier elemento que añadimos al proyecto. Se trata por lo tanto de un formulario vacío, sin ningún control, componente, u objeto insertado en él, que nos permita añadir los controles o componentes que deseemos. En la figura 6.10., podemos observar un formulario Windows cargado por defecto.

Figura 6.10: formulario Windows por defecto creado en el entorno. 6.8.2.- Cuadro de diálogo Al seleccionar esta plantilla, el entorno de desarrollo nos inserta un formulario Windows con un control TabletLayoutPanel, y dentro de este control, dos controles Button. Se trata de la estructura típica de un formulario Windows de este tipo, pero sin programación de ningún tipo. En la figura 6.11., podemos observar este formulario o plantilla de formulario, insertado en el entorno de desarrollo.


202

Figura 6.11: Cuadro de diálogo creado en el entorno. 6.8.3.- Formulario del explorador Al seleccionar esta plantilla, el entorno de desarrollo nos presenta un formulario con todos los objetos necesarios insertados en él, para disponer de un formulario de tipo explorador. En la figura 6.12., podemos ver la captura de esta plantilla dentro del entorno de desarrollo.

Figura 6.12: Formulario del explorador creado en el entorno. Aún y así, esta plantilla no presenta el código completo de este tipo de formulario, el cuál es necesario programar para realizar la base principal de nuestra aplicación, pero sirve de gran ayuda para ahorrarnos gran parte del trabajo. 6.8.4.- Formulario primario MDI Esta plantilla nos inserta en el entorno, un formulario MDI con sus menús, botones, etc. Se trata de la base de un formulario MDI, dónde lógicamente nos queda parte de una aplicación MDI por desarrollar, pero la base nos ahorra una gran cantidad de trabajo en el entorno. En la figura 6.13., podemos observar este formulario en el entorno de desarrollo de Visual Basic 2005.

Figura 6.13: Formulario primario MDI creado en el entorno.


203

6.8.5.- Cuadro Acerca de Esta plantilla nos inserta dentro del entorno, un formulario de tipo Acerca de. En casi todas las aplicaciones Windows, es habitual encontrarnos con formularios que nos cuentan cosas o aspectos acerca del programa. Este formulario es la base de este tipo de ventanas. En la figura 6.14., podemos observar esta ventana insertada en el entorno de desarrollo.

Figura 6.14: Cuadro Acerca de creado en el entorno. 6.8.6.- Pantalla de bienvenida Al iniciar una aplicación Windows, es también muy habitual, encontrarnos con una pantalla de inicio o presentación de la aplicación. Esta ventana es la que se puede conseguir introducir en nuestro proyecto Windows con la Plantilla de bienvenida. En la figura 6.15., podemos observar esta plantilla dentro del entorno de desarrollo, insertada en nuestro proyecto.

Figura 6.15: Pantalla de bienvenida creada en el entorno. Sobre esta base, podremos modificar esta plantilla a nuestro antojo y utilizarla como presentación de nuestra aplicación al iniciar ésta.


204

6.8.7.- Otras plantillas Hasta ahora, hemos visto las plantillas generales que nos ofrece el entorno de Visual Basic 2005 Express Edition, para crear formularios Windows base con las partes más utilizadas y generales para nuestras aplicaciones Windows. Sin embargo, hay otras plantillas que enumeraremos a continuación y que no son formularios Windows propiamente dichos, pero sí forman o pueden formar parte de cualquier aplicación Windows en este caso. Por un lado, podemos agregar a nuestro proyecto Clases y Módulos. En este manual, ya hemos hablado de clases, pero no de módulos. Los módulos, son clases con características especiales. Por ejemplo, no puede ser derivado de otra clase ni utilizarlo como base para la definición de una nueva clase. La visibilidad se extiende por todo el módulo en el que está definido, y por tanto, sus métodos son compartidos. El punto de entrada de un módulo, es normalmente el representado por la palabra clave Main. El uso de los módulos por lo tanto, se ve muchas veces recomendado según los objetivos de nuestra aplicación. Por otro lado, tenemos dentro de las plantillas, la posibilidad de trabajar con fuentes de datos añadiendo un Conjunto de datos o una Base de datos SQL. Finalmente, hay otras dos plantillas muy diferentes entre sí. Una de ellas se trata de una plantilla para añadir un Archivo de texto al entorno, que podemos utilizar como información adicional o con algún objetivo determinado. La otra plantilla es la base para crear nuestros propios Controles de usuario. De esta manera, podemos crear la base de un control personalizado para utilizar en nuestras aplicaciones o proyectos, ya que podremos reutilizarlo como deseemos.


205

CAPÍTULO 7

VISUAL BASIC 2005, TRABAJANDO CON EL ENTORNO ESTE CAPÍTULO NOS MOSTRARÁ COMO TRABAJAR CON NUESTRAS APLICACIONES DENTRO DEL ENTORNO DE DESARROLLO DE VISUAL BASIC 2005 EXPRESS EDITION. En este capítulo, aprenderemos a utilizar el entorno de trabajo de Visual Basic 2005 Express Edition en nuestras aplicaciones Windows. Hasta ahora, hemos visto como utilizar el entorno de desarrollo de forma general, pero hay que ponerse en faena cuando nos ponemos delante de una aplicación, algo que es justamente lo que vamos a hacer en este capítulo. 7.1.- Código vs Diseñador Dentro del entorno de desarrollo, podemos trabajar con el código o con el diseñador del objeto si admite objetos. Por eso, podemos cambiar entre diseñador y código, según nuestras necesidades. Dentro del Explorador de soluciones, podemos hacer doble clic sobre un elemento del proyecto y así, podremos abrir por defecto el diseñador del objeto si lo tiene. Si se abre el código directamente, es porque el objeto que abrimos no tiene diseñador asociado. En general y para entender esto de una forma mejor, un formulario Windows tiene una parte de diseño que corresponde al propio formulario, y una parte de código que corresponde con el código asociado al formulario. Si queremos abrir el código de un objeto, bastará con pulsar el botón derecho del ratón sobre el objeto dentro del Explorador de soluciones, y seleccionar la opción Ver código como se muestra en la figura 7.1.

Figura 7.1: opción para ver el código de un objeto desde el Explorador de soluciones. Otra forma de hacer esto mismo, es utilizando la barra de botones del Explorador de soluciones. El entorno tiene un botón que nos permite ver el código fuente asociado a un objeto, tal y como se muestra en la figura 7.2.


206

Figura 7.2: opción de la barra de botones del Explorador de soluciones, para ver el código de un objeto. Asimismo, si queremos ver el objeto en el diseñador del entorno, deberemos hacer clic sobre el correspondiente botón dentro del Explorador de soluciones, tal y como se muestra en la figura 7.3.

Figura 7.3: opción de la barra de botones del Explorador de soluciones, para ver el diseñador de un objeto. Aún y con esto, tenemos otra alternativa de acceder al código o diseñador de un determinado objeto del proyecto. Haciendo clic sobre el objeto elegido en el Explorador de soluciones, acudiremos al menú Ver > Código para acceder al código de este objeto, tal y como se muestra en la figura 7.4.

Figura 7.4: opción del menú para ver el código de un objeto. De igual manera haremos, para ver el diseñador de un objeto en el menú del entorno. En esta ocasión, seleccionaremos la opción del menú Ver > Diseñador, tal y como se muestra en la figura 7.5.

Figura 7.5: opción del menú para ver el diseñador de un objeto. Para finalizar, también podemos acceder al código o diseñador de un objeto de otras maneras. Si nos encontramos en el código de nuestro objeto, podemos hacer clic con el botón derecho del ratón sobre cualquier superficie del código, y ahí seleccionaremos la opción Ver diseñador del menú contextual que nos aparecerá, como nos muestra la figura 7.6.


207

Figura 7.6: opción del menú contextual sobre el código, para ver el diseñador de un objeto. De igual forma, si nos encontramos en el diseñador del objeto, un formulario Windows por ejemplo, podremos hacer clic con el botón derecho del ratón sobre cualquier superficie del diseñador, y elegir la opción Ver código del menú emergente que aparece, tal y como se muestra en la figura 7.7.

Figura 7.7: opción del menú contextual sobre el diseñador, para ver el código de un objeto. 7.2.- Ejecutando una aplicación Para ejecutar una aplicación, bastará con pulsar la tecla F5 en el entorno de desarrollo. La aplicación iniciará todos los procesos internos de compilación y lanzará la aplicación en pantalla como si hubiéramos ejecutado la aplicación de forma normal. Otra alternativa que nos ofrece el entorno de desarrollo, es la de iniciar la depuración utilizando para ello la barra de botones como nos muestra la figura 7.8.

Figura 7.8: Iniciar depuración en la barra de botones del entorno de desarrollo. La alternativa a pulsar la tecla F5 del entorno, es seleccionar esta misma acción desde el menú del entorno. Para ello, acudiremos al menú y seleccionaremos la opción Depurar > Iniciar depuración como se muestra en la figura 7.9.


208

Figura 7.9: Iniciar depuración en el menú de opciones del entorno de desarrollo. 7.3.- Diferencias entre Iniciar depuración e Iniciar sin depurar En la figura 7.9., podíamos observar como iniciar una aplicación depurándola dentro del entorno de desarrollo, pero si hemos observado bien esa figura, habremos visto otra opción dentro del menú, que se denomina Iniciar sin depurar y que es la opción que se muestra en la figura 7.10., y que puede ser accedida pulsando las teclas alternativas Ctrl+F5.

Figura 7.10: Iniciar sin depurar en el menú de opciones del entorno de desarrollo. La diferencia entre estas dos opciones es muy clara y la entenderemos rápidamente. Por un lado, la iniciación con depuración que es la primera opción tratada, nos permite ejecutar la aplicación parándonos en los puntos de interrupción marcados por nosotros mismos como veremos a continuación, o bien, parándose el entorno directamente sobre aquellas líneas de código que realiza una operación prohibida o que genera una interrupción no tratada. Por otro lado, el inicio sin depuración nos permite ejecutar la aplicación, ignorando los puntos de interrupción marcados por nosotros, si tenemos marcado alguno, e impidiendo que el entorno se detenga en el lugar del código dónde se genera una interrupción determinada. Para comprobar esto, ejecutaremos el siguiente código:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim I As Integer I = I / 0 End Sub

Pulsaremos en primer lugar, la tecla F5. De esta manera, iniciaremos el entorno de ejecución en modo depuración. Indudablemente, hemos escrito un código que generará un error de ejecución y que se nos presentará en pantalla como se muestra en la figura 7.11.


209

Figura 7.11: gestión de errores y excepciones en el entorno de depuración. Como vemos, la ejecución del código de la aplicación encuentra un error y el sistema se detiene en la línea de código en la cuál se ha encontrado ese fallo. Pero si pulsásemos la tecla Ctrl+F5, se iniciará la ejecución de la aplicación sin atender a estos modos de depuración, y en nuestro caso, nos encontraremos ante una pantalla como la que se muestra en la figura 7.12.

Figura 7.12: gestión de errores y excepciones del entorno de ejecución. Ahora bien, hemos hablado de puntos de interrupción y aún no sabemos como gestionarlos y usarlos. Eso es justamente lo que haremos a continuación. 7.4.- Depurando una aplicación La tarea más común en el desarrollo de cualquier aplicación Windows, es la depuración. Todas las aplicaciones deben ser depuradas y probadas antes de finalizarlas, y así podremos detectar errores, probar soluciones, y confiar en la resolución de los problemas y en el funcionamiento global de la aplicación, además de la detección de problemas, errores o fallos. 7.4.1.- Puntos de interrupción Los puntos de interrupción son pequeñas señales que se ponen en el código, para que cuando el flujo lógico de la aplicación en ejecución pase por estos puntos, se detenga y nos permita depurar el código para seguir el flujo lógico de funcionamiento de nuestras aplicaciones. Para añadir un punto de interrupción al código del entorno, deberemos pulsar la tecla F9 sobre al línea o líneas de código sobre las cuales queremos marcar esos puntos de interrupción. Una vez que hemos marcado estos puntos de interrupción, el entorno nos marca un punto rojo y una línea roja, la fila sobre la cuál hemos marcado esa interrupción. 7.4.2.- Deteniendo la depuración


210

Cuando iniciamos la aplicación con depuración, podemos detener esta acción desde la barra de botones o desde la barra de menús. Para detener la depuración iniciada en el entorno desde la barra de botones de Visual Basic 2005 Express Edition, haremos clic en el correspondiente botón que aparece en la figura 7.13.

Figura 7.13: Detener depuración desde la barra de botones del entorno de ejecución. Adicionalmente a esto, también podemos detener la depuración desde la barra de menús. Esto se logra desde el menú seleccionando la opción Depurar > Detener depuración como se muestra en la figura 7.14.

Figura 7.14: Detener depuración desde el menú del entorno de ejecución. 7.4.3.- Visión práctica de la depuración de un ejemplo La mejor manera de aprender a depurar una aplicación, es trabajando con un ejemplo práctico que nos muestre como hacerlo. En primer lugar, iniciaremos una aplicación Windows y escribiremos el siguiente código fuente:


211

Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim I As Integer Dim strTexto As String = "" For I = 0 To 5 strTexto &= I Next MiMetodo(strTexto) MessageBox.Show(strTexto) End Sub Private Sub MiMetodo(ByRef strTxt As String) Dim I As Integer For I = 0 To 5 strTxt &= I Next End Sub End Class

A continuación seleccionaremos los puntos de interrupción de la aplicación que consideramos oportunos para aprender las acciones básicas de depuración de aplicaciones. Para ello pulsaremos la tecla F9 sobre varias líneas de código como se muestra en la figura 7.15.

Figura 7.15: puntos de interrupción marcados en la aplicación de ejemplo. Una vez hecho esto, pulsaremos la tecla F5 que corresponde a la ejecución con depuración de la aplicación. La primera interrupción de la aplicación se producirá en la instrucción:

For I = 0 To 5

Como vemos, hemos creado un punto de interrupción dentro de un bucle, por lo que para recorrerlo depurándolo, pulsaremos la tecla F10 repetitivamente para pasar de una línea a otra. También podemos hacer esta misma acción pulsando el botón Paso a paso por procedimientos como se muestra en la figura 7.16.

Figura 7.16: Paso a paso por procedimientos desde la barra de botones del entorno. Como tenemos otro punto de interrupción después del bucle y puesto que estamos ejecutando la depuración dentro del bucle, si consideramos conveniente el buen funcionamiento de esta parte del código, podemos pulsar la tecla F5 para que se


212

ejecute la aplicación de ejemplo en su modo normal nuevamente hasta que encuentre otro punto de interrupción. Eso es lo que haremos, encontrando así que el código se para en el siguiente código:

MiMetodo(strTexto)

Este es un caso especial de depuración, ya que este código está llamando a un método, por lo que si pulsamos la tecla F10, lo que estaremos haciendo es pasar por el método recogiendo el valor que nos devuelve, pero no depurándolo como queremos. Para entrar en el método y depurarlo adecuadamente, deberemos pulsar la tecla F11 dentro de este punto de interrupción. Una vez dentro del método, podremos pulsar la tecla F10 nuevamente para depurar el método. También podemos saltar al método desde la barra de botones del entorno haciendo clic sobre el botón Paso a paso por instrucciones como se muestra en la figura 7.17.

Figura 7.17: Paso a paso por instrucciones desde la barra de botones del entorno. Cuando depuramos una aplicación con puntos de interrupción, podemos también añadir, quitar y modificar los puntos de interrupción. Otra de las posibilidades que nos ofrece Visual Basic 2005 Express Edition y Visual Studio 2005 en general, es la posibilidad de depurar y modificar el código en depuración y volver a ejecutar la aplicación reconociendo los cambios introducidos en la depuración, algo que veremos a continuación. 7.4.4.- Modificando el código en depuración Otra de las alternativas que podemos llevar a cabo a la hora de depurar el código de nuestras aplicaciones, es la de modificar la línea y líneas de código que hay dentro de la aplicación cuando nos encontramos con un error. Imaginemos el siguiente ejemplo sencillo para demostrar como realizar este tipo de acciones:

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim I As Integer = 5 I = I / 0 MessageBox.Show(I) End Sub

Ejecutemos la aplicación con depuración pulsando la tecla F5 de ejecución. La aplicación se detendrá en el punto de error de desbordamiento detectado tal y como se muestra en la figura 7.18.

Figura 7.18: punto de interrupción marcado por el sistema ante una excepción. Al mismo tiempo, Visual Basic 2005 Express Edition nos informará del error con una pantalla como la que se muestra en la figura 7.19.


213

Figura 7.19: ventana de mensaje de depuración y consejo de Visual Basic 2005 Express Edition. En esta ventana, el entorno nos informa del error detectado e incluso nos puede dar consejos útiles para resolver este error. Si nos posicionamos en el código, podremos modificar éste para solventar el problema detectado como se muestra en la figura 7.20.

Figura 7.20: en tiempo de depuración, podemos modificar el código para resolver un problema detectado. Una vez modificado el código, podemos pulsar la tecla F5 de ejecución nuevamente, para relanzar la aplicación una vez más. De esta manera, comprobaremos que la modificación realizada resuelve el problema que detectó en este caso el entorno de desarrollo. 7.5.- Utilizando los recortes como solución a pequeños problemas Una novedad introducida en el entorno de trabajo, son los denominados recortes de código o fragmentos de código. Estos fragmentos son pequeñas porciones de código insertadas dentro del entorno, que nos facilita tareas muy repetitivas. Visual Basic 2005 Express Edition, viene con un conjunto de recortes o fragmentos de código listos para ser utilizados, pero nosotros mismos podemos crear los nuestros propios para incorporarlos en el entorno. De hecho, hay ya herramientas en Internet desarrolladas por terceros para realizar estas tareas. Para ver los fragmentos de código en acción, haga clic con el botón derecho del ratón sobre el código y seleccione la opción Insertar fragmento de código… como se muestra en la figura 7.21.


214

Figura 7.21: opción para Insertar fragmento de código… en el entorno de desarrollo. De esta manera, aparecerá una ventana como la que se muestra en la figura 7.22 con un repositorio de recursos a los que podremos acceder con pequeños clics de ratón o de teclado por medio de la tecla Enter y de los cursores. De esta forma, accederemos a los recortes o fragmentos de código del entorno.

Figura 7.22: ventana de fragmentos de código en el entorno de desarrollo. Al ir seleccionando los fragmentos de código, iremos adecuando el entorno de la manera en la que se muestra en la figura 7.23.

Figura 7.23: fragmentos de código seleccionados en el entorno. Una vez seleccionado el fragmento, aparecerá en el código de la aplicación, el código base insertado que debemos pulir levemente para adecuarlo a nuestras necesidades. Al tratarse de un recorte o fragmento de código, lo que se inserta es la base de ese código, tal y como se muestra en la figura 7.24.


215

Figura 7.24: fragmentos de código seleccionados en el entorno. Indudablemente, siempre que trabajemos con fragmentos de código, debemos realizar pequeños cambios y adecuaciones para prepararlo a nuestras necesidades. 7.6.- Diseñando nuestras aplicaciones Windows Otra de las partes más destacables del entorno de trabajo Visual Basic 2005 Express Edition, es el trabajo que debemos hacer con los controles dentro de un formulario. En un formulario, podemos insertar muchísimos controles y objetos, pero disponerlos en el formulario de forma que queden bien definidos, es una tarea a veces más que trabajosa. A continuación veremos algunas de las acciones generales a la hora de trabajar con controles en el entorno de trabajo, y repasaremos también algunos de los controles nuevos destacables incorporados a esta nueva versión de .NET Framework. 7.6.1.- Cuadro de herramientas Dentro de la ventana Cuadro de herramientas, encontraremos todos los controles y componentes listos para ser utilizados en nuestros formularios Windows. Adicionalmente, podemos agregar controles y componentes adicionales, reorganizar los controles y componentes, cambiar el nombre de estos objetos o de las solapas que los contienen, etc. 7.6.2.- Controles contenedores Existen un conjunto de controles denominados contenedores que encontraremos en la ventana del Cuadro de herramientas, tal y como se muestra en la figura 7.25.

Figura 7.25: Contenedores del Cuadro de herramientas.


216

Un control contenedor no es otra cosa que un control con la capacidad de contener otros controles dentro de estos. Esto nos ofrece la posibilidad de ajustar, redimensionar, situar y mover controles sin apenas esfuerzo. Como ejemplo del comportamiento de uno de estos controles en el entorno de desarrollo, añadiremos un control TableLayoutPanel para contener otros controles. Este control insertado en el formulario Windows es similar al que se muestra en la figura 7.26.

Figura 7.26: control TableLayoutPanel insertado en un formulario Windows. Como vemos, este control simula una tabla de 2 filas y 2 columnas. En nuestro caso, eliminaremos la fila inferior y nos quedaremos con la fila superior. Para hacer esto, nos posicionaremos sobre la segunda fila y pulsaremos el botón derecho del ratón. Del menú emergente, seleccionaremos la opción Fila > Eliminar tal y como se muestra en la figura 7.27.

Figura 7.27: eliminando una fila del control TableLayoutPanel.


217

Después de seleccionar esta opción, nuestro control TableLayoutPanel, estará formado por una tabla de 1 fila y 2 columnas como se muestra en la figura 7.28.

Figura 7.28: control TableLayoutPanel con 1 fila y 2 columnas. Ahora ya tenemos nuestro formulario Windows con nuestro control TableLayoutPanel listo para ser utilizado. Como es un control contenedor, lo que tendremos que hacer a continuación es insertar dos controles que se sitúen dentro de cada fila y columna del control contenedor. En nuestro ejemplo, insertaremos dos controles Button que encontraremos en la solapa Controles comunes de la ventana Cuadro de herramientas del entorno de desarrollo. Estos controles insertados en el formulario quedarán tal y como se muestran en la figura 7.29.

Figura 7.29: controles Button insertados en el control TableLayoutPanel. Lo que haremos ahora para comprobar como funciona este control es redimensionar el control alargando y reduciendo el espacio del control como se muestra en la figura 7.30.


218

Figura 7.30: redimensión del control TableLayoutPanel en el formulario Windows. Como podemos observar, los controles contenidos en el control contenedor, se redimensionan de acuerdo a las dimensiones del control contenedor. De todas las maneras, podemos manipular los espacios que hay de alto y ancho dentro de cada fila y columna del control TableLayoutPanel. Para tener acceso a las propiedades de este control, podemos acceder a la ventana de propiedades pulsando la tecla F4 del teclado o bien, pulsando el botón derecho del ratón sobre el control y seleccionando la opción Editar filas y columnas… del menú emergente, tal y como se muestra en la figura 7.31.

Figura 7.31: redimensión del control TableLayoutPanel en el formulario Windows. También podemos acceder a estas propiedades de forma directa desde la opción Fila y Columna del mismo menú emergente. 7.6.3.- Posicionando los controles en nuestros formularios Cuando diseñamos nuestras aplicaciones con Visual Basic 2005 Express Edition, el entorno nos facilita un conjunto de herramientas que nos ayudan enormemente a posicionar nuestros controles en los formularios y a manipular estos para conseguir que se muestren en un formulario tal y como deseamos. Insertaremos dos controles Button y dos controles TextBox como se muestra en la figura 7.32.


219

Figura 7.32: controles Button y TextBox insertados en nuestro formulario Windows. Ahora bien, nuestro objetivo es poner estos controles de forma ordenada, así que situaremos el control Button antes que el TextBox para posicionarlos de una forma más o menos ordenada. De esta manera tendremos nuestros controles dispuestos en el formulario más o menos como se muestra en la figura 7.33.

Figura 7.33: controles Button y TextBox insertados en nuestro formulario Windows. La tarea que tenemos ahora por delante, es la de posicionar los controles dentro del entorno de desarrollo para dejar los controles de nuestro formulario lo más ordenado posible. Seleccione los dos controles Button seleccionando en primer lugar el control que cuyo tamaño queremos que sirva de patrón. En mi caso he seleccionado el control Button1. Posteriormente y sin soltar la tecla Ctrl he seleccionado el segundo control, el control Button2 y he elegido del menú de botones la opción Igualar tamaño como se muestra en la figura 7.34.

Figura 7.34: igualando los tamaños de los controles Button del formulario.


220

Con esto, nuestros controles Button tendrán el mismo tamaño. De igual manera, haremos con los controles TextBox, seleccionando por ejemplo el control TextBox1 en primer lugar. Una vez realizadas estas simples operaciones, los controles de nuestro formulario, tendrán un aspecto similar al que se muestra en la figura 7.35.

Figura 7.35: igualando los tamaños de todos los controles del formulario. Otra característica del entorno Visual Basic 2005 Express Edition que debemos que tener en cuenta cuando desarrollamos aplicaciones Windows es la posibilidad de este entorno de preparar los controles de manera tal que nos permita alinearlos. Hay opciones como la anterior, que nos permite esta posibilidad, pero dentro del entorno hay unas guías que nos ayudan eficientemente a saber cuando un determinado control se encuentra alineado con otro o no. En la figura 7.36., podemos observar esta operación para alinear controles en el entorno.

Figura 7.36: alineando los controles de un formulario con ayuda del entorno. Esas guías o líneas azules, nos permite saber si un control está o no alineado con respecto a los otros objetos o controles cercanos insertados dentro del formulario. En esta figura 7.36., observamos que los controles están correctamente alineados. Sólo como añadido breve a estas operaciones, de las cuales hay muchas y aquí sólo hemos visto una pequeña introducción, comentar que si seleccionamos dos controles de un formulario Windows, podemos modificar su tamaño al mismo tiempo, aunque lo recomendable primero, es seleccionar la opción de Alinear lados izquierdos como se muestra en la opción de la figura 7.37.


221

Figura 7.37: alineando lados izquierdos de los controles insertados en el formulario. Y posteriormente a esta acción, seleccionar los dos controles y modificar los tamaños alargando cualquiera de los controles y seleccionando otras opciones de alineación de controles del entorno de desarrollo. 7.6.4.- Tabulando los controles en nuestros formularios Otra de las opciones con la que debemos trabajar es la de tabular los controles. Para esto, podemos acceder a la opción Orden de tabulación de la barra de botones tal y como se muestra en la ventana 7.38.

Figura 7.38: orden de tabulación de los controles insertados en un formulario. O bien también, podemos seleccionar esta opción accediendo al menú Ver > Orden de tabulación como se muestra en la figura 7.39.

Figura 7.39: orden de tabulación de los controles insertados en un formulario desde el menú del entorno. Al seleccionar cualquiera de estas dos opciones, los controles de nuestro formulario aparecerán con unos dígitos encima de estos que representan el orden de tabulación, orden que podemos modificar haciendo clic sobre estos dígitos y modificándolos según nuestras necesidades. En la figura 7.40., podemos observar algunos controles insertados en el formulario y el orden de tabulación que representa cada control.


222

Figura 7.40: controles de un formulario con su correspondiente orden de tabulación. De esta manera, y haciendo clic sobre punto, número ó dígito, podemos reordenar los órdenes de tabulación correspondientes a cada control insertado en el formulario, tal y como se indica en la figura 7.41.

Figura 7.41: controles con su orden de tabulación correctamente indicado. 7.7.- Las propiedades de un proyecto Si hacemos clic con el botón derecho del ratón sobre el proyecto y seleccionamos la opción Propiedades del menú emergente tal y como se muestra en la figura 7.42., accederemos a la ventana de propiedades del proyecto.

Figura 7.42: opción de Propiedades del proyecto. Al seleccionar esta opción, accederemos a la ventana de Propiedades del proyecto. Ventana dentro de la cuál, podremos acceder a diferentes puntos de la aplicación


223

relacionados con la aplicación, la compilación, las referencias de la aplicación a las librerías de uso, la configuración, los recursos, la firma, la seguridad y la publicación, todo ello de nuestra aplicación. En la figura 7.43., podemos observar la ventana Propiedades del proyecto.

Figura 7.43: ventana de Propiedades abierta en el proyecto. Dentro de esta ventana, se reúnen las partes fundamentales, directamente relacionadas con nuestro proyecto. De esta manera, tenemos visibilidad directa con toda la configuración de la aplicación y tenemos así, el control completo de la implantación de nuestro proyecto.


224

CAPÍTULO 8

MY, NAMESPACE PARA TODO ESTE CAPÍTULO NOS MOSTRARÁ LAS CUALIDADES Y CARACTERÍSTICAS DEL NOMBRE DE ESPACIO MY INCORPORADO A VISUAL BASIC 2005. En este capítulo aprenderemos a utilizar el nombre de espacio o Namespace My, que ha sido incorporado a Visual Basic 2005 para permitirnos acceder a funciones o acciones de uso frecuente y común en aplicaciones Windows. 8.1.- ¿En qué consiste My? My es un nombre de espacios genérico de Visual Basic 2005 que nos permite acceder a diferentes servicios y objetos de forma directa sin necesidad de instanciarlo previamente. Esto nos proporciona una rapidez y sencillez bastante alta a la hora de acceder a funciones de carácter general. Así, podemos ahorrar en muchas ocasiones, la necesidad de utilizar las APIs del sistema para realizar estas funciones o acciones generales. Pero, ¿cómo funciona My?. Esto es lo que veremos a continuación. 8.2.- Funcionamiento de My Para utilizar este nombre de espacio, bastará con escribir la palabra reservada My en el entorno de desarrollo y así, aparecerá un conjunto de funciones organizadas de manera tal, que nos permita su uso extensivo dentro de nuestras aplicaciones. Al escribir la palabra reservada My dentro del entorno de desarrollo, aparecerá una lista de funciones y clases listas para ser utilizadas tal y como se muestra en la figura 8.1.

Figura 8.1: nombre de espacio My junto a las clases listas para ser utilizadas en Visual Basic 2005. Cada función y clase tiene su cometido, de esta manera, My.Application nos proporciona información sobre la ejecución de la aplicación como el directorio actual dónde se ejecuta la aplicación, la versión de la aplicación, posibilidades para escribir logs ya sean de sistema o personalizados por nosotros mismos, etc. My.Computer, nos proporciona acceso sobre la plataforma y el hardware del equipo. Así, podemos obtener información del registro, el teclado y la regionalizad de éste, la pantalla, etc. My.Forms nos proporciona una colección de todos los formularios del proyecto actual, permitiéndonos de manera sencilla, acceder a todos ellos para manipular algunas acciones generales, como mostrarlos, ocultarlos, etc., todo ello sin necesidad de instanciar los formularios. My.Resources proporciona acceso a los recursos de la aplicación, permitiéndonos manejar la información de recursos de nuestra aplicación de forma dinámica.


225

My.Settings nos proporciona información sobre la configuración de nuestra aplicación. De esta manera, no sólo podemos salvar o guardar la configuración de usuario que indiquemos, sino que también podemos dar marcha atrás y utilizar la última configuración usada. My.User proporciona información sobre el usuario que está ejecutándose en el sistema, proporcionando así, información de carácter general como el dominio y nombre de usuario, de que grupos es miembro el usuario, etc. My.WebServices nos proporciona acceso rápido y sencillo a los Servicios Web que han sido añadidos como referencias a nuestro proyecto. 8.3.- Una primera toma de contacto con My Para iniciarnos en el uso de My, probaremos este interesante nombre de espacio con un sencillo ejemplo que nos muestre y demuestre como utilizarlo. Será nuestro particular Hola Mundo de este nombre de espacio. Sirva como ejemplo la necesidad que podemos tener en un momento dado de hacer sonar un determinado sonido. Si queremos realizar esta operación, tendremos a buen seguro que añadir interesantes porciones de código, pero con este nombre de espacio, todo estará solucionado en apenas una simple línea de código. Añadiremos a nuestro formulario Windows un control Button y añadiremos el siguiente código fuente:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click My.Computer.Audio.Play("c:\windows\media\notify.wav") End Sub

Si ejecutamos este código y pulsamos el botón del formulario, oiremos el correspondiente sonido wav en el sistema operativo Windows. Como vemos, el objeto My nos proporciona entre otras cosas, la posibilidad de simplificar enormemente nuestras aplicaciones. En apenas una línea de código, hemos sido capaces de realizar una simple función que en otras ocasiones o con versiones anteriores de Visual Basic, consumiría gran parte de nuestro tiempo o nos obligaría a escribir nuestra propia clase, eso sin contar las líneas de código a las que estaríamos obligados a escribir para realizar esta operación. Para que veamos con otro ejemplo la increíble simplicidad de My, escribiremos a continuación el siguiente código:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim strTexto As String = My.Computer.FileSystem.ReadAllText("c:\Prueba.txt") MessageBox.Show(strTexto) End Sub

Este código, nos permite abrir un fichero de texto, leer su contenido y en este caso, almacenar su contenido en una variable para mostrarlo por pantalla. 8.4.- El corazón de My En sí, My no es otra cosa que un atajo que nos permite realizar acciones pesadas de una manera mucho más ligera, ahorrando gran cantidad de código y tiempo. El equipo de desarrollo de Visual Basic, se marcó como objetivo el hecho de desarrollar un nombre de espacio que facilitara la vida a los programadores que utilizan un entorno RAD (Rapid Application Development) como Visual Basic 2005 Express Edition y un lenguaje de programación tan usado y extendido como Visual


226

Basic 2005. De esta manera, usando el nombre de espacio My, los programadores pueden escribir código de aplicaciones de forma extraordinariamente rápida, sin tantas complicaciones y reduciendo así el código enormemente. CAPÍTULO 9 XML, LOS DOCUMENTOS EXTENSIBLES ESTE CAPÍTULO NOS PERMITIRÁ CONOCER COMO USAR XML COMO DOCUMENTOS EXTENSIBLE DE MARCAS EN NUESTRAS APLICACIONES VISUAL BASIC 2005. Los documentos XML nos proporcionan muchas ventajas dentro del desarrollo de aplicaciones actuales. La interactuación entre diferentes sistemas o entornos, aplicaciones con diferentes naturalezas y otros recursos, proporcionan a XML una forma de comunicación ideal en la mayoría de los casos. En Visual Basic 2005 podemos usar XML en nuestras aplicaciones. Recoger datos, tratar y manipular datos, traspasar esos datos a un DataSet para su tratamiento como fuente de datos, etc. En este capítulo veremos algunas de las formas de trabajar con documentos XML y como Visual Basic 2005, nos facilita una vez más, la vida en el tratamiento de este tipo de documentos. 9.1.- Agregando la referencia a System.Xml El nombre de espacio encargado de tratar y manipular los documentos XML es el denominado System.Xml. Este nombre de espacio lo deberemos agregar al proyecto mediante la palabra reservada Imports, pero antes, deberemos agregar una referencia a la librería en el entorno, por eso, accederemos a la ventana de Propiedades del proyecto que vimos en el capítulo 7. Una vez dentro de la ventana Propiedades, accederemos a la solapa Referencias, y dentro de esta ventana, seleccionaremos el botón Agregar como se indica en la figura 9.1.

Figura 9.1: botón Agregar de la solapa Referencias dentro de la ventana Propiedades del proyecto. Al pulsar el botón Agregar, el entorno abrirá una ventana con las librerías listas para ser incluidas en el proyecto. En nuestro caso, buscaremos la librería System.Xml.dll que se encuentra en Windows como se indica en la figura 9.2., y haremos doble clic sobre ella para agregarla a la ventana de referencias del proyecto.


227

Figura 9.2: ventana para Agregar referencia al proyecto abierto. Una vez seleccionada la librería, ésta aparecerá en el proyecto referenciada, pero aún podemos usarla directamente declarándola previamente o bien, importarla mediante la palabra reservada Imports. 9.2.- Leer XML con XmlTextReader A continuación veremos la forma que tenemos en Visual Basic 2005, de leer un documento XML a través del objeto XmlTextReader. Una vez que tenemos agregada la referencia al proyecto, bastará con importar la librería (si queremos) mediante la instrucción Imports y trabajar con la clase directamente. El siguiente documento XML será el que empleemos como ejemplo para leerlo con XmlTextReader, como veremos a continuación:

<?xml version="1.0" encoding="UTF-8"?> <Coches> <Marca Fabricante="Audi"> <Modelo>A3</Modelo> </Marca> <Marca Fabricante="Citroen"> <Modelo>C1</Modelo> <Modelo>C5</Modelo> </Marca> <Marca Fabricante="Seat"> <Modelo>Arosa</Modelo> <Modelo>Leon</Modelo> </Marca> </Coches>

Este documento XML deberá ser recorrido para leer su contenido. En nuestro caso, hemos utilizado un código fuente, forzando la estructura del documento, para demostrar simplemente, como trabajar con XmlTextReader. De esta forma, nuestro código será el que se asemeje al siguiente:


228

Imports System.Xml Public Class Form1 #Region "PROPIEDAD: Fabricante" Private m_Fabricante As String Private Property Fabricante() As String Get Return m_Fabricante End Get Set(ByVal value As String) m_Fabricante = value End Set End Property #End Region #Region "PROPIEDAD: Modelo" Private m_Modelo As String Private Property Modelo() As String Get Return m_Modelo End Get Set(ByVal value As String) m_Modelo = value End Set End Property #End Region Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim xmltr As New XmlTextReader("c:\prueba.xml") xmltr.WhitespaceHandling = WhitespaceHandling.None Dim bolDatos As Boolean = False xmltr.Read() xmltr.Read() xmltr.Read() 'Ahora estamos posicionados donde queremos While Not xmltr.EOF 'Si es Marca => Fabricante If xmltr.LocalName = "Marca" Then 'Leemos Fabricante Fabricante = xmltr.GetAttribute("Fabricante") 'Continuamos leyendo xmltr.Read() ElseIf xmltr.LocalName = "Modelo" Then 'Leemos Modelo Modelo = xmltr.ReadElementString("Modelo") 'Indicamos que ya tenemos datos de Fabricante y Modelo bolDatos = True Else 'Sino hay ninguna de las anteriores, leemos el siguiente elemento xmltr.Read() End If 'Si hay datos, Fabricante y Modelo, mostramos los datos en pantalla If bolDatos Then MessageBox.Show(Fabricante & vbCrLf & Modelo) : bolDatos = False End While 'Cerramos el documento XML xmltr.Close() End Sub End Class

Este ejemplo, nos mostrará por pantalla los datos relacionados con las marcas o


229

fabricantes de automóviles y su correspondiente modelo. Como podemos ver, tenemos dos funciones que serán las encargadas de leer el atributo y el elemento. Estas son GetAttribute y ReadElementString. A continuación, veremos otro ejemplo, de cómo leer documentos XML con el objeto XmlDocument. 9.3.- Leer XML con XmlDocument A continuación y después de ver XmlTextReader, veremos como usar XmlDocument para leer documentos XML en Visual Basic 2005. Reutilizando el documento XML anterior y de una forma muy parecida, escribimos el siguiente código:

Imports System.Xml Public Class Form1 #Region "PROPIEDAD: Fabricante" Private m_Fabricante As String Private Property Fabricante() As String Get Return m_Fabricante End Get Set(ByVal value As String) m_Fabricante = value End Set End Property #End Region #Region "PROPIEDAD: Modelo" Private m_Modelo As String Private Property Modelo() As String Get Return m_Modelo End Get Set(ByVal value As String) m_Modelo = value End Set End Property #End Region Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Preparamos las variables Dim xmld As New XmlDocument Dim nodelist As XmlNodeList Dim node As XmlNode 'Cargamos el documento XML xmld.Load("c:\prueba.xml") nodelist = xmld.SelectNodes("/Coches/Marca") 'Recorremos cada nodo For Each node In nodelist 'Recogemos el valor del Fabricante Fabricante = node.Attributes.GetNamedItem("Fabricante").Value 'Recorremos la lista de hijos For I As Integer = 1 To node.ChildNodes.Count 'Recogemos el valor del Modelo Modelo = node.ChildNodes.Item(I - 1).InnerText 'Mostramos la información en pantalla MessageBox.Show(Fabricante & vbCrLf & Modelo) Next Next End Sub End Class


230

Como podemos observar, leemos la información del documento XML con ayuda de la función GetNamedItem y de la propiedad ChildNodes. Así, recorremos su información y la mostramos por pantalla. Aún y así, también es posible leer documentos XML con ayuda de XPathDocument, que es lo que veremos a continuación. 9.4.- Leer XML con XPathDocument A continuación veremos ahora, como leer documentos XML en Visual Basic 2005 con ayuda de XPathDocument. De esta manera, haremos un repaso general a como leer documentos XML desde Visual Basic 2005. Escriba el siguiente código fuente:

Imports System.Xml.XPath Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Leemos el documento XML y declaramos las variables a utilizar Dim xmlPathDoc As New XPathDocument("c:\prueba.xml") Dim xmlNav As XPathNavigator Dim xmlNI As XPathNodeIterator 'Creamos el proceso de navegación xmlNav = xmlPathDoc.CreateNavigator 'Indicamos el árbol del documento XML de dónde 'obtendremos los datos que nos interesan xmlNI = xmlNav.Select("/Coches/Marca/Modelo") 'Recorremos el documento XML While xmlNI.MoveNext() 'Mostramos la información MessageBox.Show(xmlNI.Current.Value) End While End Sub End Class

Nuestro ejemplo en ejecución nos mostrará el contenido del documento XML con los modelos de los vehículos que hay dentro del documento. Otra posibilidad sin embargo a la hora de trabajar con documentos XML es la que nos permite acceder a los documentos XML como si fuera una fuente de datos. Esto lo lograremos utilizando para ello la clase DataSet. 9.5.- Leer un XML como un DataSet La clase DataSet nos permite trabajar con un documento XML como si de una fuente de datos se tratara. En el siguiente ejemplo, leeremos el documento XML con el cuál hemos trabajado hasta ahora, para volcar su información en un DataSet. En nuestro caso no tenemos un esquema del documento, por lo que el documento será insertado de manera tal, que se almacene cierta relación entre los datos, por lo que en nuestro caso, tendremos dos tablas dentro del DataSet relacionadas entre sí. Antes de continuar, debemos indicar que para trabajar con la clase DataSet, deberemos agregar una referencia al nombre de espacio System.Data como ya hemos realizado anteriormente para el nombre de espacio System.Xml.XPath. El siguiente ejemplo por lo tanto, nos muestra una forma de cargar un documento XML en un DataSet, y como recorrerlo con el objetivo de mostrar sus datos:


231

Imports System.Xml Imports System.Data Public Class Form1 #Region "PROPIEDAD: Fabricante" Private m_Fabricante As String Private Property Fabricante() As String Get Return m_Fabricante End Get Set(ByVal value As String) m_Fabricante = value End Set End Property #End Region #Region "PROPIEDAD: Modelo" Private m_Modelo As String Private Property Modelo() As String Get Return m_Modelo End Get Set(ByVal value As String) m_Modelo = value End Set End Property #End Region Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Declaramos un DataSet Dim dtMiDS As New DataSet 'Leemos los datos del documento XML dtMiDS.ReadXml("c:\prueba.xml") Dim miDoc As New XmlDataDocument(dtMiDS) 'Recorremos las tablas y datos del DataSet Dim row For Each row In miDoc.DataSet.Tables(0).Rows 'Las dos tablas están relacionadas 'mediante un campo de tipo índice Dim intRelacion = row(0) Fabricante = row(1).ToString() Dim row2 For Each row2 In miDoc.DataSet.Tables(1).Rows If row2(1) = intRelacion Then Modelo = row2(0).ToString() 'Mostramos la pareja de valores Fabricante - Modelo MessageBox.Show(Fabricante & vbCrLf & Modelo) End If Next Next End Sub End Class

De esta manera, recorremos los campos de las tablas de nuestro DataSet y mostramos su contenido. 9.6.- Ejemplo práctico para escribir un documento XML Sirva el siguiente ejemplo como demostración de cómo podemos escribir un documento XML de manera sencilla:


232

Imports System.Xml Imports System.Data Public Class Form1 #Region "PROPIEDAD: Fabricante" Private m_Fabricante As String Private Property Fabricante() As String Get Return m_Fabricante End Get Set(ByVal value As String) m_Fabricante = value End Set End Property #End Region #Region "PROPIEDAD: Modelo" Private m_Modelo As String Private Property Modelo() As String Get Return m_Modelo End Get Set(ByVal value As String) m_Modelo = value End Set End Property #End Region Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim txtUE As New System.Text.UTF8Encoding Dim objXML As New XmlTextWriter("c:\prueba_wr.xml", txtUE) With objXML .WriteStartDocument() .WriteStartElement("Coches") '--------------------------- .WriteStartElement("Marca") .WriteAttributeString("Fabricante", "Audi") .WriteStartElement("Modelo") .WriteName("A3") .WriteEndElement() .WriteEndElement() '--------------------------- .WriteStartElement("Marca") .WriteAttributeString("Fabricante", "Citroen") .WriteStartElement("Modelo") .WriteName("C1") .WriteEndElement() .WriteStartElement("Modelo") .WriteName("C5") .WriteEndElement() .WriteEndElement() '--------------------------- .WriteStartElement("Marca") .WriteAttributeString("Fabricante", "Seat") .WriteStartElement("Modelo") .WriteName("Arosa") .WriteEndElement() .WriteStartElement("Modelo") .WriteName("Leon") .WriteEndElement() .WriteEndElement() '--------------------------- .WriteEndElement()


233

.WriteEndDocument() .Close() End With End Sub End Class

Como podemos observar, la forma de escribir un documento XML es realmente sencilla. La clase XmlTextWriter es la encargada de realizar la escritura del documento XML, y tan sólo debemos indicar las partes que forman parte del documento y los valores de estas partes.


234

CAPÍTULO 10

BREVE INTRODUCCIÓN AL ACCESO A DATOS ESTE CAPÍTULO NOS PERMITIRÁ INTRODUCIRNOS BREVEMENTE EN EL DESARROLLO DE APLICACIONES DE ACCESO A DATOS CON VISUAL BASIC 2005. Las aplicaciones de acceso a datos, forman casi de forma habitual, parte de una aplicación Windows estándar. Sin lugar a dudas, no siempre necesitaremos acceder a fuentes de datos en nuestras aplicaciones, de hecho, podemos incluso trabajar con documentos XML, pero en muchas ocasiones, nos resultará imprescindible acceder a fuentes de datos. En el siguiente capítulo, veremos como acceder a fuentes de datos de forma sencilla, desde nuestro entorno de desarrollo. 10.1.- Una pequeña introducción a ADO.NET Si conoce el desarrollo de aplicaciones con versiones anteriores de Visual Basic a la tecnología .NET, entonces le sonará algunos aspectos entre otros como ADO, DAO. Visual Basic 2005 por su lado, ha visto de cerca el nacimiento de ADO.NET. Sin embargo, no es recomendable comparar ADO.NET con los anteriores métodos de conexión a fuentes de datos. Nos olvidaremos de todo esto y nos centraremos en la forma de conectar de Visual Basic 2005 con fuentes de datos a través de ADO.NET 2.0. ADO.NET es por lo tanto, un conjunto de clases que nos permiten leer e interactuar con fuentes de datos almacenadas en bases de datos y otras fuentes de almacenamiento de datos. Estas clases de ADO.NET, las encontraremos dentro de System.Data. Entre todas las clases de este nombre de espacio, destacaremos la clase DataView, DataSet y DataTable. Si usted sabe, conoce o ha trabajado con RecordSet en anteriores versiones de Visual Basic, debe saber que ahora, podremos hacer lo mismo con los objetos DataSet y DataReader. Pero sobre todo, algo que destaca a ADO.NET sobre otros métodos de acceso, es que nos permite el desarrollo de aplicaciones en n-capas. Todo esto, unido a la posibilidad de trabajar con estándares como documentos XML, nos proporciona una intercomunicación entre entornos y dispositivos que está asegurada. Aún y así, existe otro detalle a tener en cuenta a la hora de trabajar con fuentes de datos junto a las clases y objetos de la tecnología .NET, y es que podemos trabajar con fuentes de datos conectadas o fuentes de datos desconectadas. La diferencia entre ellas, es la que veremos de forma breve a continuación. 10.2.- ¿Acceso conectado o acceso desconectado? Cuando trabajamos con fuentes de datos dentro de la tecnología .NET, podemos trabajar con fuentes de datos conectadas o fuentes de datos desconectadas. La diferencia entre ambos métodos de conexión es clara. Por un lado, el trabajo con fuentes de datos conectadas, requiere que exista un canal de comunicación existente entre la aplicación y la fuente de datos en todo momento. De esta manera, la conectividad con la aplicación, la apertura de la conexión, etc., que es la tarea más pesada en la comunicación de una aplicación con una fuente de datos, permanece abierta mientras se trabaja con la fuente de datos, estemos en un instante dado manipulando datos de la fuente de datos o no. Por decirlo de otra forma, la puerta de acceso la hemos dejado abierta y pasaremos de una habitación a otra y viceversa cuando queramos.


235

Por otro lado, el trabajo con fuentes de datos desconectadas, requiere que cuando se accede a la base de datos, se recoja no sólo una copia de los datos con los que vamos a trabajar, sino que además se almacene una copia de la estructura de la tabla o tablas que hemos decidido descargar y otros datos relacionados con las tablas. En sí, es una copia exacta o una foto exacta de los datos de la tabla o tablas y de todas las características de la tabla o tablas. Por lo tanto, se abre un canal de comunicación, se recogen los datos para trabajar con ellos y se cierra nuevamente el canal de comunicación. Esos datos se almacenan en memoria, y se trabaja por lo tanto, con los datos de memoria, no con la fuente de datos directamente como en el caso anterior dónde trabajábamos con fuentes de datos conectadas. La única particularidad a tener en cuenta en este último caso, es que como lógicamente haremos una copia de la estructura, propiedades, características y datos de la tabla o tablas con las que queremos trabajar de forma desconectada, no es muy recomendable por no decir totalmente prohibido, hacer una copia de cualquier tabla, ya que podemos sobrecargar la aplicación y afectar considerablemente en el rendimiento de ésta. 10.3.- DataSet, DataView y DataTable Ya hemos hablado antes de DataSet, pero es bueno hacer un repaso breve no sólo a esta clase, sino a la clase DataView y DataTable también. La clase DataSet contiene un conjunto de datos volcado desde un proveedor de datos determinado. Esta clase, está preparada especialmente, para trabajar con fuentes de datos desconectadas. Dentro de una clase DataSet, podemos establecer colecciones DataTables y DataRelations. La colección DataTable contiene o puede contener, una o varias tablas de datos. La colección DataRelation, contiene por su parte, las relaciones entre las DataTables. La clase DataView por otro lado, nos permite crear múltiples vistas de nuestros datos para presentar los datos de su correspondiente DataTable posteriormente. Adicionalmente a esto, también podemos ordenar y filtrar los datos, buscar y navegar un conjunto de datos dado, etc. La clase DataTable, nos permite representar como ya hemos adelantado, una determinada tabla en memoria para que podamos interactuar con ella. 10.4.- Ejemplo de conectividad de datos con DataSet Para que veamos como conectarnos a una fuente de datos, en nuestro caso, Microsoft SQL Server 2000, escribiremos el siguiente ejemplo:


236

Imports System.Data Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Preparamos la cadena de conexión con la base de datos Dim Conexion As String = "Data Source=BURGOS;Database=PRUEBAS;Integrated Security=True" Dim MiTabla As DataTable Dim MiColumna As DataColumn 'Declaramos el objeto DataSet Dim MiDataSet As New DataSet() 'Ejecutamos el comando SELECT para la conexión establecida Dim Comando As New SqlClient.SqlDataAdapter("SELECT * FROM MiTabla", Conexion) 'Volcamos los datos al DataSet Comando.Fill(MiDataSet, "PERSONAS") 'Liberamos el adaptador de datos, 'pues ya tenemos los datos en el DataSet Comando = Nothing Dim strTexto As String = "" ' Recorremos las tablas For Each MiTabla In MiDataSet.Tables strTexto += "Tabla: " & MiTabla.TableName & vbCrLf & vbCrLf ' Recorremos las Columnas de cada Tabla For Each MiColumna In MiTabla.Columns strTexto += MiColumna.ColumnName & vbTab & _ "(" & MiColumna.DataType.Name & ")" & vbCrLf Next Next 'Mostramos la información por pantalla MessageBox.Show(strTexto) End Sub End Class

Nuestra aplicación en ejecución es la que se muestra en la figura 10.1.

Figura 10.1: ejecución del ejemplo de conectividad DataSet. 10.5.- Recorriendo los datos de un DataSet El siguiente ejemplo, nos muestra como recorrer los datos de un DataSet. Para ello, nos basamos en el ejemplo anterior y en los mismos datos de la base de datos. De esta manera, tenemos el siguiente código:


237

Imports System.Data Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Preparamos la cadena de conexión con la base de datos Dim Conexion As String = "Data Source=BURGOS;Database=PRUEBAS;Integrated Security=True" 'Declaramos el objeto DataSet Dim MiDataSet As New DataSet() 'Ejecutamos el comando SELECT para la conexión establecida Dim Comando As New SqlClient.SqlDataAdapter("SELECT * FROM MiTabla", Conexion) 'Volcamos los datos al DataSet Comando.Fill(MiDataSet, "PERSONAS") 'Liberamos el adaptador de datos, 'pues ya tenemos los datos en el DataSet Comando = Nothing Dim strTexto As String = "" ' Recorremos las tablas Dim Row For Each Row In MiDataSet.Tables(0).Rows strTexto += Row(1).ToString() & " tiene " & Row(2).ToString() & " años" & vbCrLf Next 'Mostramos la información por pantalla MessageBox.Show(strTexto) End Sub End Class

Este pequeño ejemplo en ejecución es el que se muestra en la figura 10.2.

Figura 10.2: ejecución del ejemplo de acceso a datos con un DataSet. A continuación, veremos un ejemplo de acceso conectado a datos. De esta manera, habremos cubierto la parte general del acceso de datos con Visual Basic 2005. 10.6.- Ejemplo de acceso conectado de datos Hemos visto como conectar un DataSet a una fuente de datos, como volcar los datos de la fuente de datos al DataSet, y como trabajar con esos datos estando ya desconectados del servidor de datos. A continuación veremos un ejemplo idéntico al anterior, con la particularidad de que en este caso, estaremos accediendo al servidor en todo momento. Es decir, trataremos los datos en un ambiente conectado. El siguiente ejemplo, nos muestra como realizar estas operaciones de forma práctica:


238

Imports System.Data Public Class Form1 Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Preparamos la cadena de conexión con la base de datos Dim Conexion As String = "Data Source=BURGOS;Database=PRUEBAS;Integrated Security=True" 'Establecemos la conexión a utilizar Dim MiConexion As New SqlClient.SqlConnection(Conexion) 'Declaramos el objeto DataReader Dim MiDataReader As SqlClient.SqlDataReader 'Ejecutamos el comando SELECT para la conexión establecida Dim Comando As New SqlClient.SqlCommand("SELECT * FROM MiTabla", MiConexion) 'Abrimos la conexión MiConexion.Open() 'Indicamos al objeto DataReader el comando a ejecutar MiDataReader = Comando.ExecuteReader 'Declaramos la variable vacía para almacenar la información de los campos de la tabla Dim strTexto As String = "" 'Recorremos el DataReader mientras haya datos While MiDataReader.Read() strTexto += MiDataReader("Nombre") & " tiene " & MiDataReader("Edad") & " años" & vbCrLf End While 'Liberamos el Comando Comando = Nothing 'Mostramos la información por pantalla MessageBox.Show(strTexto) End Sub End Class

Nuestro pequeño ejemplo en ejecución es el que se muestra en la figura 10.3.

Figura 10.3: ejecución del ejemplo de acceso conectado a datos.

software interactiu de simulació de camps elèctrics generats per...

Documents