.Net – Espamática https://espamatica.com Programación en 8 bits y algo más. Sat, 23 Aug 2025 16:19:36 +0000 es hourly 1 https://wordpress.org/?v=7.1.3 https://i0.wp.com/espamatica.com/wp-content/uploads/2023/11/LogoWeb.png?fit=32%2C29&ssl=1 .Net – Espamática https://espamatica.com 32 32 147753459 MediaTime https://espamatica.com/mediatime/ https://espamatica.com/mediatime/#respond Mon, 20 Mar 2023 07:57:14 +0000 https://espamatica.com/?p=264 MediaTime es una utilidad para control de tiempos multimedia, tanto de vídeo como de audio.

En vídeo, si hablamos de televisión, el tiempo se representa como h:mm:ss.ff:

  • h: horas
  • mm: minutos
  • ss: segundos
  • ff: frames

Es muy importante entender que el número de frames por segundo no altera la duración de un vídeo. Como ejemplo se puede decir que un vídeo de dos segundos de duración, si tiene veinticinco frames por segundo tiene cincuenta frames, si tiene treinta frames por segundo tiene sesenta frames, pero en ambos casos tiene una duración de dos segundos, la duración no cambia.

También es muy importante entender que un vídeo codificado a veinticinco frames por segundo, con una duración de un segundo y sesenta milésimas, tiene veintiséis frames que se reproducen durante cuarenta milésimas y un último frame que se reproduce durante veinte milésimas. El vídeo no tiene veintiséis frames y medio, sino veintisiete frames. El último frame se reproduce durante tan solo veinte milésimas, la mitad de tiempo que los otros veintiséis frames.

En el caso de esta utilidad, «ff» representa fracciones por segundo, y su valor se cambia a través de la propiedad FractionsPerSeconds. Al trabajar con vídeo en televisión, las fracciones por segundo más comunes son veinticinco o treinta, mientras que si se trabaja con audio la fracción más común es cien, o lo que es lo mismo centésimas.

Implementando MediaTime

La implementación que voy explicar es la de C#, aunque al final del artículo podéis descargar el código fuente en C#, Visual Basic .Net y C++ (es la primera vez que hago algo en C++). El espacio de nombres que voy a usar es Espamatica.Multimedia.Core, aunque sois libres de cambiarlo.

Lo primero que implemento es un enumerado para indicar como se van a redondear las fracciones para representarlas como texto: esto es muy importante a la hora de representar una parrilla de televisión.

C#
namespace Espamatica.Multimedia.Core
{
    /// <summary>
    /// Enumera los modos en lo que se pueden redondear las fracciones a la hora de su representación en texto.
    /// </summary>
    public enum FractionRoundMode
    {
        /// <summary>
        /// La fracción de trunca.
        /// </summary>
        Truncate,

        /// <summary>
        /// Si la fracción tiene decimales, se trunca y se le suma 1.
        /// </summary>
        Real,

        /// <summary>
        /// La fracción se redondea.
        /// </summary>
        Round
    } // FractionRoundMode
} // Espamatica.Multimedia.Core

He implementado tres tipos de redondeo de fracción. Si tenemos un vídeo a veinticinco frames por segundo, esto implica que cada frame se va a reproducir durante cuarenta milésimas. Según esto, si el vídeo tiene una duración de cincuenta milésimas, podríamos decir que el vídeo tiene un frame y cuarto (1.25), aunque en realidad tiene dos: uno se reproduce durante cuarenta milésimas y otro que se reproduce durante diez milésimas.

Teniendo en cuenta estos datos, el comportamiento según el valor seleccionado del enumerado sería:

Valor (milisegundos)FractionPerSecondsFraccionesFractionRoundModeResultado (fracciones)
50251.25Truncate1
50251.25Real2
50251.25Round1
60251.50Truncate1
60251.50Real2
60251.50Round2
Fracciones redondeadas según el valor asignado a FractionRoundMode

La implementación de MediaTime la realizo como una estructura, al modo de TimeSpam o DateTime.

C#
namespace Espamatica.Multimedia.Core
{
    using System;

    /// <summary>
    /// Estructura para manejo de tiempos multimedia.
    /// </summary>
    public struct MediaTime
    {
    } // MediaTime
} // Espamatica.Multimedia.Core

Lo primero que implemento son las constantes que voy a usar para definir el número de unidades inferiores que hay en una unidad superior (las defino como long para evitar posteriores transformaciones).

C#
/// <summary>
/// Número de ticks por milisegundo.
/// </summary>
public const long TicksMillisecond = 10000;

