> For the complete documentation index, see [llms.txt](https://elguerre.gitbook.io/de0an/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://elguerre.gitbook.io/de0an/capitulo-9-la-construccion.-navegacion-y-configuracion-de-usuario/herramientas-de-diagnosticos.md).

# Herramientas de Diagnosticos

Aunque ya disponemos de las builds y pruebas automáticas, estas no son suficientes para la detección y depuración de errores. También contamos con el gestor de trazas que hemos creado en el capítulo anterior. Además de estas opciones, existen otras situaciones difíciles de detectar que requieren herramientas y enfoques adicionales para asegurar la estabilidad y el rendimiento óptimo de la aplicación.

## Rendimiento y Diagnósticos

Tal y como comentamos en el **Capítulo 1**, el rendimiento de una aplicación es crucial para la experiencia del usuario. Una aplicación lenta o que consume excesivos recursos puede llevar a la insatisfacción del usuario e incluso a la desinstalación de la aplicación. Por ello, es esencial utilizar herramientas de diagnóstico que nos permitan identificar y resolver problemas de rendimiento.

Una de las herramientas más potentes para el análisis de rendimiento en aplicaciones UWP es el **Performance Profiler** de Visual Studio. Esta herramienta nos permite monitorizar el uso de CPU, memoria, y otros recursos en tiempo real, identificar cuellos de botella y optimizar el rendimiento de nuestra aplicación.

**Recursos Adicionales:**

* [Herramientas de generación de perfiles de Visual Studio](https://learn.microsoft.com/es-es/visualstudio/profiling/profiling-feature-tour)

### Uso del Performance Profiler

1. **Iniciar el Profiler:**
   * Abre tu proyecto en Visual Studio.
   * Ve al menú **Debug** > **Performance Profiler**.
   * Selecciona las herramientas que deseas utilizar, como **CPU Usage**, **Memory Usage**, etc.
   * Haz clic en **Start** para comenzar la sesión de perfilado.
2. **Analizar los Resultados:**
   * Realiza las acciones en tu aplicación que deseas analizar.
   * Detén la sesión de perfilado haciendo clic en **Stop collection**.
   * Visualiza los resultados detallados proporcionados por el profiler para identificar áreas de mejora.

### Integración del Gestor de Trazas

En el **Capítulo Anterior**, implementamos un gestor de trazas que nos permite registrar eventos y errores durante la ejecución de la aplicación. Este gestor es fundamental para la depuración y el análisis de comportamientos inesperados.

```csharp
// TraceManager.cs
public static class TraceManager
{
    private static readonly List<string> _traces = new List<string>();

    public static void Log(string message)
    {
        _traces.Add($"{DateTime.Now}: {message}");
        Debug.WriteLine(message);
    }

    public static IEnumerable<string> GetTraces()
    {
        return _traces;
    }
}
```

**Uso del TraceManager:**

```csharp
// Ejemplo de uso en un ViewModel
public class MainViewModel : INotifyPropertyChanged
{
    public MainViewModel()
    {
        try
        {
            // Lógica de inicialización
            TraceManager.Log("MainViewModel inicializado correctamente.");
        }
        catch (Exception ex)
        {
            TraceManager.Log($"Error en MainViewModel: {ex.Message}");
        }
    }

    // Implementación de INotifyPropertyChanged
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string name = null) =>
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
```

## Herramientas Adicionales del Emulador

Como ya vimos en el **Capítulo 4**, tenemos a nuestra disposición una serie de herramientas para probar muchas de las características de un dispositivo real desde el emulador: **Acelerómetro**, **Notificaciones**, **Sensores** y **Red**. Es el momento de ver cómo podemos probar cada una de ellas:

* **Acelerómetro:** *No aplica para ePomo3.*
* **Notificaciones:** \[Ver en capítulos posteriores.]
* **Sensores:**

  Los sensores proporcionan datos sobre el entorno físico del dispositivo, como la orientación, el movimiento y otros factores. Probar sensores en el emulador puede ser desafiante debido a la falta de hardware físico, pero UWP proporciona herramientas que simulan estos sensores.

  **Simulación de Sensores en el Emulador:**

  1. **Abrir el Emulador:**
     * Inicia el emulador desde Visual Studio seleccionando **Debug** > **Start Without Debugging**.
  2. **Acceder a las Opciones de Simulación:**
     * En la ventana del emulador, haz clic en el icono de **More** (tres puntos) para abrir el menú de herramientas adicionales.
  3. **Simular Datos del Sensor:**
     * Navega a la sección **Sensors**.
     * Ajusta los valores de los sensores como **Acelerómetro**, **Giróscopo** y **Magnetómetro** según las necesidades de tu prueba.
     * Observa cómo tu aplicación responde a estos cambios en tiempo real.

  **Ejemplo de Uso del Acelerómetro en Código:**

  ```csharp
  using Windows.Devices.Sensors;

  public class SensorViewModel : INotifyPropertyChanged
  {
      private Accelerometer _accelerometer;
      private AccelerometerReading _currentReading;

      public AccelerometerReading CurrentReading
      {
          get => _currentReading;
          set
          {
              _currentReading = value;
              OnPropertyChanged();
          }
      }

      public SensorViewModel()
      {
          _accelerometer = Accelerometer.GetDefault();
          if (_accelerometer != null)
          {
              _accelerometer.ReadingChanged += Accelerometer_ReadingChanged;
          }
      }

      private void Accelerometer_ReadingChanged(Accelerometer sender, AccelerometerReadingChangedEventArgs args)
      {
          var reading = args.Reading;
          // Actualizar la propiedad en el hilo de la UI
          var ignore = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(
              CoreDispatcherPriority.Normal, () =>
              {
                  CurrentReading = reading;
              });
      }

      // Implementación de INotifyPropertyChanged
      public event PropertyChangedEventHandler PropertyChanged;
      protected void OnPropertyChanged([CallerMemberName] string name = null) =>
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
  }
  ```
* **Red:**

  Probar las capacidades de red de la aplicación es esencial para garantizar que funcione correctamente en diferentes condiciones de conectividad. El emulador de UWP incluye herramientas para simular diversas condiciones de red.

  **Simulación de Condiciones de Red:**

  1. **Abrir el Emulador:**
     * Inicia el emulador desde Visual Studio.
  2. **Acceder a las Opciones de Red:**
     * Haz clic en el icono de **More** (tres puntos) en la ventana del emulador.
     * Selecciona **Network**.
  3. **Configurar la Simulación:**
     * Puedes elegir entre diferentes perfiles de red, como **Full Speed**, **3G**, **Edge**, etc.
     * También puedes simular la pérdida de conexión o introducir latencia y pérdida de paquetes.

  **Ejemplo de Manejo de Cambios en la Conectividad:**

  ```csharp
  using Windows.Networking.Connectivity;

  public class NetworkViewModel : INotifyPropertyChanged
  {
      private bool _isConnected;

      public bool IsConnected
      {
          get => _isConnected;
          set
          {
              if (_isConnected != value)
              {
                  _isConnected = value;
                  OnPropertyChanged();
              }
          }
      }

      public NetworkViewModel()
      {
          var profile = NetworkInformation.GetInternetConnectionProfile();
          UpdateConnectionStatus(profile);

          NetworkInformation.NetworkStatusChanged += OnNetworkStatusChanged;
      }

      private void OnNetworkStatusChanged(object sender)
      {
          var profile = NetworkInformation.GetInternetConnectionProfile();
          UpdateConnectionStatus(profile);
      }

      private void UpdateConnectionStatus(ConnectionProfile profile)
      {
          IsConnected = profile != null &&
                        profile.GetNetworkConnectivityLevel() == NetworkConnectivityLevel.InternetAccess;
      }

      // Implementación de INotifyPropertyChanged
      public event PropertyChangedEventHandler PropertyChanged;
      protected void OnPropertyChanged([CallerMemberName] string name = null) =>
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
  }
  ```

## Integración con el Gestor de Trazas

El **gestor de trazas** que implementamos en el **Capítulo Anterior** juega un papel fundamental en el diagnóstico y depuración de la aplicación. Al registrar eventos clave y errores, nos permite tener una visión clara del comportamiento de la aplicación en diferentes escenarios.

**Ejemplo de Uso del Gestor de Trazas en el Servicio `AppointmentService`:**

```csharp
// AppointmentService.cs
public class AppointmentService
{
    private readonly ICalendarProvider _calendarProvider;

    public AppointmentService(ICalendarProvider calendarProvider)
    {
        _calendarProvider = calendarProvider;
        TraceManager.Log("AppointmentService inicializado.");
    }

    public async Task<IEnumerable<Appointment>> GetAppointmentsAsync(DateTime date)
    {
        try
        {
            TraceManager.Log($"Obteniendo citas para la fecha: {date.ToShortDateString()}.");
            var appointments = await _calendarProvider.FetchAppointmentsAsync(date);
            TraceManager.Log($"Citas obtenidas: {appointments.Count()}.");
            return appointments;
        }
        catch (Exception ex)
        {
            TraceManager.Log($"Error al obtener citas: {ex.Message}");
            throw;
        }
    }

    // Otros métodos relacionados con la gestión de citas
}
```

## Buenas Prácticas en el Uso de Herramientas de Diagnósticos

Para maximizar la eficacia de las herramientas de diagnóstico, es importante seguir algunas **buenas prácticas**:

* **Monitoreo Continuo:** Implementa monitoreo continuo del rendimiento y los errores para detectar y resolver problemas de manera proactiva.
* **Análisis de Trazas:** Revisa regularmente las trazas registradas para identificar patrones y tendencias que puedan indicar problemas subyacentes.
* **Pruebas en Diferentes Condiciones:** Utiliza el emulador para probar la aplicación bajo diversas condiciones de hardware y red, asegurando que funcione correctamente en una variedad de escenarios.
* **Optimización Basada en Datos:** Utiliza los datos recopilados por las herramientas de diagnóstico para guiar las optimizaciones y mejoras de la aplicación.
* **Documentación y Reportes:** Mantén una documentación clara de los hallazgos de diagnóstico y las acciones tomadas para resolverlos, facilitando la colaboración y el seguimiento.

## Conclusión

Implementar y utilizar adecuadamente las herramientas de diagnóstico es esencial para garantizar la estabilidad, el rendimiento y la calidad de una aplicación UWP. Al combinar las builds y pruebas automáticas con un gestor de trazas robusto y las capacidades de diagnóstico proporcionadas por el emulador y Visual Studio, podemos identificar y resolver eficazmente una amplia gama de problemas que podrían afectar la experiencia del usuario.

**Ver también:**

* [Herramientas de generación de perfiles de Visual Studio](https://learn.microsoft.com/es-es/visualstudio/profiling/profiling-feature-tour)