text
stringlengths 0
2.85k
| source
stringclasses 1
value |
|---|---|
ILERNA, centro autorizado con código 25002775 (Lleida), 28077294 (Madrid) y 41023090 (Sevilla)PROGRAMACIÓN-A www. ilerna. es Administr Ación de sistem As informáticos en red des Arrollo de Aplic Aciones multipl At Aform A des Arrollo de Aplic Aciones web | DAW Modulo 03 - Programacion A.pdf |
© Ilerna Online S. L., 2023 Maquetado e impreso por Ilerna Online S. L. © Imágenes: Shutterstock Impreso en España-Printed in Spain Reservado todos los derechos. No se permite la reproducción total o parcial de esta obra, ni su incorporación a un sistema informático, ni su transmisión en cualquier forma o por cualquier medio (electrónico, mecánico, fotoco-pia, grabación u otros) sin autorización previa y por escrito de los titulares del copyright. La infracción de dichos derechos puede constituir un delito contra la propiedad intelectual. Ilerna Online S. L. ha puesto todos los recursos necesarios para reconocer los derechos de terceros en esta obra y se excusa con antelación por posibles errores u omisiones y queda a disposición de corregirlos en posteriores ediciones. 2. a edición: marzo 2023 | DAW Modulo 03 - Programacion A.pdf |
1. Introducción a la programación....................................................... 6 2. Estructura de un programa informático......................................... 16 2. 1. Bloques de un programa informático........................................ 19 2. 2. Variables. Usos y tipos ............................................................... 25 2. 3. Constantes y literales. Tipos y utilidades................................... 28 2. 4. Operadores del lenguaje de programación............................... 30 2. 5. Conversiones de tipos de clase.................................................. 34 2. 6. Comentarios al código................................................................ 37 3. Programación estructurada........................................................... 40 3. 1. Fundamentos de programación................................................. 42 3. 2. Introducción a la algoritmia y herramientas de diseño............ 43 3. 3. Ciclo de vida de un proyecto software...................................... 43 3. 4. Prueba de programas.................................................................. 45 3. 5. Tipos de datos: simples y compuestos...................................... 46 3. 6. Estructuras de selección (instrucciones condicionales)........... 50 3. 7. Estructuras de repetición ........................................................... 54 3. 8. Estructuras de salto..................................................................... 57 3. 9. Tratamiento de cadenas............................................................. 58 3. 10. Depuración de errores................................................................ 61 3. 11. Documentación de programas................................................... 63 3. 12. Entornos de desarrollo de programas........................................ 65 4. Programación modular................................................................... 66 4. 1. Concepto..................................................................................... 67 4. 2. Ventajas e inconvenientes.......................................................... 67 4. 3. Análisis descendente (top down)............................................... 68 4. 4. Modulación de programas. Subprogramas............................... 69 4. 5. Llamadas a funciones (métodos). Tipos y funcionamiento...... 71 4. 6. Ámbito de las llamadas a funciones.......................................... 79 4. 7. Prueba, depuración y comentarios de programas.................... 83 4. 8. Concepto de librerías.................................................................. 86 4. 9. Uso de librerías............................................................................ 89 4. 10. Introducción al concepto de recursividad................................. 91ÍNDICE Programación-A | DAW Modulo 03 - Programacion A.pdf |
5. Gestión de ficheros......................................................................... 96 5. 1. Concepto y tipos de ficheros...................................................... 97 5. 2. Diseño y modulación de las operaciones sobre ficheros........ 103 5. 3. Operaciones sobre ficheros secuenciales................................ 106 5. 4. Control de excepciones............................................................. 115 Bibliografía / webgrafía.................................................................... 116 Solucionario ...................................................................................... 117 | DAW Modulo 03 - Programacion A.pdf |
DAW Modulo 03 - Programacion A.pdf |
|
1 INTRODUCCIÓN A LA PROGRAMACIÓN | DAW Modulo 03 - Programacion A.pdf |
Programación-A 77Un programa es un conjunto de instrucciones dadas al or-denador en un lenguaje que solo es entendible por él para comunicarle lo que queremos que haga. Un algoritmo es una secuencia finita de operaciones que resuelven un de-terminado problema. Un algoritmo es más parecido a una idea, una forma de resolver un problema, mientras que un programa está más relacionado con la realización de una o más tareas por parte de un ordenador. Un programa debe cumplir una serie de características: Deber ser finito: formado por un conjunto limitado de sentencias. Debe ser legible: es importante crear códigos limpios y fáciles de leer con tabulaciones y espacios que diferen-cien las partes del programa. Debe ser modificable: debe ser sencillo el proceso de ac-tualización o modificación ante nuevas necesidades. Debe ser eficiente: debemos crear programas que ocu-pen poco espacio en memoria y se ejecuten rápidamente. Debe ser modulable: debemos realizar algoritmos que se dividan a su vez en subalgoritmos de forma que se dis-ponga de un grupo principal desde el que llamaremos al resto. Así, incitamos a la reutilización de código. Debe ser estructurado: engloba a las características an-teriores, ya que un programa estructurado será fácil de leer y modificar, y estará compuesto de subprogramas que permitirán la reutilización de código. | DAW Modulo 03 - Programacion A.pdf |
Tema 1: Introducción a la programación8Representaciones gráficas Para representar un algoritmo, podemos utilizar dos herramientas gráficas: los diagramas de flujo y el pseu-docódigo. Un diagrama de flujo es una representación gráfica de un proceso. Cada paso del proceso se representa con un sím-bolo diferente que contiene una breve descripción. Debemos usar una serie de símbolos estándar: Indican inicio o fin de programa. Representan una instrucción, un paso a dar o un proceso. Por ejemplo: cont= cont+1. Operaciones de entrada/salida de datos. Por ejemplo: visuali-za en pantalla suma. Usaremos este símbolo si nos encontramos en un punto en el que se realizará una u otra acción en función de una decisión. Por ejemplo, si mi Variable= 0, hacemos la instrucción 1. Si no, hacemos la instrucción 2. Conector. Permite unir diferentes zonas del diagrama de forma que se redefine el flujo de ejecución hacia otra parte del diagrama. Representa un método o subprograma. Flechas para indicar la dirección de flujo. | DAW Modulo 03 - Programacion A.pdf |
Programación-A9Características de los diagramas de flujo: Deben escribirse de arriba abajo o de izquierda a derecha. Debemos evitar el cruce de líneas, para eso se define la forma de conector. El uso de conectores debe producirse cuando no exista otra opción. Todas las líneas de flujo deben estar conectadas a algún objeto. El texto que se escribe en las formas debe ser escueto y legible. Todos los símbolos de decisión deben tener más de una línea de salida, es decir, deben indicar qué camino seguir en función de la decisión tomada. EJEMPLO Se representa el siguiente diagrama de flujo, que muestra todos los números pares del 0 al 98: F i = 0 i = i+2 FINi <100 i VINICIO | DAW Modulo 03 - Programacion A.pdf |
Tema 1: Introducción a la programación10La otra herramienta para representar los algoritmos es el pseudocódigo. Es la manera de representar las distintas sentencias que va a realizar nuestro algoritmo con un lenguaje cercano al natural. Por tanto, es un lenguaje que no se puede ejecutar en una máquina. Características del pseudocódigo Comienza con la palabra algoritmo seguido de su nombre. A continuación, tenemos la secuencia de instrucciones de este algoritmo. Finaliza con la estructura Fin Algoritmo. No es necesaria la indentación (sangrado), aunque es re-comendable. No se diferencia entre mayúsculas ni minúsculas. Algoritmo triángulo Definir área, altura, base de tipo números reales; Escribir “Introduce la altura del triángulo:”; Leer altura; Escribir “Introduce la base del triángulo:”; Leer base; Área = (altura*base)/2; Escribir “El área del triángulo es:”, área; Fin Algoritmo Comunicación de un sistema informático En el proceso de programación se comunica a un usuario con una máquina. Para que se pueda realizar dicha comu-nicación, debemos tener: Los dos agentes principales, usuario y máquina. El canal. Para continuar con el ejemplo con el que esta-mos explicando el proceso de programación, podemos decir que el canal por el que se comunica nuestro usuario será el teclado. El lenguaje. Tanto el receptor como el emisor hablan un lenguaje completamente diferente. Para que la comunica-ción sea fluida, debemos acercar los lenguajes, tanto de la máquina como del usuario, y así lograr el entendimiento. | DAW Modulo 03 - Programacion A.pdf |
Programación-A11Ahora bien, para solventar el problema de la comunicación, tenemos lenguajes de programación de tres tipos: alto nivel, nivel medio y bajo nivel. Los lenguajes de alto nivel están más cerca del lenguaje que habla el usuario, mien-tras que los lenguajes de bajo nivel se acercan más a las estructuras del lenguaje de la máquina. Por su parte, los lenguajes de nivel medio toman características de ambos, como por ejemplo el lenguaje C. | DAW Modulo 03 - Programacion A.pdf |
Tema 1: Introducción a la programación12Para facilitar el trabajo, implementaremos nuestro código con lenguajes de alto nivel, de modo que necesitaremos un proceso de traducción para convertir el programa escri-to en lenguaje máquina. Características del lenguaje de alto nivel Es totalmente independiente de la máquina y, por tanto, muy portable. Muy utilizado en el mercado laboral informático. Tanto las modificaciones como las actualizaciones son muy fáciles de realizar. Para la tarea de traducción de código necesitamos un compilador y un enlazador con librerías del propio len-guaje de programación elegido. Algunos ejemplos de lenguajes de alto nivel son java, php, c#, VB. NET, Python... Características del lenguaje de bajo nivel Está relacionado con las características del hardware. Es fácilmente traducible al lenguaje máquina. Es totalmente dependiente de la máquina. Un ejemplo de lenguaje de bajo nivel es Ensamblador. Este lenguaje trabaja con registros a más bajo nivel. | DAW Modulo 03 - Programacion A.pdf |
Programación-A13 A lo largo de esta unidad formativa hablaremos de la es-tructura de un programa informático y de sus elementos principales, como son las variables, las constantes y los distintos operadores que podemos usar a la hora de imple-mentar un código fuente. Lenguajes compilados e interpretados Aquellos lenguajes de alto nivel que utilizan un compilador para poder traducirlo al lenguaje máquina se denominan lenguajes compilados. En nuestro caso, un programa escrito en C# necesita un compilador de C#. En este supuesto, el lenguaje máquina no corresponde al del ordenador, sino al de una máquina ficticia llamada máquina virtual. En C#, la máquina virtual se denomina CLR (Common Language Runtime). Esta máquina no existe físicamente, sino que es simulada por un ordenador. Podemos instalarla en nuestro ordena-dor copiando ese programa en nuestro disco duro. Gracias a esa máquina, podemos ejecutar nuestro progra-ma en cualquier ordenador del mundo. Un lenguaje interpretado no genera un programa escrito en una máquina virtual. Efectúa directamente la traduc-ción y ejecución simultáneamente para cada una de las sentencias. | DAW Modulo 03 - Programacion A.pdf |
Tema 1: Introducción a la programación14Un intérprete verifica cada línea del programa cuando se escribe. La ejecución es más lenta debido a esta traducción simultánea. En esta asignatura vamos a centrarnos en el lenguaje de programación C#. Otro lenguaje muy utilizado actualmen-te es el lenguaje Java. En la siguiente tabla mostramos las características de ambos: C# Java Es un lenguaje orientado a objetos. Es un lenguaje orientado a objetos. Contiene dos categorías generales de tipos de datos integrados: tipos de valor y tipos de referencia. Los argumentos son siempre pasados por valor independientemente del tipo de variable. La migración de C# a Java es sencilla porque mantiene una sintaxis muy similar. La migración de Java a C# es sencilla porque mantiene una sintaxis muy similar. C# está incluido en la plataforma. NET que tiene a su disposición el recolector de basura del CLR (Common Language Runtime o entorno en tiempo de ejecución). Gracias al recolector de basura, se elimina la necesidad de la liberación explícita de memoria. En C# todos los tipos derivan de una superclase común llamada System. Object. A diferencia de Java, esta característica también se aplica para los tipos básicos. Java soporta sincronización de múlti-ples hilos de ejecución (multithreading) a nivel de lenguaje. C# es un lenguaje compilado. Java es compilado, en la medida en que su código fuente se transforma en un código máquina muy parecido al lenguaje ensamblador. Se genera un código intermedio llamado MSIL (Microsoft Intermediate Language) y luego ese código se vuelve a compilar para obtener el formato nativo en la máquina en la que se va a ejecutar. Java es interpretado, ya que ese código máquina se puede ejecutar directamente sobre cualquier máquina la cual tenga el intérprete y el sistema de ejecución en tiempo real. | DAW Modulo 03 - Programacion A.pdf |
Programación-A15 ponte a prueba ¿Cómo debe ser un programa informático? a) Legible. b) Modificable. c) Eficiente. d) Todas las opciones anteriores son correctas. ¿Cuál de las siguientes opciones sobre el siguiente diagrama de flujo es correcta? a) Muestra los n primeros números impares. b) Realiza un producto de dos números. c) Muestra los n primeros múltiplos. d) Realiza la suma de dos números. C# tiene dos categorías tipos de datos inte-grados: por valor y por referencia. a) Verdadero. b) Falso. i = 1 Result = 0 “Escribe el valor de result”si “Escribe el valor de N” Result = 2*i-1 i = i+1FINi<=Nno INICIO | DAW Modulo 03 - Programacion A.pdf |
2 ESTRUCTURA DE UN PROGRAMA INFORMÁTICO | DAW Modulo 03 - Programacion A.pdf |
Programación-A17 El lenguaje de programación C# es un lenguaje de alto nivel que pertenece al conjunto de lenguajes de. NET. C# es una evolución de C++ y mucha de la sintaxis está heredada de este lenguaje. Con C#, podemos crear aplicaciones con una interfaz de texto, que denominamos aplicaciones de consola. Una de las ventajas de aprender este lenguaje es que es independiente de la plataforma donde lo ejecutemos (sea Intel o AMD). Para desarrollar nuestros programas ne C#, utilizaremos un IDE. Un entorno de desarrollo integrado (IDE) es un software diseñado para el desarrollo de aplicaciones con un conjunto de herramientas integradas en una interfaz gráfica de usuario (GUI). Sus características son: Editor de código fuente: ayuda al programador a es-cribir el código, resaltando la sintaxis de forma visual y rellenando de forma automática las distintas opciones que nos proporciona el lenguaje. Depurador: ayuda al programador a localizar sus errores de código. Compilación del código fuente: un código binario en-tendible por la máquina. Para plataformas Windows y Mac OSX, podemos desa-rrollar con IDE Visual Studio. El proyecto que implementa el desarrollo de. NET en GNU/Linux es el proyecto Mono, concretamente el entorno de desarrollo Mono Develop. Con estos programas, vamos a ir generando los diferentes proyectos. Cada vez que creemos un proyecto nuevo, el programa va a generar solo un fichero de código fuente, que es el que va a dar lugar al ejecutable que necesita la aplicación. Este fichero que se genera debe tener la extensión cs, ya que es la extensión utilizada por los ficheros en C#. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático18Instalación de Visual Studio Para instalar nuestro Visual Studio, vamos a la página oficial de Microsoft, donde, en la parte de downloads, tendremos varias opciones. Así, descargamos Visual Studio Community, que es la versión gratuita: BUSCA EN LA WEB https://visualstudio. microsoft. com/es/downloads/ Una vez descargado, procedemos a la instalación. Durante la instalación, nos dará a elegir entre una serie de paquetes instalables. Nosotros, para realizar nuestras aplicaciones de consola, añadiremos el siguiente paquete: | DAW Modulo 03 - Programacion A.pdf |
Programación-A19Instalación de Mono Develop Para la instalación de este IDE en plataformas como Ubun-tu o Debian, podemos seguir las indicaciones de la página oficial: BUSCA EN LA WEB https://www. monodevelop. com/download/ 2. 1. Bloques de un programa informático Estructura de un programa youtu. be/MTJo NPq XT1E Podemos definir un programa como una secuencia de ins-trucciones separadas por un punto y coma que se van a ir agrupando en diferentes bloques mediante llaves. Para crear un proyecto, abrimos nuestro Visual Studio y seleccionamos la opción de Crear un proyecto. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático20Posteriormente, elegiremos la opción de Crear un aplicati-vo de consola. Nombramos nuestra aplicación con el nombre que quera-mos y seleccionamos la ruta donde lo guardaremos. Cuando hayamos configurado estos parámetros, se nos abrirá la interfaz de nuestro IDE, que estará formado por tres partes principales: | DAW Modulo 03 - Programacion A.pdf |
Programación-A21 La primera parte será nuestro editor de código. El desa-rrollador implementará todas las instrucciones necesarias para completar su programa. La segunda es el explorador de soluciones. En esta parte de nuestro IDE, veremos los archivos generados de nues-tro aplicativo. La tercera parte es la salida. Nos proporcionará el resulta-do de si la compilación ha sido correcta o, por el contrario, si ha habido un error, así como también el porqué de ese error. Cuando creamos el proyecto, se crea la siguiente estructura: using System; namespace Mi Aplicación { class Program { static void Main(string[] args) { } } } La estructura que Visual Studio nos crea por defecto es la clase program. Una clase es una estructura de datos que está compuesta por atributos o variables (de las que ha-blaremos más adelante) y métodos o funciones. El método principal se denomina Main. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático22De hecho, siempre que ejecutemos un programa, el primer método que se ejecutará será el Main. Este método tiene una serie de argumentos. Estos argumentos son cade-nas de caracteres que podemos pasar línea de comandos (CMD): Nosotros trabajaremos con la Consola de nuestro entorno de desarrollo. Entrada y salida por pantalla Para establecer la comunicación entre el usuario y el pro-grama, emplearemos la clase Console. Para la salida por pantalla, podemos utilizar los métodos de esta clase, Write y Writeline: -El método Write() escribe un valor o valores especifica-do(s) en el flujo de salida estándar, que generalmente será nuestra pantalla. -El método Write Line() escribe un valor o valores especificado(s) en el flujo de salida estándar, que gene-ralmente será nuestra pantalla, y se realiza un salto de línea en nuestra consola. | DAW Modulo 03 - Programacion A.pdf |
Programación-A23using System; namespace Mi Aplicación { class Program { static void Main(string[] args) { Console. Write Line(“Hello World!”); Console. Write(“Programming... ”); } } } La salida será: Para la entrada de datos de usuario, utilizaremos el méto-do Read Line(). Este método leerá el dato introducido por el usuario y devolverá un dato de tipo cadena (string). using System; namespace Mi Aplicación { class Program { static void Main(string[] args) { Console. Write Line(“Introduce un dato”); string dato = Console. Read Line(); } } } Otra forma para recoger los datos de entrada de usuario es el método Read(). Este método leerá el dato introducido por el usuario y devolverá un dato de tipo entero (int). Asimismo, otro método utilizado por la clase Console es el método Read Key(). En este caso, se obtiene el carácter presionado por el usuario y se muestra esta tecla por la pantalla. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático24Se pueden consultar más métodos de esta clase en el sigui-ente enlace: BUSCA EN LA WEB https://docs. microsoft. com/es-es/dotnet/api/system. console?view=netframework-4. 8 ponte a prueba ¿Qué es un IDE? a) El lenguaje C# es considerado como un IDE. b) El lenguaje java es considerado como un IDE. c) Es un software diseñado para el desarrollo de aplicaciones. d) Ninguna de las respuestas es correcta. Siempre que ejecutemos un programa, el primer método que se ejecutará será el Main. a) Verdadero. b) Falso. ¿Qué realiza el siguiente código? static void Main(string[] args) { Console. Write Line(“Hello World!”); } a) Muestra por pantalla args. b) Muestra por pantalla “Hello World!”. c) Muestra por pantalla Hello World! d) Realiza una lectura de datos de args. | DAW Modulo 03 - Programacion A.pdf |
Programación-A252. 2. Varia Bles. usos y tipos Una variable es una estructura de datos que ocupan un es-pacio en memoria y pueden variar a lo largo de un programa. Cuando declaramos una variable, establecemos el tipo de dato (entero, cadena, carácter, etc. ) y su identificador. class Program { static void Main(string[] args) { int numero; numero = 10; char letra = 'a'; string cadena = “Esta es una cadena”; } } Tipos de datos en C#: Tipo simple Descripción Sbyte, short, int, long Enteros con signo Byte, unshort, uint, ulong Enteros sin signo Float, double Punto flotante Char Uno o varios caracteres Decimal Decimal de alta precisión Bool Booleano Tipo String: son cadenas de caracteres. Por ejemplo: string cadena = “Hola mundo”; Tipo de dato enumerado: enum días_semana {lunes, martes, miercoles}; Tipos matriz: -Unidimensionales: int[] array = new int[5]; int[] array2 = new int[] { 1, 3, 5, 7, 9 }; int[] array3 = { 1, 2, 3, 4, 5, 6 }; -Multidimensionales: int[,] multi Dimensional Array1 = new int[2, 3]; int[,] multi Dimensional Array2 = { { 'a', 'b', 'c' }, { 'd', 'e', 'f' } }; | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático26Para definir una variable, necesitamos conocer primero el tipo de datos que va a almacenar y, a continuación, el nombre que le vamos a asignar. Es recomendable que este nombre tenga relación con el ejercicio que estemos desarrollando. Para identificar a una variable, y que tenga un identifica-dor válido por el compilador, debemos seguir una serie de normas: Debe comenzar por un carácter (letra o “_”). Debe estar formada por caracteres del alfabeto (no pode-mos usar “ñ”) o por dígitos (del 0 al 9). Se puede utilizar el subrayado (“_”). No debe comenzar con un dígito. Distingue entre mayúsculas y minúsculas. No puede llevar espacios en blanco. No se pueden utilizar palabras reservadas. Por ejemplo, string es una palabra reservada como tipo de dato cadena. A continuación, encontraréis una lista de las palabras claves (o identificadores) predefinidos por el compilador: BUSCA EN LA WEB https://docs. microsoft. com/es-es/dotnet/csharp/ language-reference/keywords/ Para declarar una variable: <tipo> <nombre_variable>; Y en C# lo pondríamos de la siguiente forma: int num; En este caso, estamos definiendo una variable de tipo en-tero denominada num. A las variables también se les puede asignar un valor: int num=5; Definimos una variable de tipo entero, denominada num y le asignamos el valor de 5. Debemos utilizar un tipo u otro de variable, dependiendo del tipo de dato que queremos tratar. | DAW Modulo 03 - Programacion A.pdf |
Programación-A27A grandes rasgos, podemos dividir las variables en dos grandes bloques, dependiendo del ámbito en el que se encuentren: Variables locales: aquellas declaradas dentro de un mé-todo o función. Variables globales: aquellas declaradas fuera de un mé-todo o función. Podemos acceder a ellas desde cualquier punto del programa. Más adelante definiremos el concepto de ámbito de va-riables, cuando hablemos del concepto de programación modular. No es buena práctica utilizar variables globales. AVISO El problema de las variables globales es que crean depen-dencias ocultas. Cuando se trata de una aplicación grande, el programador no conoce los objetos que tiene ni sus relaciones. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático28 ponte a prueba ¿Cuál de las siguientes opciones es una característica de una variable? a) Ocupa espacio en memoria. b) Puede variar su contenido a lo largo del programa. c) Es de un tipo de dato. d) Todas las respuestas son correctas. ¿Qué tipo de dato es un char? a) Carácter. b) Entero. c) String. d) Decimal. Las variables globales son aquellas que están declaradas dentro de un método o función. a) Verdadero. b) Falso. 2. 3. constantes y literales. tipos y utilidades Constantes En el apartado anterior hemos hablado de las variables como espacio de memoria donde se almacenan datos que pueden variar a lo largo del programa. Ahora trabajaremos con los espacios de memoria cuyo contenido no se puede alterar a lo largo del programa: las constantes. El valor se establece en tiempo de compilación y no se puede cambiar su contenido. const <tipo> <nombre_variable>; Por ejemplo: const int num; | DAW Modulo 03 - Programacion A.pdf |
Programación-A29Después, declaramos una constante de tipo entero que denominamos num. A continuación, exponemos una constante llamada días semana, con el valor 7, ya que todas las semanas tienen 7 días: class Calendar1 { public const int dias_semanas = 7; } Las constantes se definen fuera del cuerpo de cualquier función, normalmente al principio del programa. Literales Mediante un literal podemos representar de forma explí-cita todos los valores que pueden tomar los tipos básicos del lenguaje. Seguidamente, vamos a explicar los diferentes tipos de literales que podemos encontrarnos en C#. Literales enteros: -Decimales: sin ningún prefijo. Por ejemplo: int d Literal = 10; -Hexadecimales: con el prefijo de 0x o 0X. Por ejemplo: int h Literal= 0x3F; Literales reales: -El literal sin sufijo o con el sufijo d o D es del tipo double. -Por ejemplo: double num = 3. 4d; -Double num2= 3. 4; -El literal con el sufijo f o F es del tipo float. -Por ejemplo: float variable = 4. 5F; -El literal con el sufijo m o M es del tipo decimal. -Por ejemplo: decimal numero = 3. 2m; Literales de lógicos: representados por los valores lógi-cos true (verdadero) y false (falso). Literales de carácter: cualquier carácter en C# podemos representarlo con comillas simples. Por ejemplo, 'a' co-rrespondería al carácter a. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático30Existen caracteres especiales que pueden representarse de la siguiente forma: Carácter Representación Comilla simple \' Comilla doble \” Carácter nulo \0 Retroceso \b Salto de página \f Nueva línea \n Retorno de carro \r Tabulación horizontal \t Tabulación vertical \v 2. 4. operadores del lenguaje de programación Operadores aritméticos Operadores aritméticos + Suma aritmética de dos valores. ++ Incremento en 1 del operando.-Resta aritmética de dos valores.--Decremento en 1 del operando. * Multiplicación aritmética de dos valores. / División aritmética de dos valores. % Obtiene el resto de la división entera. El operador de incremento ++ puede ser aplicado como prefijo o sufijo de una variable. ¿Con qué palabra reservada se define una constante? a) Const b) Enum c) Array d) Ninguna de las opciones es correcta ¿Qué representa el literal \n? a) Una nueva línea b) Un carácter nulo c) Un salto de página d) Una tabulación verticalponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A31El resultado de num++ es el valor de num antes de la ope-ración: int num = 100; Console. Write Line(num); // salida por pantalla: 100 Console. Write Line(num++); // salida por pantalla: 100 Console. Write Line(num); // salida por pantalla: 101 El resultado de ++num es el valor de num después de la operación: double num = 10. 4; Console. Write Line(num); // salida por pantalla: 10. 4 Console. Write Line(++num); // salida por pantalla: 11. 4 Console. Write Line(num); // salida por pantalla: 11. 4 Asimismo, sucede lo mismo con el operador decremento--. La prioridad de los operadores (de mayor a menor prio-ridad) es: 1. Operadores de incremento x++ y decremento x--sufijos. 2. Operadores de incremento ++x y decremento--x prefijos. 3. Operadores de multiplicación, división y resta *, / y %. 4. Operadores de suma y resta + y-. Operadores booleanos Operadores booleanos & AND lógico. Evalúa ambos operandos. && AND lógico. Evalúa el operando derecho solo si es necesario. | OR lógico. Evalúa ambos operandos. || OR lógico. Evalúa el operando derecho solo si es necesario. ^ XOR lógico. ! Negación lógica. El operador AND lógico & calcula el AND lógico de sus operandos. El resultado de a & b es true si a y b se evalúan como true. Si no, el resultado es false. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático32El operador AND lógico condicional && también evalúa el operador AND lógico de sus operandos, pero no evalúa el operando derecho si el izquierdo se evalúa como false. El operador | calcula el operador OR lógico de sus operandos. El resultado de a | b es true si a o b se evalúan como true. Si no, el resultado es false. El operador OR lógico condicional || también evalúa el operador OR lógico de sus operandos, pero no evalúa el operando derecho si el izquierdo se evalúa como true. El operador ^ es el operador OR exclusivo o XOR. La tabla de la verdad (tabla que muestra el resultado de una combi-nación de valores) es la siguiente: a b a^b a||b a&&b T T F T T T F T T F F T T T F F F F F F El operador ! calcula la negación lógica de su operando, es decir, si el operando es true, devolverá el valor false. Si el operando es false, devolverá el valor true. Operadores de comparación e igualdad Operadores de comparación > Mayor < Menor >= Mayor o igual <= Menor o igual == Igual != Desigualdad = Asignación El operador < devuelve true si el operando izquierdo es menor que el derecho. El operador > devuelve true si el operando izquierdo es mayor que el derecho. | DAW Modulo 03 - Programacion A.pdf |
Programación-A33 El operador <= devuelve true si el operando izquierdo es menor o igual que el derecho. El operador >= devuelve true si el operando izquierdo es mayor o igual que el derecho. El operador de igualdad == devuelve true si sus operandos son iguales. El operador de desigualdad != devuelve true si sus operandos son distintos. ponte a prueba ¿Cuál es el resultado del siguiente código? int x = 1; num++; Console. Write Line(num); a) 1. b) 2. c) 0. d) Ninguna de las repuestas es correcta. ¿Cuál de las siguientes opciones sobre el operador ! es correcta? a) Calcula la negación lógica de nuestro operando. b) Incrementa en 1 nuestro operando. c) Decrementa en 1 nuestro operando. d) Compara dos operandos. | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático342. 5. con Versiones de tipos de clase Como hemos visto anteriormente, en C#, cuando declara-mos una variable, no se puede volver a declarar, ni asignar un valor de otro tipo. Por tanto, si tenemos una variable de tipo entero, no pode-mos asignar un valor de tipo string. Este fragmento de código daría un error: int numero=10; numero = “a”; // No se puede convertir implícitamente el tipo 'string' en 'int' Sin embargo, en ocasiones, podemos convertir el valor de una variable de un tipo de dato a otro tipo. A estas conver-siones se les denomina conversiones de tipos. Podemos tener diferentes clases de conversiones: Conversiones implícitas: son aquellas que se producen cuando el valor que se va a almacenar se puede almace-nar en la variable sin truncarse ni redondearse. Por ejemplo, una variable de tipo long puede almacenar datos de hasta 64 bits. Por tanto, puede almacenar cual-quier dato de tipo int (32 bits). int a = 300; long numero=a; Conversiones explícitas: cuando no hay posibilidad de realizar una conversión implícita es cuando debemos indicar al compilador que se pretende realizar una con-versión que pueda producir una pérdida de datos. En este caso, se antepone a la variable el nuevo tipo de datos en-tre paréntesis. double num = 100. 85; int b; b = (int)num; System. Console. Write Line(b); // La salida por pantalla será 100 Parse y Try Parse Con los métodos Parse y Try Parse, podemos convertir una cadena en varios tipos numéricos: int, decimal, double... El método Parse devuelve el número convertido. El método Try Parse devuelve un valor booleano indicando si la | DAW Modulo 03 - Programacion A.pdf |
Programación-A35conversión se realizó correctamente o no, y devuelve el número convertido. int num Valido = Int32. Parse(“-100”); Console. Write Line(num Valido); // La salida por pantalla será-100 while (Int32. Try Parse(“50”, out int mi Numero)) // El argumento mi Numero, se pasa por referencia. Lo veremos más adelante en el apartado 4. 5. Llamadas a funciones. Tipos y funcionamento. Console. Write Line(mi Numero); // La salida por pantalla será 50 Convert Es una clase que convierte un tipo de datos en otro. Algu-nos métodos son: Método Descripción To Boolean Convierte un valor especificado en un valor booleano. To Char Convierte un valor especificado en un carácter. To Decimal Convierte un valor especificado en un número decimal. To Double Convierte un valor especificado en un número de punto flotante. To Int16 Convierte un valor especificado en un entero de 16 bits. To Int32 Convierte un valor especificado en un entero de 32 bits. To Int64 Convierte un valor especificado en un entero de 64 bits. To String Convierte un valor especificado en su representación de cadena. double numero = 30. 5; string cadena = Convert. To String(numero); // Mostraría por pantalla la cadena “30. 5” | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático36EJEMPLO Ejemplo Según el siguiente código: int a=10, b=3, c=1, d, e; Float x,y; x=a/b; c=a<b && c; d= a + b++; e= ++a-b; y= (float)a / b; // habría un error en la sentencia c=a<b && c; porque estamos evaluando una condición booleana, mien-tras que la variable c es una variable de tipo entero. | DAW Modulo 03 - Programacion A.pdf |
Programación-A372. 6. comentarios al código Hasta ahora nos hemos introducido en la creación por parte de un programador de código fuente con una fina-lidad concreta. No debemos pasar por alto que, además de realizar programas, lo debemos hacer de la forma más optimizada y ordenada posible. En el ámbito de la organización entra en escena el concepto de los comentarios. Es una herramienta disponible en el compilador para que el programador pueda hacer anota-ciones en el código sin que sea procesado por el compilador. Estas anotaciones deben de esclarecer el propio código y ayudar a entender las sentencias del programa. Así, futuros programadores podrán conocer su funcionamiento. En el lenguaje de programación C# está permitido hacer dos tipos de comentarios: Comentarios de una línea: son frases cortas y, por tan-to, solo pueden ocupar una línea del código. Debemos de escribir “//” antes de comenzar con dichas anotaciones. Comentarios multiline o multilíneas: son comentarios de varias líneas, que se utilizan para hacer una explicación mucho más detallada del código en cuestión. También podemos hacer uso de este tipo de comentarios cuando deseamos que una parte del código no sea procesada por el compilador. En este caso, debemos de englobar el tex-to entre los caracteres “/*” y “*/”. Las conversiones implícitas son aquellas que se producen cuando el valor que se va a almacenar se puede almacenar en la variable sin pérdida de información. a) Verdadero. b) Falso. ¿Qué convierte el método To String? a) Un valor especificado en un entero de 64 bits. b) Un valor especificado en un carácter. c) Un valor especificado en un valor booleano. d) El valor especificado en su repre-sentación de cadena. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Tema 2: Estructura de un programa informático38El uso de los comentarios es muy útil y, por tanto, se acon-seja a los programadores que implementen programas con tantos comentarios como sea posible para documentar el código. /*Programa que muestra por pantalla la frase Buenas tardes*/ // Está compuesto por la clase Hello1 y el método Main() public class Hello1 { public static void Main() { System. Console. Write Line("Buenas tardes"); } } ponte a prueba Según el siguiente código, ¿qué saldrá por pantalla? static void Main(string[] args) { /* Console. Write Line (“HOLA MUNDO”); Int i=10; Console. Write Line (i); */ } a) HOLA MUNDO b) HOLA MUNDO10 c) HOLA MUNDO 10 d) Nada, porque el código está comentado Para hacer comentarios de una sola línea, debemos utilizar el operado /. a) Verdadero b) Falso | DAW Modulo 03 - Programacion A.pdf |
Programación-A 39 | DAW Modulo 03 - Programacion A.pdf |
3 PROGRAMACIÓN ESTRUCTURADA | DAW Modulo 03 - Programacion A.pdf |
Programación-A41La programación estructurada es un procedimiento que consiste en diseñar e implementar programas de forma clara y sencilla para que puedan ser mantenidos con fa-cilidad. La idea de la programación estructurada fue expuesta por E. W. Dijkstra en 1965 y su base teórica se apoyó en los trabajos de Böhm y Jacopini. El estudio concluyó que, con la combinación de tres tipos de instrucciones, podemos crear un programa estructurado: Secuencia de instrucciones Selección de instrucciones Iteración o bucle de instrucciones BUSCA EN LA WEB Si quieres conocer más sobre Edsger W. Dijkstra, visita esta web sobre el científico: https://dialnet. unirioja. es/ descarga/articulo/3402333. pdf BUSCA EN LA WEB Para saber más sobre los trabajos de Böhm y Jacopini, puedes visitar esta web: https://dl. acm. org/doi/ pdf/10. 1145/355592. 365646x y x ycondiciónverdadero falso x condiciónverdadero iteraciónfalso | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada423. 1. fundamentos de programación Los fundamentos de la programación se basan en un conjunto de técnicas que persiguen desarrollar algo-ritmos que sean sencillos de escribir, leer, modificar y testear. El orden en que se ejecutan las sentencias de un programa es secuencial. Este flujo significa que las sentencias se eje-cutan en secuencia, una después de otra, y en el orden en que se encuentran dentro del programa. Teorema de Böhm y Jacopini Un programa debe de cumplir las siguientes características: Debe tener un único punto de entrada y uno de salida. Toda acción del algoritmo debe ser accesible. Tiene que haber al menos un camino que va desde el inicio hasta el fin del algoritmo. No deben existir, por tanto, bucles infinitos. El programa se encarga de transformar la entrada en salida: ENTRADA SALIDA PROGRAMA Por lo tanto, la programación es un proceso de desarrollo que nos ayuda a resolver un determinado problema. Dijkstra concluyó que la combi-nación de varios tipos de instruc-ciones, podemos crear un programa estructurado. ¿Cuáles son? a) Secuencia de instrucciones. b) Selección de instrucciones. c) Iteración de instrucciones. d) Todas las opciones son correctas. Según Böhm y Jacopini, ¿cuál de las siguientes opciones sobre un programa es cierta? a) Tiene un único punto de entrada y uno de salida. b) Toda acción del algoritmo debe ser accesible. c) No deben existir bucles infinitos. d) Todas las respuestas son correctas. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A433. 2. introducción a la algoritmia y herramientas de diseño Un algoritmo es una secuencia de los pasos y las distintas operaciones que debe realizar el programa para conseguir resolver un problema planteado. En cambio, la algoritmia es un conjunto ordenado y finito de operaciones que permite encontrar la solución a un pro-blema cualquiera. La algoritmia utiliza un conjunto de herramientas lógicas, matemáticas e informáticas con el objetivo de diseñar y presentar un algoritmo. Anteriormente, ya hemos hablado de dos herramientas para la construcción de algoritmos: el pseudocódigo y los diagramas de flujo. Este conjunto de herramientas es utilizado en las etapas de Ingeniería del Software que veremos a continuación. 3. 3. ciclo de Vida de un proyecto software La imagen representa el ciclo de vida de un programa informático, de manera que las flechas indican el orden de realización de cada etapa. | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada44 Análisis de requisitos: a partir de las necesidades del usuario o del programa planteado, se decide qué es lo que hay que hacer para llegar a conseguir una solución óptima, y se genera un documento de requisitos. Se trata de la etapa más importante del ciclo de vida. Existen varias técnicas para obtener los requisitos del usuario: -Entrevistas -Brainstrorming -Prototipos -Casos de uso -JAD (entrevistas en grupos o talleres) Diseño de la arquitectura: se hace un estudio para ver los distintos componentes que van a formar parte de nuestro programa (módulos, subsistemas, etc. ) y se ge-nera un documento de diseño. Esta fase se va a revisar todas las veces que sea necesario hasta que estemos se-guros de cuál va a ser la mejor solución. -Diseño estructurado: tenemos varias notaciones como los diagramas de flujo o el pseudocódigo. -Diseño orientado a objetos: trabajaremos con repre-sentaciones en UML (diagramas de clases, diagramas de secuencia, etc. ). Etapa de implementación o codificación: en esta eta-pa vamos a pasar a codificar las aplicaciones que hemos elegido en la etapa anterior, empleando el lenguaje de programación con el que estemos trabajando. El resulta-do que vamos a obtener va a ser el código fuente. Pruebas de integración: hay que realizar ensayos del funcionamiento, combinando todos los módulos de la aplicación. Así, haciendo funcionar la aplicación comple-ta, comprobamos que cumple lo establecido en el diseño. | DAW Modulo 03 - Programacion A.pdf |
Programación-A45 Pruebas de validación: el último paso de la integración se basa en realizar nuevas pruebas de la aplicación en su conjunto. El objetivo es cerciorarse de que se cumple lo establecido en el documento de requisitos y que cubre las necesidades de los usuarios que ya habíamos previsto. Fase de mantenimiento: revisar todo el proceso anterior e ir actualizando o modificando los cambios oportunos en las etapas anteriores. ponte a prueba En la etapa de diseño, tomamos los requi-sitos de los clientes. a) Verdadero b) Falso Después de la fase de pruebas, ¿qué etapa se lleva a cabo? a) Análisis b) Implementación c) Mantenimiento d) Ninguna de las opciones es correcta 3. 4. prue Ba de programas Una vez implementado y compilado el código de nuestro algoritmo, debemos ponerlo en marcha y comenzar la etapa de testing, plan de prueba o prueba de programa. En ella, se prueba un programa para demostrar la existencia de defectos: algorítmicos, de sintaxis, de documentación, de sobrecarga, de capacidad, de rendimiento, de sincro-nización, de recuperación, de hardware y software y de estándares. Este proceso de prueba del programa se lleva a cabo de manera automática o manual y persigue los siguientes objetivos: Comprobar los requisitos funcionales y no funcionales del programa. Probar todo tipo de casos para detectar alguna anomalía en su ejecución. | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada46Tenemos dos tipos de técnicas de pruebas: Pruebas de caja blanca: donde se valida la estructura del sistema. Pruebas de caja negra: donde se analizan las entradas y salidas del sistema sin tener en cuenta el funcionamiento interno. Entrada(s) Entrada(s)CAJA BLANCA CAJA NEGRASalida(s) Salida(s) El plan de prueba consta de varias etapas, ya que, después de implementar el código, si existiera algún tipo de fallo en el programa, tendríamos que volver a empezar con el nuevo código modificado. 3. 5. tipos de datos : simples y compuestos C# es un lenguaje de programación en el que cada variable, constante, atributo o valor que devuelve una función se en-cuentra establecido en un rango de elementos ya definidos. Podemos diferenciar entre: Tipos simples A la hora de seleccionar un determinado tipo, debemos considerar el rango de valores que puede tomar, las ope-raciones a realizar y el espacio necesario para almacenar datos. Debemos tener en cuenta que el tipo de datos simple no está compuesto por otros tipos, y que contiene un valor único. Tipos simples predefinidos: entre sus propiedades más importantes podemos destacar que son indivisibles, tie-nen existencia propia y permiten operadores relacionales. | DAW Modulo 03 - Programacion A.pdf |
Programación-A47Se utilizan sin necesidad de ser definidos previamente: -Natural: números naturales (N): byte, uint, ushort, ulong. -Entero: números enteros (Z): sbyte, int, long, short. -Real: números reales (R): decimal, float, double. -Carácter: caracteres (C): char. -Lógico: booleanos (B): bool. Tipos simples definidos por el usuario -Tipos enumerados: es un tipo de valor definido por el usuario, así como un conjunto de constantes. Para defi-nir un tipo de enumeración, utilizamos la palabra clave enum y especificamos los nombres de componentes de la enumeración: public class Enum Test { enum d ias {Domingo,Lunes,Martes,Miercoles,Jueves,Viernes,Sabado}; static void Main() { int x = (int)dias. Domingo; int y = (int)dias. Viernes; Console. Write Line( «Domingo = {0}», x); Console. Write Line( «viernes = {0}», y); } } /* Salida: Domingo = 0 Viernes = 5 */ | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada48Tipos compuestos o estructurados Se crean mediante la unión de varios tipos (simples o com-puestos). Vectores: estructura donde almacenamos varias varia-bles del mismo tipo. Se puede declarar una matriz si se especifica el tipo de sus elementos. También son llama-dos array unidimensional, es decir, de una dimensión. Con esto, nos damos cuenta de la cantidad de indica-dores de posición que necesitamos para acceder a un elemento de la tabla. Sintaxis: <tipo> [] <nombre > = new <tipo> [<tamaño>]; Por ejemplo: int [] v = new int [10]; int[] array1 = new int[] { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 }; int[] array2 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; Con el anterior código, estamos declarando 10 números enteros en un vector al que hemos llamado v. A continuación, veremos la manera de acceder a cada uno de ellos. Cabe recordar que la primera posición de todo array es el 0: v[0] Primer número entero del vector. v[1] Segundo número entero del vector. v[2] Tercer número entero del vector. v[3] Cuarto número entero del vector.... v[9] Último número entero del vector Veamos el siguiente ejemplo: char[] mi Array = { 'a', 'b', 'c', 'd', 'e'}; for (int x=0; x<5; x++) { mi Array [1]='z'; } Console. Write Line(mi Array[1]); // Guardamos en la posición 1, el carácter z. Por lo que, por panta-lla, mostrará ese carácter en esa posición. Ahora el vector estaría formado por {'a', 'z', 'c', 'd', 'e'} Matrices: unión de varios vectores de cualquier tipo simple (enteros, reales, etcétera). También la podemos | DAW Modulo 03 - Programacion A.pdf |
Programación-A49ver como un array bidimensional, por tanto, esos datos nos indican que necesitamos dos indicadores de posición para acceder al elemento. La primera posición de una matriz es (0,0). Sintaxis: Tipo [,] Nombre= new Tipo [filas, columnas]; Por ejemplo: int [,] matriz = new int[2,3]; int[,] array2D = new int[,] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; int[,] mi Matriz = new int[4, 2] { { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }; En este caso: int [,] matriz = new int[2,3]; estamos declarando una matriz denominada matriz, de tipo entero, que consta de 2 filas y 3 columnas. Accedemos a cada uno de sus elementos de la forma que se indica a continuación: matriz[0,0] Elemento correspondiente a la primera fila, primera columna. matriz[0,1] Elemento correspondiente a la primera fila, segunda columna. matriz[0,2] Elemento correspondiente a la primera fila, tercera columna. matriz[1,0] Elemento correspondiente a la segunda fila, primera columna. matriz[1,1] Elemento correspondiente a la segunda fila, segunda columna. matriz[1,2] Elemento correspondiente a la segunda fila, tercera columna. Matriz de 6 elementos (2 filas por 3 columnas): | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada503. 6. estructuras de selección (instrucciones condicionales ) Las estructuras de selección son aquellas que permiten ejecutar una parte del código dependiendo de si cumple o no una determinada condición. Instrucción simple (IF): su estructura sería de la siguiente forma: Instrucción simple (IF) SI CONDICIÓN ENTONCES: INSTRUCCIONES_1 FIN SI; INSTRUCCIONES 1 FINCONDICIÓN sino ¿Qué tipo de datos es el tipo enumerado? a) Compuesto b) Simple ¿Cómo puedo acceder al dato 2 si tenemos el siguiente array? int[] a = new int[] {1, 2, 3}; a) a[1] b) a[0] c) a[2] d) Ninguna de las opciones es correcta. ¿Cuántas columnas contendrá la siguiente matriz? int [,] matriz = new int[2,3]; a) 2 b) 3 c) 6 d) Ninguna de las respuestas es correcta. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A51Instrucción doble (IF-ELSE) SI CONDICIÓN ENTONCES: INSTRUCCIONES_1; SI NO: INSTRUCCIONES_2; FIN SI; INSTRUCCIONES 1 FINCONDICIÓN si Si No INSTRUCCIONES 2 En este caso, si CONDICIÓN ES CIERTA, ejecutaremos lo que hay en INSTRUCCIONES_1 y saltaremos hasta el FIN SI. Sin embargo, si CONDICIÓN ES FALSA, ejecutaremos lo que hay en INSTRUCCIONES_2. CONCEPTO En las estructuras dobles, por cada IF, debe haber un ELSE. Operadores lógicos && AND: ambas condiciones deben cumplirse para entrar en el bloque IF. No evalúa el operando derecho si el izquierdo es false. || OR: es suficiente con que una de las condi-ciones se cumpla para entrar en el bloque IF. El resultado de x || y es true si x o y es true. ^ XOR: El resultado se evalúa como true si una condición se evalúa como false y otra como true. Si ambas condiciones se evalúan como false o como true, el resultado será false. | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada52Ejemplo AND lógico condicional &&: SI CONDICIÓN_1 && CONDICIÓN_2 ENTONCES: FIN SI; Si condición_1 y condición_2 son true, el resultado se eva-lúa como true. Si alguna condición es false, el resultado se evalúa como false. Ejemplo OR lógico condicional ||: SI CONDICIÓN_1 || CONDICIÓN_2 ENTONCES: FIN SI ; Si condición_1 es true o condición_2 es true, el resultado se evalúa como true. Ejemplo XOR exclusivo: SI CONDICIÓN_1 ^ CONDICIÓN_2 ENTONCES: FIN SI : CONDICIÓN_1 CONDICIÓN_2 RESULTADO false false False false true True True false true true true false Sentencia Switch (o de selección múltiple) Es una instrucción de selección que elige una sola acción de una lista de opciones en función de una coincidencia de distintos patrones con la expresión. Añadiremos una sentencia de salto (break) al final de cada bloque “case” para abandonar dicho bloque. | DAW Modulo 03 - Programacion A.pdf |
Programación-A53using System; public class Example { public static void Main() { int var = 1; switch (var) { case 1: Console. Write Line( "Caso 1" ); break; case 2: Console. Write Line( "Caso 2" ); break; default: Console. Write Line( "Otro caso" ); break; } } } // La salida mostrada será Caso 1 porque nuestra variable 'var' contiene el valor 1. La cláusula default es optativa en esta estructura. Según el siguiente código, ¿cuándo imprimimos la cadena “Hola a todos”? If (a && b) {Console. Write Line(“Hola a todos”);} a) Cuando la condición a se cumpla. b) Cuando la condición b se cumpla. c) Cuando se cumpla la condición a y b. d) Cuando se cumpla a, pero no b. Según el siguiente código, ¿qué sucede? int a=1; if (a>0) {Console. Write Line(“Estamos en el if”);} else{ Console. Write Line(“Estamos en el else”);} } a) Escribimos por pantalla “Estamos en el if”. b) Escribimos por pantalla “Estamos en el else”. c) No se ejecuta ni el if ni el else. d) La variable a no está correctamente declarada. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada543. 7. estructuras de repetición Las estructuras de repetición siempre se ejecutan median-te el uso de bucles. Estos son los que permiten que una o varias líneas de código se ejecuten de forma repetida. Se van a ir repitiendo mientras que se cumpla una determina-da condición de salida. Existen diferentes estructuras de repetición: Mientras (While) Mientras que se cumpla una condición, el código incluido dentro del bucle se repite. La condición se evalúa al prin-cipio, por lo que puede que no llegue a ejecutarse nunca. Mientras CONDICIÓN Hacer Instrucción_1; Instrucción_2; ... ; Instrucción_N; Modificar Condición; Fin Mientras;INSTRUCCIONES RESTO DEL PROGRAMACONDICIÓN verdadero falso Hacer... mientras (Do... while) Mientras que se cumpla una condición, el código incluido dentro del bucle se repite. La condición se evalúa al final, por lo que, como mínimo, se va a ejecutar una vez. Hacer Instrucción_1; Instrucción_2; ... ; Instrucción_N; Modificar Condición; Mientras CONDICIÓN;CONDICIÓN RESTO DEL PROGRAMAINSTRUCCIONES verdadero falso Para (For ) Mientras que se cumpla una condición, el código incluido dentro del bucle se repite tantas veces como indique el contador, que se irá modificando en cada sentencia. La condición se evalúa al principio, por lo que puede que no llegue a ejecutarse nunca. | DAW Modulo 03 - Programacion A.pdf |
Programación-A55Para CONDICIÓN Instrucción1; Instrucción2; ... Instrucción N; Modificar Condición;verdadero Instruccionesk < N K = k+1K = 1 falso Índice = v (k) Foreach Ejecuta una instrucción o bloque de instrucciones para cada elemento de ciertas estructuras de datos como arrays o listas. EJEMPLO 1 int [] dias Mes = {1, 21, 30}; foreach (int dias in dias Mes) { Console. Write Line(“Dias del mes: {0}”, dias); // creamos una variable días de tipo entero que nos servirá para recorrer cada elemento del array dias Mes } EJEMPLO 2 List‹string› Lista Colores = new List‹string›(); //creamos una lista de tipo string //añadimos un color a la lista Lista Colores. Add (“Azul”); Lista Colores. Add (“Rojo”); Lista Colores. Add (“Verde”); Lista Colores. Add (“Amarillo”); Lista Colores. Add (“Morado”); foreach (string color in Lista Colores) { // recorremos la lista mediante la variable string color Console. Write Line ( color ); } | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada56 Según el siguiente código, ¿ejecutaríamos el código de la salida por pantalla? int a=0; int b=0; while (a>0 || b==0) {Console. Write Line(“Hola Ilerna”); b = b -1;} a) Sí, con que se cumpla una condición es suficiente. b) No, porque se deben cumplir ambas condiciones. c) No, porque no se cumple la condición a>0. d) Ninguna de las respuestas es correcta. ¿Cuántas veces ejecutaríamos un bucle do-while? a) Depende de la condición. b) Mínimo, una vez. c) Cero o más veces. d) Mínimo, dos veces. ¿Es correcto el siguiente código? int [] array = {1,2,3}; for (i = 0; i < array. Length; i++) { Console. Write Line(“HOLA MUNDO!!!”); } a) Sí. Entra en el bucle for y muestra los datos 1, 2 y 3. b) No. La variable i no está declarada. c) Sí. Entra en el bucle y muestra por pantalla HOLA MUNDO!!! d) Ninguna de las respuestas es correcta. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A57 3. 8. estructuras de salto Las estructuras de salto son todas aquellas que detienen (de diferentes formas) la ejecución de alguna de las sen-tencias de control de nuestro programa. break Se encuentra al final de la sentencia switch. Interrumpe el bucle indi-cando que debe continuar a partir de la siguiente sentencia después del bloque del ciclo. El control se devuelve a la instrucción que haya a continuación de la instrucción finalizada. continue Se utiliza en sentencias repetitivas con bucles for, foreach, while y do... while. Transfiere el control a la siguiente iteración. for (int i = 1; i <= 10; i++) { if (i < 9) { continue ; } Console. Write Line(i); } Console. Read Key(); // Mostraría por pantalla 9 y 10 return Esta estructura de salto obliga a que finalice la ejecución de una deter-minada función. Normalmente se utiliza para devolver el control a la función de llamada. static double Calcula Area (int radio) { double area = radio * radio * Math. PI; return area; } //Devuelve la variable local área como un valor de tipo entero | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada58 Según el siguiente código, ¿qué saldrá por pantalla? int case Switch = 1; switch (case Switch) { case 1: Console. Write Line(“Case 1”); break; case 2: Console. Write Line(“Case 2”); break; default: Console. Write Line(“Default case”); break; } a) Case 1 b) Case 2 c) Default case d) case Switchponte a prueba 3. 9. tratamiento de cadenas Una cadena es un objeto de tipo string. Para la repre-sentación de cadenas de caracteres se utiliza la palabra reservada string. En C#, la representación del tipo de datos sería de la si-guiente forma: string frase = "buenos días"; Console. Write Line("El caracter de la posición 5, es {0}", frase [5]); // La salida por pantalla sería el carácter 's' que está en la posición 5 Siempre que queramos escribir combinaciones alfanumé-ricas, en nuestro código, irán entre comillas dobles (“”), ya que el compilador las va a tomar como un tipo string. Estas variables string se pueden inicializar a partir de una tabla de caracteres creada previamente. | DAW Modulo 03 - Programacion A.pdf |
Programación-A59char []letras = { 'h', 'o', 'l', 'a'}; string frase = new string (letras); char caracter = frase [0]; /* Creamos un array de caracteres llamado letras. A continuación, vamos a crear un objeto de tipo string con la palabra reservada new. Con esta palabra reservada, creamos una nueva instancia de tipo string (frase). Por último, asignamos el primer valor de nuestro string a la variable carácter. En este caso, el valor será 'h' */ new El operador new crea una nueva instancia de un tipo. La palabra new crea un objeto tipo string al que pasamos el parámetro letras como una tabla de caracteres. A continuación, vamos a ver los principales métodos de los que dispone string: Length Devuelve el número de caracteres. To Char Array() Convierte un string en array de caracteres. Sub String() Extrae parte de una cadena. Método que puede ser sobrecargado indicando su inicio y su fin: Sub String (int inicio) o Sub String (int inicio, int tamaño). Copy To() Copia un número de caracteres especificados a una determinada posición del string. Compare To() Compara la cadena que contiene el string con otra pasada por parámetro. Devuelve un entero que indica si la posición de esta instancia es anterior, posterior o igual que la posición del string. Contains() Si la cadena que se le pasa por parámetro forma parte del string, devuelve un booleano. Index Of() Si aparece un carácter especificado en el string, devuelve el índice de la posición de la primera vez que aparece. Devuelve-1 si el carácter no se encuentra en la cadena. Insert() Inserta una cadena de caracteres en una posición concreta del string. Trim() Quita todos los espacios en blanco del principio y el final de la cadena de caracteres. | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada60En el siguiente link, se puede consultar la información de los métodos string: BUSCA EN LA WEB https://docs. microsoft. com/es-es/dotnet/api/sys-tem. string?view=netcore-3. 1#methods ponte a prueba ¿Qué mostrará por pantalla el siguiente código? int[] array = { 1, 2, 3 }; Console. Write Line(array. Length); a) 3 b) 1, 2, 3 c) 1 d) 2 La función Trim() elimina cualquier carácter del principio y el final de la cadena. a) Verdadero b) Falso Replace() Devuelve una cadena, donde se ha sustituido un carácter por otro. Remove() Devuelve una cadena donde se ha eliminado un número de caracte-res especificado. Split() Ofrece la posibilidad de separar en varias partes una cadena de caracteres. To Lower() Devuelve una cadena convertida en minúsculas. To Upper() Devuelve una cadena convertida en mayúsculas. | DAW Modulo 03 - Programacion A.pdf |
Programación-A613. 10. depuración de errores Una vez que llegamos a la etapa de depuración de nues-tro programa, nuestro objetivo será descubrir todos los errores que existan e intentar solucionarlos de la mejor forma posible. Podemos encontrar tres tipos de errores diferentes: De compilación o sintaxis: errores en el código. De tiempo de ejecución: los que producen un fallo a la hora de ejecutar el programa. Se trata de fragmentos de código que parecen estar correctos y que no tienen ningún error de sintaxis, pero que no se ejecutarán. Por ejemplo, se podría escribir correctamente una línea de código para abrir un archivo, pero si el archivo no existe, la aplicación no puede llevar a cabo la apertura de ese archivo, por lo que se detendrá la ejecución. Lógicos: son aquellos errores que dan resultados erróneos, diferentes a los esperados o no deseados, en respuesta a las acciones del usuario. Son los más difíciles de corregir, ya que no siempre está claro dónde se originan. Cuando queramos depurar errores, tenemos la opción, en cualquier momento de nuestro programa, de poner un punto de interrupción en una determinada línea de código. Para ello, presionamos F9. Si queremos ejecutar la aplicación en el depurador de Visual Studio, podemos hacerlo presionando F5. La aplicación se detiene en la línea y podremos examinar cuánto valen las variables para ir realizando su seguimiento, o podemos comprobar cuándo finalizan los bucles, entre otras cosas. Para depurar el código, teclearemos F10 (paso a paso). Errores de compilación: estos errores impiden la eje-cución de un programa. Inicialmente se compila el programa, y, si el compilador encuentra cualquier cosa que no entiende, lanza un error de compilación. Casi to-dos los errores que ocasiona el compilador se producen mientras escribimos el código. | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada62 Errores en tiempo de ejecución: aparecen mientras se ejecuta el programa, normalmente cuando se pretende realizar una operación que no lleva a ninguna solución, como, por ejemplo, cuando se pretende dividir por cero. Errores lógicos: impiden que se lleve a cabo lo que se había previsto. El código se puede compilar y ejecutar sin problema, pero, en el caso de que se compile, devuelve algo que no era la solución que se esperaba. El programa no da error cuando se ejecuta en el inicio, por lo que su corrección es más difícil. Tenemos que encontrar el error en un programa que sí funciona, pero que funciona de forma diferente a la que debería. ¿Qué errores podemos encontrar en la etapa de la depuración de un programa? a) Errores lógicos b) Errores de compilación c) Errores en tiempo de ejecución d) Todas las respuestas son correctas El programador está realizando un programa en el cual quiere introducir dos datos enteros. Uno, que sea la base y otro que sea el exponente para realizar la operación potencia. Intro-duce como base el número 5 y como exponente 2. El resultado es 10. ¿Qué tipo de error le está dando a nuestro programador? a) De compilación b) Lógico c) De ejecución d) No hay errores. El programa es correctoponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A633. 11. documentación de programas Una vez que finaliza nuestro proceso de compilación y eje-cución, debemos elaborar una memoria para que quede registrado todo el desarrollo que hemos llevado a cabo, los fallos que ha presentado y cómo hemos conseguido solventarlos. Los ficheros que entreguemos que formen parte del proyecto deben estar testeados y tener un correcto fun-cionamiento. Habrá que solventar los errores descritos anteriormente. summary La etiqueta <summary> debe usarse para describir un tipo y para agregar información adicional dentro de nuestro código. Gracias a herramientas de documentación como Ghost Doc y Sandcastle, creamos hipervínculos internos a las páginas de documentación de los elementos de código: BUSCA EN LA WEB https://docs. microsoft. com/es-es/dotnet/csharp/ programming-guide/xmldoc/cref-attribute <summary> description </summary> | DAW Modulo 03 - Programacion A.pdf |
Tema 3: Programación estructurada64namespace Console App33 { // Implementamos los métodos a utilizar class Program { /// <summary> /// /// Main es el método principal de nuestra clase /// /// </summary> static void Main( string [] args) { // Voy a realizar un programa y a documentarlo char []letras = { 'h', 'o', 'l', 'a'}; string frase = new string (letras); char caracter = frase [0]; //salida por pantalla Console. Write Line(caracter); Console. Read Line(); } } } <?xml version =”1. 0”?> <doc> <assembly > < name>Console App33 </name> </assembly > <members > < member name=”M:Console App33. Program. Main(System. String[]) ”> < summary> Main es el método principal de nuestra clase. </ summary> </ member> </members> </doc> | DAW Modulo 03 - Programacion A.pdf |
Programación-A65 3. 12. entornos de desarrollo de programas Una vez que diseñamos un programa, podemos denominar entorno de desarrollo integrado (IDE o integrated development environment) al entorno de programación que hemos uti-lizado para su realización: editor de código, compilador, depurador e interfaz gráfica (GUI o graphical user interface). Los IDE son utilizados por distintos lenguajes de programación como C++, PHP, Python, Java, C#, Visual Basic, etcétera. A modo de ejemplo, podemos señalar algunos entornos integrados de desarrollo como Eclipse, Netbeans, Visual Code o Visual Studio, entre otros. Los IDE deben cumplir con una serie de carac-terísticas para su correcto funcionamiento, como, por ejemplo: Son multiplataforma. Actúan como soporte para diferentes len-guajes de programación. Reconocen sintaxis. Están integrados con sistemas de control de diferentes versiones. Tienen un depurador. Permiten importar y exportar proyectos. Manejan diferentes idiomas. Facilitan un manual de ayuda para el usuario. Las diferentes ventajas que ofrecen los IDE son: Presentan una baja curva de aprendizaje. Son de uso óptimo para usuarios que no son expertos. Formatean el código. Usan funciones para renombrar funciones y variables. Permiten crear proyectos. Muestran en pantalla errores y warnings. ¿Qué ventajas nos ofrecen los IDE? a) Una baja curva de aprendizaje. b) Crear un proyecto desde cero. c) Un intelligence que nos marca qué funciones podemos utilizar. d) Todas las opciones son correctas. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
4 PROGRAMACIÓN MODULAR | DAW Modulo 03 - Programacion A.pdf |
Programación-A67Hasta ahora hemos estudiado el desarrollo de un programa como una unidad compuesta por líneas que se ejecutan de forma secuencial, sin embargo, un acercamiento más próximo a la realidad sería el paradigma conocido como programación modular. 4. 1. concepto La programación modular consiste en dividir el problema original en diversos subproblemas, que se pueden resolver por separado, para, después, recomponer los resultados y obtener la solución al problema. Un subproblema se denomina módulo, y es una parte del problema que se puede resolver de manera independiente. 4. 2. Ventajas e incon Venientes Enumeramos las ventajas e inconvenientes más relevantes en el trabajo de diseño modular: Ventajas: -Facilita el mantenimiento, la modificación y la docu-mentación. -Escritura y testing. -Reutilización de módulos. -Independencia de fallos. Inconvenientes: -¿Cuánto hay que dividir nuestro problema? -Aumenta el uso de memoria y el tiempo de ejecución. ponte a prueba ¿Qué ventajas nos proporciona la programa-ción modular? a) Facilita el mantenimiento. b) Facilita el testing. c) Podemos reutilizar los módulos. d) Todas las opciones son correctas. Introducción a la programación modular youtu. be/tj9NOGBWRSQ | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular68 4. 3. análisis descendente (top down ) El diseño descendente es una técnica que permite diseñar la solución de un problema con base en la modulari-zación o segmentación, dándole un enfoque de arriba hacia abajo (top down). Esta solución se divide en módu-los que se estructuran e integran jerárquicamente. Este diseño se basa en el principio divide y vencerás: Va de lo más general a lo más específico. Se basa en una representación por niveles: el primer nivel resuelve el problema, y los sucesivos van depurando el primero. El programa, por tanto, tendrá una estructura de árbol. PROBLEMAS MÓDULO 2 MÓDULO 1 MÓDULO 3 ponte a prueba ¿En qué consiste el diseño top down? a) Empezar desde los módulos más pequeños hasta el módulo mayor. b) Dividir un gran problema en subproblemas. c) Inventar el código. d) Ninguna de las opciones es la correcta. | DAW Modulo 03 - Programacion A.pdf |
Programación-A694. 4. modulación de programas. su Bprogramas Podemos denominar los módulos como subprogramas, y estos como las diferentes partes del problema que puede resolverse de forma independiente. Los módulos, al ser independientes unos de otros, permiten que podamos cen-trarnos en una de sus partes (sin tener en cuenta el resto). También ofrecen la posibilidad de que se puedan utilizar las soluciones obtenidas en otras partes del programa. Cada módulo codificado dentro del programa como sub-programa se puede definir como una parte del código independiente, que realiza una tarea asignada. A continuación, vamos a ver a modo de ejemplo un progra-ma que devuelva la nota media de un alumno: //Declaramos el array de enteros que almacenará las notas del alumno int [] notas = new int [ 5 ]; /*Mediante un bucle for recorremos el array almacenando en su interior notas que le pedimos al usuario por teclado */ for ( int i = 0 ; i < notas. Length ; i ++) { Console. Write ( “Introduce la nota en la posición “ + ( i + 1 )+ “: “ ); notas [ i ]= Convert. To Int32 ( Console. Read Line ()); } //Declaramos la variable en la que almacenaremos la media int nota Media = 0; /* Mediante una nueva estructura for, vamos recorriendo el array y vamos acumulando las notas */ for ( int i = 0 ; i < notas. Length ; i ++) { nota Media += notas [ i ]; } //Finalmente, dividimos el sumatorio por el número de notas nota Media /= notas. Length; //Mostramos por pantalla la media obtenida Console. Write Line ( “Su nota media es “ + nota Media ); Console. Read Key (); Si observamos bien el código, podemos comprobar que existen dos partes bien diferenciadas: por un lado, tenemos la lectura de las notas que el alumno debe introducir, y, por otro lado, el cálculo de la media. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular70PROBLEMAS LECTURA NOTAS CÁLCULO MEDIA Se puede comprobar perfectamente que nuestro programa podría estar formado por dos módulos independientes de la siguiente manera: Función Main Todos los programas desarrollados en C# tienen una función principal denominada main() que se ejecuta al iniciar el programa. Esta función se encarga de gestionar el flujo de ejecución, llamando a los diferentes módulos si es necesario. En esta parte, el usuario va introduciendo las notas de los alumnos. Mostraremos por pantalla la nota media. static void Main ( string [] args) { int [] notas = new int [ 5 ]; for ( int i = 0 ; i < notas. Length ; i ++) { Console. Write ( “Introduce la nota en la posición “ + ( i + 1 )+ “: “ ); notas [ i ]= Convert. To Int32 ( Console. Read Line ()); } Console. Write Line ( «Su nota media es « + calcular Media ( notas )); Console. Read Key (); } Función calcular Media(). Creamos esta función en la división de nuestro problema. Esta función recibe las notas introducidas por los alum-nos y devuelve la nota media de las mismas. public int calcular Media ( int [] newarray ){ int nota Media = 0; for ( int i = 0 ; i < newarray. Length ; i ++){ nota Media += newarray [ i ]; } nota Media /= newarray. Length; return nota Media; } | DAW Modulo 03 - Programacion A.pdf |
Programación-A71Podemos comprobar que en C# los programas se dividen en subprogramas, denominados funciones o métodos. Estas funcionan de forma similar a una caja negra, es decir, el programa principal solo debe conocerlas para llamarlas por su nombre, los parámetros que reciben (las variables que debemos enviar) y lo que devuelven como resultado. Por ejemplo, nuestra función calcular Media recibe un array de notas y devuelve un entero con la media. 4. 5. llamadas a funciones (métodos ). tipos y funcionamiento Funciones en C# Los métodos con los que trabajamos en C# se denominan funciones. De hecho, cuando nos referimos a una función, un método o un subprograma en C#, nos estamos refiriendo al mismo concepto. Las funciones se pueden definir como un conjunto de ins-trucciones, delimitadas por llaves, que tienen un nombre y son de un tipo específico. Sintaxis: Modificadores Tipo Nombre Funcion (Parámetros de entrada ){ Código de la función return expresión ; } Veamos paso a paso el significado de cada parte de la función: Modificadores: conjunto de palabras reservadas que modifican o aplican propiedades a la función. Los más comunes son los modificadores de acceso: Public, Priva-te, Protected, Internal: -Public: el acceso no está restringido. -Private: el acceso está limitado a la misma clase. -Protected: el acceso está limitado a la clase contene-dora o a los tipos derivados de la clase contenedora. -Internal: el acceso no está restringido, siempre y cuan-do sea dentro del mismo ensamblado. Un ensamblado es un conjunto de tipos que se compilan para obtener una misma solución. Si no indicamos un modificador, por defecto, nuestros métodos tendrán un nivel de ac-cesibilidad internal. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular72 Tipo: las funciones, al igual que ocurría con las variables, poseen un tipo, es decir, el dato que devuelven es de un tipo determinado. Nombre de la función: es el identificador de la función, lo usaremos para referenciarla, del mismo modo que usábamos los nombres de las variables. Parámetros de entrada: una lista de las variables que re-cibirá la función en el momento de su llamada. Es posible que una función no requiera parámetros. Return: si nuestro método está tipado, es obligatorio que devuelvan un valor del tipo adecuado. Utiliza la palabra reservada return. Veamos cómo quedaría utilizando el mismo ejemplo que propusimos en el apartado anterior: Mediante el uso de parámetros, se permite la comunica-ción de las diferentes funciones con el código. Métodos no tipados. Void Los métodos no tipados son aquellos que realizan una tarea específica y que pueden recibir parámetros, pero no necesitan devolver un valor. Para referenciar que ese método no nos devuelve un valor, utilizamos la sentencia void. Modificadores void Nombre Procedimiento (Parámetros de entrada ){ //Código del procedimiento }TIPO CÓDIGO FUNCIÓNPARÁMETROS DE ENTRADA MODIFICADORNombre Función VALOR DE RETORNO | DAW Modulo 03 - Programacion A.pdf |
Programación-A73CÓDIGO EJEMPLO: static void Par (int b) { int x; x = (b % 2); if (x == 0) { Console. Write Line(«\n Es par»); } else { Console. Write Line(«\n Es impar»); } } EJERCICIO 1 Realice un programa modular donde se calcule la suma de los dígitos de un número que el usuario introduzca por pantalla. Por ejemplo, si el usuario introduce el número 369, el resultado sería: 3+6+9=18 Solución public static int Calcular( int a ) { string cad = Convert. To String(a); // Convertimos el parámetro a en string int sum = 0; for (int i = 0; i < cad. Length; i++) // recorremos el número y vamos tomando las subcadenas (dígitos) del mismo con la función Substring almacenándolo en una variable entera para ir haciendo la suma de cada uno de sus dígitos sum += Convert. To Int32( cad. Substring(i,1)); return sum; } public static void Main() { int numero; Console. Write (“Introduzca el número: “); numero = Convert. To Int32( Console. Read Line() ); Console. Write Line(Calcular( numero )); } | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular74EJERCICIO 2 Realice un programa modular donde el usuario introduzca dos números enteros y se intercambien de posición. 5 10 510 10 105 5 Solución public static void intercambio( ref int numero1, ref int numero2) { int aux ; // creamos una variable auxiliar para guardar temporalmente en número 1 aux = numero1; numero1 = numero2; numero2 = aux ; } public static void Main() { int numero1,numero2; Console. Write (“Introduzca el primer número”); numero1= Convert. To Int32( Console. Read Line()); Console. Write (“Introduzca el Segundo número “); numero2= Convert. To Int32( Console. Read Line()); // pasamos los parámetros por referencia con la palabra reservada ref (veremos el paso de parámetros en la siguiente sección) intercambio( ref numero1, ref numero2 ); Console. Write Line(“{0}\n{1}”,numero1,numero2); } | DAW Modulo 03 - Programacion A.pdf |
Programación-A75Paso de parámetros. Paso por valor y paso por referencia En C#, podemos distinguir dos tipos de paso de paráme-tros diferentes: Por valor o copia. Por referencia. Paso de parámetros por valor Cuando ejecutamos una función que tiene parámetros pas-ados por valor, se realiza una copia del parámetro que se ha pasado, es decir, que todas las modificaciones y/o cambios que se realicen se están haciendo en esta copia que se ha creado. El original no se modifica, de manera que no se altera su valor en la función. MEMORIA variable número | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular76Paso de parámetros por referencia Sin embargo, cuando ejecutamos una función que tiene parámetros pasados por referencia, todas aquellas modi-ficaciones que se realicen en la función van a afectar a sus parámetros, ya que se trabaja con los originales. MEMORIA número CÓDIGO EJEMPLO: static void Main(string[] args) { int a = 0; metodo(ref a); /* cuando pasamos por valor la variable 'a' al método, tanto la variable 'a' como la variable 'numero' ocupan el mismo espacio de memoria, pero lo que el valor se so-breescribirá. En este caso, inicialmente, tenemos el valor 0, pero al asignar a 'numero' el valor 1, éste sobreescribe al 0 */ Console. Write Line(a); } static void metodo(ref int numero) { numero = 1; } params, in y out Cuando trabajamos con la palabra clave 'params' estamos especificando un paso por valor. En este caso, el tipo de parámetro debe ser una matriz unidimensional (array). | DAW Modulo 03 - Programacion A.pdf |
Programación-A77No se permiten pasar más parámetros después de la pal-abra clave 'params' en una declaración de método. Si el tipo declarado del parámetro 'params' no es un vector, se produciría un error (Error del compilador CS0225). CÓDIGO EJEMPLO: public static void mi Metodo( params int[] list) { for (int i = 0; i < list. Length; i++) { Console. Write(list[i] + “ “); } Console. Write Line(); } static void Main() { int[] mi Array Int = { 5, 6, 7, 8, 9 }; mi Metodo(mi Array Int); } La palabra clave 'in' sirve para pasar parámetros por refe-rencia. Las variables que se han pasado como argumentos con la palabra clave 'in' deben inicializarse antes de pasarse en una llamada de método o función. Si pasamos un pa-rámetro con 'in', este no puede ser modificado dentro del método. CÓDIGO EJEMPLO: 0 referencias static void Main() { int solo Lectura = 44; ejemplo(solo Lectura); Console. Write Line (solo Lectura ); // el valor es 44 } 1 referencia static void ejemplo (in int number ) { // error CS8331 number = 19; } [] (parámetro) in int number No se puede asignar a variable “in int” porque es una variable readonly. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular78La palabra clave 'out' también sirve para pasar parámetros por referencia. No es necesario iniciar la variable antes de pasarla al método. CÓDIGO EJEMPLO: static void Main() { int entera; Out Ejemplo(out entera); Console. Write Line(entera); // la salida por pantalla será 40 } static void Out Ejemplo(out int numero) { numero = 40; } Las funciones deben tener un tipo asociado. a) Verdadero b) Falso ¿Cuál es la salida del siguiente código? static void Main(string[] args) { int a = 10; int b = 5; Console. Write Line(suma(a,b)); } static int suma(int x,int y) { return x + y; } a) 15 b) 10 c) 5 d) La función no está bien construida Cuando realizamos un paso por valor de una variable, creamos dos posi-ciones de memoria distintas. a) Verdadero b) Falsoponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A794. 6. ám Bito de las llamadas a funciones Hasta ahora, hemos trabajado tanto con variables dentro de nuestro Main, con variables creadas dentro de nuestros métodos y con el paso de parámetros. Veamos cuál es el ámbito o el alcance de estas variables. Variables globales Una variable global es creada fuera de nuestro Main y fuera de cualquier método. Podemos acceder a ella en cualquier momento de nuestro programa. class Program { static int n = 10; // Variable global public static void Cambia Valor N() { n++; } public static void Main() { Console. Write Line("n vale {0}", n); // el valor de n es 10 Cambia Valor N(); Console. Write Line("Ahora n vale {0}", n); // el valor de n es 11 } } En términos generales, debemos intentar construir nues-tros programas con variables locales. Así hacemos que cada parte del programa trabaje con sus propios datos, y ayudamos a evitar que un error en un trozo de programa pueda afectar al resto. Si modificamos una variable global en cualquier punto del programa, podemos perdernos en su flujo. La forma correcta de pasar datos entre distintos métodos no es a través de variables globales, sino usando los pa-rámetros de cada función y los valores devueltos (como hemos visto en ejemplos anteriores con el paso de pará-metros por valor y por referencia). Variables locales Las variables que se declaran dentro de un método (o de una función), y que, por tanto, solo este fragmento de có-digo las conocerá, son las llamadas variables locales. No se podrán usar desde ningún otro método del programa. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular80public static int Potencia(int n Base, int n Exponente) { int temporal = 1; // Valor local de mi método Potencia for (int i = 1; i <= n Exponente; i++) // Multiplico “n” veces temporal *= n Base; // Para aumentar el valor temporal return temporal; // Al final, obtengo el valor que buscaba } public static void Main() { int num1, num2; // variables locales de mi método Main Console. Write Line(“Introduzca la base: “); num1 = Convert. To Int32(Console. Read Line()); Console. Write Line(“Introduzca el exponente: “); num2 = Convert. To Int32(Console. Read Line()); Console. Write Line(“{0} elevado a {1} vale {2}”, num1, num2, Potencia(num1, num2)); } En este caso, las variables temporal e i son locales a la función potencia. Para Main no existen. Si en Main intentá-ramos hacer i=10, obtendríamos un mensaje de error. Lo mismo ocurre con las variables, num1 y num2, que son locales para Main. Desde la función potencia no podemos acceder a su valor (ni para leerlo ni para modificarlo). En este ejemplo, no encontramos ninguna variable global. Conflictos de nombres en las variables ¿Qué ocurre si trabajamos con la misma variable global en dos métodos diferentes? static int n = 7; public static void Cambia N() { n++; } public static void Main() { Console. Write Line(“n vale {0}”, n); // el valor será 7 Cambia N(); Console. Write Line(“Ahora n vale {0}”, n); // el valor cambiará a 8 } | DAW Modulo 03 - Programacion A.pdf |
Programación-A81En este ejemplo, vemos que tanto en el método Cambia N como en el método Main estamos trabajando con una va-riable global. Ahora veamos otro ejemplo: static int n = 7; public static void Cambia N() { int n = 10; n++; Console. Write Line(“Ahora n vale {0} dentro del método Cambia N”, n); } public static void Main() { Console. Write Line(“n vale {0}”, n); Cambia N(); Console. Write Line(“Ahora n vale {0}”, n); // el valor que estamos sacando de n es el de la variable global } En el siguiente ejemplo, estamos trabajando con dos varia-bles 'n' distintas. Hemos creado una variable local 'n' dentro del método Cambia N, en el cual modificamos su valor asig-nando 10 e incrementando después. En Main, estamos trabajando con la variable global creada al inicio, por lo que el valor no varía siendo 7. En este último ejemplo, vemos que podemos llegar a tener conflicto de variables a la hora de trabajar con variables globales (el ejemplo son pocas líneas de código. Si traba-járamos con un proyecto de cientos de líneas, la confusión podría ser mayor). Por ello, se recomienda trabajar con variables locales y paso de parámetros entre métodos. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular82 Una variable local puede ser accedida desde cualquier función o método. a) Verdadero. b) Falso. ¿Qué muestra por pantalla el siguiente código? public static string mi Var=””; static void Main(string[] args) { int a = 10; int b = 5; Console. Write Line(suma(a,b)); Console. Write Line(mi Var); } static int suma(int x,int y) { mi Var = “HOLA ILERNA”; re-turn x + y; } a) 15. b) HOLA ILERNA. c) 15 HOLA ILERNA. d) El paso de parámetros a la función no es correcto. Según el siguiente código, ¿qué ocurrirá con la función? public static float Mayor (float num1, float num2) { if (num1 > num2) return num1; else return num2; } a) La función nos devolverá dos valores: num1 y num2. b) Es incorrecto porque hay dos return. c) La función nos devolverá num1 si es mayor que num2 o num2 si es mayor que num1. d) Ninguna de las opciones es correcta. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
Programación-A834. 7. prue Ba, depuración y comentarios de programas Una vez tenemos terminado nuestro programa con su código ya implementado, es momento de probarlo para comprobar que no tiene fallos y, sobre todo, que su funcio-namiento es correcto. En muchos casos no existen errores, pero el programa no realiza la tarea que debería cuando se ejecuta. Por esto es muy conveniente que nuestro programa tenga comentarios, al menos, en todo lo importante que realiza. De esta manera, nos será más fácil manejarnos con él. Podemos encontrarnos errores en nuestro código, tanto sintácticos como semánticos, que pueden ir apareciendo sin esperarlo. La mayoría de los lenguajes de programación disponen de una serie de herramientas que nos van a servir para tratar estos errores y conseguir solucionarlos. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular84Por ejemplo, el programa Visual Studio cuenta con un menú Depurar que permite acceder a las herramientas que dis-pone el depurador. El C#, además, nos facilita unas técnicas propias para controlar diferentes situaciones en las que se produzcan errores en tiempo de ejecución. Cuando ponemos una aplicación en modo depuración, Visual Studio tiene la posibilidad de visualizar, línea a línea (F11), nuestro código para analizarlo de forma más detallada. Cuando ejecutamos un programa, podemos dividir el pro-ceso en varias partes: Compilación Vinculación Ejecución | DAW Modulo 03 - Programacion A.pdf |
Programación-A85Veamos cómo funcionan cada una de estas etapas: Compilación Mientras vamos escribiendo un determinado programa, el entorno de desarrollo de C# va haciendo comproba-ciones exhaustivas para exponer los errores que podrían persistir en el código. Estos errores aparecen subrayados conforme escribimos las distintas instrucciones, y son denominados errores de compilación. Algunos ejem-plos serían la falta de un punto y coma, una variable no declarada, etcétera. Una vez que estos errores se corrigen, podríamos decir que el programa se va a compilar y va a pasar a ejecutar-se, aunque no sabemos todavía si va a realizar la función exacta para la que ha sido diseñado. Vinculación Debemos señalar que todos los programas hacen uso de bibliotecas y, además, algunos utilizan clases diseñadas por el programador. Las clases se vinculan cuando el pro-grama comienza a ejecutarse, aunque son los IDE los que comprueban el programa a medida que se va escribiendo para intentar garantizar que todos los métodos que se in-voquen existan, y que coincidan con su tipo y parámetros. Ejecución Si hemos conseguido llegar a la fase de ejecución signifi-ca que nuestro programa ya no tiene errores, pero todavía no sabemos si el resultado es el correcto. Los errores ló-gicos son los más complicados de detectar. Estos pueden producir cambios inesperados, por lo que debemos co-menzar con un proceso de depuración en el que vamos a ir comprobando, paso a paso, cómo va a funcionar nuestro programa. Así, nos proporcionará el resultado deseado. ponte a prueba Podemos poner un punto de interrupción en nuestros programas y depurar línea a línea. a) Verdadero b) Falso | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular864. 8. concepto de li Brerías Cuando hablamos de librerías nos referimos a archivos que nos permiten llevar a cabo diferentes acciones y tareas sin necesidad de que el programador se preocupe de cómo están desarrolladas, solo debe entender cómo utilizarlas. Las librerías en C# permiten hacer nuestros programas más modulares y reutilizables, facilitando además crear progra-mas con funcionalidades bastante complejas. Cuando compilamos nuestro programa, solamente se comprueba que se ha llamado de manera correcta a las funciones que pertenecen a las diferentes librerías que nos ofrece el compilador, aunque el código de estas funciones todavía no se ha insertado en el programa. Va a ser el enla-zador o linkador el que realice esta inserción y, por tanto, será el encargado de completar el código máquina con la finalidad de obtener el programa ejecutable.. obj. obj. obj. lib Enlazador. exe Una vez que hemos obtenido el código fuente, debemos comprobar que no se producen errores en tiempo de ejecución. Si los hubiera, debemos depurar el programa. Encontrar cuál es la causa que produce un error en tiempo de ejecución es, a veces, una tarea complicada, por lo que los IDE nos proporcionan una herramienta denominada “Depurador” que nos facilita la tarea. Uno de los motivos por lo que es recomendable utilizar el lenguaje de programación C# es que permite la interope-ración con otros lenguajes, siempre que estos tengan: | DAW Modulo 03 - Programacion A.pdf |
Programación-A87 Acceso a las diferentes librerías a través de COM+ y ser-vicios. NET. Soporte XML (a nivel de documentación). Simplificación en administración y componentes gracias a un mecanismo muy cuidado de versiones. Podemos crear nuestras propias librerías en C# con VS2019. Veámoslo paso a paso: 1. Creamos un proyecto nuevo como aplicación de consola. 2. Agregamos a nuestra solución una biblioteca de clases (ir a la ventana del explorador de soluciones, botón derecho y agregar). 3. Creamos nuestra dll, realizando un módulo de 'Mul-tiplicar'. Allí crearemos una función que realizará la multiplicación de dos números. | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular88 4. A mi proyecto, agregaremos como referencia (botón derecho-> referencia) mi dll con el nombre que había-mos puesto con anterioridad 'Operaciones'. 5. Ahora ya podemos llamar desde nuestro programa a nuestra referencia. | DAW Modulo 03 - Programacion A.pdf |
Programación-A89 4. 9. uso de li Brerías Una librería es un conjunto de métodos relacionados con el mismo objetivo para poder ser reutilizado cada vez que el programador lo desee. Para la realización de este módu-lo, en los ejercicios prácticos, vamos a utilizar las librerías Math para cualquier operación matemática y la librería Random. Vamos a explicar algunos ejemplos: A. En este primer ejemplo vamos a calcular la potencia de base 10 y exponente 2. Para ello debemos mirar cuáles son los métodos que están implementados en la librería Math y podemos comprobar que existe un método llamado Pow que realiza las operaciones exponenciales. Using System; //Para la utilización de dicha librería debemos de importar System double calculo = Math. Pow(10, 2); | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular90B. Para el siguiente ejercicio vamos a poder comprobar el funcionamiento de varios ejemplos de Random con distin-tos intervalos. using System; public class Example { public static void Main() { Random rnd = new Random(); // Declaración e inicialización de la variable aleatoria Console. Write Line(“\n20 random integers from-100 to 100:”); for (int ctr = 1; ctr <= 20; ctr++) { Console. Write(“{0,6}”, rnd. Next(-100, 101)); /* El método Next calcula el número aleatorio que está dentro de un intervalo especificado devolviendo un número menor que el valor máximo de ese intervalo. Mostraremos los números dejando una separación de 6 unidades entre ellos */ if (ctr % 5 == 0) Console. Write Line(); } Console. Write Line(“\n20 random integers from 1000 to 10000:”); for (int ctr = 1; ctr <= 20; ctr++) { Console. Write(“{0,8}”, rnd. Next(1000, 10001)); if (ctr % 5 == 0) Console. Write Line(); } Console. Write Line(“\n20 random integers from 1 to 10:”); for (int ctr = 1; ctr <= 20; ctr++) { Console. Write(“{0,6}”, rnd. Next(1, 11)); if (ctr % 5 == 0) Console. Write Line(); } } } // Un ejemplo de salida de números enteros de-100 a 100 // 5 -5 -20 94 -86 // -3 -16 -45 -19 47 // -67 -93 40 82 68 // -60 -55 67 -51 -11 // Un ejemplo de salida de números enteros de 1000 a 10000 // 4857 9897 4405 6606 1277 // 9238 9113 5151 8710 1187 // 2728 9746 1719 3837 3736 // 8191 6819 4923 2416 3028 // Un ejemplo de salida de números enteros de 1 a 10 // 4 4 5 9 9 // 5 1 2 3 5 // 5 4 5 10 5 // 7 7 7 10 5 | DAW Modulo 03 - Programacion A.pdf |
Programación-A91 Gracias a la librería de matemáticas, el IDE nos proporciona métodos ya implementados. Según esto, ¿qué realiza el siguiente código? double grados =90; double angulo = Math. PI * grados / 180. 0; double result = Math. Cos(angulo); Console. Write Line(result); a) Saca por pantalla el coseno de un ángulo. b) Saca por pantalla el seno de un ángulo. c) El código no es correcto. d) Ninguna de las opciones es correcta. ponte a prueba 4. 10. introducción al concepto de recursi Vidad Cuando trabajamos con funciones, podemos definir la re-cursividad como la llamada de una función a sí misma hasta que cumpla una determinada condición de salida. Sintaxis: modificador tipo_devuelto nombre_funcion(tipo par1, tipo par2,..., tipo parn) { nombre_funcion(var1,..., var2) ... } Podemos definir la recursividad de la siguiente manera: Un caso base que permita la finalización del programa (sería nuestra condición de salida). Casos recursivos, que son los que se van a encargar de que la función vuelva a ejecutarse, pero acercándose cada vez más al caso base. Vamos a ver un ejemplo para poner en práctica todos estos conceptos: | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular92Factorial de un número El factorial de un número n se calcula: n! = n*(n-1)*(n-2)*(n-3)*... *1 Debemos saber qué es el factorial de un número. Por ejemplo: 3!=3*2*1 4!=4*3*2*1 5!=5*4*3*2*1” Si queremos realizar en C# una función que calcule el fac-torial de un número, podríamos definirla de la siguiente forma: int factorial(int n) ¿Cuál podría ser el caso base? Debemos encontrar uno que finalice el programa. En este supuesto, siempre tenemos que buscar el caso más peque-ño que existe. En nuestro ejemplo, el “1!=1”. factorial(1)=1; Pensemos ahora en el caso recursivo Debemos encontrar uno que sirva para todos los números. Debe ir haciéndose cada vez más pequeño hasta que con-siga llegar al caso base, que es el factorial de 1. Si nos fijamos en el ejemplo que hemos puesto: 3!=3*2*1 4!=4*3*2*1 5!=5*4*3*2*1” Podemos apreciar lo siguiente: 3!=3*2*1 4!=4*3! 5!=5*4!.... | DAW Modulo 03 - Programacion A.pdf |
Programación-A93Vemos que en todos los casos sucede lo mismo, se multi-plica el número por el número restando una unidad. Por lo que ya tenemos el caso recursivo: factorial(n)=n*factorial(n-1) De modo que nos quedaría de la siguiente forma: Caso base Si n=1, factorial(1) devuelve 1. Caso genérico Si n>1, factorial(n) = n*factorial(n-1). Si hacemos una función llamada “factorial” (entero n) re-torna entero: { si n>1 entonces // Caso recursivo devuelve n*factorial(n-1); Si no // Caso base devuelve 1; Fin Si; } Si lo traducimos al lenguaje de programación C#: static int factorial(int n) | DAW Modulo 03 - Programacion A.pdf |
Tema 4: Programación modular94{ if (n>1) return n*factorial(n-1); else return 1; } A continuación, analizaremos otro ejemplo recursivo. En este caso, vamos a imprimir por pantalla n números natu-rales. Será el usuario quién decida qué números naturales querrá imprimir. Por ejemplo, si el usuario introduce el número 6, se imprimirá por pantalla la siguiente secuencia: 1 2 3 4 5 6 Caso base: el usuario introduce valores que no son nú-meros naturales (es decir, menores que uno), el programa devolverá siempre 1. Caso recursivo: vamos a llamar a la función con dos parámetros. Así, uno de ellos controlará la salida e irá incrementando en 1, y el otro irá decrementando hasta llegar al caso base. int salida = 1; { si n>1 entonces // Caso recursivo n--; Escribimos salida devuelve naturales (salida +1, n) Si no // Caso base devuelve salida; Fin Si; } El código en C# quedaría de la siguiente forma: static int naturales (int salida, int n) { if (n > 1) { n--; Console. Write(“ {0} “, salida); return print Natural (salida + 1, n); } else return salida } | DAW Modulo 03 - Programacion A.pdf |
Programación-A95 ¿A qué se refiere el concepto de recursividad? a) Un tipo de método. b) La visibilidad de una función. c) Llamada de una función a sí misma. d) Una librería. La recursividad necesita un caso base que permita la finalización del programa. a) Verdadero. b) Falso. ¿Qué realiza el siguiente código? static int print Natural(int ctr, int stval) { if (ctr < 1) {return stval; } Console. Write(“ {0} “, ctr); ctr--; return print Natural(ctr, stval); } static void Main() { Console. Write(“ ¿Cuántos números quieres imprimir? : “); int ctr = Convert. To Int32(Console. Read Line()); print Natural(ctr, 1); } a) Muestra por pantalla los n primeros números naturales. b) Muestra por pantalla los números de n a 1. c) Muestra la resta de dos números naturales. d) Muestra la suma de dos números naturales. ponte a prueba | DAW Modulo 03 - Programacion A.pdf |
5 GESTIÓN DE FICHEROS | DAW Modulo 03 - Programacion A.pdf |
Programación-A97Hasta aquí, hemos visto el uso de variables y las estructu-ras de datos y hemos trabajado con información que, una vez que finaliza la ejecución del programa, desaparece de la memoria, ya que ha estado almacenada en la memoria principal el tiempo que dura la ejecución del software. La solución para que los datos persistan después de la eje-cución es almacenarlos en un fichero. Entonces, cada vez que ejecutemos una aplicación que trabaja con esos datos podrá leer del fichero aquellos que sean necesarios. 5. 1. concepto y tipos de ficheros Un fichero es una parte de un dispositivo no volátil a la que se le asigna un nombre y que puede contener una cantidad de datos que va a estar limitada, o por la cantidad de espa-cio del que disponga el dispositivo, o por las características del sistema operativo. Entendemos por dispositivos no vo-látiles aquellos que no pierden la información que poseen cuando apagamos nuestro ordenador. Debido a la importancia que tienen los ficheros al actuar de almacenes no volátiles de la información, la BCL (Base Class Library) reserva un espacio de nombres denominados System. IO, destinado a trabajar con ellos. El espacio de nombres System. IO contiene tipos que per-miten leer y escribir en los archivos. Además, ese espacio de nombres nos proporciona compatibilidad entre archivos y directorios. Algunas de las clases que nos proporciona son: CLASE DESCRIPCIÓN Binary Reader Lee tipos de datos primitivos como valores binarios. Binary Writer Escribe tipos primitivos en formato binario en una secuencia y admite la escritura de cadenas. File Proporciona métodos estáticos para crear, copiar, eliminar, mover y abrir un solo archivo. Contribuye a la creación de objetos File Stream. Buffered Stream Almacena en un búfer los datos necesarios para las operaciones de lectura y escritura en otra secuencia. No se puede heredar esta clase. File Stream Proporciona un Stream para un archivo, lo que permite operaciones de lectura y escritura sincrónica y asincrónica. | DAW Modulo 03 - Programacion A.pdf |
Tema 5: Gestión de ficheros98Para obtener más información de las clases que del espacio de nombres de System. IO, podemos acceder a la documen-tación de Microsoft: BUSCA EN LA WEB https://docs. microsoft. com/es-es/dotnet/api/sys-tem. io?view=netcore-3. 1 Los ficheros se almacenan en directorios o carpetas. Cada directorio puede contener, a su vez, otros directorios dife-rentes, y esto hace que el sistema de archivos vaya creando una estructura jerárquica en la que cada fichero o directorio tiene como padre el directorio que lo contiene. Como es lógico, y para que esta estructura sea finita, debe existir un directorio raíz, que va a ser el que contenga a todos los demás y no tenga dependencia de ningún otro. En resumen Los ficheros o archivos son una secuencia de bits, bytes, líneas o registros que se almacenan en un dispositivo de almacenamiento secundario, por lo que la información va a permanecer a pesar de que se cierre la aplicación que los utilice. Esto permite más independencia sobre la información, ya que no necesitamos que el programa se esté ejecutando para que la información que contiene exista. Cuando se di-seña un programa y se quiere guardar información en algún fichero, el programador es el encargado de indicar cómo manejar esas estructuras (creación de ficheros, añadir in-formación en un fichero ya existente... ). Stream Reader Implementa un Text Reader que lee los caracteres de una secuencia de bytes. Stream Writer Implementa Text Writer para escribir los caracteres de una secuencia. Text Reader Representa un lector que puede leer una serie secuencial de caracteres. Text Writer Representa un escritor que puede escribir una serie secuencial de caracteres. | DAW Modulo 03 - Programacion A.pdf |
Programación-A99Por tanto, para manipular un fichero, que lo identificamos por un nombre, realizaremos tres operaciones: Abrir el fichero. Escribir o leer registros del fichero. Cerrar el fichero. A la hora de trabajar con ficheros, debemos tener en cuenta: La información es binaria (conjunto de ceros y unos). Al agrupar los bits, se forman bytes o palabras. Los tipos de datos van a estar formados por un conjunto de bytes o palabras. Al agrupar los campos, se crean los registros de infor-mación. Un fichero es un conjunto de bytes con una misma es-tructura. Los directorios tienen la función de agrupar distintos fi-cheros siguiendo unas condiciones determinadas dadas por el sistema operativo o por el programador. Utilidades de los ficheros Permiten organizar más fácilmente el sistema de archivos. Evitan conflictos con sus nombres, ya que cada programa instala sus ficheros en directorios diferentes. Por tanto, en una misma máquina pueden existir dos ficheros iden-tificados por el mismo nombre, ya que, como van a tener distinta ruta, los vamos a poder diferenciar. La relación entre ficheros y directorio es muy cercana, en C# se establece entre tipos y espacio de nombres. | DAW Modulo 03 - Programacion A.pdf |
Tema 5: Gestión de ficheros100Rutas de ficheros y directorios En el apartado anterior hemos visto la relación entre fiche-ro y directorio. Para la identificación inequívoca de este fichero, habrá que nombrar el camino que nos lleva hasta él. A este camino lo denominamos ruta. Dependiendo de cómo empecemos la ruta de directorio para nombrar el archivo, podemos tener dos tipos de rutas bien diferenciados: Ruta absoluta o completa: se indica el camino del direc-torio desde el comienzo. En el sistema operativo Linux, empieza por “/”. En el sistema operativo Windows o MS-DOS, cada partición posee un directorio raíz (por ejemplo, C:\). No existe un directorio raíz común que los contenga a todos ellos como en Linux. Ruta relativa: se le indica el camino del directorio desde la posición actual. Por tanto, la ruta no empezaría desde el directorio raíz. Tipos de ficheros Según su acceso: según la forma de organizar la infor-mación, podemos distinguir entre tres tipos diferentes de ficheros: -Secuencial: en los ficheros secuenciales, los registros se van almacenando en posiciones consecutivas de manera que cada vez que queramos acceder a ellos tendremos que empezar desde el primero e ir reco-rriéndolos de uno en uno. | DAW Modulo 03 - Programacion A.pdf |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.