/// <summary>
/// Número de milisegundos por segundo.
/// </summary>
public const long MillisecondsSecond = 1000;

/// <summary>
/// Número de segundos por minuto.
/// </summary>
public const long SecondsMinute = 60;

/// <summary>
/// Número de minutos por hora.
/// </summary>
public const long MinutesHour = 60;

/// <summary>
/// Número de horas por día.
/// </summary>
public const long HoursDay = 24;

/// <summary>
/// Número de ticks por segundo.
/// </summary>
public const long TicksSecond = TicksMillisecond * MillisecondsSecond;

/// <summary>
/// Número de ticks por minuto.
/// </summary>
public const long TicksMinute = TicksSecond * SecondsMinute;

/// <summary>
/// Número de ticks por hora.
/// </summary>
public const long TicksHour = TicksMinute * MinutesHour;
        
/// <summary>
/// Número de ticks por día.
/// </summary>
public const long TicksDay = TicksHour * HoursDay;

Una vez implementadas estas constantes, implemento los campos privados que uso para las propiedades.

C#
/// <summary>
/// Campo de control para la propiedad Days.
/// </summary>
private int days;

/// <summary>
/// Campo de control para la propiedad DigitPerFraction.
/// </summary>
private int digitPerFraction;

/// <summary>
/// Campo de control para la propiedad Fractions.
/// </summary>
private double fractions;

/// <summary>
/// Campo de control para la propiedad FractionsPerSecond.
/// </summary>
private int fractionsPerSecond;

/// <summary>
/// Campo de control para la propiedad Hours.
/// </summary>
private int hours;

/// <summary>
/// Campo de control para la propiedad Milliseconds.
/// </summary>
private int milliseconds;

/// <summary>
/// Campo de control para la propiedad MillisecondsPerFraction.
/// </summary>
private double millisecondsPerFraction;

/// <summary>
/// Campo de control para la propiedad Minutes.
/// </summary>
private int minutes;

/// <summary>
/// Campo de control para la propiedad RoundMode.
/// </summary>
private FractionRoundMode roundMode;

/// <summary>
/// Campo de control para la propiedad Seconds.
/// </summary>
private int seconds;

/// <summary>
/// Campo de control para la propiedad Ticks.
/// </summary>
private int ticks;

/// <summary>
/// Campo de control para la propiedad Time.
/// </summary>
private long time;

Lo siguiente es implementar la propiedad donde indicaremos el número de fracciones por segundo con el que trabajaremos.

C#
/// <summary>
/// Obtiene el número de milisegundos por fracción.
/// </summary>
public double MillisecondsPerFraction
{
    get
    {
        return this.millisecondsPerFraction;
    }

    private set
    {
        if (value != this.millisecondsPerFraction)
        {
            this.millisecondsPerFraction = value;
        }
    }
} // MillisecondsPerFraction

Existen varias propiedades que al cambiar de valor refrescan el tiempo (time) y el tiempo multimedia (days, minutes, seconds, fractions, milliseconds y ticks). Lo siguiente que implemento son dos métodos que se encargan de realizar estas operaciones.

C#
/// <summary>
/// Actualiza los valores del tiempo mutimedia.
/// </summary>
private void RefreshMediaTime()
{
    long remainder = this.Time;

    this.days = (int)((remainder - (remainder % TicksDay)) / TicksDay);
    remainder -= this.days * TicksDay;

    this.hours = (int)((remainder - (remainder % TicksHour)) / TicksHour);
    remainder -= this.hours * TicksHour;

    this.minutes = (int)((remainder - (remainder % TicksMinute)) / TicksMinute);
    remainder -= this.minutes * TicksMinute;

    this.seconds = (int)((remainder - (remainder % TicksSecond)) / TicksSecond);
    remainder -= this.seconds * TicksSecond;

    this.fractions = ((double)remainder / (double)TicksMillisecond) / this.MillisecondsPerFraction;

    this.milliseconds = (int)((remainder - (remainder % TicksMillisecond)) /TicksMillisecond);
    remainder -= this.milliseconds * TicksMillisecond;

    this.ticks = (int)remainder;
} // RefreshMediaTime

/// <summary>
/// Actualiza el tiempo.
/// </summary>
private void RefreshTime()
{
	this.time = (this.Days * TicksDay) + (this.Hours * TicksHour) + (this.Minutes * TicksMinute)
		+ (this.Seconds *TicksSecond) + (this.Milliseconds * TicksMillisecond) + this.Ticks;
} // RefreshTime

