Creación de la estructura básica de la escuela

• Mayús. + Alt + F = dar formato al documento (texto)
• Ctrl + K + S = ver lista completa de atajos de teclado (lo compartió @danrmrz en una clase anterior)

Para quienes no les aparece los archivos de la solucion .vscode pueden presionar Ctrl + Shift + P y seleccionar la opción "Generate Assets for Build and Debug "

Al usar el shortCut ctrl + punto no me aparecia el comando para seleccionar “using CoreEsceula.Entidades”. Para solucionarlo fui a la sección de extensions y descargue C# Extensions, verifique que el nombre de la clase Escuela fuera correcto y volví a aplicar el mismo shortCut. Así es como funciono.

Constructores: En pocas palabras, es una función que en C# debe tener el mismo nombre de la clase a la que pertenece (en otros lenguajes se hace con palabras reservadas), y este, se ejecuta automáticamente al momento de crear un nuevo objeto a partir de la clase a la que pertenece.

Cuando digo “Crear un nuevo objeto”, se puede entender a crear una nueva “instancia” de dicha clase.

Generalmente se ocupa, para asignar valores a otras propiedades la misma clase, como es en este caso, en donde asignamos los valores a las propiedades, directamente por el constructor.

Muy bien explicado el constructor y la referencia .this.
Muy buena clase!

Este es un excelente referente sobre COMO DEBEN DE HACER TODOS SUS CURSOS (TODOS). @Platzerito26032019

Me parece que va muy rápido hay partes como en el método constructor que no comprendo como la igualdad de las propiedades a los parámetros debería ser mas explicito y explicar el porque se asigna de esa manera.

Encapsulamiento:
Es hacer que los datos sean inviolables e inalterables , cuando se le asigne un Modificador de Acceso.
Modificadores de Acceso:
Public: Todas las clases pueden acceder al atributo
Protected: Sólo las clases,los paquetes y subclases pueden acceder al atributo
Default: Las clases y los paquetes de la clase pueden acceder al atributo
Private: Solo la clase puede acceder al atributo
**Imporante: **
Dejar que un atributo sea de acceso público por si solo dentro de una clase no es buena práctica, para ello se debe crear una manera intermedia para acceder a el, estos se conocen dentro de POO como métodos get -set , en C# se les llama propiedades.
Si no lo tienen claro, pueden ir al Curso de Programación Orientada a Objetos: POO

Esta bien este curso, estoy entendiendo a sin problemas.

Lo de usar la letra ñ o acentos, no se yo… No me gusta usar este tipos de caracteres aunque se pueda en C#

Intente esata forma de inicializar parametros en una clase de javascript, Funciona

class MyClass {
	constructor(...arg) {
		[this.name, this.lastname] = arg;
	} 
} 
	
console.log(new MyClass("Juanito", "Peres"))

Les dejo un link a las convenciones para C# de acuerdo con la comunidad de Github.

C# Coding Standards and Naming Conventions

seria mas fácil y mas prolijo usar visual studio comunity

no me gusta que puedan declara variablas con tildes y caracteres especiales como ñ

Orale we, explicas bien, pero creo que te hizo falta una cosa importante, escribir tu código en ingles, de esa forma nuestros compañeros empiecen aplicando buenas practicas. :v

Quien mas noto que el profesor dejo suelta una variable llamada MyVar que jamaz uso.

Similar a los metodos getters y setters de Java.

Me gusta esta metodología que usa para enseñar

al fin entendí los constructores, muchas gracias Crack

namespace CorEscuela.Entidades
{
    class Escuela
    {
        //encapsulamiento
        string nombreEscuela;
        public string NombreEscuela{
            get{return nombreEscuela;} 
            set{nombreEscuela = value;}
        }

        //opcion 2 de encapsulamiento
        public int añoCreacion{get;set;}
        //atajo de vsc "prop" crear rapidamente los metodos
        public string Pais { get; set; }
        public string Ciudad { get; set; }

