C# Pildora Informatica

Distingue minus y mayusc

{
esto es un bloque
}

código que terminan en punto y coma ( ;)

se usa para declarar un ámbito que contiene un conjunto de objetos relacionados. Puede usar un espacio de nombres para organizar los elementos de código y crear tipos únicos globales.Los espacios de nombres con ámbito de archivo no pueden incluir declaraciones de espacio de nombres adicionales. No se puede declarar un espacio de nombres anidado ni un segundo espacio de nombres con ámbito de archivo:

las Creadas por nosotros

Son las bibliotecas de lases conocidas como API
En el using System;
el using sirve para usar el contenido dentro del namespace Console

Comentario de una linea
Comentario de Varias lineas
son los nombres para identificar Namespaces, Clases, Métodos, Variables y Constantes. solo se pueden usar letras, num. y _ Deben comenzar con letra o_y nodeben usar palaras reserbadas (azules ) salvo si se antepone el @ palabrareservada

por valor:
primitivos :
Enteros
Reales
Booleanos
estructuras
enumerados
Por Referencia

es una zona de memoria reservada para almacenar información de uso inmediato por parte del hilo de ejecución actual del programa. Por ejemplo, cuando se llama a una función se reserva un bloque en la parte superior de esta zona de memoria (de la pila) para almacenar los parámetros y demás variables de ámbito local. Cuando se llama a la siguiente función este espacio se “libera” (en el sentido de que ya no queda reservado) y puede ser utilizado por la nueva función. Es por esto que si hacemos demasiadas llamadas anidadas a funciones (en recursión, por ejemplo) podemos llegar a quedarnos sin espacio en la pila, obteniendo un “stack overflow”.

es una zona de memoria reservada para poder asignarla de manera dinámica. Al contrario que en la pila no existen “normas” para poder asignar o desasignar información en el montón, pudiendo almacenar y eliminar datos en cualquier momento, lo cual hace más complicada la gestión de la memoria en esta ubicación.

son tipos sencillos que almacenan un dato concreto y que se almacenan en la pila. Por ejemplo, los tipos primitivos de .NET como int o bool, las estructuras o las enumeraciones. Se almacenan en la pila y se copian por completo cuando se asignan a una función. Por eso cuando se pasa un tipo primitivo a una función, aunque lo cambiemos dentro de ésta, el cambio no se ve reflejado fuera de la misma.

son todos los demás, y en concreto todas las clases de objetos en .NET, así como algunos tipos primitivos que no tienen un tamaño determinado (como las cadenas). Estos tipos de datos se alojan siempre en el montón, por lo que la gestión de la memoria que ocupan es más compleja, y el uso de los datos es menos eficiente (y de menor rendimiento) que con los tipos por valor.

En este caso definimos una función que simplemente le suma 2 al parámetro que se le pase (de una forma poco eficiente, eso sí) transformando el valor que se le pasa. Se podría pensar que ya que la función cambia el valor que le hemos pasado, cuando mostremos por pantalla posteriormente el valor de i, éste debería ser 7. Sin embargo vemos que, aunque se ha cambiado dentro de la función, sigue siendo 5:

Esto es debido a que los números enteros son tipos por valor y por lo tanto se pasa una copia de los mismos a la pila de la función que se llama, no viéndose afectado el valor original.

Lo que hacemos en el fragmento anterior es definir una clase persona muy sencilla y pasársela a una función que modifica su nombre. Cuando ejecutemos el código se verá por pantalla el nombre de la persona cambiado:

Es decir, los cambios son apreciables en el origen, fuera de la propia función.

¿A qué es debido esto?
El motivo es que, como hemos dicho, los tipos por referencia se almacenan siempre en el montón, y lo que se pasa a la función como parámetro no es una copia del dato, como en el caso de los tipos por valor, sino una copia de la referencia al dato.

Esto que suena muy lioso es fácil de entender si lo visualizamos.

https://www.campusmvp.es/recursos/post/Que-son-los-tipos-por-valor-y-por-referencia-en-NET-y-C.aspx

Codigo, Pila, Monton

Con Signo
sbyte -128 to 127
short -32,768 to 32,767
int -2,147,483,648 to 2,147,483,647
long -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
Sin Signo:
byte 0 to 255
ushort 0 to 65,535
uint 0 to 4,294,967,295
ulong 0 to 18,446,744,073,709,551,615

