using
Conserva el namespace Pack con public class Box, un campo public int llamado size y public Box(int n) que asigna size = n;. Arriba del archivo, después de using System;, añade using Pack;. En Pine conserva Main y construye una caja con el nombre corto Box b = new Box(4);, luego escribe b.size. Mantén todo en el mismo archivo didáctico para que dotnet run siga siendo simple. Ejecuta con dotnet run. La pantalla debe mostrar una línea: 4. La directiva using es lo que permite a Pine quitar el prefijo Pack.. Conserva el nombre de la clase pública inicial Pine.
Una directiva que acorta el nombre del tipo
En la página de namespaces escribiste Pack.Box cada vez. Eso sigue funcionando. Esta página añade using Pack; para que el compilador trate Box a secas como la clase dentro de Pack. Sigues conservando el namespace alrededor del tipo. Solo cambias cómo Main escribe el nombre.
Abre el archivo Pine. El nombre de la clase inicial sigue siendo Pine. Esta página no renombra el arranque. Borra cualquier sobrante Pack.Box b = new Pack.Box(5); si la demo de nombre largo es todo lo que tienes en Main. Puedes conservar el tipo Pack / Box. Borra sobrantes de Lid. Borra cualquier línea ReadLine. El archivo que conservas no espera que escribas.
Arriba conserva using System;. En la línea siguiente escribe using Pack;. Luego conserva namespace Pack { public class Box { public int size; public Box(int n) { size = n; } } }. Fuera de ese namespace conserva public class Pine. Dentro de Main escribe la forma corta Box b = new Box(4); y Console.WriteLine(b.size);. Guarda antes de ejecutar.
No pongas using Pack; dentro de Main. Las directivas van arriba del archivo con using System;. No anides Pine dentro de namespace Pack en esta página.
using System;
using Pack;
namespace Pack
{
public class Box
{
public int size;
public Box(int n)
{
size = n;
}
}
}
public class Pine
{
public static void Main()
{
Box b = new Box(4);
Console.WriteLine(b.size);
}
}
Pine llama a Box tras using Pack
Pine conserva public static void Main(). Como using Pack; está presente, Box significa la clase en ese namespace. El constructor guarda 4. La escritura muestra ese campo. No estás obligado a escribir Pack.Box en esta página. La forma larga sigue compilando si la usas, pero el objetivo de la lección es el nombre corto tras la directiva.
using System;
using Pack;
namespace Pack
{
public class Box
{
public int size;
public Box(int n)
{
size = n;
}
}
}
public class Pine
{
public static void Main()
{
Box b = new Box(4);
Console.WriteLine(b.size);
}
}
Lee el archivo conservado desde arriba. using System; prepara los nombres de consola. using Pack; trae el namespace Pack al alcance del nombre corto. namespace Pack sigue envolviendo public class Box. Tras cerrar el namespace, public class Pine es el arranque. public static void Main() es donde empieza el tiempo de ejecución. La expresión new Box(4) construye el mismo tipo de objeto que antes como new Pack.Box(5) en la página anterior. Luego Main escribe b.size y la pantalla muestra 4.
Ejecútalo con dotnet run. El programa escribe una línea y para. No espera que escribas. Si dotnet run espera, ReadLine sigue en el archivo. Borra esa línea y conserva Box b = new Box(4); más la escritura. La pantalla muestra 4. Si muestra 5, puede seguir ejecutándose una demo sobrante de nombre largo con argumento 5. Si la compilación no encuentra Box, puede faltar using Pack; — vuelve a ponerlo bajo using System;.
Si escribes solo using System; y luego Box b = new Box(4); sin using Pack;, la compilación falla salvo que vuelvas a Pack.Box. Esta página quiere la directiva y el nombre corto juntos.
Comparado con Pack.Box y con olvidar la directiva
En la página de namespaces, cada construcción usaba Pack.Box. Esa forma larga sigue siendo legal. El punto de control de esta página es using Pack; más Box a secas. Un sobrante Pack.Box b = new Pack.Box(5); sin practicar el nombre corto salta el nuevo hábito. En esta página conserva la directiva y escribe Box b = new Box(4);.
using System; no es lo mismo que using Pack;. Ya necesitabas System para Console. La línea nueva es específica de tu grupo Pack. Dejar fuera using Pack; mientras quitas el prefijo Pack. es el error habitual aquí.
Dos nombres cortos Box en un Main
Puedes construir dos cajas con el nombre corto tras la misma directiva. Escribe Box a = new Box(1); y Box b = new Box(6);, luego escribe a.size y b.size. No necesitas un segundo using Pack;. Una directiva cubre el archivo.
Si prefieres Pack.Box en una de las líneas, mezclas estilos. Para la comprobación didáctica, usa el nombre corto en ambas construcciones para que la directiva haga trabajo real.
Lo que queda para list
Esta página acorta un tipo calificado por namespace con using Pack;. Una página posterior — list — inicia la vía de colecciones con List para una secuencia de valores que crece. Quédate con using aquí. No inventes demos de list en esta página salvo que ya las conozcas; el objetivo es la directiva y el nombre corto Box.
No pongas Main dentro de Box. No dejes una demo Lid en Main. Si la compilación no encuentra Box, comprueba using Pack; arriba y namespace Pack alrededor de la clase. Si la pantalla muestra 0, el constructor puede no estar guardando — conserva public Box(int n) { size = n; } antes de la escritura.
Puedes conservar namespace Pack { public class Box { public int size; public Box(int n) { size = n; } } }, escribir using Pack; bajo using System; y desde Pine.Main ejecutar Box b = new Box(4);, luego escribir b.size. Con dotnet run la pantalla muestra 4. La directiva hizo funcionar el nombre corto. Imagina using Pack; como una nota que dice «cuando escribo Box, me refiero al de la estantería Pack». Pine sigue siendo la puerta que abres con dotnet run. La página siguiente es list, donde guardas varios valores en una colección que crece en lugar de un solo campo de caja.
Conserva using Pack; arriba. Conserva el nombre corto Box en Main en esta página. Mantén fuera del punto de control las demos sobrantes solo con nombre largo Pack.Box para practicar de verdad la directiva. Esos hábitos son la puerta antes de seguir.
Errores que ocultan la línea using
Escribir using Pack; dentro de Main no es la forma de directiva a nivel de archivo que enseña esta página. Muévela junto a using System;. Escribir new Box(4) mientras Box vive solo bajo Pack y falta la directiva hace fallar la compilación — restaura using Pack; o usa temporalmente solo Pack.Box mientras depuras, luego vuelve al nombre corto para la lección.
Otra trampa es borrar using System; al añadir using Pack;. La escritura en consola sigue necesitando System salvo que escribas llamadas a consola totalmente calificadas que esta página no exige. Conserva ambas líneas using. Si IntelliSense ofrece otro Box de otro namespace, quédate con tu tipo Pack para este archivo.
🧠 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