        //la palabra reservada "this" hace referencia al nombre de la variable dentro del mismo metodo
       /*  public Escuela(string nombreEscuela, int añoCreacion)
        {
            this.nombreEscuela = nombreEscuela;
            this.añoCreacion = añoCreacion;
        }*/

        //metodo corto de un constructor igualacion por tuplas

        public Escuela(string nombre, int año) => (NombreEscuela, añoCreacion) = (nombreEscuela, añoCreacion);



    }
}```

Para evitar confusiones, por ejemplo confundir el nombre del archivo Escuela con el nombre de la clase Escuela se deben usar diferentes convenciones, personalmente prefiero usar para las clases el prefijo cls, de tal manera que la clase se llamaría clsEscuela

Esto fue muy abrumador, no entendi casi nada 😦

nunca pude realizar lo de powershell me sale errores todavia! 😭

COMENTARIO: ojala pudiese hacer correr el programa con cada cambio importante que hace al código para ver como afecta el resultado o si no lo hace.

namespace CoreEscuela.Entidades
{
    class Escuela
    {
        string nombre;
        
        /*Encapsulamiento - poder modificar sin tener que cambiar nada y se usa para dar más seguridad en tus aplicaciones
        , para evitar que la información se filtre y para dar mucho más orden en las clases*/
        public string Nombre /*Nos mostrara el nombre de una manera publica */
        {
            get{return "copia "+nombre;} /*Cuando alguien pregunte por el Nombre retornamos el campo nombre*/
            
            set { nombre = value; } /*Cuando alguien le quiera asignar valor, se la asignamos a este campo con "Value" 
                                        y con ToUpper ese valor lo convertimos en mayuscula*/
        }

        

        public int AñoDeCreacion{get;set;} /*Opcion menos compleja de encapsulamiento,
                                            aqui se encarga de crear la logica del ejemplo Nombre*/

        public string Ciudad { get; set; } /*Con el atajo "prob" te genera automaticamente el metodo*/
        public string Pais { get; set; }
        private int myVar { get; set; }

        /*Constructor es un método especial de una clase que se llama automáticamente siempre que se declara un objeto
         de esa clase. Su función es inicializar el objeto y sirve para asegurarnos que los objetos siempre 
         contengan valores válidos*/
        public Escuela(string nombre,int año)
        {
            this.nombre= nombre; /*This, hace referencia al nombre de la variable dentro del mismo metodo*/
            AñoDeCreacion = año; /*Se hace con diferentes variables, dentro de la propiedad */
        }

        /*
        Constructor de una manera mas corta por igualacion de tuplas, una Tupla es una estructura de datos que
         nos permite almacenar hasta 8 valores diferentes, de diferentes tipos, que están relacionados de algún 
         modo y usando una sola variable.

        public Escuela(string nombrea,int año) => (Nombre, AñoDeCreacion) = (nombre, año);
        */
    }
}```

He realizado varios cursos de diferentes escuela buscando que me puede llegar a gustar para dedicarme de lleno y este profesor me hizo enamorarme de C# y ya tengo bien claro que quiero estudiar

Diciembre del 2020, sigue siendo funcional lo visto en este video, excelente maestro Juan Carlos.

Encapsulamiento: definición del nivel de acceso sobre atributos de una clase, sirve para controlar la seguridad de nuestras estructuras de datos y su información; los metodos de asignación y consulta de información para cada atributo generalmete se conocen como Getters y Setters respectivamente.

Niveles de acceso:

Public: acceso desde cualquier parte de codigo desde donde se instancie la clase.
Private: solo la clase dueña del atributo o método puede hacer uso de éstos.
Protected: solo la clase dueña del atributo o método y sus hijos [Herencia], pueden hacer uso de éstos.

Constructor de clase: se debe declarar despues de la definición de atributos, debe tener el mismo nombre de la clase y es quien obliga o exige que parametros y acciones se hacen al momento de instanciar un objeto de su tipo.

Saludos.

muy buenas las clases del profesor juan carlos

