Qu es esto del mbito?

El mbito es la cobertura o duracin de la vida de una variable, un procedimiento o una clase, es decir, hasta dnde son visibles y, por decirlo de alguna forma, durante cuanto tiempo. Hasta ahora hemos estado usando dos instrucciones (o modificadores) que permiten indicar el mbito de un miembro de una clase (o mdulo), uno de ellos es Public y el otro es Private. Como habrs podido comprobar, (y si no lo has comprobado, al menos s que te lo he dicho), al usar el modificador Public, permitimos que el miembro al que se le ha aplicado ese modificador sea visible desde cualquier sitio y por tanto estar accesible para que podamos usarlo desde la propia clase o desde fuera de ella; por otro lado, cuando usamos Private, estamos indicando que ese miembro es "privado" a la clase en la que se ha declarado y por tanto slo podremos usarlo desde la propia clase. Antes de entrar en detalles y para que lo comprendas mejor, (o si no para que lo comprendas mejor, al menos para que no te queden dudas, que para el caso es lo mismo), vamos a verlo con un ejemplo, el cual ser parecido a uno de los usados en la entrega anterior. Veamos el cdigo y ahora te explico. Public Class Prueba15 Private elNombre As String Public Apellidos As String ' Public Property Nombre() As String ' la parte Get es la que devuelve el valor de la propiedad Get Return elNombre End Get ' la parte Set es la que se usa al asignar el nuevo valor Set(ByVal Value As String) If Value <> "" Then elNombre = Value End If End Set End Property ' ' mtodo pblico para mostrar el nombre completo Public Sub Mostrar()

Console.WriteLine(elNombre & " " & Apellidos) End Sub End Class En esta clase hemos definido dos campos: elNombre y Apellidos, el primero est declarado como Private, por tanto slo ser visible dentro de la clase, es decir: no podemos acceder a ese campo desde fuera de la clase, ahora lo comprobaremos. El segundo est declarado como Public, por tanto ser accesible (o visible) tanto desde dentro de la clase como desde fuera de ella. Cuando digo que ser visible o accesible, me refiero a la posibilidad de poder usarlo. Como te imaginars, para poder usar cualquier miembro de una clase "desde fuera", tendremos que declarar una variable del tipo de la clase e instanciarla por medio de New, ya que esta es la nica forma de poder acceder a una clase... (Eh! Guille, eso no es del todo cierto) bueno, vale... espabilao! que eres un espabilao!, (espabilao = perspicaz, "listillo", etc.), en este caso, cuando digo clase, me refiero a un "tipo" declarado usando Class, ya que, como tendrs ocasin de comprobar, si el "tipo" lo declaramos con Module o Structure, la cosa cambia... pero no te compliques la vida todava, que ya tendrs tiempo de complicrtela. A lo que iba, en ese cdigo que he mostrado, (as est mejor dicho), para poder acceder a los miembros de la clase, tendremos que crear una nueva instancia; pero a los miembros a los que podemos acceder, slo sern los que estn declarados como Public. Adems de esos dos campos, tambin tenemos una propiedad y un mtodo, ambos declarados como Public. El mtodo Mostrar, que es un procedimiento de tipo Sub, puede acceder tanto a la variable declarada como Private como a la que hemos declarado como Public, ya que ambas variables (en este caso tambin campos de la clase) tienen la "cobertura" suficiente para que sean vistas (o accesibles) desde cualquier sitio "dentro" de la propia clase. La propiedad Nombre, tiene dos bloques de cdigo, uno ser la parte Get (la que devuelve el valor de la propiedad) y la otra es el bloque Set (el que asigna el valor a la variable privada). Desde los dos bloques podemos acceder a la variable privada elNombre, ya que el mbito de dicha variable es: toda la clase. Pero si te fijas, en el bloque Set de la propiedad se ha declarado una variable, esa variable slo ser "visible" dentro de ese bloque y no podr ser accedida desde ningn otro sitio, en cuanto acabe ese bloque, la variable Value "desaparece" y deja de existir... (si no te aclaras, no te preocupes por ahora, que esto lo aclararemos). Antes de seguir con ms explicaciones, veamos el cdigo desde el que usaremos esa clase. Module Module1 Sub Main() Dim n As New Prueba15()

