Namespaces
Escribe un namespace Pack que contenga public class Box con un campo public int llamado size y un constructor public Box(int n) que pone size = n;. En Pine conservas Main y construyes una caja con Pack.Box b = new Pack.Box(5);, luego escribes b.size. Mantén el namespace y Pine en el mismo archivo de enseñanza para que dotnet run siga siendo simple. Ejecuta con dotnet run. La pantalla debe mostrar una linea: 5. El tipo vive bajo el nombre Pack. Llegar a el como Pack.Box es lo que ensena esta pagina. Conserva el nombre de la clase publica inicial Pine.
Un nombre de grupo alrededor de un tipo
En la pagina de acceso ocultaste seal con private y abriste Read. Aqui la idea nueva es un namespace. Un namespace es un nombre de grupo alrededor de uno o mas tipos. Dentro de namespace Pack { ... } colocas public class Box. Fuera de ese grupo, Pine nombra el tipo como Pack.Box, no como un Box suelto, en esta pagina.
Abre el archivo Pine. El nombre de la clase inicial sigue siendo Pine. Esta pagina no renombra el inicio. Borra cualquier sobrante Lid L = new Lid(9); si la demo de acceso es todo lo que tienes en Main. Borra cualquier sobrante de la clase Lid. Borra cualquier sobrante Cup. Borra cualquier linea ReadLine. El archivo que conservas no espera que escribas.
Arriba o al lado de Pine — aun en el mismo archivo — escribe namespace Pack. Dentro de sus llaves escribe public class Box. Dentro de Box declara public int size; y public Box(int n) { size = n; }. No hay Main dentro de Pack en esta pagina. Guarda el archivo antes de ejecutar.
Pine queda fuera de las llaves de Pack como hermano en el archivo. No anides Pine dentro de namespace Pack en esta pagina. La clase inicial sigue siendo la puerta que abre dotnet run.
using System;
namespace Pack
{
public class Box
{
public int size;
public Box(int n)
{
size = n;
}
}
}
Pine construye Pack.Box
Pine conserva public static void Main(). Dentro de Main escribes dos lineas en orden: Pack.Box b = new Pack.Box(5);, luego Console.WriteLine(b.size);. El nombre cualificado Pack.Box apunta a la clase dentro del namespace. El constructor guarda 5. La escritura muestra ese campo. No escribes Lid L = new Lid(9); ni L.Read() en esta pagina. Esa fue la leccion de acceso.
using System;
namespace Pack
{
public class Box
{
public int size;
public Box(int n)
{
size = n;
}
}
}
public class Pine
{
public static void Main()
{
Pack.Box b = new Pack.Box(5);
Console.WriteLine(b.size);
}
}
Lee el archivo conservado desde arriba. using System; prepara nombres cortos para la consola. namespace Pack abre el grupo. Dentro, public class Box guarda size y el constructor. Despues de cerrar el namespace, public class Pine es el inicio. public static void Main() es donde arranca el tiempo de ejecucion. La expresion new Pack.Box(5) construye una caja bajo ese nombre de grupo y guarda 5 en size. Luego Main escribe b.size y la pantalla muestra 5.
Ejecuta con dotnet run. El programa escribe una linea y para. No espera que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa linea y conserva Pack.Box b = new Pack.Box(5); mas la escritura. La pantalla muestra 5. Si muestra 9, puede que aun corra una demo sobrante de Lid. Si el build no encuentra Box, quizas escribiste new Box(5) sin el prefijo Pack. en esta pagina — recupera Pack.Box.
Si anidas Pine dentro de namespace Pack, cambia la forma de inicio que usa este curso y dotnet run puede buscar otra entrada. Manten Pine fuera de Pack como hermano. Si las llaves de namespace Pack nunca cierran, el build rechaza — empareja cada llave de apertura.
Comparado con acceso Lid y con un nombre Box suelto
En la pagina de acceso, Lid estaba en el archivo de ensenanza global sin envoltorio de namespace. Eso sigue valiendo para demos pequenas. Esta pagina pone Box bajo Pack para que el nombre completo sea Pack.Box. Un sobrante Lid L = new Lid(9); Console.WriteLine(L.Read()); es otra leccion. Para esta pagina conserva Pack, Box y Pine.
📊 nombre corto vs Pack.Box
| Como escribes el tipo | Significado en esta pagina |
|---|---|
Box suelto en Main |
no es la forma que esta pagina conserva — prefiere Pack.Box |
Pack.Box |
la clase Box dentro del namespace Pack |
Dos cajas bajo el mismo namespace
Puedes construir dos valores Pack.Box con tamanos distintos. Escribe Pack.Box a = new Pack.Box(2); y Pack.Box b = new Pack.Box(7);, luego escribe a.size y b.size. El nombre del namespace sigue igual. Cada objeto aun tiene su propio size.
using System;
namespace Pack
{
public class Box
{
public int size;
public Box(int n)
{
size = n;
}
}
}
public class Pine
{
public static void Main()
{
Pack.Box a = new Pack.Box(2);
Pack.Box b = new Pack.Box(7);
Console.WriteLine(a.size);
Console.WriteLine(b.size);
}
}
Ejecuta otra vez con dotnet run. La pantalla debe mostrar 2 en una linea y 7 en la siguiente. Cada constructor guardo su argumento. Si ambas lineas muestran 5, quizas sigues en la demo de una caja — cambia al archivo de dos cajas cuando quieras esa comprobacion. Si la pantalla muestra 9 u otro numero sobrante, una demo Lid mas vieja puede seguir en Main. Conserva las dos lineas Pack.Box y las dos escrituras.
Escribir Pack.Box c = a; no construye una tercera caja. Usa otro new Pack.Box(...) cuando quieras un size separado. Para esta pagina, dos construcciones bastan para ver el nombre cualificado dos veces.
Lo que esto deja para using
Esta pagina alcanza el tipo con un nombre totalmente cualificado: Pack.Box. Una pagina posterior — using — muestra como una directiva using puede traer un namespace al alcance de nombres cortos para que puedas escribir Box tras declarar using Pack;. Quédate con el nombre largo aqui. No inventes ese atajo en esta pagina a menos que ya lo conozcas; el objetivo de la leccion es el envoltorio de namespace y Pack.Box.
No pongas Main dentro de Box. No dejes Lid en el archivo. Si el build no encuentra Pack.Box, comprueba que namespace Pack envuelve public class Box y que Pine queda fuera de esas llaves. Si la pantalla muestra 0, al constructor le puede faltar la asignacion — conserva Box(int n) { size = n; } antes de escribir.
Puedes escribir namespace Pack { public class Box { public int size; public Box(int n) { size = n; } } }, y desde Pine.Main ejecutar Pack.Box b = new Pack.Box(5);, luego escribir b.size. Ejecuta con dotnet run. La pantalla muestra 5. El namespace agrupo el tipo. El nombre cualificado le dijo a Pine que Box querias. Piensa en Pack como un estante etiquetado y Box como el objeto en el. Pine sigue siendo la puerta que abres con dotnet run. La pagina siguiente es using, donde una directiva puede acortar Pack.Box a Box despues de que aceptes.
Mantiene las llaves del namespace alrededor de Box. Manten Pack. delante del nombre del tipo en Main en esta pagina. Manten fuera de Main demos sobrantes L.Read() para que la pantalla no muestre un numero de tapa por error. Esos habitos son el punto de control antes de seguir.
🧠 Pon a Prueba tu Conocimiento
Pon a Prueba tu Conocimiento
Ponte a prueba con este cuestionario interactivo y descubre qué tan bien entiendes el tema
📝 Instrucciones
- Lee cada pregunta cuidadosamente
- Selecciona la mejor respuesta para cada pregunta
- Puedes repetir el quiz tantas veces como quieras
- Tu progreso se mostrará en la parte superior