float 32 –3.4 × 10–38 hasta 3.4 × 1038
double 64 ±5.0 × 10–324 hasta ±1.7 × 10308
decimal 128 28 dígitos significativos monetario

true
false

Espacio de memoria (RAM) donde se almacenara un valor que podra cambiar durante la ejecucion de programa
int edad_alumno;
edad_alumno=20;
int edadAlumno = 20;

Suma + (También concatena texto)
Resta -
Multiplicacion *
Division /
Resto / Modulo %
Incremento ++ (de a 1) +=5; //incrementa de a 5
Decremento -- (de a 1) -=5; //decrementa de a 5

Console.WriteLine(7*5); // SALIDA: 35
Console.WriteLine(5/2); // SALIDA: 2
Console.WriteLine(5.0/2.0); // SALIDA: 2.5
Console.WriteLine(5/2.0); // SALIDA: 2.5
Console.WriteLine(9%3); // SALIDA: 0

int edad = 19;
Console.WriteLine("Tienes una edad de " + edad+"años");
// SALIDA: Tienes una edad de 19 años

// La interpolacion es propia de C#
int edad = 19;
Console.WriteLine($"Tienes una edad de {edad} años");
// SALIDA: Tienes una edad de 19 años

int edadP1;
int edadP2;
int edadP3;
int edadP4;

edadP1 = edadP2 =edadP3 = edadP4 = 27;
Console.WriteLine(edadP2);
// SALIDA: 27

var edadP = 27; // asigna en tiempo de ejecucion el tipo de variable
Console.WriteLine(edadP); // SALIDA: 27

no se puede cambiar el tipo de var una vez ingresado un valor ejemplo si al ingerar valor es del tipo int nse puede cambiar a float
var edadP=27;// en var ingrese valor tipo int
edadP=27.5; // ahora cambio por un tipo flot y da error

===== Conversión Explicita (Casting) =====
double temperatura = 34.5;
int temperaturaMadrid;
temperaturaMadrid = (int) temperatura;
Console.WriteLine(temperaturaMadrid);
// SALIDA: 34
// hay una PERDIDA DE INFORMACION en este caso los decimales

int habitantesCiudad = 10000000;
long habitantesCiudad2018 = habitantesCiudad;

float pesoMaterial= 5.78F;
double pesoMaterialPrecio = pesoMaterial

/* se realiza entre tipos compatibles pero de distinto alcance int y long almacenas datos del tipo entero VER tabla de conversiones en Docs*/

Console.WriteLine("Introduce el Primer Nro");
int num1=int.Parse (Console.ReadLine());
Console.WriteLine("Introduce el Segundo Nro");
int num2=int.Parse (Console.ReadLine());
Console.WriteLine("El Resultado es "(num1+num2));
Console.WriteLine("El Resultado es {0} ", num1+num2);

VARIABLES: Espacio en la memoria del ordenador donde se almacenara un valor que SI podría cambiarse durante la ejecución del programa.
CONSTANTES: Espacio en la memoria del ordenador donde se almacenara un valor que NO podrá cambiarse durante la ejecución del programa.
const int VALOR=123456;
// si o si se declara y asigna valor en la misma linea y ya no se podra modificar
Console.WriteLine("La constante es: {0}", VALOR);

Que son
Grupo de sentencias ( instrucciones) a las que se les da un nombre identificativo, que realizan una tarea en concreto.
Para que sirven
Para realizar una tarea en concreto en un momento determinado. Un método no realiza su tarea hasta que es llamado.
Sintaxis:
Tipodevuelto nombreMetodo (parametros)
{
cuerpo del método
}
Ejemplo
int sumaNumeros()
{
int num1=7;
int num2=9;
int resultado= num1+num2;
return resultado; // valor devuelto por el método
}
/*No se ejecutara hasta su llamada
todos los métodos están dentro de una clase
se debe especificar bien el tipo devuelto y los parámetros
no hay distinción entre métodos y funciones. En C# ambos términos son los mismo
*/