' n.Nombre = "Guille" n.Apellidos = "Som" n.Mostrar() End Sub End Module En este mdulo tenemos un procedimiento en el cual declaramos una variable del tipo Prueba15. Creamos una nueva instancia en la memoria y usamos los miembros pblicos. Si intentas acceder al miembro privado, por ejemplo para hacer esta asignacin: n.elNombre = "Guille", el compilador de Visual Basic .NET se quejar, ya que no "sabe" nada de un miembro llamado elNombre. Estando en el Visual Studio .NET nos mostrar la variable sealada con unos dientes de sierra y si posicionas el ratn encima te informar del error, el cual, tal como podemos ver en la figura 1, indica que la variable est declarada como privada y, por tanto, no accesible.

Figura 1

Antes de explicarte los diferentes modificadores de mbito (o de niveles de visibilidad) que podemos aplicar a los distintos elementos de un proyecto de Visual Basic .NET, vamos a aclarar unos cuantos conceptos.

Cmo declarar las variables.

No, no ests volviendo al pasado, ests en la entrega 15. Para declarar una variable podemos hacerlo de varias formas, dependiendo dnde se declaren esas variables. Usando la misma nomenclatura que en la documentacin de Visual Studio .NET, existen varios niveles de mbito, es decir, existen distintos "sitios" en los que podemos declarar una variable, (o cualquier otro elemento, pero para simplificar, vamos a centrarnos en las variables), estos niveles son: Bloque: Un bloque puede ser, por ejemplo, un If... Then, un Do... Loop o los bloques Get y Set. Procedimiento: Un Sub, Function o Property. Mdulo: Una clase (Class), mdulo (Module) o estructura (Structure) Espacio de nombres: Un bloque Namespace.

Nota: Fjate que en Visual Basic, todos los "bloques" o niveles (que siempre estn encerrados entre un inicio y un final), suelen terminar con End <tipo de nivel>. Por ejemplo un bloque If... Then ocupar desde el If... Then hasta el End If, (aclaro que salvo que est definido como si no fuese un bloque). Las excepciones son For que llegar hasta el Next y Do que lo har hasta Loop. Los tipos de niveles estn enumerados de menor a mayor, es decir, una variable declarada en un nivel de mdulo, tendr ms cobertura que otra declarada en un bloque If. Lo cual quiere decir que si declaramos una variable a nivel de mdulo, esa variable ser visible desde cualquier otro "nivel" inferior. Cosa que hemos comprobado en el cdigo de la clase anterior. La variable elNombre declarada a nivel de mdulo (en este caso el mdulo es uno del tipo Class) es visible en un nivel inferior, en ese ejemplo podemos acceder a ella desde los dos procedimientos que tenemos. Como te comentaba al principio de esta seccin, las variables las podemos declarar de varias formas, dependiendo del "nivel" en el que la declaremos, salvo a nivel de Namespace, ya que en un Namespace no podemos declarar una variable. Como hemos visto desde el principio de este curso, lo habitual para declarar una variable es usando Dim. De hecho, usar Dim es la nica forma de declarar una variable en los dos niveles inferiores (bloque y procedimiento). Pero en el nivel de mdulo podemos usar tanto Dim como las instrucciones Private, Public (y las que ahora veremos). Cuando declaramos una variable con Dim en un nivel de mdulo es lo mismo que declararla con Private.

Las variables declaradas en los procedimientos. Como acabo de comentarte, las variables en un procedimiento, (Sub, Function o Property), tenemos que declararlas con Dim. Esto significa que las variables son privadas (o locales) al procedimiento, por tanto slo se podrn usar dentro del procedimiento y desde fuera de l no sabrn de la existencia de esas variables. Pero an hay ms, si hubiese una variable de "nivel superior" que se llamase igual que una variable "local" al procedimiento, sta ltima ocultara a la que est declarada en un nivel superior. Por ejemplo, en la clase Prueba15 tenemos la variable elNombre, declarada a nivel de mdulo, sta variable podr usarse dentro del procedimiento Mostrar, pero si el procedimiento Mostrar lo re-escribimos de esta forma: Public Sub Mostrar() ' prueba declarando una variable "local" ' que se llama igual que otra declarada a nivel de mdulo