En RefreshMediaTime lo primero que hago es cargar los ticks totales que representan el tiempo (Time) en la variable remainder. Lo siguiente es calcular el número de días enteros que representan esos ticks, y se los resto a remainder para quedarme con los ticks que quedan. Calculo las horas, minutos, segundos y milisegundos de la misma manera. Antes de calcular los milisegundos, calculo las fracciones que representan estos milisegundos (recordad que las fracciones pueden cambiar pero los milisegundos no). Por último, una vez realizados todos los cálculos, ya solo quedan los ticks sobrantes.

De esta manera he calculado que un número determinado de ticks representan N días, N horas, N minutos, N segundos, N milisegundos y N ticks, como si de un TimeSpan se tratara, pero además he calculado que los N milisegundos representan N fracciones, que pueden cambiar en base a las fracciones por segundo que se hayan especificado.

En RefreshTime hago la operación inversa, tomo todos los componentes del tiempo y calculo los ticks totales (observad que no tengo en cuenta las fracciones).

El siguiente paso es implementar las propiedades que representan los distintos componentes de tiempo en nuestra estructura.

C#
/// <summary>
/// Obtiene o establece los días.
/// </summary>
public int Days
{
	get
	{
		return this.days;
	}

	set
	{
		if (value != this.days)
		{
			this.days = value;

			this.RefreshTime();

			this.RefreshMediaTime();
		}
	}
} // Days

/// <summary>
/// Obtiene o establece las fracciones.
/// </summary>
public double Fractions
{
	get
	{
		return this.fractions;
	}

	set
	{
		if (value != this.fractions)
		{
			this.Milliseconds = (int)Math.Truncate(value * this.MillisecondsPerFraction);
		}
	}
} // Fractions

/// <summary>
/// Obtiene o establece las horas.
/// </summary>
public int Hours
{
	get
	{
		return this.hours;
	}

	set
	{
		if (value != this.hours)
		{
			this.hours = value;

			this.RefreshTime();

			this.RefreshMediaTime();
		}
	}
} // Hours

/// <summary>
/// Obtiene o establece los milisegundos.
/// </summary>
public int Milliseconds
{
	get
	{
		return this.milliseconds;
	}

	set
	{
		if (value != this.milliseconds)
		{
			this.milliseconds = value;

			this.RefreshTime();

			this.RefreshMediaTime();
		}
	}
} // Milliseconds

/// <summary>
/// Obtiene o establece los minutos.
/// </summary>
public int Minutes
{
	get
	{
		return this.minutes;
	}

	set
	{
		if (value != this.minutes)
		{
			this.minutes = value;

			this.RefreshTime();

			this.RefreshMediaTime();
		}
	}
} // Minutes

/// <summary>
/// Obtiene o establece los segundos.
/// </summary>
public int Seconds
{
	get
	{
		return this.seconds;
	}

	set
	{
		if (value != this.seconds)
		{
			this.seconds = value;

			this.RefreshTime();

			this.RefreshMediaTime();
		}
	}
} // Seconds

/// <summary>
/// Obtiene o establece los ticks.
/// </summary>
public int Ticks
{
	get
	{
		return this.ticks;
	}

	set
	{
		if (value != this.ticks)
		{
			this.ticks = value;

			this.RefreshTime();

			this.RefreshMediaTime();
		}
	}
} // Ticks

/// <summary>
/// Obtiene o establece el tiempo en ticks.
/// </summary>
public long Time
{
	get
	{
		return this.time;
	}

	set
	{
		if (value != this.time)
		{
			this.time = value;

			this.RefreshMediaTime();
		}
	}
} // Time

Podéis observar como la mayoría de estas propiedades llaman a RefreshMediaTime y RefreshTime cuando cambian su valor.

El siguiente paso es implementar la propiedades que faltan: dígitos necesarios para representar las fracciones, el número de fracciones por segundo y el modo de redondeo a la hora de representar las fracciones.

C#
/// <summary>
/// Obtiene el número de dígitos usados para representar las fracciones.
/// </summary>
public int DigitPerFraction
{
	get
	{
		return this.digitPerFraction;
	}

	private set
	{
		this.digitPerFraction = value;
	}
} // DigitPerFraction

/// <summary>
/// Obtiene o establece el número de fracciones por segundo.
/// </summary>
public int FractionsPerSeconds
{
	get
	{
		return this.fractionsPerSecond;
	}

	set
	{
		if (value != this.fractionsPerSecond)
		{
			if (value < 1 || value > (int)MillisecondsSecond)
			{
				value = 1000;
			}

			this.fractionsPerSecond = value;

			this.RefreshFractionPerSeconds();

			this.RefreshMediaTime();
		}
	}
} // FractionsPerSeconds