Ejemplo
int sumaNumeros(int num1, int num2)
{
int resultado= num1+num2;
return resultado; // valor devuelto por el método
}
Ejemplo Sin valor devuelto
void sumaNumeros(int num1, int num2) // no devuelve valor
{
int resultado= num1+num2;
Console.WriteLine(resultado);
}
//Un método void nunca llevara return

namespace ConsoleAppEje
{ internal class Program
{
static void Main(string[] args)
{ //llamada al método
mensajeEnPantalla();
// mensaje de la main
Console.WriteLine("mensaje de la main");
Console.ReadKey();
}
//es static por estar en la class Program
static void mensajeEnPantalla()
{
Console.WriteLine("mensaje del método mensajeEnPantalla");
}
}
}

namespace ConsoleAppEje
{ internal class Program
{
static void Main(string[] args)
{//llamada al método pasando parámetros por valores
sumaNros(7,9);
Console.ReadKey();
}
//es static por estas en la class Program
static void sumaNros(int num1, int num2)
{
Console.WriteLine($"la suma es: {num1+num2} ");
}
}
}

Son metodos que no son void y usan return para devolver un valor
namespace ConsoleAppEje
{ internal class Program
{
static void Main(string[] args)
{/*llamada al metodo pasando parametros
por valores y escribiendo en pantalla*/
Console.WriteLine(divideNros(9,2));
Console.ReadKey();
}
//es static por estas en la class Program
static double divideNros(int num1, int num2)// => return num1 num2;
{
return num1 / num2;
}
}
}
NOTA :cuando el métodoes tan simple puede escrivirse de la siguiente forma:
static int sumaNros(int num1, int num2) => num1 /num2;

Ámbito o Alcance o Contexto: cuando de declara una Variable o Constante será accesible dentro el bloque {...} del código donde fue declarada.
Campo: es una Variable o Constante declarada en el contexto de una clase

internal class Program
{
/*Las Variables declaradas en la clase
solo son utilizabes en su clase*/
int nroClase = 1;
static void Main(string[] args)
{
Console.ReadKey();
}
void primerMetodo()
{
/*Las Variables declaradas en el metodo
solo son utilizabes en su metodo*/
int nroMetodo1 = 5;
int nroMetodo2 = 7;
Console.WriteLine(nroMetodo1+ nroMetodo2);

}
void segundoMetodo()
{/*NO puede acceder a una Variable xq esta
fuera del ambito{...} del primerMetodo(){...}*/
Console.WriteLine(nroMetodo1);
/*SI puede acceder a una Variable xq esta
declarada en el ambito{...} de su claseclass Program {...} */
Console.WriteLine(nroClase);
}
}
}

Las Sobrecargas son cuando mas de un método tienen el mismo nombre para que funcionen deben tener diferentes tipo o cantidades de parámetros y al realizar su llamado se activara el método sobrecargado que corresponda según su cantidad y tipo de parametro

internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("Llamada Sobrecarga "+Suma(7, 5));
Console.ReadKey();
}
/* La sobrecarga de Métodos se diferencian
por las cantidad y tipo de variables */
static int Suma(int op1, int op2) => op1 + op2;
static int Suma(int nro1, double nro2) => nro1;
//igual cantidad de variables pero de distinto tipo
static int Suma(int op1, int op2, int op3) => op1 + op2 + op3;
// mismo tipo pero distinta cantidad de variables
}
}

Los Métodos con Parámetros Opcionales: Sirven de alternativa a la Sobrecarga y Son aquellos que al momento del llamado del método puede prescindir de algunos parámetros ya que estos le son opcionales por tener un valor preestablecido en su declaración. Ej:
private static double Suma(int v1, double v2, double v3 = 0)
tener en cuenta que los parámetros opcionales vendrán a continuación de los obligatorios

namespace ConsoleAppEje
{
internal class Program
{
static void Main(string[] args)
{ int va1= 7;
double va2=5.2, va3= 8.3;
//solo se pasan por parámetros dos valores los de va1 y va2
Console.WriteLine("Llamada 1: " + Suma(va1, va2));
//se pasan por parámetros todos valores los de va1, va2 y va3
Console.WriteLine("Llamada 2: "+Suma(va1, va2, va3));
Console.ReadKey();
}
// método con parámetro opcional v3 que tiene un valor inicial v3=0
private static double Suma(int v1, double v2, double v3 = 0)
{
return v1 + v2 + v3;
}} }