Dim elNombre As String ' Console.WriteLine(elNombre & " " & Apellidos) End Sub La variable declarada dentro del procedimiento "ocultara" a la declarada a nivel de mdulo, por tanto, ahora no se mostrara el nombre que hubisemos asignado a la clase, sino una cadena vaca, ya que no hemos asignado nada a esa variable. Pero an hay ms, si el parmetro de un procedimiento recibe una variable que se llama como otra declarada a nivel superior, esa variable tambin ocultara a la de nivel superior. Por ejemplo, si tenemos este procedimiento: Public Sub Mostrar2(ByVal elNombre As String) Console.WriteLine(elNombre & " " & Apellidos) End Sub El nombre de la variable usada como parmetro tambin se llama igual que la declarada a nivel de mdulo, por tanto esa variable (la del parmetro) ocultar a la otra (la declarada a nivel de mdulo). Cuando digo que ocultar, me refiero a que la variable que "eclipsa" a la otra no la sustituye, ya que realmente son dos variables diferentes y cada una tendr su propia direccin de memoria, por tanto el valor asignado a esas variables locales no afectar en nada a la variable declarada a nivel de mdulo. Cuando declaramos variables locales (al procedimiento), stas durarn (o existirn) mientras dure el procedimiento, es decir, cuando se sale del procedimiento, el valor que tuviera asignado, se perder. Cuando se vuelva a entrar en el procedimiento se volvern a crear esas variables y el valor que antes tenan ya no ser recordado. Nota: Para aclarar esto, seguramente tendra que dar explicaciones de cmo funciona la pila (stack) y cmo se almacenan las variables locales en la pila, pero creo que esto es un tema que lo que podra hacer es complicarte an ms las cosas... de todas formas, sin que lo tomes como "doctrina", te dir que cada vez que se usan las variables locales a un procedimiento (incluidos los parmetros declarados con ByVal), estos valores (o referencias en el caso de que sean tipos por referencia), se almacenan en una memoria especial llamada "pila", cuando se sale del procedimiento se "limpia" la pila y por tanto esas variables se pierden. Pero, habr ocasiones en que no queramos que esos valores de las variables locales se pierdan, en Visual Basic podemos hacerlo declarando las variables

usando la instruccin Static en lugar de Dim. Static le indica al compilador que esa variable debe mantener el valor entre distintas llamadas al procedimiento, para que de esa forma no se pierda el valor que tuviera. Las variables declaradas con Static siguen siendo locales al procedimiento y tambin "ocultarn" a variables declaradas a nivel de mdulo que se llamen de igual forma. Es decir, funcionan como las declaradas con Dim, pero mantienen el valor, adems de que Static slo se puede usar para declarar variables dentro de procedimientos. Veamos un ejemplo que lo aclare. Si escribimos este cdigo (el cual no tendr nada que ver con la clase y mdulo que hemos usado antes): Module Modulo2 Sub Main() Dim i As Integer For i = 1 To 3 Prueba() Next End Sub ' Sub Prueba() Dim numDim As Integer Static numStatic As Integer ' Dim i As Integer For i = 1 To 10 ' incrementamos las variables numDim += 1 numStatic += 1 Next Console.WriteLine("El valor de numDim = {0}, " & _ "el valor de numStatic = {1}", _ numDim, numStatic) End Sub End Module Comprobars que el valor de la variable numStatic mantiene el valor entre distintas llamadas, (mostrando los valores 10, 20 y 30), mientras que el valor de la variable numDim siempre mostrar 10. Fjate tambin que en el procedimiento Main tenemos una variable llamada

"i", esta variable al ser "local" al procedimiento no tendr nada que ver con la variable "i" declarada en el procedimiento Prueba. Nota para curiosos: En C# no existen las variables Static, realmente la instruccin static tiene otro significado diferente. Si miramos el cdigo IL generado, el compilador lo que hace es declarar una variable a nivel de mdulo con un nombre especial. Cada variable declarada como Static tendr una variable declarada a nivel de mdulo, en el caso de numStatic, el compilador la ha declarado de esta forma: .field private static specialname int32 $STATIC$Prueba$001$numStatic Esto es cdigo IL, el cual puedes ver usando la utilidad ILDASM.EXE.