/// <summary>
/// Obtiene o establece el modo en el que se redondean las fracciones a la hora de representarlas en texto.
/// </summary>
public FractionRoundMode RoundMode
{
	get
	{
		return this.roundMode;
	}

	set
	{
		this.roundMode = value;
	}
} // RoundMode

Ahora mismo tenemos un error en el código ya que al asignar el valor a FractionsPerSeconds se llama a un método que todavía no está implementado, y ese es el siguiente paso.

C#
/// <summary>
/// Actualiza los datos relativos a las fracciones por segundo.
/// </summary>
private void RefreshFractionPerSeconds()
{
	if (this.FractionsPerSeconds > 0 && this.FractionsPerSeconds < (int)MillisecondsSecond)
	{
		this.MillisecondsPerFraction = Math.Round(1.0 / (double)this.FractionsPerSeconds * (double)MillisecondsSecond, 4);

		this.DigitPerFraction = this.FractionsPerSeconds.ToString().Length;

		if (Math.Pow(10.0, (double)this.DigitPerFraction - 1.0) == (double)this.FractionsPerSeconds)
		{
			this.DigitPerFraction--;
		}
	}
} // RefreshFractionPerSeconds

En RefreshFractionPerSeconds calculo el número de milisegundos que dura cada fracción, y el número de dígitos necesarios para representar las fracciones. El ajuste que hago en el número de dígitos necesarios para representar las fracciones (Math.Pow …) es debido a que las fracciones las represento empezando desde 0 (0 a 9, 0 a 99, 0 a 999, etcétera), por lo que si las fracciones por segundo son potencia de 10, hay que restar un dígito.

Cuando estamos trabajando con tiempo, es muy habitual que queramos sumar y restar tiempo, así como saber si es mayor, menor, igual, etcétera, motivo por el cual implemento la sobrecarga de diversos operadores.

C#
/// <summary>
/// Compara dos objetos para determinar si el primer objeto especificado es menor que el segundo objeto especificado.
/// </summary>
/// <param name="obj1">Primer objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Si el primer objeto especificado es menos que el segundo objeto especificado true, en caso contrario false.</returns>
public static bool operator <(MediaTime obj1, MediaTime obj2)
{
	return obj1.Time < obj2.Time;
} // <

/// <summary>
/// Compara dos objetos para determinar si el primer objeto especificado es menor o igual que el segundo objeto especificado.
/// </summary>
/// <param name="obj1">Primer objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Si el primer objeto especificado es menor o igual que el segundo objeto especificado true, en caso contrario false.</returns>
public static bool operator <=(MediaTime obj1, MediaTime obj2)
{
	return obj1.Time <= obj2.Time;
} // <=

/// <summary>
/// Campara dos objetos para determinar si el primer objeto especificado no es igual al segundo objeto especificado.
/// </summary>
/// <param name="obj1">Primer objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Si los dos objetos son distintos true, en caso contrario false.</returns>
public static bool operator !=(MediaTime obj1, MediaTime obj2)
{
	return !obj1.Equals(obj2);
} // !=

/// <summary>
/// Resta dos objetos especificados.
/// </summary>
/// <param name="obj1">Primero objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Objeto resultante de la resta.</returns>
public static MediaTime operator -(MediaTime obj1, MediaTime obj2)
{
	MediaTime mt = new MediaTime(obj1.Time, obj1.FractionsPerSeconds);

	mt.Time -= obj2.Time;

	return mt;
} // -

/// <summary>
/// Suma dos objetos especificados.
/// </summary>
/// <param name="obj1">Primero objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Objeto resultante de la suma.</returns>
public static MediaTime operator +(MediaTime obj1, MediaTime obj2)
{
	MediaTime mt = new MediaTime(obj1.Time, obj1.FractionsPerSeconds);

	mt.Time += obj2.Time;

	return mt;
} // +

/// <summary>
/// Campara dos objetos para determinar si el primer objeto especificado es igual al segundo objeto especificado.
/// </summary>
/// <param name="obj1">Primer objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Si los dos objetos son iguales true, en caso contrario false.</returns>
public static bool operator ==(MediaTime obj1, MediaTime obj2)
{
	return obj1.Equals(obj2);
} // ==