Declaraciones Booleanas (true / false):
bool haceFrio;
hace Frio= false;
Operadores de Relacionales:
== Igual que
!= Distinto que
< Menor que
<= Menor igual que
> Mayor igual que
>= Mayor igual que

Operadores Lógicos:
&& y & and Lógico
|| y | or Lógico
! not Lógico
^ xor Lógico
Los operadores && y || se diferencian de & y | en que los primeros realizan evaluación perezosa y los segundos no. La operación perezosa consiste en que si el resultado de evaluar el primer operando permite deducir el resultado de la operación, entonces no se evalúa el segundo y se devuelve dicho resultado directamente, mientras que la evaluación no perezosa consiste en evaluar siempre ambos operandos.
Operaciones de manipulación de bits:
Operación Operador
and &
or |
not ~
xor ^
a la izquierda <<
a la derecha >>

Los ya conocidos operadores de asignación son:
Operación Operador
asignación =
suma y asigna +=
resta y asigna -=
multiplica y asigna *=
divide y asigna /=
calcula el resto y asigna %=
evalúa y asigna &=
evalúa y asigna |=
evalúa y asigna ^=
desplaza y asigna <<=
desplaza y asigna >>=
incrementa ++
decrementa --

internal class Program
{
static void Main(string[] args)
{ int edad= 7;

Console.WriteLine("Vamos a evaluar si eres mayor de 18 años ");
if (edad >= 18)
{
Console.WriteLine("Felicidades eres Mayor");
}
Console.ReadKey();
}

}}

namespace ConsoleAppEje
{
internal class Program
{
static void Main(string[] args)
{ bool carnet = true;

Console.WriteLine("Vamos a evaluar si puedes conducir ");
if (carnet)
{
Console.WriteLine("Felicidades puedes conducir");
}
else
Console.WriteLine("No puedes Conducir");
Console.ReadKey();
}
}
}
NOTA: Cuando las lineas de codigo solo tienen una linea se pueden eliminar la { } y resumir el codigo en una sola linea EJ:
...
if (carnet) Console.WriteLine("Felicidades puedes conducir");
...
else Console.WriteLine ("No puedes Conducir");
...

int edad = Int32.Parse(Console.ReadLine());

Console.WriteLine("¿Humano como te llamas?");
string nombre = Console.ReadLine();
Console.WriteLine("¿"+ nombre +" en que año naciste?");
int añoNacimiento = int.Parse(Console.ReadLine());
int edad = DateTime.Now.Year - añoNacimiento;
Console.WriteLine("¿" + nombre + " de pura casualidad cunto ganas al mes?");
float salario = float.Parse(Console.ReadLine());
Console.WriteLine("Pobre "+nombre+" a tus "+edad+" años y solo ganas "+salario+ " pesitos ");

usaremos el método CompareTo. Esta función nos va a devolver 0 si las cadenas son iguales, un número menor a 0 si la primera cadena es menor que la segunda, y un número mayor a 0 si la primera es mayor que la segunda.
La sintaxis de uso en el lenguaje C# es:
resultado = unaCadena.CompareTo(otraCadena);
Verás que queda más claro con ejemplos.
namespace App
{

class Programa
{

static void Main(string[] args)
{
string cadena1 = "Aloy";
string cadena2 = "Zelda";
Console.WriteLine("Resultado de comparar '{0}' con '{1}'", cadena1, cadena2);
int resultado = cadena1.CompareTo(cadena2);
if (resultado == 0)
{
Console.WriteLine("Las cadenas son iguales");
}
else if (resultado < 0)
{
Console.WriteLine("{0} es lexicográficamente menor que {1}", cadena1, cadena2);
}
else
{
Console.WriteLine("{0} es lexicográficamente mayor que {1}", cadena1, cadena2);
}
}
}
}

String.Copare: sirve para comparar dos cadenas de texto y con bollCase si debe discriminar Mayus y Munis o no String.Compare( StringA,StringB, BoolCase);
int compara = String.Compare(carnet, "si", true);