Las variables declaradas en los "bloques" En los bloques podemos declarar variables "privadas" a esos bloques, pero en esta ocasin slo pueden declararse con Dim. Las variables declaradas en un bloque slo sern visibles "dentro" de ese bloque, por tanto no podrn ser accedidas desde fuera del bloque. Las limitaciones que tenemos en Visual Basic .NET respecto a las variables "locales" declaradas en un bloque, es que no pueden llamarse de igual forma que una declarada en el mismo "nivel" en el que se usa el bloque, normalmente en un procedimiento, ya que no podemos usar un bloque fuera de un procedimiento. Cuando digo bloque, me estoy refiriendo a un "bloque" IF, DO, FOR, CASE, etc. Una variable declarada en un bloque si se puede llamar como otra declarada a nivel de mdulo, en ese caso, la variable "local" ocultar a la declarada a nivel de mdulo. Lo que debemos tener presente es que las variables declaradas en un bloque "mantienen" el valor mientras dure la vida del procedimiento en el que se encuentran. Es como si fuesen "estticas" mientras dure el procedimiento, aunque, cuando termina el procedimiento, ese valor se pierde. Tambin debemos saber que esto slo es aplicable si no hemos asignado un valor a la variable al declararla, ya que si se asigna un valor al declararla, siempre usar ese valor. No te aclaras? Pues entonces mejor ser verlo con un ejemplo. Module Modulo3 Sub Main() Dim i As Integer For i = 1 To 2 Console.WriteLine("Llamando a Prueba3, cuando i vale {0}", i)

Prueba3() Next End Sub ' Sub Prueba3() Dim i As Integer For i = 1 To 5 If i > 1 Then Dim j As Integer Dim k As Integer = 2 ' ' incrementamos las variables k += 1 j += 1 Console.WriteLine("j = {0}, k = {1}", j, k) End If Next End Sub End Module En este ejemplo, dentro del bloque If i > 1 Then... tenemos dos variables locales al bloque. La variable j se ha declarado de forma "normal", mientras que la variable k se ha declarado usando un valor inicial. Cada vez que llamemos al procedimiento Prueba3, el bucle se repetir 5 veces y la condicin para entrar en el bloque se ejecutar 4 de esas 5 veces, y como podemos comprobar la variable j va tomando valores desde 1 hasta 4, mientras que k siempre muestra el valor 3, (dos que le asignamos al declarar y uno del incremento). La salida de esta prueba sera la siguiente:

Llamando j = 1, k j = 2, k j = 3, k j = 4, k Llamando j = 1, k j = 2, k j = 3, k j = 4, k

a = = = = a = = = =

Prueba3, cuando i vale 1 3 3 3 3 Prueba3, cuando i vale 2 3 3 3 3

En estos casos, lo recomendable sera declarar la variable j a nivel de procedimiento, ya que, adems de que no podemos tener una variable que se llame j, nos aseguramos de que no nos "confundiremos" y podamos pensar de que el valor que tendr la variable ser cero, que es lo que podra parecer. En C#, ese problema no existe, ya que todas las variables declaradas a nivel de un bloque deben tener un valor inicial, el cual, a diferencia del Visual Basic, no es automtico. Y ya que estamos con C#, (que se que a algunos os gusta que haga este tipo de comparaciones), en C# tampoco se puede tener una variable declarada en un bloque que se llame igual que otra declarada en el mismo nivel en el que se encuentra el bloque.

Las variables declaradas a nivel de mdulo. Para ir completando conceptos, vamos a terminar viendo las variables declaradas a nivel de mdulo. Te recuerdo que cuando hablo de mdulo, me refiero tanto a un Module como a un Class o a un Structure. En las declaraciones de las variables declaradas a nivel de mdulo pueden entrar en juego otros modificadores de visibilidad, estos "modificadores", como comprobaremos, tambin sern aplicables a los procedimientos. Cuando declaramos una variable a nivel de mdulo, sta ser visible en todo el mdulo (clase) en el que se ha declarado, adems, dependiendo del modificador de nivel de visibilidad que tenga, podr ser "vista" (o estar accesible) desde otros sitios. Recuerda que las variables declaradas en los mdulos se les llama "campos" y si son accesibles desde fuera de la clase, pueden llegar a confundirse con las propiedades, al menos en la forma de usarla.