/// <summary>
/// Compara dos objetos para determinar si el primer objeto especificado es mayor que el segundo objeto especificado.
/// </summary>
/// <param name="obj1">Primer objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Si el primer objeto especificado es mayor que el segundo objeto especificado true, en caso contrario false.</returns>
public static bool operator >(MediaTime obj1, MediaTime obj2)
{
	return obj1.Time > obj2.Time;
} // >

/// <summary>
/// Compara dos objetos para determinar si el primer objeto especificado es mayor o igual que el segundo objeto especificado.
/// </summary>
/// <param name="obj1">Primer objeto especificado.</param>
/// <param name="obj2">Segundo objeto especificado.</param>
/// <returns>Si el primer objeto especificado es mayor o igual que el segundo objeto especificado true, en caso contrario false.</returns>
public static bool operator >=(MediaTime obj1, MediaTime obj2)
{
	return obj1.Time >= obj2.Time;
} // >=

Llegados a este punto, me falta un constructor que reciba dos parámetros.

C#
 #region Constructors
 /// <summary>
 /// Inicializa una nueva instancia de la estructura MediaTime.
 /// </summary>
 /// <param name="time">Tiempo en ticks.</param>
 /// <param name="fractionsPerSecond">Fracciones por segundo (entre 1 y 1000).</param>
 public MediaTime(long time, int fractionsPerSecond)
 {
   if (fractionsPerSecond < 1 || fractionsPerSecond > MediaTime.MillisecondsSecond)
   {
     throw new ArgumentOutOfRangeException("fractionsPerSecond", fractionsPerSecond, string.Format("to {0} from {1}", 1, MediaTime.MillisecondsSecond));
   }

   this.days = 0;
   this.digitPerFraction = 0;
   this.fractions = 0;
   this.fractionsPerSecond = fractionsPerSecond;
   this.hours = 0;
   this.milliseconds = 0;
   this.millisecondsPerFraction = 0.0;
   this.minutes = 0;
   this.roundMode = FractionRoundMode.Truncate;
   this.seconds = 0;
   this.ticks = 0;
   this.time = time;

   this.RefreshFractionPerSeconds();

   this.RefreshMediaTime();
 } // MediaTime

Lo último que implemento es una serie de métodos que permiten sumar o restar unidades de tiempo, determinar si dos objetos son iguales, obtener la cantidad total de tiempo representada por uno de sus componentes u obtener la representación en texto del tiempo.

Empiezo por los métodos que permiten sumar o restar unidades de tiempo.

C#
/// <summary>
/// Añade el número de días especificado al tiempo actual.
/// </summary>
/// <param name="days">Número de días especificado.</param>
public void AddDays(int days)
{
	this.Time += (long)days * TicksDay;
} // AddDays

/// <summary>
/// Añade el número de horas especificado al tiempo actual.
/// </summary>
/// <param name="hours">Número de horas especificado.</param>
public void AddHours(int hours)
{
	this.Time += (long)hours * TicksHour;
} // AddHours

/// <summary>
/// Añade el número de fracciones especificado al tiempo actual.
/// </summary>
/// <param name="fractions">Número de fracciones especificado.</param>
public void AddFractions(int fractions)
{
	this.Time += (long)((double)fractions * this.MillisecondsPerFraction * (double)TicksMillisecond);
} // AddFractions

/// <summary>
/// Añade el número de milisegundos especificado al tiempo actual.
/// </summary>
/// <param name="milliseconds">Número de milisegundos especificado.</param>
public void AddMilliseconds(int milliseconds)
{
	this.Time += (long)milliseconds * TicksMillisecond;
} // AddMilliseconds

/// <summary>
/// Añade el número de minutos especificado al tiempo actual.
/// </summary>
/// <param name="minutes">Número de minutos especificado.</param>
public void AddMinutes(int minutes)
{
	this.Time += (long)minutes * TicksMinute;
} // AddMinutes

/// <summary>
/// Añade el número de segundos especificado al tiempo actual.
/// </summary>
/// <param name="seconds">Número de segundos especificado.</param>
public void AddSeconds(int seconds)
{
	this.Time += (long)seconds * TicksSecond;
} // AddSeconds

/// <summary>
/// Añade el número de ticks especificado al tiempo actual.
/// </summary>
/// <param name="ticks">Número de ticks especificado.</param>
public void AddTicks(int ticks)
{
	this.Time += (long)ticks;
} // AddTicks

Aunque todos los métodos son Add, para restar solo hay que pasarle valores negativos. Por otro lado, al contrario de lo que pasa con los operadores que permiten sumar o restar objetos MediaTime y devuelven el resultado en un nuevo objeto, los métodos Add alteran el valor Time de la instancia con la que se está trabajando.