Crear un proyecto tipo consola, para cualquier app en vs code.

Excelente proyecto, estoy emocionado jajaja

Muy Buen Profesor !!

Espacio de Nombres: Los espacios de nombres nos permite agrupar objetos lo que nos hace mäs facil encontrarlos cuando trabajemos con muchos de ellos.

Encapsulamiento: Es cuando envolvemos nuestros atributos para poder agregar logica a futuro sin tener que cambiar nada más en el código.

Se puede seguir el curso en Vs Studio Comunity ???

Lo explicado en esta clase en el siguiente resumen:
Creamos un archivo de C# con el nombre Escuela.cs
En este archivo creado que está vacío procedemos a crear un espacio de nombre esto servirá para cuando tengamos más objetos, nos hará más fácil encontrar estos objetos

namespace CoreEscuela.Entidades
{
    
}

Continuando con nuestra estructuración del proyecto creamos los atributos

 string nombre;

Pero además de eso utilizaremos encapsulamiento que esto nos servirá para poder adicionar lógica en un futuro

public string Nombre{
         //Método get retorna la variable o campo nombre
         get{ return "Copia:"+ nombre; }
         //Método set, cuando quiera asignarle desde afuera, asginar al valor
         set {nombre =value.ToUpper();}
}

En la creación del constructor nos encontramos con que tendemos que usar this ¿Para qué sirve?, sirve para poder diferencia que esa variable pertenece a la clase, cuando la variable que recibimos en el parámetro tiene el mismo nombre

public Escuela(string nombre, int año)
       {
         this.nombre=nombre;
         AñoDeCreacion=año;
       }

Además también tenemos otra forma de escribir el constructor que es la siguiente:

public Escuela(string nombre, int año)=>(Nombre,AñoDeCreacion)=(nombre,año);

Se hace una igualación por tuplas

Cuándo se programa en C# ¿Lo común es nombrar las variables con la inicial en Mayúscula?

Utilice el signo ? para declarar las variables como nulas, ya que el compilador se alertaba.

using System;

namespace CoreEscuela
{

class Escuela
{
    public string? nombre;
    public string? direccion;
    public int? anoFundacion;

    public void Timbrar()
    {
        Console.Beep(2000, 3000); //Si
        
    }
}

class program
{
    static void Main( string[] args )
    {
        var miEscuela = new Escuela();
        miEscuela.nombre ="Faja de oro";
        miEscuela.direccion = "Prados del Rosario No 12.";
        miEscuela.anoFundacion=2000;
        Console.WriteLine("Timbrar...");
        miEscuela.Timbrar();

        //Console.WriteLine("Hola Mundo...");
    }
}

}

largo, confuso y enredado.

Rutina en el main

// ========== CREAMOS OBJETOS E INSTANCIAS DE CADA CLASE ==========
Escuela MiEscuela = new("Procontic", 2022, "Medellín");

// ========== ACCIONES DE LOS METODOS DE LAS CLASES ==========
Console.WriteLine($"Bienvenidos a: {MiEscuela.Nombre}, " +
    $"Fundado en: {MiEscuela.CreatYear} en la ciudad de {MiEscuela.City}:");

// ========== CREAMOS LA CLASE ESCUELA ==========

class Escuela
    {
        // +++++++++ CREACION DEL CONSTRUCTOR ++++++++++
        public Escuela(string nombre, int creatYear, string city)
        {
            this.nombre = nombre;
            this.creatYear = creatYear;
            this.city = city;
        }

            // +++++++++ CREACION DE ATRIBUTOS ++++++++++
        private string nombre;
        private int creatYear;
        private string city;

        // +++++++++ CREACION DE METODOS DE ACCESOS DE LAS PROPIEDADES ++++++++++
        public string Nombre { get => nombre; set => nombre = value; }
        public int CreatYear { get => creatYear; set => creatYear = value; }
        public string City { get => city; set => city = value; }
    }

El constructor se debe llamar igual que la clase?