Los niveles de visibilidad (accesibilidad o mbito).

Veamos un resumen de los modificadores de visibilidad que podemos usar en los programas de Visual Basic .NET y C#: Modificador (VB) (C#) Dim N.A Descripcin Declara una variable en un mdulo, procedimiento o bloque. Cuando se usa para declarar una variable a nivel de mdulo, se puede sustituir por Private. El elemento declarado slo es visible dentro del nivel en el que se ha declarado. El elemento es visible en cualquier parte.

Private Public

private public

Friend Protected Protected Friend

internal protected protected internal

El elemento es visible dentro del propio ensamblado (proyecto). El elemento es visible slo en las clases derivadas. El elemento es visible en las clases derivadas y en el mismo ensamblado.

Hay que tener en cuenta que el mbito que tendrn los elementos declarados, (por elemento entenderemos que es una variable, un procedimiento, una clase, mdulo, estructura o una enumeracin), dependern del nivel en el que se encuentran. Por ejemplo, cuando declaramos un elemento con el modificador Public dentro de un nivel que ha sido declarado como Private, el elemento declarado como pblico no podr "sobrepasar" el nivel privado. Por otro lado, si se declara un elemento como Private, ser visible desde cualquier otro elemento que est en el mismo nivel o en un nivel inferior. Nota: En la documentacin de Visual Studio .NET, mbito es el nivel de visibilidad que puede tener, ya sea a nivel de bloque, procedimiento, mdulo o espacio de nombres. Y la accesibilidad es la "visibilidad" de dicho elemento, si es pblico, privado, etc. Te aclaro esto, ya que yo suelo usar indistintamente mbito y accesibilidad para referirme a cmo podemos acceder (o desde dnde) a un elemento, ya sea una variable, procedimiento o clase. Espero no confundirte demasiado... Otra cosa a tener en cuenta es que cuando declaramos en Visual Basic .NET una clase, una estructura, una enumeracin o un procedimiento sin especificar el mbito, (ver los ejemplos anteriores), de forma predeterminada ser Public. En C# el mbito predeterminado es private. Que porqu te digo tambin lo de C#... porque hoy me ha dado por ah... adems de que algunos me lo habis pedido y como casi me cuesta el mismo trabajo... pero no s si esto ser una tnica general en futuras entregas, todo depender de la "aceptacin" que tenga... si no te parece bien dmelo, igualmente si te parece una buena idea, dmelo tambin. Cmo decrmelo? Envindome un mensaje que en el asunto diga algo como: Me parece bien que digas lo de C# en el curso de VB o como esto otro: Guille passa de decir las cosas de C# en el curso de VB que me las! (pero digas lo que digas, el Guille har lo que le parezca... je, je...) bueno, vale, a lo mejor tengo en cuenta tu opinin... pero, por favor, opina. Gracias. Los Namespace no pueden tener modificadores de acceso, siempre sern accesibles. Los mdulos (o clases) declaradas como Module, tampoco pueden tener modificadores de acceso, y tambin se consideran como Public, por tanto, siempre accesibles.

Adems de que cualquier elemento declarado en un Module podr usarse sin necesidad de indicar el nombre del mdulo; dnde puedan usarse depender del mbito que le hayamos dado. Ya que estamos con esto de los Module, voy a explicrtelo mejor o con ms detalle.

Diferencia entre Class y Module y miembros compartidos.