namespace ConsoleAppEje
{
internal class Program
{

static void Main(string[] args)
{ string carnet = "no";
Console.WriteLine("Vamos a evaluar si puedes conducir ");
Console.WriteLine("Ingrece su Edad: ");
int edad = Int32.Parse(Console.ReadLine());
if (edad < 18)
{ Console.WriteLine("No puedes Conducir");}
else
{
Console.WriteLine("¿Tienes Carnet?");
carnet = Console.ReadLine();
int compara = String.Compare(carnet, "si", true);
if (compara == 0)
Console.WriteLine("Puede Conducir");
else
{ Console.WriteLine("No puedes Conducir");}
}
Console.ReadKey();
}
}
}

cada expresionconstante debe ser unica
Solo se puede usar como expresion de control:
int, char o String ( para float y double han de
utilizar if)
Cada Case solo deve tener expresiones constantes
Todos los case deben llevar su case
sepuede utilizar return y throw
Sintaxis Basica
switch (expresionControl)
{
case expresionConstante: codigoxRealizar break;
...
case expresionConstante: codigoxRealizar break;
default: codigoxRealizar break;
}

Permiten repetir la ejecución de líneas de código un nro determinado o indeterminado de veces
Ventajas:
* Permite repetir código de forma rápida y sencilla.
* Ahorro de tiempo a la hora de programar.
* Permite trabajar con grandes volúmenes de datos
TIPO DE BUCLES:
Determinados: For
Indeterminados: While y Do-While

while (condicionxEvaluar(true/false))
{ codigo a repetir;}

ejemplo:
namespace ConsoleAppEje
{
internal class Program
{
static void Main(string[] args)
{
Random nroAleatorio = new Random();
int sorteo = nroAleatorio.Next(0,100);
int miNro;
Console.WriteLine("Adivina el Nro que se ha sorteado : ");
miNro=Int32.Parse(Console.ReadLine());
while (miNro != sorteo)
{
if (miNro < sorteo)
{ Console.WriteLine(" Tu Numero es Menor");}
else
{ Console.WriteLine(" Tu Numero es Mayor"); }
Console.WriteLine(" Vuelve a Intentarlo");
miNro = Int32.Parse(Console.ReadLine());
}
Console.WriteLine("Felicidades Has Acertado");
Console.ReadKey();
}
}
}

Su funcionamiento es igual al WHILE, la diferencia es que el do-while se ejecutara al menos una vez.
Sintaxis
do {
Instruciones;
} while (Condicion);

Son errores en tiempo de ejecución del programa que escapan al control del programador. EJ: Memoria corrupta, desbordamiento de plia, Fallas de conexion de BBDD, etc
La sentencia para manejo de errores Try-Catch en C# es utilizado en programación .Net para evitar romper el flujo de trabajo de una aplicación.

La instrucción Try-Catch esta formado de un bloque try y seguida de este se coloca el catch.

Try: se encarga de encapsular todas las operaciones.

try
{
//boque try con todas las operaciones
}
Catch: captura los errores generados en el bloque Try, aqui se manejan las diferentes excepciones.

catch (Exception ex) //bloque catch para captura de error
{
//acción para manejar el error
}

TRY CATCH SINTAXIS
try
{ código a ejecutar }
catch(formatExeption e)
{ codigo que se ejecuta si hay error }

EJEMPLO
namespace ConsoleAppEje
{
internal class Program
{
static void Main(string[] args)
{
Random nroAleatorio = new Random();
int sorteo = nroAleatorio.Next(0,100);
int miNro;
Console.WriteLine("Adivina el Nro que se ha sorteado : ");
try
{
miNro=Int32.Parse(Console.ReadLine());
}
catch (Exception)
{ Console.WriteLine("No has introducido un valor numerico entero");
miNro = 101;
}
while (miNro != sorteo)
{
if (miNro < sorteo)
{ Console.WriteLine(" Tu Numero es Menor");}
else
{ Console.WriteLine(" Tu Numero es Mayor"); }
Console.WriteLine(" Vuelve a Intentarlo");
miNro = Int32.Parse(Console.ReadLine());
}
Console.WriteLine("Felicidades Has Acertado");
Console.ReadKey();
}
}
}

try
{ código a ejecutar }

catch(FormatExeption e)
{ código que se ejecuta si hay FormatExeption }

catch(OverFlowExeption e)
{ código que se ejecuta si hay OverFlowExeption }