Hay varias cosas que se pueden comentar:

1. El constructor por defecto, se sabe que el constructor es un elemento que permite crear una instancia de un objeto, todas las clases tienen un constructor por defecto nombre_clase(); que se explicó que es un método más, sin embargo se da que después de definir el constructor en la clase el constructor por defecto no se podrá usar hasta que se declare también en la clase osea que con el nuevo constructor se tendrá que agregar el constructor por defecto dentro de la clase, ya saben, agregar el clase_nombre(), en este caso Escuela();.

2. Eso nos lleva al siguiente punto, los métodos son únicos como las clases y variables, no pueden tener el mismo nombre, pero existe la “SOBRECARGA DE METODOS” que permite que se tengan muchos métodos con el mismo nombre PERO que sus parámetros (o las variables que tengas definidas entre ()) sean diferentes. Ósea se pueden tener 3 métodos con el mismo nombre, pero las variables de entrada deben ser diferentes, uno puede ser País, otro Nombre, etc. Pero no pueden ser exactamente iguales como tener 2 constructores Escuela(); eso da a un error de compilación.

Muy bien… Interesante

Encapsulamiento
El encapsulamiento consiste en hacer que los atributos o métodos internos de una clase no se puedan acceder ni modificar desde afuera. La encapsulación define los niveles de acceso para los elementos de esa clase.

• Público: Las funciones de todas las clases pueden acceder a los datos o métodos de una clase que se define con el nivel de acceso público.

• Protegido: El acceso a los datos está restringido a las funciones de clases heredadas, es decir, las funciones miembro de esa clase y todas las subclases.

• Privado: El acceso a los datos está restringido a los métodos de esa clase en particular.

❤️

saben cuando coloco la new escuela y la cambio a corescuela no me la reconoce y no me da ninguna otra opcion a alguien mas le paso?

Que es y como funciona un namespace?

recordando c# 😃

buena clase se entendio bien!

Buenas noches, el visual studio code no me corrige la sintaxis del lenguaje. ¿Qué puede ser?

Excelente definición de las caracteristicas de la herramienta y del lenguaje… gran trabajo y muchas gracias

Los niveles de encapsulamiento de una clase estan definidos por
public Access is not restricted.
protected Access is limited to the containing class or types derived from the containing class.
internal Access is limited to the current assembly.
protected internal Access is limited to the current assembly or types derived from the containing class.
private Access is limited to the containing type.
private protected Access is limited to the containing class or types derived from the containing class within the current assembly. Available since C# 7.2.

Me agrada el uso de shortcuts nativos en el lenguaje.

el constructor es un metodo que nos ayuda a crear una instancia del objeto !! 😃

Mi código compilado y ejecutado de** Escuela.cs** por si le funciona a alguien.

namespace CoreEscuela.Entidades
{
    class Escuela
    {   
        string nombre;
        public string Nombre{ 
            //definimos manualmente el metodo get y set
            get {return "Copia: "+nombre; }  //el método get se utiliza para retornar (consultar) el valor almacenado en el atributo (en este caso el nombre)
            set {nombre = value.ToUpper();}  //el método set se utiliza para asignar el valor  en el atributo (en este caso el nombre) posteriormente con la funcion ToUpper() tranformamos el string a letras mayusculas
        }

        public int AñoDeCreación {get; set;} //La manera corta para definir el método get y set

        public string País { get; set; }
        public string Ciudad { get; set; }

        //Constructor   Define los valores iniciales que necesita nuestra intancia para funcionar correctamente
        /* 
        public Escuela(string nombre, int año){
            this.nombre = nombre; //This para indicar que hablamos de la variable interna
            AñoDeCreación = año;

        }
        */
        //Manera corta de crear el Constructor    
        public Escuela(string nombre, int año) => (Nombre, AñoDeCreación) = (nombre, año);
    }
}

Mi código compilado y ejecutado de Program.cs por si le funciona a alguien.