En los ejemplos que te estoy mostrando, hemos visto que estoy usando tanto Class como Module, segn el caso. Por regla general, se usarn las clases de tipo Class cuando "realmente" queramos crear una clase. Para poder acceder a los miembros de una clase, tendremos que crear una nueva instancia en la memoria. Por otro lado, usaremos las clases de tipo Module cuando queramos tener "miembros" que puedan ser usados en cualquier momento, sin necesidad de crear una nueva instancia de la clase, de hecho no podemos crear una instancia de un tipo declarado como Module. El que podamos acceder a los miembros de un Module sin necesidad de crear una nueva instancia, es por el hecho de que esos miembros son miembros compartidos. Bueno, realmente no slo porque son miembros compartidos, sino porque el compilador de Visual Basic .NET trata de forma especial a los "tipos de datos" declarados como Module. Los cuales, como coment hace unas lneas, se pueden acceder sin necesidad de usar el nombre del mdulo en el que estn incluidos. Pero los Module no son los nicos "poseedores" de la exclusiva de los miembros compartidos, ya que podemos declarar clases, (del tipo Class), que tengan miembros compartidos. De hecho, esta es la nica forma de hacerlo en C#. Veamos cmo podemos crear estas clases con miembros compartidos, y lo que es ms importante (o casi), cmo decirle al Visual Basic .NET que un miembro de una clase es un miembro compartido. Para que un miembro de una clase est compartido, hay que usar el modificador Shared (static en C#). Esta instruccin le indicar al runtime de .NET que ese miembro puede ser accedido sin necesidad de crear una nueva instancia de la clase. Para simplificar, te dir que es como si el CLR hubiese creado una instancia de esa clase y cada vez que queramos acceder a un miembro compartido, usara esa instancia para acceder a ese miembro, (seguramente no ser as, pero esa es la impresin que da). La nica "pega" con los miembros compartidos es que no se pueden usar en ellos variables u otros miembros que no estn compartidos. Nota: A los miembros de una clase que no estn compartidos se les llama

miembros de instancia, ya que slo podemos acceder a ellos desde una instancia creada en la memoria por medio de New. Otra nota: A los miembros compartidos tambin se les llama miembros estticos, as que, si en algn sitio te dicen que este o aquel miembro es esttico, ya sabes que estn diciendo que son compartidos... seguramente esa es la razn de que en C# se use static en lugar de Shared. Adems, en la documentacin de Visual Studio .NET (versin en castellano), cuando se tratan temas de Visual Basic, se dice que son miembros compartidos, mientras que al tratar temas de C# dicen que son miembros estticos. As que... que no te confundan! (que ya me encargo yo de confundirte... je, je).

Cmo declarar miembros compartidos en una clase, y cmo usarlos. Veamos un pequeo cdigo en el que tenemos una clase con elementos compartidos y no compartidos. Class Prueba15_5 ' miembros compartidos Public Shared elNombreShared As String Public Shared Sub MostrarCompartido() Console.WriteLine("Este procedimiento est declarado como compartido (Shared)") Console.WriteLine("Slo podemos acceder a miembros compartidos: {0}", elNombreShared) End Sub ' ' miembros de instancia Public elNombreInstancia As String Public Sub MostrarInstancia() Console.WriteLine("Este procedimiento es de instancia.") Console.WriteLine("Podemos acceder a miembros de instancia: {0}", elNombreInstancia) Console.WriteLine("y tambin a miembros compartidos: {0}", elNombreShared) End Sub ' End Class

En esta clase, hemos declarado un "campo" y un procedimiento compartido (usando Shared) y otro campo y otro procedimiento no compartido (de instancia). Desde el procedimiento compartido slo podemos acceder al campo compartido. Pero desde el procedimiento de instancia podemos acceder tanto al miembro compartido como al de instancia. Recuerda que una instancia es un nuevo objeto creado en la memoria. Por tanto cada instancia (u objeto en la memoria) tendr su propia copia de los miembros de instancia; mientras que de los miembros compartidos slo existe una copia en memoria que ser comn para todos y cada uno de los objetos instanciados. Esto lo podemos comprobar en el siguiente cdigo. Module Modulo5 Sub Main() ' para acceder a miembros compartidos ' usaremos el nombre de la clase: Prueba15_5.elNombreShared = "Shared" Prueba15_5.MostrarCompartido() ' Console.WriteLine() ' ' creamos una instancia de la clase Dim o As New Prueba15_5() ' o.elNombreInstancia = "Instancia" o.MostrarCompartido() o.elNombreShared = "Shared cambiado" o.MostrarInstancia() ' Console.WriteLine() ' ' creamos otro objeto del mismo tipo (otra instancia) Dim o2 As New Prueba15_5() ' o2.elNombreInstancia = "Instancia 2" o2.MostrarInstancia() 'o2.MostrarCompartido()

Prueba15_5.MostrarCompartido() End Sub End Module La salida de este cdigo ser la siguiente:

Este procedimiento est declarado como compartido (Shared) Slo podemos acceder a miembros compartidos: Shared Este procedimiento est declarado como compartido (Shared) Slo podemos acceder a miembros compartidos: Shared Este procedimiento es de instancia. Podemos acceder a miembros de instancia: Instancia y tambin a miembros compartidos: Shared cambiado Este procedimiento es de instancia. Podemos acceder a miembros de instancia: Instancia 2 y tambin a miembros compartidos: Shared cambiado Este procedimiento est declarado como compartido (Shared) Slo podemos acceder a miembros compartidos: Shared cambiado

Como puedes comprobar, para acceder a los miembros compartidos, hemos usado el nombre de la clase. De esta forma slo podemos acceder a los miembros compartidos. Por otro lado, al crear una instancia de esa clase, podemos acceder tanto a los miembros compartidos como a los de instancia, en este ejemplo, se asigna un valor al campo de instancia, se llama al procedimiento compartido y despus cambiamos el contenido del campo compartido y llamamos al procedimiento de instancia. En la segunda clase, al mostrar el contenido del campo compartido, mostrar el valor que el objeto (de instancia) le asign, ya que ese campo est compartido por todas las instancias. En la ltima lnea de cdigo he usado el mtodo compartido usando la clase, pero el resultado sera el mismo si se usara el objeto para llamar al mtodo compartido. Nota sobre C#: En C# no existe el tipo Module, siempre habr que declararlo como class, e indicar mediante static los miembros que queramos que estn compartidos. Decirte que en el caso de los campos compartidos, (realmente son variables), si no indicamos el nivel de visibilidad, stos sern Private y que se pueden declarar con cualquiera de los "niveles" de visibilidad. Por otro lado, los procedimientos compartidos, si no se indica el nivel de visibilidad, sern Public, (recuerda que todos los procedimientos, ya sean de instancia o compartidos, siempre tienen el nivel predeterminado de Public), y tambin podemos usar cualquiera de los niveles de visibilidad que queramos.

En ambos casos, si indicamos Protected, slo podremos acceder a ellos a partir de una clase derivada.

Sobre el cdigo y los datos de una clase.

Para terminar esta entrega, te voy a contar algo, que si bien no es necesario saber para poder trabajar con las clases, puede que alguna vez te surja la curiosidad de saber cmo maneja el Visual Basic .NET y en general, creo, que todos los lenguajes de programacin orientados a objeto o al menos los que utilizan las clases, incluido el Visual Basic clsico. A lo que me refiero es a si existe "sobrecarga" (en este caso me refiero a que el programa se sobrecargue en el sentido de que tenga ms consumo de memoria/trabajo) cuando se utilizan varios objetos en la memoria. Como sabemos cada vez que creamos (instanciamos) un objeto en la memoria, estamos reservando espacio para ese objeto, la pregunta es: Se reserva espacio tanto para los datos como para el cdigo de los procedimientos? La respuesta es que s... Si se reserva espacio tanto para el cdigo como para los datos, pero... el cdigo siempre es el mismo para todos los objetos creados en la memoria, es decir, slo existe una copia en la memoria del cdigo, no se "copia" ese cdigo una vez por cada objeto que hemos creado. Por otro lado, los datos si que ocupan espacios de memoria diferentes, uno para cada instancia. Al menos eso es lo que tengo entendido, no de ahora con el .NET, sino de antes... con el VB5, incluso me atrevera a decir que con el VB4. Cuando se usa un procedimiento de una clase y en ese procedimiento se usan valores de instancia, (los que existen de forma independiente para cada objeto creado), el runtime realmente hace una llamada al "cdigo" indicndole dnde estn los datos que tiene que manipular, es decir, le pasa al cdigo la direccin de memoria en la que se encuentran los datos a manipular, de esta forma, slo existe una copia del cdigo (igual que ocurre con los datos compartidos) y varias direcciones de memoria para los datos no compartidos, (segn el nmero de instancias que se hayan creado). As que, no te preocupes demasiado si el cdigo contenido en un procedimiento es demasiado largo, ya que slo existir una vez en la memoria y no una vez por cada objeto creado.

Bueno, creo que ya es bastante por hoy. S, ya se que nunca es suficiente... devoradores de entregas, eso es lo que

sois!