El siguiente par de métodos que implemento evalúa si dos instancias de MediaTime son consideradas iguales, el primero, y obtiene el código hash de la instancia, el segundo.

C#
/// <summary>
/// Compara el objeto especificado con la instacia actual para determinar si se consideran iguales.
/// </summary>
/// <param name="obj">Objeto especificado.</param>
/// <returns>Si los dos objetos son considerados iguales true, en caso contrario false.</returns>
public override bool Equals(object obj)
{
	return obj is MediaTime && ((MediaTime)obj).Time == this.Time;
} // Equals

/// <summary>
/// Obtiene el código hash de la instancia actual.
/// </summary>
/// <returns>Código hash de la instancia actual.</returns>
public override int GetHashCode()
{
	return this.Time.GetHashCode();
} // GetHashCode

Y vamos llegando al final. Implemento una serie de métodos Get que obtienen las unidades totales de los distintos componentes de tiempo que representa el valor de MediaTime.

C#
/// <summary>
/// Obtiene el número total de días.
/// </summary>
/// <returns>Número total de días.</returns>
public double GetTotalDays()
{
	return (double)this.Time / (double)TicksDay;
} // GetTotalDays

/// <summary>
/// Obtiene el número total de fracciones.
/// </summary>
/// <returns>Número total de fracciones.</returns>
public double GetTotalFractions()
{
	return (double)this.Time / (double)TicksMillisecond / this.MillisecondsPerFraction;
} // GetTotalFractions

/// <summary>
/// Obtiene el número total de horas.
/// </summary>
/// <returns>Número total de horas.</returns>
public double GetTotalHours()
{
	return (double)this.Time / (double)TicksHour;
} // GetTotalHours

/// <summary>
/// Obtiene el número total de milisegundos.
/// </summary>
/// <returns>Número total de milisegundos.</returns>
public double GetTotalMilliseconds()
{
	return (double)this.Time / (double)TicksMillisecond;
} // GetTotalMilliseconds

/// <summary>
/// Obtiene el número total de minutos.
/// </summary>
/// <returns>Número total de minutos.</returns>
public double GetTotalMinutes()
{
	return (double)this.Time / (double)TicksMinute;
} // GetTotalMinutes

/// <summary>
/// Obtiene el número total de segundos.
/// </summary>
/// <returns>Número total de segundos.</returns>
public double GetTotalSeconds()
{
	return (double)this.Time / (double)TicksSecond;
} // GetTotalSeconds

Y por último, pero no menos importante, implemento el método con el que obtengo la representación en cadena de texto del valor de MediaTime.

C#
/// <summary>
/// Obtiene la representación en cadena del tiempo actual.
/// </summary>
/// <returns>Representación en cadena del tiempo actual.</returns>
public override string ToString()
{
	int fractionsRounded = 0;

	switch (this.RoundMode)
	{
		case FractionRoundMode.Real:
			fractionsRounded = this.fractions % 1 > 0.0 
				? (int)Math.Truncate(this.fractions) + 1 
				: (int)this.fractions;

			break;

		case FractionRoundMode.Round:
			fractionsRounded = (int)Math.Round(this.fractions, 0, MidpointRounding.AwayFromZero);

			break;

		default:
			fractionsRounded = (int)Math.Truncate(this.fractions);

			break;
	}

	string fractions = fractionsRounded.ToString().PadLeft(this.DigitPerFraction, '0');

	return string.Format("{0:d2}:{1:d2}:{2:d2}:{3:d2}.{4}", 
		new object[] 
		{ 
			this.Days, 
			this.Hours, 
			this.Minutes, 
			this.Seconds, 
			fractions });
} // ToString

Ya solo queda ver si todo funciona, lo cual voy a comprobar con una aplicación de consola.

C#
namespace Espamatica.Multimedia.Core
{
    using System;

    /// <summary>
    /// Programa de ejemplo.
    /// </summary>
    public class Sample
    {
        /// <summary>
        /// Punto de inicio del programa.
        /// </summary>
        public static void Main()
        {
            MediaTime time = new MediaTime((new TimeSpan(0, 27, 34, 45, 60)).Ticks, 25);

            Console.WriteLine(time.ToString());

            time.AddFractions(1);

            Console.WriteLine(time.ToString());

            time.FractionsPerSeconds = 30;

            Console.WriteLine(time.ToString());

            time.AddFractions(1);

            Console.WriteLine(time.ToString());

            time.RoundMode = FractionRoundMode.Round;

            Console.WriteLine(time.ToString());

            time.RoundMode = FractionRoundMode.Real;

            Console.WriteLine(time.ToString());

            Console.Read();
        }
    }
} // Espamatica.Multimedia.Core