using System;
using CoreEscuela.Entidades; //importamos el archivo del namespace CoreEscuela.Entidades para poder acceder y utilizar la clase Escuela

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            var escuela = new Escuela("Platzi Academy", 2012); //creamos una nueva instancia de la clase Escuela, recibe dos parametros para el constructor (nombre, año de creación)
            escuela.País = "Colombia"; //Definimos el atributo del país de la escuela
            escuela.Ciudad = "Bogota"; //Definimos el atributo de ka ciudad de la escuela
            Console.WriteLine(escuela.Nombre); //Escribimos en consola el valor asignado en el atributo de nombre del objeto
        }
    }
}

A Platzi le hace falta un Dark Theme… 😃

Duda, en el minuto 13.58 cuando se habla de constructores, quiero que me corrijan, se usar para crear como una plantilla de lo que quiero pasar a la clase??

Les dejo mi proyecto en GitHub:
https://github.com/fenixrtr7/CursoFundametosDeC-ConNetCore

Me aparece ese error! dotnet

Excelente!

por que no se trabaja con visual studio y se usa el framework de .net que es MVC ???

cuando pones cd como haces para autocompletar con la ruta???

Super bien explicado

Que diferencia hay entre

// 1 -
var escuela = new Escuela()
escuela.Nombre = "Platzi Academy";
escuela.Ciudad = "XCiudad";
escuela.Pais = "XPais;

// 2 -

var escuela = new Escuela() {
	Nombre = "Platzi Academy,
	Ciudad = "XCiudad",
	Pais = "XPais"
}

// 3 - 
var escuela = new Escuela("Platzi Academy", "XCiudad", "Xpais"

Que diferencia hay entre los tres, y cuando usaremos el tipo de instanciado y porque? si alguien lo sabe, porque responderme!

Tengo este error, estoy en iOS y no me deja agregar el espacio de nombres donde estamos agregando las entidades.
Escuela’ is a namespace but is used like a type

Me llevo una hora ver todo el vídeo amigo, si hablas rapidísimo, pero muy bien explicado, te felicito! Solo me pregunto si la palabra ‘value’ es una variable o es palabra reservada?

Hay cosas nuevas desde la ultima ves que estudie c#

Buenas clases

El orden en el código, es muy importante => NAMESPACE

Quiero hacer dos aportes: El primero que los namespace además de darle un orden al código lo que hace es que separa funcionalidades. Por ejemplo si se tienen dos proyectos y dentro de estos hay métodos que se llaman de igual manera pueden presentar un choque. Los nombres de espacios permiten eliminar esto.

El segundo aporte es que por claridad y por una buena legibilidad del código. Los valores que van a ser asignados a una variable privada de una clase, por ejemplo, debería asignarse con this .Así inmediatamente sabremos que hace referencia a algo propio de la clase.

https://github.com/Logicainformatica18/poo_c_sharp
Acá les comparto mi repositorio del curso aplicando clases, herencia, asociación,encapsulamiento,constructor

Muy buena introduccion a los objetos.

Excelente clase

Tengo una consulta. A veces escribo errores y VSC no me los marca, por ejemplo en particular con esta clase, no me marcó los mismos que el Profesor, así costara encontrar un error. Alguno sabe si es que tengo que descargar una extensión?

NO ME APARECE LA OPCION "using CoreEscuela. Entidades"
se que en mi programa me aparecería otro nombre … pero no me aparece como tal la opción

En visual studio 2017 , en la ejecución me apareció "Copia: " pero no me concatenó el nombre, ¿Alguien sabe por qué?

using System;
using CorEscuela.Entidades;

namespace Etapa1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Creacion de un Constructor
        
            var escuela = new Escuela("Platzi Academy", 2012);
            escuela.NombreEscuela="Platzi Academy"; 
            escuela.Pais="Colombia";
            escuela.Ciudad="Bogota";           
            Console.WriteLine(escuela.NombreEscuela);
        }
    }
}

Tambien se pueden mostrar los datos de la escuela sin tener que haver un overrite de toString()

