> **EXAME TÉCNICO: DESENVOLVEMENTO E BASES DE DATOS**

# I. SINTAXE E LÓXICA (Visual Studio .NET / C# o VB.NET)

*Nota: Puedes responder en el lenguaje de .NET que prefieras o en pseudocódigo si lo que quieres es explicar la lógica.*

## 1. El bucle infinito (Tema 1):

Observa el siguiente fragmento de lógica (imagina que es C#) y dime qué está mal o qué pasará al ejecutarlo. Justifica tu respuesta:
C#

```cs
int contador = 10;
while (contador > 0) 
{
    Console.WriteLine("Procesando datos...");
    if (contador == 5) 
    {
        continue;
    }
    contador--;
}
```

### Respuesta

Es un bucle infinito porque al iterar, éste reducirá hasta 5, donde quedaría en un bucle infinito por ser mayor que 0 e igual a 5, por culpa de la condición y su `continue`.

### Corrección

Correcto. Lo has cazado perfectamente. Al llegar a 5, el `continue` salta directamente a la siguiente evaluación del `while` antes de llegar al `contador--`. Como 5 > 0, entra otra vez, llega al 5, salta... y ahí se queda para siempre.

## 2. El reto de la POO (Tema 4):

Tienes que diseñar una clase básica para gestionar un **Ticket de Soporte** del Ayuntamiento (Tema 27).

- Define una clase `Ticket` que tenga:
    - Un atributo privado para el `id`.
    - Una propiedad pública para la `descripcion`.
    - Un **constructor** que inicialice el `id`.
    - Un método que devuelva si el ticket está "Urgente" (si la descripción contiene la palabra "CRÍTICO").

### Respuesta

En C#:

```cs

namespace Examen{
    class Ticket{

        private int id;
        public string descripcion = "DESCONOCIDO";

        public Ticket(int id){
            this.id = id;
        }

        public bool es_urgente(){
            return this.descripcion == "CRÍTICO";
        }

    }
}

```

En Python:

```py
from typing import Self

class Ticket:

    def __init__(self:Self, id:int) -> None:
        self.__id:int = id
        self.description:str = "DESCONOCIDO"

    def es_urgente(self:Self) -> bool:
        return self.descripcion == "CRÍTICO"

```

### Corrección

Aquí hay un par de matices importantes:

- **C#**: En el método `es_urgente`, el enunciado pedía si la descripción **contiene** la palabra "CRÍTICO". Tu código hace un `==`, lo cual solo funcionaría si la descripción fuera *exactamente* esa palabra.
    - *Corrección*: `return this.descripcion.Contains("CRÍTICO");`
- **Python**: ¡Cuidado! En el constructor definiste `self.description`, pero en el método usas `self.descripcion` (en español). Además, te pasó lo mismo con el `==`.

# II. LINGUAXE DE CONSULTAS SQL (Tema 7)

## 3. La consulta de los Usuarios (SQL Server):

Tenemos una tabla llamada `Usuarios` con las columnas: `id`, `nome`, `departamento` y `data_alta`.

Escribe una consulta SQL que devuelva:

- El nombre de los usuarios.
- Que pertenezcan al departamento de 'Informática'.
- Que se hayan dado de alta en el año 2023.
- Ordenados alfabéticamente por nombre.

### Respuesta

En SQL Server:

```sql
use Examen

select nombre where dbo.Usuarios where 
    departamento = 'Informática' and 
    year(data_alta) = 2023 
order by nombre asc

```

En MySQL/MariaDB

```sql
use Examen;

select nombre where Usuarios where 
    departamento = 'Informática' and 
    year(data_alta) = 2023 
order by nombre asc

```

En SQLite:

```sql

select nombre where Usuarios where 
    departamento = 'Informática' and 
    year(data_alta) = 2023 
order by nombre asc

```

### Corrección

¡Aquí el cansancio te ha traicionado! Has escrito:

`SELECT nombre WHERE Usuarios WHERE...`

- **O erro**: En SQL no se usa `WHERE` para indicar la tabla, se usa `FROM`.
- **A solución correcta**:

```sql
SELECT nome FROM Usuarios 
WHERE departamento = 'Informática' 
    AND YEAR(data_alta) = 2023 
ORDER BY nome ASC;
```

*(Nota: Usaste "nombre" en el SELECT pero la columna en el enunciado era "nome", ¡ojo con los enunciados traicioneros!).*

# III. TRAPALHADAS TÉCNICAS (Pregunta Trampa)

4. Valor vs Referencia (Tema 1):

Si tengo una variable de tipo int y la paso a un método para incrementarla, pero al salir del método el valor sigue siendo el original... ¿Qué ha pasado? ¿Cómo lo solucionarías en .NET?

## Respuesta

Cuando se hace un paso de variable nativa o cruda, como pasa con int, ésta se clona haciendo referencia a otro punto en memoria por lo que por defecto, si haces un incremento dentro de la función, el ámbito local de la misma, así como su definición en los argumentos de entrada impiden hacer uso de la original. Para solventar dicho problema podemos hacer un paso por referencia.

```cs

namespace Examen{
    class Prueba{

        public static void incrementar(ref int valor){
            valor ++;
        }

    }
}

```

## Corrección

**Perfecto**. La explicación del clonado en memoria (stack vs heap) es correcta. El uso de la palabra clave `ref` es la solución exacta en .NET para tipos por valor como `int`.