El resultado de la ejecución es el siguiente.

MediaTime
Prueba de MediaTime.

Aquí puedes descargar el código fuente en C#, Visual Basic .Net y C++.

También puedes visitar el resto de tutoriales:

Y recuerda, si lo usas no te limites a copiarlo, intenta entenderlo y adaptarlo a tus necesidades.

MediaTime

]]> https://espamatica.com/mediatime/feed/ 0 264 NullableDateTimePicker https://espamatica.com/nullabledatetimepicker/ https://espamatica.com/nullabledatetimepicker/#respond Mon, 20 Mar 2023 07:26:35 +0000 https://espamatica.com/?p=1708 Una de las solicitudes habituales de los usuarios, cuando desarrollamos una aplicación Windows Forms en .Net, es que si no se selecciona ninguna fecha en un control DateTimePicker, no aparezca ninguna fecha reflejada.

El control DateTimePicker se puede configurar para que muestre un CheckBox, y si este no está seleccionado la fecha se difumina dando apariencia de no estar habilitada, pero los usuarios prefieren que no aparezca fecha alguna: este es el aspecto que he implementado en NullableDateTimePicker.

NullableDateTimePicker es una clase que hereda de DateTimePicker, en la que he implementado dos propiedades, ocultado otras dos e implementado un controlador de evento.

Lo primero es importar los espacios de nombres necesarios, que en este caso son tres.

C#
using System;
using System.ComponentModel;   
using System.Windows.Forms;

En realidad System.ComponentModel no es necesario, pero a mi personalmente me gusta dejarlo todo lo máximo documentado posible. Con System.ComponentModel añado descripciones a las propiedades para que aparezcan en tiempo de diseño y las incluyo en la categoría que creo conveniente (esto lo podéis adaptar a vuestro gusto). También limito que quiero que se muestre en tiempo de diseño.

Lo siguiente es implementar dos propiedades para indicar el formato en el que se debe mostrar la fecha cuando se muestra el CheckBox y esta chequedao, DefaultFormat, y el formato cuando se muestra el CheckBox y no está chequeado, NullFormat.

C#
public DateTimePickerFormat DefaultFormat { get; set; }

public DateTimePickerFormat NullFormat { get; set; }

Hay dos propiedades de DateTimePicker que vamos a usar, pero las vamos a ocultar con nuestra implementación para que funcionen de manera distinta a como lo hacen, Checked y Format.

C#
public new bool Checked
{
    get
    {
        return base.Checked;
    }

    set
    {
        base.Checked = value;

        this.OnValueChanged(new EventArgs());
    }
}

public new DateTimePickerFormat Format
{
    get
    {
        return base.Format;
    }

    internal set
    {
        base.Format = value;
    }
}

En el caso de Checked, la única diferencia es que desencadena el evento ValueChanged, y dado que Checked no es virtual, he tenido que ocultarla.

En el caso de Format, quiero que el valor no se pueda asignar directamente, por eso he cambiado el modificador de set y lo he puesto como internal. Como se verá en el código final, he usado System.ComponentModel para que la propiedad Format no sea accesible en tiempo de diseño.

He implementado un constructor para asignar valores por defecto a las propiedades cuando se agrega el control desde el cuadro de herramientas a, por ejemplo, un formulario.

C#
public NullableDateTimePicker()
{
    this.DefaultFormat = this.NullFormat = DateTimePickerFormat.Long;

    this.Format = this.Checked ? this.DefaultFormat : this.NullFormat;

    this.ValueChanged += this.NullableDateTimePicker_ValueChanged;
}

Como podéis ver, también he añadido un controlador al evento ValueChanged de DateTimePicker.

Por último, he implementado dicho controlador para cambiar el formato dependiendo de si CheckBox está o no chequeado.

C#
private void NullableDateTimePicker_ValueChanged(object sender, EventArgs e)
{
    this.Format = this.Checked ? this.DefaultFormat : this.NullFormat;
}

Y con esto ya tenemos todo lo necesario para que, cuando mostremos el CheckBox y borremos la fecha, el control no muestre nada. Para que se comporte de esta manera tenéis que configurar el control de la siguiente manera.

ShowCheckBox = true
NullFormat = CustomFormat
CustomFormat = " "