namespace CoreEscuela.Entidades
{
    class Escuela
    {
        public string Nombre { get; set; }
        public int AnioDeCreacion { get; set; }
        public string Pais { get; set; }
        public string Ciudad { get; set; }       
        public TiposEscuela TipoEscuela { get; set; }

        public Escuela(string nombre, int anio) => (Nombre, AnioDeCreacion) = (nombre, anio);

        public string MuestraEscuela()
        {
            return $"Nombre: {Nombre}, Tipo: {TipoEscuela} \n Pais: {Pais}, Ciudad: {Ciudad}";
        }
    }
}

Explication sobre lo que es encapsulamiento

Excelente explicación de como crear un objeto y el uso de constructores con sus propiedades. Muy fácil de entender

Genial, muchas dudas se resolvieron con esta clase. Thx!

<Entidades\Escuela.cs(14,13): error CS1520: El método debe tener un tipo de valor devuelto [C:\Users\monzo\OneDrive\Escritorio\Proyectos\C# net core\PlatziEscuela\Etapa1\Etapa1.csproj]
Entidades\Escuela.cs(16,13): error CS1520: El método debe tener un tipo de valor devuelto [C:\Users\monzo\OneDrive\Escritorio\Proyectos\C# net core\PlatziEscuela\Etapa1\Etapa1.csproj]

No se pudo llevar a cabo la compilación. Corrija los errores de compilación y vuelva a ejecutar el proyecto.
PS C:\Users\monzo\OneDrive\Escritorio\Proyectos\C# net core\PlatziEscuela\Etapa1>
>

lo unico que no me hizo es que no lo puso en mayusculas 😦

Muy bien explicado

qué es el encapsulamiento.

Hola comunidad , No hay manera de que no me tire error, lo mire a pie de la letra, lo copide de otros colegas y no existe manera de compilar este capitulo. me sale siempre este error, porfavor ayudaaaaaa.

Entidades\Escuela.cs(14,13): error CS1520: El método debe tener un tipo de valor devuelto [C:\Users\monzo\OneDrive\Escritorio\Proyectos\C# net core\PlatziEscuela\Etapa1\Etapa1.csproj]
Entidades\Escuela.cs(16,13): error CS1520: El método debe tener un tipo de valor devuelto [C:\Users\monzo\OneDrive\Escritorio\Proyectos\C# net core\PlatziEscuela\Etapa1\Etapa1.csproj]

No se pudo llevar a cabo la compilación. Corrija los errores de compilación y vuelva a ejecutar el proyecto.
PS C:\Users\monzo\OneDrive\Escritorio\Proyectos\C# net core\PlatziEscuela\Etapa1>

TENGO UN PAR DE PREGUNTAS … SI ALGUIEN ME PUEDE AYUDAR !

Buena explicación, tema de los constructores muy bueno, el tema de promocionan funcional.

Muy buena la explicación y se aclara el uso de un constructor funcional por tuplas…Excelente

Buena explicación de las diferentes formas de establecer el constructor.

hola tengo un error ![](

Hola al apretar control y punto no me figura la opción para CoreEscuela.Entidades. Si alguien me pudiese ayudar se lo agradecería

Recuerden visitar la pagina de microsoft donde vienen las convenciones que debe utilizar el código.
Hay una Guía de estilos en github que resume todo muy bien.

Muy bien explicado!

Me gusto que explico las diferentes formas de realizar una cosa.

Se dice que cuando hacemos una declaración del tipo :

public string Pais { get; set; }

que son propiedades autoimplementadas

Para que se pueda crear un objeto se hace uso de la palabra reservada new, esto invoca al método constructor de la clase.

Dentro de nuestro proyecto crearemos una carpeta llamada “Entidades” donde iremos guardando las entidades del proyecto como un Curso, una Escuela, etc.

Dentro de cada archivo .cs añadiremos un espacio de nombres o namespace, este nos sirve para facilitar el encontrar objetos en nuestro proyecto.