Herencia de exepciones
Exception:
>SystemException:
>>FormatException
>>OverflowException
con : catch (Exeception ex) capturamos todas las excepciones
pero si queremos captar un tipo de Excepcion como FormatException e y despues Exeception ex sera compatible si van en el flujo de ejecucion de las excepciones particulares a las excepciones generales.
cuando hay múltiples catch el compilador toma el que mejor se adecua e ignora a lo demás
uso de filtros:
catch (Exception e) when (e. GetType()!= typeof(FortmatException)) //captura todas las excepciones cuando las excepciones sean diferentes de FormatException
donde:
when () : la clausula "cuando"
e : es el objeto error de la excepcion
GetType(): metodo del objeto e
typeof() : tipo de...

El compilador debería dar error en el siguiente programa, pero en su lugar da un resultado erróneo, pero con el "checked { código a chequear}" revelara las excepción por desbordamiento aritmético

checked y uncheked solo funcionan con int o long

...
static void Main(string[] args)
{
checked
{
int nro = int.MaxValue;
int nro2 = nro + 20;
Console.WriteLine(nro2);
Console.ReadKey();
}
}...
otra forma es configurar el compilador
Explorador de soluciones
click Derecho en tu proyecto
click en propiedades
ir a compilación
click en el botón de avanzadas
tildar la opción de desbordamiento y subdesbordamiento aritmético

el Unchecked suspende el checked y su sintaxis es:
unchecked()
ej:
...
//devuelve el maximo valor de tipo int
int nro = int.MaxValue
int resultado= unchecked (nro +20);
Console.WritLine(resultado)

sirve para lanzar excepciones su sintaxis es:
throw new nombreClaseException();

public class MyService: IMyService
{
private readonly IDependency _first;
private readonly IAnotherDependency _second;

public MyService(IDependency first, IAnotherDependency second)
{
if (first==null)
throw new ArgumentNullException("first");

if (second == null) // O mejor, usando el operador nameof
throw new ArgumentNullException(nameof(second));

_first = first;
_second = second;
}
...
}