Una última cosa a tener en cuenta es a la hora de enlazar el control con una propiedad, de por ejemplo una clase, de tal manera que cuando cambie la propiedad de la clase se actualice el valor del control y viceversa, es la forma en la que lo debemos implementar.

clase.Fecha = nullableDateTimePicker.Checked ? nullableDateTimePicker.Value.Date : null;
if (clase.Fecha.HasValue)
{
    nullableDateTimePicker.Value = clase.Fecha.Value;
    nullableDateTimePicker.Checked = true;
}
else
{
    nullableDateTimePicker.Checked = false;
}

NullableDateTimePicker, el resultado final

Y éste es el resultado final de la clase. Cambiadlo y adaptadlo a vuestro gusto, si algo os parece que no está bien mejoradlo, pero sobre todo no os limitéis a copiarlo, intentad entenderlo. Seguro que hay otras formas de implementarlo.

C#
namespace Espamatica.Windows.Forms
{
    #region Includes
    using System;
    using System.ComponentModel;
    using System.Windows.Forms;
    #endregion
    
    /// <summary>
    /// <para>NullableDateTimePicker que permite mostrar la fecha en blanco cuando se muestra el CheckBox y Checked es false.</para>
    /// <para>Valores a proporcionar:</para>
    /// <para>DefaultFormat: formato de la fecha cuando Checked = true.</para>
    /// <para>NullFormat: formato de la fecha cuando Checked = true (Custom para que no muestre nada).</para>
    /// <para>CustomFormat: espacio en blanco para que no muestre nada.</para>
    /// </summary>
    public class NullableDateTimePicker : DateTimePicker
    {
        #region Constructores
        /// <summary>
        /// Incializa una nueva instancia de la clase NullableDateTimePicker.
        /// </summary>
        public NullableDateTimePicker()
        {
            this.DefaultFormat = this.NullFormat = DateTimePickerFormat.Long;

            this.Format = this.Checked ? this.DefaultFormat : this.NullFormat;

            this.ValueChanged += this.NullableDateTimePicker_ValueChanged;
        } // NullableDateTimePicker
        #endregion

        #region Propiedades públicas
        /// <summary>
        /// Obtiene o establece un valor que indica si la propiedad System.Windows.Forms.DateTimePicker.Value
        /// se ha establecido con un valor de fecha y hora válido, y si el valor mostrado
        /// se puede actualizar.
        /// </summary>
        [Category("Comportamiento")]
        [Description("Cuando ShowSelectBox está establecida en true, determina si la casilla está activada, indicando que el usuario ha seleccionado un valor.")]
        public new bool Checked
        {
            get
            {
                return base.Checked;
            }

            set
            {
                base.Checked = value;

                this.OnValueChanged(new EventArgs());
            }
        } // Checked

        /// <summary>
        /// Obtiene o establece el formato por defecto en el que se muestra el valor cuando Checked = true.
        /// </summary>
        [Category("Apariencia")]
        [Description("Obtiene o establece el formato por defecto en el que se muestra el valor cuando checked = true.")]
        public DateTimePickerFormat DefaultFormat { get; set; }

        /// <summary>
        /// Obtiene o establece el formato.
        /// </summary>
        [Browsable(false)]
        [Category("Apariencia")]
        [Description("Obtiene o establece el formato.")]
        public new DateTimePickerFormat Format
        {
            get
            {
                return base.Format;
            }

            internal set
            {
                base.Format = value;
            }
        } // Format

        /// <summary>
        /// Obtiene o establece el formato por defecto en el que se muestra el valor cuando Checked = false.
        /// </summary>
        [Category("Apariencia")]
        [Description("Obtiene o establece el formato por defecto en el que se muestra el valor cuando Checked = false.")]
        public DateTimePickerFormat NullFormat { get; set; }
        #endregion

        #region Métodos privados
        /// <summary>
        /// Controlador del evento ValueChanged de NullableDateTimePicker.
        /// </summary>
        /// <param name="sender">Objeto que desencadena el evento.</param>
        /// <param name="e">Datos del evento.</param>
        private void NullableDateTimePicker_ValueChanged(object sender, EventArgs e)
        {
            this.Format = this.Checked ? this.DefaultFormat : this.NullFormat;
        } // NullableDateTimePicker_ValueChanged
        #endregion
    } // NullableDateTimePicker
} // Espamatica.Windows.Forms
NullableDateTimePicker

También puedes visitar el resto de tutoriales:

Y recuerda, si lo usas no te limites a copiarlo, intenta entenderlo y adaptarlo a tus necesidades.

]]> https://espamatica.com/nullabledatetimepicker/feed/ 0 1708