{"id":19093161,"url":"https://github.com/axelop96/c-sharp","last_synced_at":"2026-06-29T14:31:33.266Z","repository":{"id":154087257,"uuid":"391668690","full_name":"AxelOP96/C-sharp","owner":"AxelOP96","description":"curso de c#","archived":false,"fork":false,"pushed_at":"2023-05-17T15:57:05.000Z","size":575,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-11-12T14:37:38.335Z","etag":null,"topics":["csharp","guia"],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/AxelOP96.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2021-08-01T15:43:40.000Z","updated_at":"2021-09-20T00:36:35.000Z","dependencies_parsed_at":null,"dependency_job_id":"83409a7e-4c7a-443b-b282-5f358188f35a","html_url":"https://github.com/AxelOP96/C-sharp","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/AxelOP96/C-sharp","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AxelOP96%2FC-sharp","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AxelOP96%2FC-sharp/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AxelOP96%2FC-sharp/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AxelOP96%2FC-sharp/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/AxelOP96","download_url":"https://codeload.github.com/AxelOP96/C-sharp/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/AxelOP96%2FC-sharp/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34931586,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-29T02:00:05.398Z","response_time":58,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["csharp","guia"],"created_at":"2024-11-09T03:23:30.934Z","updated_at":"2026-06-29T14:31:33.242Z","avatar_url":"https://github.com/AxelOP96.png","language":null,"funding_links":[],"categories":[],"sub_categories":[],"readme":"# C-sharp\n\nPrimera clase: Software necesario\n\n\nEn este curso vamos a programar con un lenguaje de programación llamado C# (C sharp). El lenguaje fue desarrollado por Microsoft y tiene una forma de ser escrito bastante\nparecida a lo que es C++ o Java.\nPara poder programar en C# necesitamos contar con toda la suite de desarrollo de Microsoft que se instala automáticamente al descargar e instalar un IDE que se llama Visual\nStudio Community. El tema es que este programa es súper pesado y no tiene mucho sentido, por ahora.\nAsí que lo que vamos a usar es su hermano menor, que no es menos importante y de hecho es uno de los más famosos hoy en día. Se llama Visual Studio Code. No confundan el nombre,\nes muy parecido, pero son dos cosas bastante distintas.\nEl tema es que el Visual Studio Code no te instala todo automáticamente. Pero no pasa nada, es instalar una sola cosa aparte.\nEntonces, lo primero que tenés que hacer es descargar e instalar:\nVisual Studio Code\nY luego de que lo tengas instalado, vamos a descargar e instalar el Software Development Kit de Microsoft .Net Core. Ufff... cuánto nombre... es básicamente un kit de desarrollo\nque tiene todo lo que necesitamos, no te asustes.\nSDK .Net Core\nNota: para poder instalar todo esto necesitás contar con Windows. Si no usás Windows, contame que lo podemos adaptar para el sistema que uses. \nCrear nuevo proyecto\nLo vamos a ver en la clase, pero si querés ir intentando, te dejo los pasos a seguir para poder crear un nuevo proyecto.\nLo primero que necesitamos hacer es abrir la terminal, o consola de comandos. En Windows, para ello podés presionar la combinación de teclas Windows + R y en el cuadro de\ndiálogo escribir \"cmd\" y presionar Enter. Otra forma es buscando la consola en el buscador del menú de Windows.\nUna vez allí lo que tendrás que hacer es posicionarte en una carpeta. O sea entrar a una carpeta en la que vamos a crear el proyecto. Para ello te recomiendo que vayas al\nescritorio o a Documents y te crees una carpeta que se llame \"Práctica Programación\" o algo por el estilo. Allí dentro crearás luego todos tus proyectos.\nSupongamos que en Documents creaste la carpeta \"Ejercicios\", entonces en la consola deberías escribir:\ncd C:\\Users\\msarfernandez\\Documents\\Ejercicios\nO sea, la clave \"cd\" seguida por un espacio y luego la ruta completa de la carpeta. En el ejemplo es la ruta completa en MI máquina, vos tenés que poner la ruta completa en la\ntuya. \nUna vez que logres eso vas a ver algo así:\n \nEso quiere decir que ya estás dentro de la carpeta.\nAhora lo que tenés que poner es lo siguiente:\ndotnet new console -o nombreproyecto\nEsto va a crear una nueeeva carpeta adentro de tu carpeta Ejercicios con el nombre \"nombreproyecto\" o el nombre que le pongas.\nAhora abrís Visual Studio Code y lo que hacés es simplemente arrastrar la nueva carpeta al Visual Studio Code. Se te va a abrir el proyecto y deberías ver algo así:\n \nBueno, falta poquito. Parece largo pero vas a ver que luego de hacerlo dos o tres veces, ya está.\nVolvemos a la consola y escribimos:\ncd nombreproyecto\nEsto nos deja DENTRO de la carpeta del proyecto que corresponda, acordate que en mi ejemplo se llama así... qué ejemplo, no?...\nBueno, una vez allí, ahora escribimos:\ndotnet restore\ny presionamos enter. Y luego:\ndotnet run\nTardará unos segundos y vas a ver en pantalla la frase \"Hello World\". \nUff, listo, ejecutaste tu primer programa. \n\nTe repito que esto lo vamos a ver y varias veces clase a clase. Pero siempre tendrás esta guía paso a paso o para anticiparte o para venir. a consultar cuando necesites.\nCualquier cosa, me consultás!\n\nhttp://youtube.com/watch?v=s6i5I1b4y-I\u0026utm_source=youtube.com\u0026utm_medium=short_domains\u0026utm_campaign=ssyoutube.com\u0026a_ts=1626454393.643\n\nIntroducción\nLa programación es una disciplina (de tantas hoy en día) que pertenece a la informática, ciencia que se dedica al análisis y transformación de datos e información a partir del\nuso de computadoras.\nEn dicha disciplina se desarrollan algoritmos en un determinado lenguaje de programación, los cuales serán implementados en una computadora para de esa manera realizar los\nllamados programas.\nAlgoritmo\nUn algoritmo es una secuencia finita y ordenada de instrucciones que deben ser seguidas en pos de resolver un problema. \n\nhttps://www.youtube.com/watch?v=i3J42rmbrBQ\n\n\nhttps://www.youtube.com/watch?v=kJCin3JwIBY\n\n\nPrograma\nUn programa es, técnicamente hablando, uno o más (al menos uno) algoritmos de programación escrito en un lenguaje que puede ser interpretado y ejecutado por una computadora. En\notras palabras, decimos que un programa es la solución a un problema, ya que cada vez que se requiere desde sumar números hasta realizar traducciones, grandes cálculos o enviar\nmensajes de texto, se recurre a un programa (o aplicación, o web, lo que corresponda). \n\nhttps://www.youtube.com/watch?v=xmbRFUy8fcc\n\n\nExisten distintos tipos de programas o aplicaciones (podemos decir que son sinónimos), por ejemplo:\n- Programas de escritorio: Se ejecutan en windows, por ejemplo Word, Excel, el buscaminas.\n- Programas web: Facebook, Mercado Libre, son aplicaciones o sistemas web.\n- Programas de celular: también llamados apps, o aplicaciones, por ejemplo Whatsapp, Instagram, Google Maps.\nTodos estos son parte de un gran grupo dentro de la informática que se denomina Software.\nSistema Informático\nEl sistema informático está compuesto necesariamente por tres partes:\n- Hardware\n- Software\n- Humano\nAnte la ausencia de alguna de éstas partes, no podríamos completar el sistema y este no tendría sentido dado que:\nSoftware es todo lo que creamos para que una computadora funcione, pero requiere justamente una computadora donde hacerlo, ahí entra el Hardware.\nHardware es “todo lo que se puede tocar” en una computadora: el monitor, el teclado, incluso todos los componentes internos dentro de la misma. \nSin embargo, sin programas para utilizar, todo ese poder de procesamiento, no nos sería de utilidad.\nHumano. Se completa el ciclo con el humano que es quien hace uso de ese Software gracias a ese Hardware, y quizá pueda sonar a una obviedad, pero es clave tener en cuenta este\ncírculo.\nComo ya dijimos, el Software es lo que le da vida a la computadora. Son los programas que nos permiten utilizarlas, y existen distintas categorizaciones dentro del software. \nLas más comunes son:\n- Software de base: esto corresponde a las cuestiones básicas y de sistema operativo que se requiere para poder encender y usar una computadora (Windows, Linux, Mac OS,\n- Android, iOS).\n- Software utilitarios: son aplicaciones complementarias para el correcto funcionamiento y/o administración de los sistemas. Podemos hablar del desfragmentador de disco, \no utilidades de análisis de errores en memoria, entre otros.\n- Software de aplicación: los programas, sistemas o aplicaciones que utilizamos a diario.\nExisten más categorías y sub-categorías y además ciertas características adicionales como si son libres, o no, o si son open source, o multiplataforma, pero eso es para indagar\nen otro contexto.\nTambién podemos mencionar los “programas para programar”. Desde ya que hoy en día para poder desarrollar programas, vamos a necesitar una computadora, pero además vamos a\nnecesitar uno o más (según corresponda) programas que nos sirvan para ello. Hay aplicaciones específicamente preparadas para, justamente, desarrollar otras aplicaciones, en\ndefinitiva, para programar. Estas aplicaciones se suelen conocer como IDE, de sus siglas en inglés \"Entorno de Desarrollo Integrado\".\nDependiendo de lo que quisiéramos programar, será la aplicación que deberíamos utilizar, y esto aplica del mismo modo para la tecnología o lenguaje de programación a utilizar.\n\n\nhttps://www.youtube.com/watch?v=_rl4vXVgoyE\n\n \nhttps://www.youtube.com/watch?v=wvJv1CDptvc\nTipos de datos\nComo veremos más adelante, al programar no solo hay que escribir en un lenguaje determinado, sino que vamos a tener que utilizar muchas herramientas distintas, dentro de la propia programación, que iremos adquiriendo a medida que vayamos avanzando. Una de esas herramientas y de la que más vamos a hablar y utilizar de entrada (y para siempre si seguís con la programación) es la variable.\nUna variable, técnicamente hablando, un espacio en la memoria de la computadora destinado a ser utilizado por nuestro programa para poder guardar un dato. La variable tiene ciertas características como que debe contar con un nombre, que puede guardar un solo dato a la vez (el mismo puede ir cambiando, de allí su nombre) y que debe tener un tipo. Este tipo se refiere a qué es lo que precisamente va a guardar esa variable. Los primeros tipos que aprendemos son los más basicos y elementales pero que nos acompañarán, junto a las variables, en toda la vida dentro de la programación. Estos tipos son:\n- Int para guardar números enteros.\n- Float o double (dependiendo del lenguaje, hay otras variantes) para guardar números con coma.\n- Char para guardar letras.\n- Bool para guardar verdadero o falso (que es lo mismo a 1 o 0 respectivamente.\nQue le asignemos un tipo de dato a una variable afecta y tiene una relevancia puntual. Si estoy creando una variable de tipo entera, la misma solamente podrá guardar valores enteros. Qué sucederá si quiero guardarle un número con coma? Bueno, dependiendo del momento, el lenguaje o la operación, podrá dar error o bien podrá redondear el valor quitando los decimales y quedándose solo con la parte entera. Ninguno de los escenarios serían pertinentes en nuestro programa. Lo ideal sería que si la variable solo admite valores enteros, pues que se la use con valores enteros.\nhttps://www.youtube.com/watch?v=kJ2vUwgxzSY\n\nhttps://www.youtube.com/watch?v=IfvTgaMX4J4\n\n\nEjercicios 1\n\n\nhttps://www.youtube.com/watch?v=8ANRCYtveMI\n\n\nhttps://www.youtube.com/watch?v=Bm3X8eHVv-s\n\n\nEsta unidad es más teórica introductoria que para ejercitar. Por eso el siguiente ejercicio va a ser más que nada para que testeemos que el entorno quedó configurado\ncorrectamente y que estamos en condiciones para comenzar a programar.\n1. Para este primer ejercicio deberás crear tu primer programa que emita en pantalla \"Hola Mundo\".\nAdicionalmente, podés hacer las modificaciones correspondientes para que el programa emita \"Bienvenido Juanito\", donde \"Juanito\" puede ser tu nombre. \nEn este módulo comenzamos a manejar conceptos más precisos y técnicos, puntuales y necesarios para la confección de nuestros primeros programas.\nEn la unidad anterior comprendimos las herramientas a utilizar y llevamos a cabo la creación del primer proyecto para corroborar que todo estaba en orden.\nLo primero que tenemos que comenzar a comprender en cuanto a los programas es que existe un principio básico de todo algoritmo, de todo programa, de toda aplicación; el cual se\nbasa en el esquema que se muestra a continuación:\n \nTodo programa, para poder operar, necesita contar con una entrada de datos con los cuales realizará un posterior procesamiento, una transformación de esos datos, a partir de \nlos cuales terminará obteniendo información para finalmente brindar una salida.\nNuestro ejemplo más sencillo parte de la necesidad de sumar dos números. Para poder sumar dos números, el programa deberá solicitarlos (o recibirlos), es decir, contar con una\nentrada de datos que serán esos dos números. Luego aplicará un procesamiento, que en este caso será sumar esos dos valores que fueron ingresados; para finalmente obtener el\nresultado de la suma y mostrarlo en pantalla. Esta última sería la salida de información.\n¿Dato o Información?\nPor qué se hace hincapié en la diferencia de que lo que entra son Datos y lo que sale es Información? Podríamos tomarlos como sinónimos?\nLa definición de datos dice que: un dato es un conjunto de símbolos sin significado alguno, mientras que por otro lado, la definición de información afirma que: la información está compuesta por símbolos a los que se le ha atribuido algún significado.\nYo siempre suelo dar un ejemplo un tanto fantástico, pero simple y que, a mí entender, funciona para comprender la idea.\nSe trata de una persona que, caminando por la calle, se encontró con un pergamino tirado. Cuando lo abre se trata de un documento bastante elegante, con firmas y demás pero con\nun texto que esta persona no podía comprender. Pensó en hacer un cuadro, ya que era lindo, vistoso; terminó por regalárselo a un amigo hijo de japoneses. Este amigo resulta que\nmanejaba la lengua nativa de Japón por sus padres y al ver el pergamino entendió de qué se trataba y no solo eso, pudo leerlo pues estaba escrito en un lenguaje que manejaba y\ncomprendía. Se trataba de un documento correspondiente a un testamento el cual otorgaba una fortuna a quién lo encuentre y, desde ya, pueda reclamarlo por saber de qué se\ntrataba.\nA qué quiero llegar con todo esto? Para la primera persona ese pergamino no era más que un papel \"lindo\" que a lo sumo podría utilizar para decorar una sala. Un papel con un\nconjunto de símbolos sin sentido. Pero por otro lado, para su amigo, quien contaba con los elementos necesarios para comprender ese papel, lo que decía en él, par aplicar un\nprocesamiento (a partir de traducir -aplicar un algoritmo-) el contenido del mismo, pasó a atribuirle un significado valiosísimo, en este caso monetario, transformando esos\ndatos en información, mediante un procesamiento.\nEl fin de toda aplicación es siempre obtener información.\nEl proceso y las variables\nPara poder realizar las transformaciones de las que hablamos necesitamos construir nuestros algoritmos con las instrucciones necesarias. Desde ya que tendremos, generalmente,\npara comenzar un ingreso de datos y para terminar una salida de información. Pero en el medio es donde vamos a tener que establecer las instrucciones necesarias para darle \nforma al proceso pertinente que realice la transformación, o \"la magia\".\nVolviendo a nuestro ejemplo de la suma, el proceso sería justamente sumar, valga la redundancia, pero hay varias cosas que se encuentran implícitas en esa operación.\nPara poder sumar dos valores necesitamos previamente contar con ellos, y para eso no alcanza con pedirlos. Una vez que los pedimos, tenemos que guardarlos. Para poder guardar\nesos datos vamos a necesitar hacer uso de un elemento fundamental en la programación: la variable. Una variable es un espacio en memoria que permite alojar un valor. Es un \nmedio que utilizaremos en nuestros programas para ir guardando todas las cosas que necesitamos dentro y a lo largo de todo algoritmo.\nImaginen la memoria RAM (si no conocen la memoria RAM repasen el video de la PC del módulo 1) como una hoja excel, la cual cuenta con columnas representadas por letras y filas\nrepresentadas por números y en cada intersección encontramos una celda. \n \nOk. Si yo digo C5, estoy haciendo referencia a la columna C en la fila 5. Podemos decir que la memoria RAM trabaja parecido a esto. C5 sería la dirección de memoria de esa\ncelda. Sin embargo, al querer usar esas \"celdas\" (variables) en nuestros programas no vamos a estar todo el tiempo usando direcciones de memoria, para ello, lo que haremos es\nponerle nombre a las variables. De ese modo, podremos hacer referencia a esas celdas mediante un nombre significativo y fácil de recordar. Significativo porque deberíamos\nnombrar nuestras variables teniendo en cuenta qué es lo que contienen dentro. \nVolviendo una vez más a nuestro ejemplo de la suma, para guardar los dos valores ingresados podemos decir que lo haremos en las variables numero1 y numero2. Los nombres de las\nvariables pueden contener cualquier letra, varias palabras y también números, aunque hay ciertas restricciones: \n•\tNo se puede comenzar el nombre de una variable con números.\n•\tEl nombre no puede estar compuesto solo por números.\n•\tEl nombre no puede contener símbolos especiales (por ejemplo * o +).\nEl nombre no puede ser igual a una palabra reservada. Dependiendo del lenguaje de programación que usemos, hay palabras que son específicas para hacer algo puntual, con lo cual\nno podemos usarlas como nombres de variables. Por ejemplo:\nConsole\nPalabra que usamos para invocar a la muestra de un mensaje en pantalla como vimos en el primer proyecto de ejemplo:\nConsole.WriteLine(\"Hola Mundo\");\n\n\nhttps://www.youtube.com/watch?v=1_xqLhsk9Ns\n\n\nhttps://www.youtube.com/watch?v=kJ2vUwgxzSY\n\n\nOperadores Aritméticos\nSon los primeros operadores que comenzaremos a utilizar. Estos son:\n•\t+ para sumar\n•\t- para restar\n•\t* para multiplicar\n•\t/ para dividir\nEstas son las operaciones básicas que el procesador ya conoce y que tenemos disponibles para utilizar. De allí para arriba, es decir, un cuadrado, un logaritmo, etc., etc., \nson operaciones que tendremos que construir a mano porque el procesador no las sabe. Es verdad que en la actualidad existen muchas cosas ya hechas las cuales podemos utilizar\n(se llaman librerías, las veremos más adelante), pero generalmente cuando se está comenzando en la programación, una de las primeras cosas se trata de recrear algunas de esas\nfuncionalidades para entender cómo trabajan.\n\n\nhttps://www.youtube.com/watch?v=BbYo0eeBNUw\n\n\nAsignación\nLa asignación es una acción mediante la cual se da un valor a una variable. Por ejemplo\njota = 10;\nLo que estamos haciendo en esa instrucción es tomar el valor 10 y asignarlo, o sea guardarlo, en la variable llamada jota. Hay varios orígenes de datos para realizar una\nasignación. La que acabamos de ver directamente asigna un valor. También se puede asignar el resultado de una operación matemática o simplemente asignar lo que se pide que una\npersona ingrese por teclado:\nresultado = jota + 7;\nvariable = Console.ReadLine();\nEl primer programa\nYa sabemos que tenemos que pedir y guardar, y que tenemos que procesar y mostrar. Y tenemos casi todas las herramientas. Hagamos nuestro primer programa en código y luego\nterminamos de analizar.\nint numero1;\nint numero2;\nint resultado;\nnumero1 = int.Parse(Console.ReadLine());\nnumero2 = int.Parse(Console.ReadLine());\nresultado = numero1 + numero2;\nConsole.WriteLine(resultado);\nEn las primeras tres líneas lo que hacemos es declarar las variables y darles un tipo. Trabajaremos con números enteros (recordemos que los tipos que manejaremos por ahora son\nint, float, char y bool).\nLuego pedimos datos por teclado con la función ReadLine. La misma devuelve un texto, es por eso que con int.Parse lo que hacemos es transformarlo a número, que es lo que\nqueremos. Tranqui, hay cosas que de a poco vamos a ir terminando de entender.\nLuego de pedir y guardar los datos en nuestras variables, volvemos a usar éstas últimas ahora para leer el contenido que antes guardamos y, haciendo uso del operador aritmético\npara sumar, realizamos la suma. El resultado lo guardamos con el operador = (que en programación no es igual, sino asignar). \nFinalmente, con WriteLine volvemos a leer, esta vez el valor que quedó guardado en resultado, para mostrarlo en pantalla.\nY listo, ese es nuestro primer programa. Todos estos pasos que tenemos detallados aquí, los tenés súper explicados en el video \"Primer Programa\" que te sugiero que veas.\nLuego de todo esto, ya estamos en condiciones para seguir avanzando en la creación de otros programas de este tipo.\nTenés algunos ejercicios para practicar. \nOtra cosas interesantes que deberías saber:\n\n\nhttps://www.youtube.com/watch?v=wvJv1CDptvc\n\n\nhttps://www.youtube.com/watch?v=pju8moNrEHE\n\n\nhttps://www.youtube.com/watch?v=gk0FOyOOw5I\n\n\nMi primer programa:\n\nhttps://www.youtube.com/watch?v=tgBDluKHcws\n\n\nCalculadora en diagrama de flujo.\nFigura de ingreso pide valores de entrada\nLa de egreso muestra en pantalla\nLa de proceso, procesa los valores de entrada\nEl inicio y el fin marcan el comienzo y final de un programa.\n\n\nEl if condicional: https://www.youtube.com/watch?v=TTvnrL1KUZM\n\n\nEjercicios resueltos: guía 1 empeza a programar: https://www.youtube.com/watch?v=SvMQ6-Qlfos\u0026t=134s\n\n\nTipo de dato INT:\n\nIntegral numeric types (C# reference)\nThe integral numeric types represent integer numbers. All integral numeric types are value types. They are also simple types and can be initialized with literals. All integral\nnumeric types support arithmetic, bitwise logical, comparison, and equality operators.\n \nIn all of the table rows except the last two, each C# type keyword from the leftmost column is an alias for the corresponding .NET type. The keyword and .NET type name are\ninterchangeable. For example, the following declarations declare variables of the same type:\nint a = 123;\nSystem.Int32 b = 123;\nThe nint and nuint types in the last two rows of the table are native-sized integers. They are represented internally by the indicated .NET types, but in each case the keyword\nand the .NET type are not interchangeable. The compiler provides operations and conversions for nint and nuint as integer types that it doesn't provide for the pointer types\nSystem.IntPtr and System.UIntPtr. For more information, see nint and nuint types.\nThe default value of each integral type is zero, 0. Each of the integral types except the native-sized types has MinValue and MaxValue constants that provide the minimum and\nmaximum value of that type.\nUse the System.Numerics.BigInteger structure to represent a signed integer with no upper or lower bounds.\nInteger literals\nInteger literals can be\n•\tdecimal: without any prefix\n•\thexadecimal: with the 0x or 0X prefix\n•\tbinary: with the 0b or 0B prefix (available in C# 7.0 and later)\nThe following code demonstrates an example of each:\nvar decimalLiteral = 42;\nvar hexLiteral = 0x2A;\nvar binaryLiteral = 0b_0010_1010;\nThe preceding example also shows the use of _ as a digit separator, which is supported starting with C# 7.0. You can use the digit separator with all kinds of numeric literals.\nThe type of an integer literal is determined by its suffix as follows:\n•\tIf the literal has no suffix, its type is the first of the following types in which its value can be represented: int, uint, long, ulong.\n Note\nLiterals are interpreted as positive values. For example, the literal 0xFF_FF_FF_FF represents the number 4294967295 of the uint type, though it has the same bit representation\nas the number -1 of the int type. If you need a value of a certain type, cast a literal to that type. Use the unchecked operator, if a literal value cannot be represented in the\ntarget type. For example, unchecked((int)0xFF_FF_FF_FF) produces -1.\n•\tIf the literal is suffixed by U or u, its type is the first of the following types in which its value can be represented: uint, ulong.\n•\tIf the literal is suffixed by L or l, its type is the first of the following types in which its value can be represented: long, ulong.\n Note\nYou can use the lowercase letter l as a suffix. However, this generates a compiler warning because the letter l can be confused with the digit 1. Use L for clarity.\n•\tIf the literal is suffixed by UL, Ul, uL, ul, LU, Lu, lU, or lu, its type is ulong.\nIf the value represented by an integer literal exceeds UInt64.MaxValue, a compiler error CS1021 occurs.\nIf the determined type of an integer literal is int and the value represented by the literal is within the range of the destination type, the value can be implicitly converted to sbyte, byte, short, ushort, uint, ulong, nint or nuint:\nbyte a = 17;\nbyte b = 300; // CS0031: Constant value '300' cannot be converted to a 'byte'\nAs the preceding example shows, if the literal's value is not within the range of the destination type, a compiler error CS0031 occurs.\nYou can also use a cast to convert the value represented by an integer literal to the type other than the determined type of the literal:\nvar signedByte = (sbyte)42;\nvar longVariable = (long)42;\nConversions\nYou can convert any integral numeric type to any other integral numeric type. If the destination type can store all values of the source type, the conversion is implicit.\nOtherwise, you need to use a cast expression to perform an explicit conversion. For more information, see Built-in numeric conversions.\nC# language specification\nFor more information, see the following sections of the C# language specification:\n•\tIntegral types\n•\tInteger literals\nSee also\n•\tC# reference\n•\tValue types\n•\tFloating-point types\n•\tStandard numeric format strings\n•\tNumerics in .NET\nFeedback\n\nTipo de dato FLOAT:\nFloating-point numeric types (C# reference)\nThe floating-point numeric types represent real numbers. All floating-point numeric types are value types. They are also simple types and can be initialized with literals. All\nfloating-point numeric types support arithmetic, comparison, and equality operators.\n \nThe default value of each floating-point type is zero, 0. Each of the floating-point types has the MinValue and MaxValue constants that provide the minimum and maximum finite\nvalue of that type. The float and double types also provide constants that represent not-a-number and infinity values. For example, the double type provides the following\nconstants: Double.NaN, Double.NegativeInfinity, and Double.PositiveInfinity.\nThe decimal type is appropriate when the required degree of precision is determined by the number of digits to the right of the decimal point. Such numbers are commonly used in\nfinancial applications, for currency amounts (for example, $1.00), interest rates (for example, 2.625%), and so forth. Even numbers that are precise to only one decimal digit\nare handled more accurately by the decimal type: 0.1, for example, can be exactly represented by a decimal instance, while there's no double or float instance that exactly\nrepresents 0.1. Because of this difference in numeric types, unexpected rounding errors can occur in arithmetic calculations when you use double or float for decimal data. You\ncan use double instead of decimal when optimizing performance is more important than ensuring accuracy. However, any difference in performance would go unnoticed by all but the\nmost calculation-intensive applications. Another possible reason to avoid decimal is to minimize storage requirements. For example, ML.NET uses float because the difference\nbetween 4 bytes and 16 bytes adds up for very large data sets. For more information, see System.Decimal.\nYou can mix integral types and the float and double types in an expression. In this case, integral types are implicitly converted to one of the floating-point types and, if\nnecessary, the float type is implicitly converted to double. The expression is evaluated as follows:\n•\tIf there is double type in the expression, the expression evaluates to double, or to bool in relational and equality comparisons.\n•\tIf there is no double type in the expression, the expression evaluates to float, or to bool in relational and equality comparisons.\nYou can also mix integral types and the decimal type in an expression. In this case, integral types are implicitly converted to the decimal type and the expression evaluates \nto decimal, or to bool in relational and equality comparisons.\nYou cannot mix the decimal type with the float and double types in an expression. In this case, if you want to perform arithmetic, comparison, or equality operations, you must\nexplicitly convert the operands either from or to the decimal type, as the following example shows:\ndouble a = 1.0;\ndecimal b = 2.1m;\nConsole.WriteLine(a + (double)b);\nConsole.WriteLine((decimal)a + b);\nYou can use either standard numeric format strings or custom numeric format strings to format a floating-point value.\nReal literals\nThe type of a real literal is determined by its suffix as follows:\n•\tThe literal without suffix or with the d or D suffix is of type double\n•\tThe literal with the f or F suffix is of type float\n•\tThe literal with the m or M suffix is of type decimal\nThe following code demonstrates an example of each:\ndouble d = 3D;\nd = 4d;\nd = 3.934_001;\n\nfloat f = 3_000.5F;\nf = 5.4f;\n\ndecimal myMoney = 3_000.5m;\nmyMoney = 400.75M;\nThe preceding example also shows the use of _ as a digit separator, which is supported starting with C# 7.0. You can use the digit separator with all kinds of numeric literals.\nYou can also use scientific notation, that is, specify an exponent part of a real literal, as the following example shows:\ndouble d = 0.42e2;\nConsole.WriteLine(d); // output 42\n\nfloat f = 134.45E-2f;\nConsole.WriteLine(f); // output: 1.3445\n\ndecimal m = 1.5E6m;\nConsole.WriteLine(m); // output: 1500000\nConversions\nThere is only one implicit conversion between floating-point numeric types: from float to double. However, you can convert any floating-point type to any other floating-point\ntype with the explicit cast. For more information, see Built-in numeric conversions.\nC# language specification\nFor more information, see the following sections of the C# language specification:\n•\tFloating-point types\n•\tThe decimal type\n•\tReal literals\nSee also\n•\tC# reference\n•\tValue types\n•\tIntegral types\n•\tStandard numeric format strings\n•\tNumerics in .NET\n•\tSystem.Numerics.Complex\n\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\nEjercicios 2\nLeer atentamente y resolver!\nPara cada ejercicio deberás escribir el código correspondiente y probar su funcionamiento.\n\n1. Hacer un programa para solicitar dos números y luego calcule y emita la suma en pantalla.\n2. Hacer un programa para solicitar por teclado un número y luego devolver su valor elevado al cubo.\n3. Hacer un programa que permita ingresar los kilómetros existentes entre dos ciudades y la velocidad promedio de un vehículo. Calcular y emitir por pantalla el tiempo aproximado que demandará llegar de un punto a otro teniendo en cuenta los datos ingresados.\n4. Una casa de computación paga a sus empleados un sueldo fijo de ARS15000 más una comisión del 5% sobre el total facturado por cada empleado. Hacer un programa para ingresar el total facturado por un empleado y que luego calcule y emita por pantalla el sueldo total a cobrar por el mismo.\n5. Hacer un programa para ingresar por teclado las tres notas de exámenes de un alumno y luego calcule y emita por pantalla el promedio final.\n\n1) using System;\n\nnamespace sumar\n{\n class Program\n {\n static void Main(string[] args)\n {\n //Mi app de sumar\n //paso cero pedirle guardar valores en variables\n //pedir 2 numeros, sumar dos numeros y devolver el resultado\n //para pedir datos en pantalla\n //Console.WriteLine() escribe una linea; Console.Write() escribe lo siguiente;\n int numero1;\n int numero2;\n int resultado; \n Console.WriteLine(\"Ingrese un numero\");\n numero1 = int.Parse(Console.ReadLine());\n\n Console.WriteLine(\"Ingrese otro numero\");\n numero2 = int.Parse(Console.ReadLine());\n \n //Operacion\n resultado = numero1 + numero2;\n Console.WriteLine(\"Gracias por usar la aplicacion\");\n Console.WriteLine(\"Los nros ingresados son:\");\n Console.WriteLine(numero1);\n Console.WriteLine(numero2);\n Console.WriteLine(\"El resultado es: \" + resultado);\n //Ejercicio 2: Hacer un programa para solicitar por teclado un número y luego devolver su valor elevado al cubo.\n int numerox;\n Console.WriteLine(\"Ingrese un numero\");\n numerox = int.Parse(Console.ReadLine());\n Console.WriteLine(\"El cubo del numero ingresado es:\");\n Console.WriteLine(numerox * numerox * numerox);\n //Ejercicio 3: Hacer un programa que permita ingresar los kilómetros existentes entre dos ciudades y la velocidad promedio de un vehículo. Calcular y emitir por pantalla el tiempo aproximado que demandará llegar de un punto a otro teniendo en cuenta los datos ingresados.\n float diferencia;\n Console.WriteLine(\"Ingrese los Km de diferencia entre las dos ciudades:\");\n diferencia = float.Parse(Console.ReadLine());\n \n Console.WriteLine(\"Ingrese la velocidad promedio\");\n float km;\n km = float.Parse(Console.ReadLine());\n Console.WriteLine(\"Llegara al punto de destino en:\");\n Console.WriteLine(diferencia / km);\n //Ejercicio 4: Una casa de computación paga a sus empleados un sueldo fijo de ARS15000 más una comisión del 5% sobre el total facturado por cada empleado. Hacer un programa para ingresar el total facturado por un empleado y que luego calcule y emita por pantalla el sueldo total a cobrar por el mismo.\n float total;\n Console.WriteLine(\"Ingrese el total facturado\");\n total = int.Parse(Console.ReadLine());\n float comision = total * 0.05;\n float sueldo = comision + 15000;\n Console.WriteLine(\"El sueldo total es:\");\n Console.WriteLine(sueldo);\n //Ejercicio 5: Hacer un programa para ingresar por teclado las tres notas de exámenes de un alumno y luego calcule y emita por pantalla el promedio final.\n int nota1;\n int nota2;\n int nota3;\n Console.WriteLine(\"Ingrese sus 3 notas:\");\n int nota1 = int.Parse(Console.ReadLine());\n int nota2 = int.Parse(Console.ReadLine());\n int nota3 = int.Parse(Console.ReadLine());\n int promedio = (nota1 + nota2 + nota3)/3;\n Console.WriteLine(\"Su promedio es: \");\n Console.WriteLine(promedio);\n }\n }\n}\n\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\nClase 3: Condicionales\nMódulo 3 - Lectura\nCondicionales\nA ésta altura ya hemos desarrollado nuestros primeros programas. Los mismos se encargan de realizar operaciones matemáticas sencillas solicitando datos a un usuario y luego mostrando un resultado en pantalla. Las operaciones no tienen por qué ser sencillas, vimos que podemos combinar los operadores aritméticos y hacer uso de paréntesis (como en matemática) para separar en términos y demás con el fin de llegar a armar operaciones un poco más complejas que una simple suma.\nSin embargo, todos estos programas siguen siendo lineales, tengan tres líneas de código o cien. Quiere decir que comienzan por la primera instrucción y recorre absolutamente cada línea ejecutando todo lo que se encuentre en su camino hasta concluir.\nExisten momentos en los que vamos a querer ejecutar instrucciones bajo determinados escenarios; en determinadas circunstancias o en situaciones específicas exceptuando de ese modo un escenario alterno. Por ejemplo: calcular y mostrar el resultado de una suma si el primer número ingresado es mayor a 10.\nYa hicimos programas que piden y suman dos números, pero ahora solamente hay que sumarlos si el primer ingreso es mayor a 10, de otro modo, no hay que hacerlo. \nPara esto, y muchas otras cosas, existe una herramienta en programación denominada \"If\", del idioma inglés \"si\". Se trata de una herramienta que nos permitirá confeccionar condiciones (realizar preguntas) que tendrán como resultado posible SI o NO y dependiendo de cuál sea la respuesta podremos programar distintos sets de instrucciones.\nUna vez que se establece una condición If, lo que sucede es que se bifurca, se divide el flujo de ejecución del programa, creando, por así decirlo, dos \"dimensiones\" o caminos alternativos. El programa deberá elegir uno de esos caminos a seguir, no ejecutará los dos al mismo tiempo ni primero uno y luego el otro. No. Se evalúa la condición, y si el resultado es SI (recordemos que los posibles son SI o NO, o true o false, o 1 o 0), entonces se ejecutará el set de instrucciones programado en ese camino; pero si la respuesta a la pregunta es NO, entonces se ejecutará el otro set de instrucciones (en caso de haberlo, el NO puede no tener nada para ejecutar).\n\nLo podemos ver un poco más en detalle y de manera gráfica en el siguiente video:\n\n\nLink de youtube: https://www.youtube.com/watch?v=TTvnrL1KUZM\u0026t=1s\n\n\nEjemplo en código\nPor otro lado, podemos ver el código del ejemplo antes mencionado;\nint a, b, c;\nConsole.WriteLine(\"ingrese un nro\");\na = int.Parse(Console.ReadLine());\nConsole.WriteLine(\"ingrese un nro\");\nb = int.Parse(Console.ReadLine());\nIf(a \u003e b) {\n c = a + b;\n Console.WriteLine(\"El resultado es: \" + c);\n}\nConsole.ReadLine();\nExplicado paso a paso:\n1.\tDeclaramos las variables.\n2.\tMostramos un cartel para pedir el primer número.\n3.\tLeemos y guardamos el primer número.\n4.\tMostramos otro cartel para pedir el siguiente número. \n5.\tLeemos y guardamos el segundo número.\n6.\tEstablecemos la condición IF. En la misma preguntamos si el contenido de la variable \"a\" es mayor a 10.\n7.\tSi es mayor a 10, se ejecutará el contenido siguiente encerrado entre llaves, sino no entra a ese set y sigue de largo.\nAlgunas consideraciones a tener en cuenta:\nFormato de las condiciones\nLas condiciones están formadas, inicialmente, por tres partes: \n•\tUn valor.\n•\tUn operador de comparación.\n•\tOtro valor a ser comparado.\nEn este caso el primer valor corresponde al contenido de la variable \"a\", mientras que el operador de comparación es \"\u003e\" (mayor) y finalmente el segundo valor es el literal\n\"10\".\nOperadores relacionales\nLos operadores disponibles para construir condiciones lógicas se denominan relacionales, y son los siguientes:\n•\t\u003e mayor\n•\t\u003c menor\n•\t\u003e= mayor o igual\n•\t\u003c= menor o igual\n•\t== igual (nótese que no es = a secas, son dos símbolos juntos para la igualdad)\n•\t!= distinto\n\nPor ahora, solo podemos poner una condición por If. Es decir, una sola \"valor condición valor\"; con lo cual, deberías tener solamente dos valores y UN operador relacional, \npara que se entienda que es correcta la condición.\nEjemplos\nEjemplos correctos\n•\tA \u003e 10\n•\tB \u003c 12\n•\tA != B\n•\tC == 20\nEjemplos incorrectos\n•\tA \u003e B \u003c 10 en este caso tenemos dos operadores y tres valores. No es correcto.\n•\t10 \u003c 15 en este caso tenemos dos literales, no tiene sentido la condición pues siempre va a dar verdadero.\n\nSi se te ocurren otros ejemplos y no sabés si son correctos, podés postearlos en el Foro de dudas y los vemos.\n\n¿Verdadero o Falso?\nHasta ahora vimos como hacer una condición y trabajar si la misma da como resultado true o no hacer nada si la misma da como resultado false. Por ejemplo:\nint edad = 21;\nif(edad \u003e 18){\n Console.WriteLine(\"Sos mayor\");\n}\nEn este caso muestra un cartel en pantalla si edad tiene un valor mayor a 18 y en caso contrario, no hace nada. Pero qué pasa si sí quisiéramos hacerlo? En ese caso lo que\npodemos hacer es escribir el bloque else, que, como te habrás dado cuenta, es opcional, ya que hasta ahora no lo habíamos hecho. \nDe este modo, siguiendo el mismo ejemplo, podemos mostrar un cartel que diga que sos menor si el valor no es mayor a 18, o sea, si la condición fue falsa.\nint edad = 17;\nif(edad \u003e 18){\n Console.WriteLine(\"Sos mayor\");\n}\nelse{\n Console.WriteLine(\"Sos menor\");\n}\nEn este caso, como ahora a edad le asignamos el valor 17, en vez de ir por el verdadero del If, va a ir por el else, o sea, el falso. Tené en cuenta que le asignamos 17 a la\nvariable. Y qué pasa si le hubiésemos asignado 18? En ese caso qué resultado daría el If, verdadero o falso? Teniendo en cuenta lo que se pregunta específicamente en el If y \nno lo que sepamos de cuándo sos mayor de edad. Si tenés dudas sobre cuál es la respuesta correcta podés probar el código o consultarlo en el Foro de dudas.\n\nBueno, comenzamos con IF. En realidad en este video primero resolvemos algunos ejercicios anteriores, creo que ya te lo había compartido antes. Pero ahora, lo relevante es el\ncomienzo de la explicación del condicional IF y comenzar a trabajar con dicha herramienta.\n\n\nLink de youtube: https://www.youtube.com/watch?v=TTvnrL1KUZM\u0026t=1s\n\n\nLuego de aprender lo básico, obviamente viene la hora de hacer ejercicios para comenzar a entrenar lo recién visto. Así que acá resolvemos algunos ejercicios. Y desde ya,\nseguimos sumando algún que otro dato de color, como también micro temas y datos relevantes!\n\n\nLink de youtube:https://www.youtube.com/watch?v=6B7oRyWqmxA\n\n\nEjercicios 3\nBueno, ya entramos en condicionales, así que ahora sí, vamos a codificar ejercicios con condiciones.\nLean atentamente y codifiquen las soluciones. Si van apareciendo dudas, me van consultando.\n\n1. Hacer un programa para ingresar un número y luego se emita por pantalla un cartel aclaratorio si “Es mayor a 10” o “No es mayor a 10”.\n2. Hacer un programa para ingresar un número y luego se emita un cartel por pantalla “Positivo” si el número es mayor a cero, “Negativo” si el número es menor a cero o “Cero”\n si el número es igual a cero.\n3. Una casa de video juegos otorga un descuento dependiendo del importe de la compra realizada según los siguientes valores:\n•\tSi el importe es menor a ARS 1000, no hay descuento.\n•\tSi el importe es ARS 1000 o más pero menor a ARS 5000, aplica un descuento del 10%.\n•\tSi el importe es ARS 5000 o más, aplica un descuento del 18%.\nHacer un programa para ingresar un importe de venta y luego muestre por pantalla el importe final con el descuento que corresponda.\n4. Hacer un programa para ingresar cuatro números distintos y luego mostrar por pantalla el menor de ellos.\n5. Hacer un programa para ingresar cuatro números y luego mostrar por pantalla cuáles son mayores a 100.\n\n1) int numero;\n numero = int.Parse(Console.ReadLine());\n Console.WriteLine(\"Ingrese un numero\");\n if(numero \u003e 10) {\n Console.WriteLine(\"El numero ingresado es mayor a 10\");\n }\n else {\n Console.WriteLine(\"El numero ingresado no es mayor a 10\");\n }\n\n }\n }\n}\n\n2)\n\n\nint positivo;\n Console.WriteLine(\"Ingrese un numero\");\n positivo = int.Parse(Console.ReadLine());\n if (positivo \u003e 0) {\n Console.WriteLine(\"Positivo\");\n }\n if (positivo \u003c 0) {\n Console.WriteLine(\"Negativo\");\n }\n else (positivo == 0) {\n Console.WriteLine(\"Cero\");\n }\n3)\n\n\n\n\n\nint descuento;\n Console.WriteLine(\"Ingrese el importe\");\n descuento = int.Parse(Console.ReadLine());\n if(descuento \u003c 1000) {\n Console.WriteLine(descuento);\n }\n else if(descuento \u003e= 1000 \u0026\u0026 descuento \u003c 5000) {\n Console.WriteLine(descuento * 0.1);\n }\n else {\n Console.WriteLine(descuento * 0.18);\n }\n\n4)\nint n1, n2, n3, n4;\n Console.WriteLine(\"Ingrese cuatro numeros:\");\n n1 = int.Parse(Console.ReadLine());\n n2 = int.Parse(Console.ReadLine());\n n3 = int.Parse(Console.ReadLine());\n n4 = int.Parse(Console.ReadLine());\n if(n1 \u003c n2 \u0026\u0026 n1 \u003c n3 \u0026\u0026 n1 \u003c n4) {\n Console.WriteLine(n1);\n }\n else if(n2 \u003c n1 \u0026\u0026 n2 \u003c n3 \u0026\u0026 n2 \u003c n4) {\n Console.WriteLine(n2);\n }\n else if(n3 \u003c n1 \u0026\u0026 n3 \u003c n2 \u0026\u0026 n3 \u003c n4) {\n Console.WriteLine(n3);\n }\n else if(n4 \u003c n1 \u0026\u0026 n4 \u003c n2 \u0026\u0026 n4 \u003c n3) {\n Console.WriteLine(n4);\n }\n\n5)\nint uno, dos, tres, cuatro;\n Console.WriteLine(\"Ingrese cuatro numeros:\");\n uno = Console.ReadLine();\n dos = Console.ReadLine();\n tres = Console.ReadLine();\n cuatro = Console.ReadLine();\n if(uno \u003e 100) {\n Console.WriteLine(uno);\n }\n else if(dos \u003e 100) {\n Console.WriteLine(dos);\n }\n else if(tres \u003e 100) {\n Console.WriteLine(tres);\n }\n else if(cuatro \u003e 100) {\n Console.WriteLine(cuatro);\n }\n \n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\n\nClase 4:\n\nMódulo 4 - Lectura\nEn este módulo vamos a ver varias herramientas complementarias a la hora de trabajar con condicionales. \n\nYa sabemos cómo trabaja el If y cuál es el modo correcto de construir condiciones lógicas a partir del uso de operadores relacionales. \n\nSin embargo, lo que vimos hasta ahora es que cada If puede tener una única condición y que si, por ejemplo, quisiéramos realizar dos preguntas, lo tenemos que hacer en dos Ifs\nseparados.\n\nBueno, hay una herramienta que nos brinda la posibilidad de crear más de una condición en un mismo If, y esa herramienta se llama: operador lógico.\n\nOperadores lógicos\nExisten dos operadores lógicos, también conocidos como operadores de concatenación lógica.\n\nOR cuyo símbolo corresponde a || (doble pipe).\nAND cuyo símbolo corresponde a \u0026\u0026 (doble ampersand).\nAND\nEl and es el operador \"y\". Al usar este operador para concatenar dos o más condiciones lógicas, el comportamiento será el siguiente:\n\nsi todas las condiciones dan verdadero, entonces el If dará como resultado verdadero.\n\nsi una condición da falso, entonces el If dará como resultado falso.\n\nEsto se debe a que al usar el operador AND para concatenar las condiciones, lo que estamos indicando es que queremos que se consulta si se cumple la condición 1 Y se cumple la\ncondición 2 Y se cumple la condición 3 Y.... etc. Estamos buscando saber si se cumplen todas; con lo cual, si se cumplen todas, dará verdadero PERO, con UNA condición que no se\ncumpla, entonces todo el If dará como resultado falso.\n\nOR\nCon el operador \"o\" pasa exactamente lo contrario. Lo que se busca es el verdadero si se cumple la condición 1 o se cumple la condición 2 o se cumple la condición 3 o... etc.\nEn el caso del operador OR, el resultado será verdadero cuando cualquiera de las condiciones dentro del If de como resultado verdadero. Ahora, cuándo el If se irá hacia el\nfalso? Cuando todas las condiciones den falso.\n\nNOT\nExiste un tercer operador lógico que es el operador de negación, cuyo símbolo es el \"!\" (signo de admiración). Este operador sirve para invertir (para negar) el resultado de\nuna condición lógica. De este modo, si la condición diera verdadero, el Not haría que se vaya para el falso.\n\nPor ejemplo:\n\nint a = 10\nif(!a==10){\n Console.WriteLine(\"no es igual a 10\");\n}\nelse{\n Console.WriteLine(\"ES igual a 10\");\n}\nContadores\nUn contador no es más que una variable que vamos a usar para realizar un conteo de algo. Por ejemplo: cuántas personas son mayores de 18, o cuántas personas se sacaron un 10 \nen la materia, etc.\n\nTodo conteo comienza desde un valor conocido, generalmente desde cero; es por eso que un de las prácticas a tener en cuenta a la hora de contar es inicializar la variable \nen cero. Inicializar significa dar un valor inicial. De ese modo nos garantizamos que el conteo arranca desde un valor determinado.\n\nContar es agregarle una unidad a una variable. Esto se puede hacer del siguiente modo:\n\nint a = 0;\na = a + 1;\na = a + 1;\na = a + 1;\nConsole.WriteLine(a);\nConsole.ReadLine();\nSi se observa, en este caso el valor de \"a\" comienza en cero y luego se realiza tres veces una suma de una unidad sobre la misma. Esto realiza un efecto de conteo ya que se \nva sumando de a uno. Al final, al mostrar el contenido de \"a\", el mismo será 3.\n\nLa idea de estos conteos es realizarlos, como se mencionó antes, de manera condicional, de modo tal que antes de contar se realizaría una comparación para identificar si hay\nque contar o no.\n\nPor ejemplo: evaluar tres edades y mostrar por pantalla cuántas son mayores a 18.\n\nint a = 16, b = 20, c = 33;\nint con = 0;\nif(a \u003e 18){\n con = con + 1;\n}\nif(b \u003e 18){\n con = con + 1;\n}\nif(c \u003e 18){\n con = con + 1;\n}\nConsole.WriteLine(\"La cantidad de mayores es: \" + con);\nConsole.ReadLine();\nEn este caso, el resultado por pantalla sería 2.\n\nOperador de incremento\nExiste un operador que nos permite simplificar el conteo aplicado a una variable. Ese operador se denomina operador de incremento, cuyo símbolo se representa con un doble más:\n++\n\nCon este operador, pasamos de tener\n\ncon = con + 1\na tener simplemente \n\ncon++\nEl ++ lo que hará es incrementar una unidad a cualquiera sea la variable y contenido que tenga a su izquierda. También existe su contraparte que corresponde a \"--\" (menos\nmenos) que lo que hace es exactamente lo opuesto: disminuir una unidad de la variable a la que se asigne.\n\nNótese que en este caso no aplica el uso de la asignación (operador =), ya que la misma se desarrolla de manera implícita.\n\nAcumuladores\nUn acumulador funciona de manera similar a un contador. La diferencia es que en este caso no se suma de a una unidad sino que se suman distintos valores y lo que escriba, se\nirá agregando a lo ya existente. Por ejemplo:\n\nint a = 0;\na = a + 10;\na = a + 3;\na = a + 5;\nConsole.WriteLine(a);\nConsole.ReadLine();\nEn este caso el resultado en pantalla será 18, la suma de todos los valores.\n\nDe la misma manera que el conteo, los acumuladores se suelen usar condicionalmente; y también contamos con un operador especial para resumir la instrucción. El operador de\nacumulación: +=.\n\nDe este modo, pasamos de tener:\n\na = a + 10;\na tener\n\na+=10;\nSon instrucciones que hace exactamente lo mismo, pero de una manera más compacta de escribir. También existe el operador para disminuir, y el mismo es el \"-=\".\n\nEl Switch\nEl switch es una herramienta de decisión que nos permite evaluar el contenido de una variable u operación y, a diferencia del If que nos permite solo una de dos opciones\nposibles (verdadero o falso), nos permite setear múltiples opciones posibles para el valor que se esté evaluando. Desde ya que una vez decidido el valor, se ejecutará un solo\ncamino como también sucede con el If.\n\nLa diferencia principal, además de la cantidad de opciones, es que e switch no hace uso de los operadores relacionales. Simplemente se evalúa un valor y se elige un camino\nposible dependiendo de lo que se haya evaluado.\n\nPor ejemplo: haremos un switch que reciba una variable y si la misma contiene un 1, mostrar Hola en pantalla, si tiene 2, mostrar Chau, si tiene 3 mostrar Blanco y si tiene 4\nmostrar Negro.\n\nint a = 3;\nSwitch(a){\ncase 1: \nConsole.WriteLine(\"Hola\");\nbreak;\ncase 2:\nConsole.WriteLine(\"Chau\");\nbreak;\ncase 3:\nConsole.WriteLine(\"Blanco\");\nbreak;\ncase 4:\nConsole.WriteLine(\"Negro\");\nbreak;\ndefault:\nConsole.WriteLine(\"Opción incorrecta\");\nbreak;\n}\nConsole.ReadLine();\nEste programa muestra por pantalla \"Blanco\", como pueden ver (también pueden copiar y probar el código en ejecución). Pueden ver dos particularidades: por un lado, contamos\ndentro de cada \"case\" el valor posible. En este caso cada \"case\" es cada brazo del Switch. Pero además, cada case al final cuenta con un break, que determina el final del\nmismo. Por otro lado, contamos con un último \"case\" denominado \"default\", que es por donde pasará la ejecución si el valor contenido en la variable que está siendo analizada \nno se corresponde con ninguna de las opciones seteadas.\n\n\nVideos 4\nEn este video seguimos resolviendo ejercicios pero en este caso sumando unos detalles más: los operadores lógicos, o concatenadores lógicos OR y AND (|| y \u0026\u0026 respectivamente).\n\nAdemás sumamos los conceptos de Acumulador y Contador.\n\nhttps://www.youtube.com/watch?v=cwonYFylSVk\n\nResolvemos algunos ejercicios haciendo uso de estos conceptos; https://www.youtube.com/watch?v=Ck_AlU2x5nc\n\nY finalmente, para cerrar la unidad de Condicionales 2, vemos una nueva herramienta: El Switch.\n\nhttps://www.youtube.com/watch?v=6hj-3F-s6ks\n\n\nEjercicios 4\nBueno, ya entramos en condicionales, así que ahora sí, vamos a codificar ejercicios con condiciones.\n\nLean atentamente y codifiquen las soluciones. Si van apareciendo dudas, me van consultando.\n\n1. Hacer un programa que solicite el ingreso de dos números y luego calcular:\n\nLa resta si el primero es mayor que el segundo.\nLa suma si son iguales.\nEl producto si el primero es menor.\nSe deberá emitir un cartel por pantalla con el resultado correspondiente.\n\n2. Un importante negocio de desinfectante líquido realiza descuentos dependiendo de la cantidad de litros vendidos según la siguiente escala:\n\nSi vende menos de 100 litros, no hay descuento.\nSi vende entre 101 y 300 litros, el descuento es del 10%.\nSi vende entre 301 y 500 litros, el descuento es del 15%.\nFinalmente, si la venta es de más de 500 litros, el descuento es del 25%.\nHacer un programa que solicite el ingreso del importe total de la venta y la cantidad de litros vendidos y calcule y emita el importe con el descuento aplicado..\n\n3. Una importante marca de computadoras permite elegir cierta configuración del equipo a comprar. Para ello existe la siguiente escala de precios:\n\ni5 (1)\ti7 (2)\ti9 (3)\n8 RAM (1)\tUSD 800\tUSD 900\tUSD 1200\n16 RAM (2)\tUSD 900\tUSD 1000\tUSD 1400\n32 RAM (3)\tUSD 1000\tUSD 1400\tUSD 2000\nAdemás, el equipo viene con un disco que permite almacenar 500 GB de información y que se puede ampliar a 1 TB si así lo desea, lo cual tiene un costo adicional de USD 300.\nHacer un programa que solicite la opción de procesador, la opción de memoria RAM, y si extiende el disco o no (ingresa 1 para extender y 0 para no extender) y calcule y emita\npor pantalla el monto de la máquina seleccionada.\n\n4. Hacer un programa para ingresar tres números y emitir un cartel aclaratorio si la suma de los dos primeros es mayor al producto del segundo con el tercero.\n\n5. Hacer un programa para ingresar 4 números. Luego analizar e informar por pantalla si los mismos se encuentran ordenados de forma decreciente .\n\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\nClase 5:\n\nMódulo 5 - Lectura\n\nCiclos\nUn ciclo es una herramienta de la programación que nos permite repetir la ejecución de cierta instrucción o cierto conjunto de instrucciones tantas veces como necesitemos. \n\nEs decir, al día de hoy, si quisiéramos mostrar un cartel \"Hola mundo\" en la pantalla 5 veces, podemos, pero tendríamos que hacer lo siguiente:\n\nConsole.WriteLine(\"Hola mundo\");\nConsole.WriteLine(\"Hola mundo\");\nConsole.WriteLine(\"Hola mundo\");\nConsole.WriteLine(\"Hola mundo\");\nConsole.WriteLine(\"Hola mundo\");\n\n\nEs decir, escribir cinco veces la misma línea de código. Con un ciclo (también conocidos como bucles) puedo programar escribir esa instrucción una sola vez pero que se ejecute\ncinco veces. O las veces que necesite. \n\n\nCiclo For\nHay distintos tipos de ciclos, vamos a comenzar con el ciclo exacto: el ciclo FOR.\n\nEl FOR es un ciclo que nos permite ejecutar un conjunto de instrucciones una cantidad de veces establecida. Por ejemplo cinco. Por ejemplo diez. De allí su calificación de\n\"ciclo exacto\", porque dará exactamente la cantidad de vueltas que esté configurado para dar.\n\nPara configurar un ciclo FOR vamos a necesitar contar con una variable, generalmente se usa como nombre para dicha variable las letras \"x\", \"y\" o \"z\" aunque también encontrarán\nmuy frecuentemente que la variable del FOR se denomina \"i\" (de \"iterar\", que significa ciclar, o dar una vuelta al ciclo).\n\nUna vez con la variable hay tres factores que se requiere configurar en un ciclo:\n\nInicialización.\nCondición.\nIncremento.\nCada una de estas acciones ya son conocidas por separado, pero en este caso van a estar trabajando en conjunto para poder configurar lo que se denomina \"reloj\" del ciclo y que\nserá lo que permita el funcionamiento del mecanismo del mismo.\n\nInicialización\nSe trata de dar un valor inicial a la variable del ciclo. Esta instrucción se ejecutará una sola vez en toda la vida del ciclo y es para darle un punto de partida al mismo. Se\npuede inicializar en cualquier valor, incluso en el valor de otra variable, aunque en una configuración regular, se suele incializar simplemente en cero.\n\nCondición\nLa condición es la instrucción que determinará si se sigue iterando o no. Se ejecuta previo a comenzar cada vuelta del ciclo y si da verdadero, se ejecuta la vuelta. Cuando sea\nfalso, se dará por terminado el ciclo. Aquí se puede asignar cualquier condición válida para un IF, ya que manejan exactamente el mismo formato, incluso se pueden agregar\noperadores lógicos. En una configuración regular se suele hacer una comparación del tipo \"menor a\" el valor cuya cantidad de vueltas se quiere dar. Por ejemplo \"x \u003c 5\" si\nquiero dar cinco vueltas.\n\nIncremento\nEl incremento es la instrucción que se encargará de modificar el valor de la variable del ciclo para que, eventualmente, la condición dé falso y el ciclo pueda concluir. De\notro modo, la condición dará siempre verdadero y el ciclo no terminaría, lo que sería un problema (se conoce como ciclo que tiende a infinito). Generalmente se utiliza un\nincremento de a una unidad (x++) aunque también puede variar.\n\nFuncionamiento\nCuando la ejecución de un programa se encuentra con un ciclo, lo primero que hace es reconocer cuál es la variable del mismo. Lo siguiente, y por única vez, es ejecutar la\ninicialización. Luego de eso ejecuta la condición y si la misma da verdadero, ingresa al ciclo y ejecuta todo lo que haya dentro. Dentro del ciclo pueden haber tantas\ninstrucciones como necesitemos, incluso otros ciclos, pero esto lo veremos más adelante. Luego de haber ejecutado todas las instrucciones dentro del ciclo y haber llegado al\nfinal del mismo, el próximo paso es el incremento. Una vez realizado, se vuelve a evaluar la condición, y si sigue dando verdadero, sigue entrando al ciclo. Así hasta que la\ncondición por fin dé falso.\n\nComo se ha dicho antes, cada una de las configuraciones cuenta con lo que llamaremos \"configuración estándar\", sin embargo se puede establecer valores de cualquier tipo en cada\nuna de ellas siempre y cuando se cumpla con la estructura respectiva. Hay que tener en cuenta que la cantidad de vueltas que dará el ciclo depende directamente de la\nconfiguración de su reloj, con lo cual tenemos que tener muy claro qué es lo que estamos configurando y por qué.\n\nConfiguración estándar\nSi queremos que un ciclo de diez vueltas, la configuración más sencilla sería:\n\nx = 0\nx \u003c 10\nx++\nDonde \"x\" arranca en cero, y en cada vuelta se preguntará si \"x\" es menor a diez. Mientras sea, se ingresa y se da una vuelta. Al final de cada vuelta se incrementará el valor\nde \"x\" en uno.\n\nEjemplo en código\nHagamos en código el ejemplo de mostrar cinco veces el hola mundo pero escribiendo una sola vez dicha instrucción:\n\nfor(x = 0; x \u003c 5; x++){\n Console.WriteLine(\"Hola mundo\");\n}\n\n\nLink de youtube: https://www.youtube.com/watch?v=v3rHho4ticQ\n\n\nCiclo While\nYa conocemos el Ciclo FOR. El mismo nos permite, a partir de una configuración previamente establecida, repetir un conjunto de instrucciones siempre y cuando conozcamos la\ncantidad de veces que necesitamos que el mismo se ejecute. Hay ocasiones en las que no se conocerá la cantidad de veces que un algoritmo deberá ser ejecutado; en dichos casos\nse utiliza otro tipo de ciclo, denominado ciclo inexacto, que repetirá el conjunto de instrucciones dado dependiendo de una condición establecida. Existen básicamente dos tipos\nde ciclos inexactos en la programación. Por un lado el While y por otro lado en Do While.\n\nEl ciclo While (del inglés “mientras”) comenzará a ciclar siempre y cuando la condición dada sea verdadera, y seguirá ciclando hasta tanto esa situación no cambie.\n\nint N = 0;\nwhile(n\u003c10){\n n++;\n Console.WriteLine(n);\n}\nEn el ejemplo se declara una variable inicializada en cero. Cuando el flujo se encuentra con el ciclo While, lo primero que se hace es evaluar la condición: “El contenido de la\nvariable, es menor a diez?”. Naturalmente en este momento la condición tiene como resultado un valor “TRUE”. Recordemos que una condición de este tipo puede adoptar sólo uno de\ndos valores (true o false. 1 o 0, etc.). Una vez dentro del ciclo, se ejecutan las instrucciones. Se incrementa el valor de la variable y se muestra en pantalla. Una vez\nconcluías estas dos instrucciones, se evaluará la condición nuevamente. El ciclo del ejemplo dejará de girar cuando la variable “N” sea igual a 10 (diez).\n\nCiclo Do While\n\nEste ciclo funciona casi de la misma manera que el ciclo While tradicional. La diferencia fundamental es que la primer vuelta se ejecutará siempre, y recién para la segunda es\nque la condición será evaluada para determinar si continuar ciclando o concluir el bloque. Un ejemplo codificado sería:\n\nint N = 0;\ndo{\n n++;\n}while(n\u003c10)\n\n\nLink de youtube: https://www.youtube.com/watch?v=HSUKndu5XAg\n\n\nVideos\nMuchachada, en este video aprendemos qué es el ciclo FOR, cómo funciona, para qué sirve y varios ejemplos de su funcionamiento!\nMirenlo, lean el apunte de la unidad, y arranquen a hacer los ejercicios de la guía 3\n\n\nArrancamos con ciclos! En el siguiente video vemos en qué consiste el ciclo FOR y cómo funciona paso a paso y súper detallado.\n\n\nLink de youtube: https://www.youtube.com/watch?v=v3rHho4ticQ\n\n\nLuego de entenderlo, vemos varios ejercicios para seguir mejorando la idea de iterar instrucciones.\n\n\nLink de youtube: https://www.youtube.com/watch?v=XXyXv6DR1xA\n\n\nLink de youtube: https://www.youtube.com/watch?v=AsRQmd9y6i8\n\n\nLink de youtube: https://www.youtube.com/watch?v=HSUKndu5XAg\n\n\nLink de youtube: https://www.youtube.com/watch?v=BX5DYuPfhOo\n\nMódulo 5 - Videos While\nGente, aquí va la explicación en video del ciclo inexacto While. \n\nhttps://www.youtube.com/watch?v=HSUKndu5XAg\n\nBueno, ejercicios resueltos de While. En este caso en un único video, pero punteado ejercicio por ejercicio. Muy importante para ver cómo se abordan, qué particularidades tener en cuenta y demás. A revisar!\n\nLista de ejercicios del video:\n\n00:00 👉Inicio\n03:00 👉 Ejercicio 1. Números 1 al 10.\n06:22 👉 Ejercicio 2. Números 10 a 1.\n07:33 👉 Ejercicio 3. Contador.\n09:57 👉 Ejercicio 4. Números entre el menor y el mayor.\n12:58 👉 Ejercicio 5. 1 a 100 de 5 en 5.\n13:59 👉 Ejercicio 6. Primo con While.\n16:01 👉 Ejercicio 7. Máximo y Posición. Cantidad de oros variable.\n21:50 👉 Ejercicio 8. Menor y segundo menor.\n31:43 👉 Ejercicio 9. Menor, segundo menor y sus posiciones.\n38:51 👉 Ejercicio 10. Máximo negativo, mínimo positivo. BANDERA.\n45:08 👉 Ejercicio 11. Contador. Ciclo dentro de ciclo.\n\nhttps://www.youtube.com/watch?v=BX5DYuPfhOo\n\nEjercicios 5\nComencemos a practicar con ciclos entonces!\n\nRecordá siempre leer atentamente lo que se pide en la consigna. Las consignas son cada vez más complejas, con lo cual seguramente vayan necesitando más lectura. Es decir, no\nalcanza con leer la consigna una sola vez para terminar de entender lo que pide. Puede que tengas que leerlas 5, 10, 15 veces o más. No te preocupes, hay que hacerlo!\n\n\n\n1. Hacer un programa para mostrar los números del 1 al 10. No se debe realizar ningún pedido de datos.\n\n2. Hacer un programa que solicite el ingreso de 10 números y que muestre el mayor de ellos por pantalla. Solo se debe emitir UN valor por pantalla.\n\n3. Hacer un programa que solicite 20 edades y luego calcule el promedio de edad de aquellas personas mayores a 18 años.\n\n4. Hacer un programa que solicite UN número y luego calcule y emita un cartel aclaratorio si el mismo es primo o no es primo. Nota: un numero es primo cuando es divisible\n únicamente por 1 y por sí mismo.\n\n5. Hacer un programa que solicite 20 números y luego emitir por pantalla el máximo de los números pares y el mínimo de los números impares.\n\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\nClase 6:\n\nBueno, comenzamos a trabajar con ciclos combinados y aquí les dejo una explicación con diagramas para que vean un poco más al respecto, además con algunos ejemplos adicionales\n\nhttps://www.youtube.com/watch?v=BX5DYuPfhOo\u0026list=PLQRFzsIQFmxrqL5ViA0k3rsR5H0oNKYxE\u0026index=15\n\n\nCorte de control\n\nEste tema es algo que no vamos a ver en este curso, pero que si tienen ganas y tiempo para ampliar sobre esto, les va a aportar bastante. Corte de control es básicamente una\n\"estrategia\" de manejo de datos a partir del uso de ciclos combinados. Les dejo un video en el que lo explico en detalle y, también, con varios ejemplos. Esto es un tema\nexclusivo que se suele ver en las carreras en la universidad.\n\nhttps://www.youtube.com/watch?v=VOjsn9liLKo\u0026list=PLQRFzsIQFmxrqL5ViA0k3rsR5H0oNKYxE\u0026index=18\n\nFinalmente, como siempre, una serie de ejercicios resueltos para ir viendo cómo es la cuestión. Pueden verlos, analizarlos, llevarlos al código y chequear su funcionamiento.\n\nhttps://www.youtube.com/watch?v=HnFENssh9-I\u0026list=PLQRFzsIQFmxrqL5ViA0k3rsR5H0oNKYxE\u0026index=19\n\nEjercicios 6\nLes dejo algunos ejercicios de ciclos combinados. Ya son un poco más largos y complejos, así que serán menos así tratan de hacerlos en la semana. Lo que sí, analicen bien ya que tendrán que determinar qué tipo de combinación de ciclos deben aplicar, es decir, si for con for, o for con while, etc.\n\n1. Hacer un programa para ingresar 10 números. El mismo debe analizar y mostrar por pantalla cuántos de esos números son primos.\n\n2. Se dispone de una lista de 5 listas de números enteros separados entre ellos por ceros. Se pide determinar e informar:\n\nEl número de grupo con mayor porcentaje de números impares respecto al total de números que forman el grupo.\nInformar cuántos grupos están formados por todos números ordenados de mayor a menor.\n3. Hacer un programa para recibir listas de números positivos que están separadas entre sí por un cero. El fin de la carga se notifica con un número negativo. Luego mostrar cuántos números tiene cada lista.\n\nhttps://www.youtube.com/watch?v=k12fjsyjah0 Ejercicio 1\n\nhttps://www.youtube.com/watch?v=VVictUqVRtI Ejercicio 2\n\nhttps://www.youtube.com/watch?v=efe2ud9rT7k Ejercicio 3\n\n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\nClase 7:\n\nVectores\nComenzamos con Vectores. Un tipo de variable especial, dimensional, que nos permite guardar muchos valores bajo un mismo pseudónimo de variable...\n\nhttps://www.youtube.com/watch?v=B-KRYhDRnt0\n\nEjercicios resueltos\nComo siempre, una serie de ejercicios para practicar lo aprendido.\n00:00 Inicio.\n01:10 Ejercicio 1. Guardar 10 números y mostrar la suma.\n06:07 Ejercicio 2. Guardar 50 números. Buscar máximo y posición.\n10:00 Ejercicio 3. Guardar 100 números. Calcular promedio, mostrar los mayores.\n12:30 Ejercicio 4. Guardar 20 números. Determinar si está ordenado.\n16:58 Ejercicio 5. Vector de valores Char. Intercambiar caracteres dados.\n30:12 Ejercicio 6. Guardar 10 números y buscar repetidos.\n37:23 Ejercicio 7. Registros de ventas. Lote y puntos a, b y c.\n57:32 Ejercicio 8. Ordenar Vector.\n\nhttps://www.youtube.com/watch?v=AYVpDkVMdVg\n\nhttps://www.youtube.com/watch?v=-MywsWPHmSI\n\nArray Class\nDefinition\nNamespace:\nSystem\nAssembly:\nSystem.Runtime.dll\nProvides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.\n\nC#\n\nCopy\npublic abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable\nInheritance\nObject\nArray\nImplements\nICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable\nExamples\nThe following code example shows how Array.Copy copies elements between an array of type integer and an array of type Object.\n\nC#\n\nCopy\n\nRun\nusing System;\npublic class SamplesArray\n{\n\n public static void Main()\n {\n\n // Creates and initializes a new integer array and a new Object array.\n int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };\n Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };\n\n // Prints the initial values of both arrays.\n Console.WriteLine(\"Initially,\");\n Console.Write(\"integer array:\");\n PrintValues(myIntArray);\n Console.Write(\"Object array: \");\n PrintValues(myObjArray);\n\n // Copies the first two elements from the integer array to the Object array.\n System.Array.Copy(myIntArray, myObjArray, 2);\n\n // Prints the values of the modified arrays.\n Console.WriteLine(\"\\nAfter copying the first two elements of the integer array to the Object array,\");\n Console.Write(\"integer array:\");\n PrintValues(myIntArray);\n Console.Write(\"Object array: \");\n PrintValues(myObjArray);\n\n // Copies the last two elements from the Object array to the integer array.\n System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2);\n\n // Prints the values of the modified arrays.\n Console.WriteLine(\"\\nAfter copying the last two elements of the Object array to the integer array,\");\n Console.Write(\"integer array:\");\n PrintValues(myIntArray);\n Console.Write(\"Object array: \");\n PrintValues(myObjArray);\n }\n\n public static void PrintValues(Object[] myArr)\n {\n foreach (Object i in myArr)\n {\n Console.Write(\"\\t{0}\", i);\n }\n Console.WriteLine();\n }\n\n public static void PrintValues(int[] myArr)\n {\n foreach (int i in myArr)\n {\n Console.Write(\"\\t{0}\", i);\n }\n Console.WriteLine();\n }\n}\n/*\nThis code produces the following output.\n\nInitially,\ninteger array: 1 2 3 4 5\nObject array: 26 27 28 29 30\n\nAfter copying the first two elements of the integer array to the Object array,\ninteger array: 1 2 3 4 5\nObject array: 1 2 28 29 30\n\nAfter copying the last two elements of the Object array to the integer array,\ninteger array: 1 2 3 29 30\nObject array: 1 2 28 29 30\n*/\nThe following code example creates and initializes an Array and displays its properties and its elements.\n\nC#\n\nCopy\n\nRun\n// Creates and initializes a new three-dimensional Array of type int.\nArray myArr = Array.CreateInstance(typeof(int), 2, 3, 4);\nfor (int i = myArr.GetLowerBound(0); i \u003c= myArr.GetUpperBound(0); i++)\n{\n for (int j = myArr.GetLowerBound(1); j \u003c= myArr.GetUpperBound(1); j++)\n {\n for (int k = myArr.GetLowerBound(2); k \u003c= myArr.GetUpperBound(2); k++)\n {\n myArr.SetValue((i * 100) + (j * 10) + k, i, j, k);\n }\n }\n}\n\n// Displays the properties of the Array.\nConsole.WriteLine(\"The Array has {0} dimension(s) and a total of {1} elements.\", myArr.Rank, myArr.Length);\nConsole.WriteLine(\"\\tLength\\tLower\\tUpper\");\nfor (int i = 0; i \u003c myArr.Rank; i++)\n{\n Console.Write(\"{0}:\\t{1}\", i, myArr.GetLength(i));\n Console.WriteLine(\"\\t{0}\\t{1}\", myArr.GetLowerBound(i), myArr.GetUpperBound(i));\n}\n\n// Displays the contents of the Array.\nConsole.WriteLine(\"The Array contains the following values:\");\nPrintValues(myArr);\n\nvoid PrintValues(Array myArray)\n{\n System.Collections.IEnumerator myEnumerator = myArray.GetEnumerator();\n int i = 0;\n int cols = myArray.GetLength(myArray.Rank - 1);\n while (myEnumerator.MoveNext())\n {\n if (i \u003c cols)\n {\n i++;\n }\n else\n {\n Console.WriteLine();\n i = 1;\n }\n Console.Write(\"\\t{0}\", myEnumerator.Current);\n }\n Console.WriteLine();\n}\n// This code produces the following output.\n\n// The Array has 3 dimension(s) and a total of 24 elements.\n// Length Lower Upper\n// 0: 2 0 1\n// 1: 3 0 2\n// 2: 4 0 3\n//\n// The Array contains the following values:\n// 0 1 2 3\n// 10 11 12 13\n// 20 21 22 23\n// 100 101 102 103\n// 110 111 112 113\n// 120 121 122 123\nRemarks\nThe Array class is not part of the System.Collections namespaces. However, it is still considered a collection because it is based on the IList interface.\n\nThe Array class is the base class for language implementations that support arrays. However, only the system and compilers can derive explicitly from the Array class. Users should employ the array constructs provided by the language.\n\nAn element is a value in an Array. The length of an Array is the total number of elements it can contain. The lower bound of an Array is the index of its first element. An Array can have any lower bound, but it has a lower bound of zero by default. A different lower bound can be defined when creating an instance of the Array class using CreateInstance. A multidimensional Array can have different bounds for each dimension. An array can have a maximum of 32 dimensions.\n\nUnlike the classes in the System.Collections namespaces, Array has a fixed capacity. To increase the capacity, you must create a new Array object with the required capacity, copy the elements from the old Array object to the new one, and delete the old Array.\n\nThe array size is limited to a total of 4 billion elements, and to a maximum index of 0X7FEFFFFF in any given dimension (0X7FFFFFC7 for byte arrays and arrays of single-byte structures).\n\n.NET Framework only: By default, the maximum size of an Array is 2 gigabytes (GB). In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment.\n\nSingle-dimensional arrays implement the System.Collections.Generic.IList\u003cT\u003e, System.Collections.Generic.ICollection\u003cT\u003e, System.Collections.Generic.IEnumerable\u003cT\u003e, System.Collections.Generic.IReadOnlyList\u003cT\u003e and System.Collections.Generic.IReadOnlyCollection\u003cT\u003e generic interfaces. The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class. In addition, there are no reference topics for interface members that are accessible only by casting an array to the generic interface type (explicit interface implementations). The key thing to be aware of when you cast an array to one of these interfaces is that members which add, insert, or remove elements throw NotSupportedException.\n\nType objects provide information about array type declarations. Array objects with the same array type share the same Type object.\n\nType.IsArray and Type.GetElementType might not return the expected results with Array because if an array is cast to the type Array, the result is an object, not an array. That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.\n\nThe Array.Copy method copies elements not only between arrays of the same type but also between standard arrays of different types; it handles type casting automatically.\n\nSome methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLength and GetLongLength return 64-bit integers indicating the length of the array.\n\nThe Array is not guaranteed to be sorted. You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.\n\nUsing an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.\n\nProperties\nPROPERTIES\nIsFixedSize\t\nGets a value indicating whether the Array has a fixed size.\n\nIsReadOnly\t\nGets a value indicating whether the Array is read-only.\n\nIsSynchronized\t\nGets a value indicating whether access to the Array is synchronized (thread safe).\n\nLength\t\nGets the total number of elements in all the dimensions of the Array.\n\nLongLength\t\nGets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.\n\nRank\t\nGets the rank (number of dimensions) of the Array. For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.\n\nSyncRoot\t\nGets an object that can be used to synchronize access to the Array.\n\nMethods\nMETHODS\nAsReadOnly\u003cT\u003e(T[])\t\nReturns a read-only wrapper for the specified array.\n\nBinarySearch(Array, Int32, Int32, Object)\t\nSearches a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value.\n\nBinarySearch(Array, Int32, Int32, Object, IComparer)\t\nSearches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.\n\nBinarySearch(Array, Object)\t\nSearches an entire one-dimensional sorted array for a specific element, using the IComparable interface implemented by each element of the array and by the specified object.\n\nBinarySearch(Array, Object, IComparer)\t\nSearches an entire one-dimensional sorted array for a value using the specified IComparer interface.\n\nBinarySearch\u003cT\u003e(T[], Int32, Int32, T)\t\nSearches a range of elements in a one-dimensional sorted array for a value, using the IComparable\u003cT\u003e generic interface implemented by each element of the Array and by the specified value.\n\nBinarySearch\u003cT\u003e(T[], Int32, Int32, T, IComparer\u003cT\u003e)\t\nSearches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer\u003cT\u003e generic interface.\n\nBinarySearch\u003cT\u003e(T[], T)\t\nSearches an entire one-dimensional sorted array for a specific element, using the IComparable\u003cT\u003e generic interface implemented by each element of the Array and by the specified object.\n\nBinarySearch\u003cT\u003e(T[], T, IComparer\u003cT\u003e)\t\nSearches an entire one-dimensional sorted array for a value using the specified IComparer\u003cT\u003e generic interface.\n\nClear(Array, Int32, Int32)\t\nSets a range of elements in an array to the default value of each element type.\n\nClone()\t\nCreates a shallow copy of the Array.\n\nConstrainedCopy(Array, Int32, Array, Int32, Int32)\t\nCopies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Guarantees that all changes are undone if the copy does not succeed completely.\n\nConvertAll\u003cTInput,TOutput\u003e(TInput[], Converter\u003cTInput,TOutput\u003e)\t\nConverts an array of one type to an array of another type.\n\nCopy(Array, Array, Int32)\t\nCopies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. The length is specified as a 32-bit integer.\n\nCopy(Array, Array, Int64)\t\nCopies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. The length is specified as a 64-bit integer.\n\nCopy(Array, Int32, Array, Int32, Int32)\t\nCopies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. The length and the indexes are specified as 32-bit integers.\n\nCopy(Array, Int64, Array, Int64, Int64)\t\nCopies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. The length and the indexes are specified as 64-bit integers.\n\nCopyTo(Array, Int32)\t\nCopies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. The index is specified as a 32-bit integer.\n\nCopyTo(Array, Int64)\t\nCopies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. The index is specified as a 64-bit integer.\n\nCreateInstance(Type, Int32)\t\nCreates a one-dimensional Array of the specified Type and length, with zero-based indexing.\n\nCreateInstance(Type, Int32, Int32)\t\nCreates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.\n\nCreateInstance(Type, Int32, Int32, Int32)\t\nCreates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.\n\nCreateInstance(Type, Int32[])\t\nCreates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. The dimension lengths are specified in an array of 32-bit integers.\n\nCreateInstance(Type, Int32[], Int32[])\t\nCreates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.\n\nCreateInstance(Type, Int64[])\t\nCreates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. The dimension lengths are specified in an array of 64-bit integers.\n\nEmpty\u003cT\u003e()\t\nReturns an empty array.\n\nEquals(Object)\t\nDetermines whether the specified object is equal to the current object.\n\n(Inherited from Object)\nExists\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nDetermines whether the specified array contains elements that match the conditions defined by the specified predicate.\n\nFill\u003cT\u003e(T[], T)\t\nAssigns the given value of type T to each element of the specified array.\n\nFill\u003cT\u003e(T[], T, Int32, Int32)\t\nAssigns the given value of type T to the elements of the specified array which are within the range of startIndex (inclusive) and the next count number of indices.\n\nFind\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.\n\nFindAll\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nRetrieves all the elements that match the conditions defined by the specified predicate.\n\nFindIndex\u003cT\u003e(T[], Int32, Int32, Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that starts at the specified index and contains the specified number of elements.\n\nFindIndex\u003cT\u003e(T[], Int32, Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that extends from the specified index to the last element.\n\nFindIndex\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire Array.\n\nFindLast\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire Array.\n\nFindLastIndex\u003cT\u003e(T[], Int32, Int32, Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.\n\nFindLastIndex\u003cT\u003e(T[], Int32, Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.\n\nFindLastIndex\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nSearches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire Array.\n\nForEach\u003cT\u003e(T[], Action\u003cT\u003e)\t\nPerforms the specified action on each element of the specified array.\n\nGetEnumerator()\t\nReturns an IEnumerator for the Array.\n\nGetHashCode()\t\nServes as the default hash function.\n\n(Inherited from Object)\nGetLength(Int32)\t\nGets a 32-bit integer that represents the number of elements in the specified dimension of the Array.\n\nGetLongLength(Int32)\t\nGets a 64-bit integer that represents the number of elements in the specified dimension of the Array.\n\nGetLowerBound(Int32)\t\nGets the index of the first element of the specified dimension in the array.\n\nGetType()\t\nGets the Type of the current instance.\n\n(Inherited from Object)\nGetUpperBound(Int32)\t\nGets the index of the last element of the specified dimension in the array.\n\nGetValue(Int32)\t\nGets the value at the specified position in the one-dimensional Array. The index is specified as a 32-bit integer.\n\nGetValue(Int32, Int32)\t\nGets the value at the specified position in the two-dimensional Array. The indexes are specified as 32-bit integers.\n\nGetValue(Int32, Int32, Int32)\t\nGets the value at the specified position in the three-dimensional Array. The indexes are specified as 32-bit integers.\n\nGetValue(Int32[])\t\nGets the value at the specified position in the multidimensional Array. The indexes are specified as an array of 32-bit integers.\n\nGetValue(Int64)\t\nGets the value at the specified position in the one-dimensional Array. The index is specified as a 64-bit integer.\n\nGetValue(Int64, Int64)\t\nGets the value at the specified position in the two-dimensional Array. The indexes are specified as 64-bit integers.\n\nGetValue(Int64, Int64, Int64)\t\nGets the value at the specified position in the three-dimensional Array. The indexes are specified as 64-bit integers.\n\nGetValue(Int64[])\t\nGets the value at the specified position in the multidimensional Array. The indexes are specified as an array of 64-bit integers.\n\nIndexOf(Array, Object)\t\nSearches for the specified object and returns the index of its first occurrence in a one-dimensional array.\n\nIndexOf(Array, Object, Int32)\t\nSearches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. The range extends from a specified index to the end of the array.\n\nIndexOf(Array, Object, Int32, Int32)\t\nSearches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. The range extends from a specified index for a specified number of elements.\n\nIndexOf\u003cT\u003e(T[], T)\t\nSearches for the specified object and returns the index of its first occurrence in a one-dimensional array.\n\nIndexOf\u003cT\u003e(T[], T, Int32)\t\nSearches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. The range extends from a specified index to the end of the array.\n\nIndexOf\u003cT\u003e(T[], T, Int32, Int32)\t\nSearches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. The range extends from a specified index for a specified number of elements.\n\nInitialize()\t\nInitializes every element of the value-type Array by calling the parameterless constructor of the value type.\n\nLastIndexOf(Array, Object)\t\nSearches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.\n\nLastIndexOf(Array, Object, Int32)\t\nSearches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that extends from the first element to the specified index.\n\nLastIndexOf(Array, Object, Int32, Int32)\t\nSearches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that contains the specified number of elements and ends at the specified index.\n\nLastIndexOf\u003cT\u003e(T[], T)\t\nSearches for the specified object and returns the index of the last occurrence within the entire Array.\n\nLastIndexOf\u003cT\u003e(T[], T, Int32)\t\nSearches for the specified object and returns the index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.\n\nLastIndexOf\u003cT\u003e(T[], T, Int32, Int32)\t\nSearches for the specified object and returns the index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.\n\nMemberwiseClone()\t\nCreates a shallow copy of the current Object.\n\n(Inherited from Object)\nResize\u003cT\u003e(T[], Int32)\t\nChanges the number of elements of a one-dimensional array to the specified new size.\n\nReverse(Array)\t\nReverses the sequence of the elements in the entire one-dimensional Array.\n\nReverse(Array, Int32, Int32)\t\nReverses the sequence of a subset of the elements in the one-dimensional Array.\n\nReverse\u003cT\u003e(T[])\t\nReverses the sequence of the elements in the one-dimensional generic array.\n\nReverse\u003cT\u003e(T[], Int32, Int32)\t\nReverses the sequence of a subset of the elements in the one-dimensional generic array.\n\nSetValue(Object, Int32)\t\nSets a value to the element at the specified position in the one-dimensional Array. The index is specified as a 32-bit integer.\n\nSetValue(Object, Int32, Int32)\t\nSets a value to the element at the specified position in the two-dimensional Array. The indexes are specified as 32-bit integers.\n\nSetValue(Object, Int32, Int32, Int32)\t\nSets a value to the element at the specified position in the three-dimensional Array. The indexes are specified as 32-bit integers.\n\nSetValue(Object, Int32[])\t\nSets a value to the element at the specified position in the multidimensional Array. The indexes are specified as an array of 32-bit integers.\n\nSetValue(Object, Int64)\t\nSets a value to the element at the specified position in the one-dimensional Array. The index is specified as a 64-bit integer.\n\nSetValue(Object, Int64, Int64)\t\nSets a value to the element at the specified position in the two-dimensional Array. The indexes are specified as 64-bit integers.\n\nSetValue(Object, Int64, Int64, Int64)\t\nSets a value to the element at the specified position in the three-dimensional Array. The indexes are specified as 64-bit integers.\n\nSetValue(Object, Int64[])\t\nSets a value to the element at the specified position in the multidimensional Array. The indexes are specified as an array of 64-bit integers.\n\nSort(Array)\t\nSorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.\n\nSort(Array, Array)\t\nSorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.\n\nSort(Array, Array, IComparer)\t\nSorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.\n\nSort(Array, Array, Int32, Int32)\t\nSorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.\n\nSort(Array, Array, Int32, Int32, IComparer)\t\nSorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.\n\nSort(Array, IComparer)\t\nSorts the elements in a one-dimensional Array using the specified IComparer.\n\nSort(Array, Int32, Int32)\t\nSorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.\n\nSort(Array, Int32, Int32, IComparer)\t\nSorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.\n\nSort\u003cT\u003e(T[])\t\nSorts the elements in an entire Array using the IComparable\u003cT\u003e generic interface implementation of each element of the Array.\n\nSort\u003cT\u003e(T[], Comparison\u003cT\u003e)\t\nSorts the elements in an Array using the specified Comparison\u003cT\u003e.\n\nSort\u003cT\u003e(T[], IComparer\u003cT\u003e)\t\nSorts the elements in an Array using the specified IComparer\u003cT\u003e generic interface.\n\nSort\u003cT\u003e(T[], Int32, Int32)\t\nSorts the elements in a range of elements in an Array using the IComparable\u003cT\u003e generic interface implementation of each element of the Array.\n\nSort\u003cT\u003e(T[], Int32, Int32, IComparer\u003cT\u003e)\t\nSorts the elements in a range of elements in an Array using the specified IComparer\u003cT\u003e generic interface.\n\nSort\u003cTKey,TValue\u003e(TKey[], TValue[])\t\nSorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable\u003cT\u003e generic interface implementation of each key.\n\nSort\u003cTKey,TValue\u003e(TKey[], TValue[], IComparer\u003cTKey\u003e)\t\nSorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer\u003cT\u003e generic interface.\n\nSort\u003cTKey,TValue\u003e(TKey[], TValue[], Int32, Int32)\t\nSorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable\u003cT\u003e generic interface implementation of each key.\n\nSort\u003cTKey,TValue\u003e(TKey[], TValue[], Int32, Int32, IComparer\u003cTKey\u003e)\t\nSorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer\u003cT\u003e generic interface.\n\nToString()\t\nReturns a string that represents the current object.\n\n(Inherited from Object)\nTrueForAll\u003cT\u003e(T[], Predicate\u003cT\u003e)\t\nDetermines whether every element in the array matches the conditions defined by the specified predicate.\n\nExplicit Interface Implementations\nEXPLICIT INTERFACE IMPLEMENTATIONS\nICollection.Count\t\nGets the number of elements contained in the Array.\n\nIList.Add(Object)\t\nCalling this method always throws a NotSupportedException exception.\n\nIList.Clear()\t\nRemoves all items from the IList.\n\nIList.Contains(Object)\t\nDetermines whether an element is in the IList.\n\nIList.IndexOf(Object)\t\nDetermines the index of a specific item in the IList.\n\nIList.Insert(Int32, Object)\t\nInserts an item to the IList at the specified index.\n\nIList.Item[Int32]\t\nGets or sets the element at the specified index.\n\nIList.Remove(Object)\t\nRemoves the first occurrence of a specific object from the IList.\n\nIList.RemoveAt(Int32)\t\nRemoves the IList item at the specified index.\n\nIStructuralComparable.CompareTo(Object, IComparer)\t\nDetermines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.\n\nIStructuralEquatable.Equals(Object, IEqualityComparer)\t\nDetermines whether an object is equal to the current instance.\n\nIStructuralEquatable.GetHashCode(IEqualityComparer)\t\nReturns a hash code for the current instance.\n\nExtension Methods\nEXTENSION METHODS\nCast\u003cTResult\u003e(IEnumerable)\t\nCasts the elements of an IEnumerable to the specified type.\n\nOfType\u003cTResult\u003e(IEnumerable)\t\nFilters the elements of an IEnumerable based on a specified type.\n\nAsParallel(IEnumerable)\t\nEnables parallelization of a query.\n\nAsQueryable(IEnumerable)\t\nConverts an IEnumerable to an IQueryable.\n\nApplies to\nAPPLIES TO\nProduct\tVersions\n.NET\t5.0, 6.0 RC 1\n.NET Core\t1.0, 1.1, 2.0, 2.1, 2.2, 3.0, 3.1\n.NET Framework\t1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8\n.NET Standard\t1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1\nUWP\t10.0\nXamarin.Android\t7.1\nXamarin.iOS\t10.8\nXamarin.Mac\t3.0\nThread Safety\nPublic static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.\n\nThis implementation does not provide a synchronized (thread safe) wrapper for an Array; however, .NET classes based on Array provide their own synchronized version of the collection using the SyncRoot property.\n\nEnumerating through a collection is intrinsically not a thread-safe procedure. Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.\n \n Ejercicios 7\nBueno, veamos algunos ejercicios para practicar lo visto!\n\n1. Hacer un programa que solicite 10 números enteros y los guarde en un vector. Luego recorrer los elementos y determinar e informar cuál es el valor máximo y su posición dentro del vector.\n\n2. Hacer un programa que solicite 10 números enteros y los guarde en un vector. Luego recorrer ese vector para calcular el promedio. Mostrar por pantalla los valores que son mayores al promedio.\n\n3. Hacer un programa que solicite una cadena de caracteres y dos caracteres sueltos (tres ingresos). El programa deberá generar una cadena donde todas las ocurrencias del primer carácter dado hayan sido reemplazadas por el segundo. Mostrar el resultado en pantalla. Ejemplo:\nCADENA FUENTE: “La mar estaba serena\"\nCARÁCTER 1: ‘a’ CARÁCTER 2: ‘i’\nCADENA RESULTADO: “Li mir estibi sereni\"\n\n4. Una empresa comercializa 15 tipos de artículos y por cada venta realizada genera un registro con los siguientes datos:\n- Número de Artículo (1 a 15)\n- Cantidad Vendida \n\nPuede haber varios registros para el mismo artículo y el último se indica con número de artículo igual a 0.\nSe pide determinar e informar:\na) El número de artículo que más se vendió en total.\nb) Los números de artículos que no registraron ventas.\nc) Cuantas unidades se vendieron del número de artículo 10.\n\n https://www.youtube.com/watch?v=1BeeaZ416vc Ejercicio 1\n \n https://www.youtube.com/watch?v=dMo3zl6-hKU Ejercicio 2\n \n https://www.youtube.com/watch?v=EqK7dppFR2M Ejercicio 3\n \n https://www.youtube.com/watch?v=_8BG8TKj1Ss Ejercicio 4\n \n Cadenas de caracteres\nBueno, como ya habremos hablado, este es un manejo de cadenas a bajo nivel, bien manual; pero entenderlo nos da una amplitud mayor sobre el funcionamiento de ciertas cosas en programación. Es completamente opcional, aunque te recomiendo que lo chequees. Es un tema que vemos obligatoriamente en la carrera de programación en la uni.\n \n \n \n--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n Clase 8:\n \n Módulo 8 - Videos\nLes dejo un video en el que explico el concepto de funciones de manera detallada junto a todas sus particularidades. Scope, parámetros por valor, por referencia, tipos, return, etc! \n \n https://www.youtube.com/watch?v=7X6qzA7pssw\n \n Y por otro lado, una serie de ejercicios resueltos. Todo en diagrama, pero con la práctica que veamos en la clase, lo pueden codificar e ir probando todo! Adelante!\n \n https://www.youtube.com/watch?v=jbgGa96R7Vc\n \n Ejercicios 8\nEn este caso, la idea va a ser armar una función que resuelva algo y luego armar un main que interactúe con una persona para pedir y mostrar datos pero que llame a esa función para resolver lo planteado. Vamos?\n\n1. Hacer una función llamada “producto” que reciba dos números enteros y que devuelva el producto de ambos. Luego hacer un programa que pida el precio de un artículo y la cantidad vendida y muestre por pantalla el monto total a pagar. Usar la función.\n\n2. Hacer una función llamada “par” que reciba un número entero y devuelva 1 si es par o cero si no lo es. Hacer un programa para ingresar 20 números y mostrar por pantalla cuántos son pares.\n\n3. Hacer una función llamada “primo” que reciba un núm","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Faxelop96%2Fc-sharp","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Faxelop96%2Fc-sharp","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Faxelop96%2Fc-sharp/lists"}