se usa para asegurarnos que siempre de error o no se ejecute siempre, se usa generalmente en bases de datos, en lecturas de ficheros externos, etc.
sintaxis completa:
try{
//código que se intenta
}catch (formatExetion e){
//código que se ejecuta si hay excepción
}
finally{
//código que se ejecuta siempre
}
ejemplo
static void Main(string[] args)
{
System.IO.StreamReader archivo = null;
try {
string linea;
int contador=0;
string path = @"C:\Users\crist\source\repos\00Ficheros\fichero.txt";
archivo= new System.IO.StreamReader(path);
//mientras alla lineas de texto
while ((linea = archivo.ReadLine()) != null) {
Console.WriteLine(linea);
contador++;
}
}
catch (Exception e) {
Console.WriteLine("ERROR EN LECTURA DE ARCHIVO");
}
finally {

ejemplo
namespace ConsoleEjFinally {
internal class Program {
static void Main(string[] args){
System.IO.StreamReader archivo = null;
try {
string linea;
int contador = 0;
string path = @"C:\Users\crist\source\repos\00Ficheros\fichero.txt";
archivo = new System.IO.StreamReader(path);
//mientras alla lineas de texto
while ((linea = archivo.ReadLine()) != null){
Console.WriteLine(linea);
contador++;
}
}
catch (Exception e){
Console.WriteLine("ERROR EN LECTURA DE ARCHIVO");
}
finally{
// cerramos el StreamReader para recuperar recurso cpu
if (archivo != null) archivo.Close();
Console.WriteLine("la conexion con el fichero se ha CERRADO");
}
Console.ReadKey();
} } }

hay dos tipos de paradigmas de programación:
>>programación orientada a procedimientos
>> programación orientadas a objetos
LA POO
consiste en trasladar la naturaleza de los obletos de la vida real al código de programación
los Objetos en la vida real tiene un estado, un comportamiento(que es lo que puede hacer), y unas propiedades
por ejemplo un coche
estado: encendio/apagado
propiedades: color, peso, tamaño, etc.
comportamientos: avanzar, reversa, acelerar, frenar, girar, etc.
Ventajas:
> programas divididos en modulos, trozos, partes o clases. MODULARIZACION
> es muy reutilizable. HERENCIA
> si existiera un fallo en una linea de código, el programa continuara con su funcionamiento. TRATAMIENTO DE EXCEPCIONES.
ENCAPSULAMIENTO

PUBLIC: Accesible desde cualquier parte, sus nombres deben comenzar con Mayúscula "PascalCase" el resto con minúscula "camelCase"
PRIVATE: Accesible desde la propia clase
PROTECTED: Accesible desde la clase derivada
INTERNAL: Accesible desde el mismo ensamblado
PROTECTED INTERNAL: Accesible desde otro ensamblado o clase derivada de otro ensamblado
PRIVATE PROTECTED: Accesible desde la misma clase o clase derivada del mismo ensamblado
POR DEFECTO: Accesible desde el mismo paquete

CLASE: Modelo donde se redactan las características de un grupo (conjunto) de objetos.
OBJETO: Es un ejemplar perteneciente a una clase (elemento del conjunto) . Y tienen PROPIEDADES (ATRIBUTOS) son los valores de sus variables y tienen COMPORTAMIENTO que son sus métodos y funciones.
Para acceder a las propiedades y comportamientos se utiliza la nomenclatura de punto
//accedo a la propiedad color del objeto Renault de la clase auto
Renault.color="rojo"
//accedo a la comportamiento arrancar del objeto Renault de la clase auto
Renault.arranca();

EJEMPLAR DE CLASE/ EJEMPLIZAR UNA CLASE
INSTANCIAR UNA CLASE
MODULARIZACION
ENCAPSULAMIENTO/ENCAPSULACION: Es una medida de seguridad que limita a una clase/modulo acceder a otro
HERENCIA
POLIMORFIRMO

namespace Console_Ej_POO_Circulo
{
internal class Program
{
static void Main(string[] args)
{//instanciando la clase Circulo
Circulo miCirculo;//creo una variable objeto del tipo circulo
//iniciacion de var objeto del tipo circulo
miCirculo = new Circulo();//Instanciar clase o Ejemplarizacion de clase
Console.WriteLine(miCirculo.calculoArea(5));
Circulo miCirculo2=new Circulo();
Console.WriteLine(miCirculo2.calculoArea(9));

Console.ReadLine();
}
}

class Circulo

{//propiedad de la clase Circulo.
//al estar definida con un valor es un campo de clase
const double pi = 3.1416;// con const ahora no se puede modificar
//al ser public puedo acceder desde la clase program
public double calculoArea(int radio)//metodo de clase Circulo
{
return pi * radio*radio;
}
}
}

Para Acceder a un método o atributo etc de una clase X en esa clase debe existir un método de acceso el cual será public void Nombre(valores)y recibirá por parámetros los valores a modificar



namespace Console_Ej_POO_Circulo
{ internal class Program
{
static void Main(string[] args)
{
ConversorPesoDolar obj = new ConversorPesoDolar();
Console.WriteLine("valor: " + obj.convierte(100));
ConversorPesoDolar obj2 = new ConversorPesoDolar();
//puedo cambiar valor de peso x metodo de acceso
obj2.AccesoValorPeso(215);
Console.WriteLine("valor 2 : " + obj2.convierte(100));

Console.ReadLine();
} }

class ConversorPesoDolar
{
private double peso = 285.00;
public double convierte(double cantidad)
{
return cantidad * peso;
}
public void AccesoValorPeso(double nuevovalor)
{
peso = nuevovalor;
} } }

Da valor inicial a los objetos
namespace UsoCoche{
internal class Program
{
static void Main(string[] args)
{
//crear instancia-objeto de tipo coche
// da un estao inicial a nuestro coche
Coche coche1 = new Coche();
Coche coche3 = new Coche(4500.25, 1200.25);
Console.WriteLine("coche 1 " + coche1.getInfoCoche());
Console.WriteLine("coche 2 " + coche3.getInfoCoche());
Console.ReadKey();
} }
class Coche {
private int ruedas;
private double largo;
private double ancho;
public Coche(){
ruedas = 4;
largo = 2300.5;
ancho = 0.800;
}
public Coche(double largoCoche, double anchoCoche){
ruedas = 4;
largo = largoCoche;
ancho = anchoCoche;
}
public String getInfoCoche(){
return "Datos del coche: \n" + ruedas + largo + ancho;
} } }

31