Estos son los links relacionados con el tema tratado en esta entrega, recuerda que los tres puntos suspensivos debers cambiarlos por lo que en tu instalacin indique. En la entrega nmero 13 te explico de que va todo esto de los enlaces a la ayuda y hasta de cmo usarlos desde el sitio de Microsoft, aunque la documentacin est en ingls. Tema Accesibilidad Tipos de acceso mbito Niveles de mbito Miembros compartidos Clases vs Module Module (instruccin) Class (instruccin) Link en la ayuda de Visual Studio .NET ms-help://.../vbcn7/html/vbconAccessibility.htm ms-help://.../vbls7/html/vblrfVBSpec4_5.htm ms-help://.../vbcn7/html/vbconscope.htm ms-help://.../vbls7/html/vblrfvbspec4_6.htm ms-help://.../vbcn7/html/vbconscopelevels.htm ms-help://.../vbcn7/html/vaconSharedMembers.htm mshelp://.../vbcn7/html/vbconClassModulesVsStandardModules.htm ms-help://.../vblr7/html/vakeyModule.htm ms-help://.../vblr7/html/vastmClass.htm

Procedimientos ms-help://.../vbcn7/html/vbconsubprocedures.htm Sub Procedimientos ms-help://.../vbcn7/html/vbconfunctionprocedures.htm Function Procedimientos ms-help://.../vbcn7/html/vaconwritingproperties.htm Property

En la prxima entrega veremos cmo acceder a diferentes miembros de diferentes espacios de nombres y de paso hablaremos de cmo usar los espacios de nombres. Tambin seguiremos tratando sobre ms cosas en relacin a la diferencia entre los mdulos y las clases, sobre todo basndonos en que estn en distintos espacios de nombres y esas cosillas. Y si el tiempo, (y la ocasin), lo permite, seguramente veremos cosas sobre los constructores de las clases y cmo declarar y usar las estructuras... ya veremos... Me apuntar por aqu que tengo que contarte tambin ms cosillas sobre la sobrecarga de procedimientos, pero eso no ser en la prxima entrega, simplemente "tomo nota" para que no se me olvide... si, ya se que podra usar una agenda, pero... para qu quiero una agenda si despus no la uso? ( ze, ze, este Guille no tiene remedio...)

Lo que es seguro, es que el contenido de la siguiente entrega se ver a cuando llegue el momento... Cuando ser ese momento? Ah, my friend... eso, como de costumbre, es un misterio... y ya no te digo que antes de un mes, porque... no lo s; confo en que s, pero...

Nos vemos. Guillermo Nerja, 28 al 30 de agosto de 2003

Nota del 05/Dic/2006:

Sobre los miembros compartidos de las clases y advertencia de Visual Basic 2005 al usarlos desde un objeto de instancia
Pues eso, que sobre este tema del acceso a los miembros compartidos desde un objeto de instancia de una clase, decirte que en Visual Basic 2005 te mostrar una advertencia indicndote que es posible que ese cdigo no se evale correctamente, en realidad la advertencia dice que NO se evaluar, pero si se evala... o ese creo, je, je, en cualquier caso, siempre es recomendable que se indique el nombre de la clase para acceder a los miembros compartidos (Shared) incluso si ests usando una versin anterior a la 2005 de Visual Basic. De la misma forma, yo tambin recomiendo siempre (o casi siempre, salvo cuando se me olvida, que a uno tambin se le olvidan las cosas... s, seguramente ser por la edad o porque solo tengo una neurona que est sobrecargada de trabajo, je, je), a lo que iba... que incluso cuando accedas a miembros definidos en los mdulos ( Module) deberas usar el nombre de dicho mdulo para accederlos, as te resultar ms fcil de depurar e incluso de entender mejor el cdigo, sobre todo cuando lo vuelves a mirar pasado un tiempo... porque cuando las cosas estn recin hechas, nos acordamos de todo, pero deja que pase unos meses y ya me dirs si te acuerdas de todo... Aclarar que en C# siempre hay que usar el nombre de la clase para acceder a los miembros compartidos (perdn estticos). Gracias a Juan Ramirez por "recordarme" que en esta entrega (muy prevb2005 debo decir en mi defensa, je, je) no estaba aclarado esto del acceso a los miembros estticos (ya estamos..., s..., vale..., compartidos...) de las clases desde VB2005.