<#@ template debug="false" hostspecific="false" language="C#" #> <#@ output extension=".cs" #> // Attention : ce fichier a été automatiquement généré par un // template T4. Toute modification manuelle sera écrasée !!! using System; using System.Text.RegularExpressions; namespace Developpez.Dotnet.Measures { <# var units = new[] { new { TypeName = "Kelvin", DisplayName = "kelvins", ConversionToKelvin = "{0}", ConversionFromKelvin = "{0}", ParseRegex = "(?.*) ?K", StringFormat = "{0} K", AbsoluteZero = "0" }, new { TypeName = "Celsius", DisplayName = "degrés Celsius", ConversionToKelvin = "{0} + 273.15", ConversionFromKelvin = "{0} - 273.15", ParseRegex = "(?.*) ?°C", StringFormat = "{0} °C", AbsoluteZero = "-273.15" }, new { TypeName = "Fahrenheit", DisplayName = "degrés Fahrenheit", ConversionToKelvin = "({0} + 459.67) / 1.8", ConversionFromKelvin = "({0} * 1.8) - 459.67", ParseRegex = "(?.*) ?°F", StringFormat = "{0} °F", AbsoluteZero = "-459.67" } }; foreach (var unit in units) { #> ///

/// Représente une température en <#= unit.DisplayName #> ///

public struct <#= unit.TypeName #> : ITemperature, IComparable<<#= unit.TypeName #>>, IEquatable<<#= unit.TypeName #>>, IFormattable { private readonly double _value; ///

/// Initialise une nouvelle instance de la structure . ///

/// La valeur de cette température en <#= unit.DisplayName #> public <#= unit.TypeName #>(double value) { _value = value; } ///

/// Obtient la valeur de cette température. ///

/// /// La valeur de cette température en <#= unit.DisplayName #> /// public double Value { get { return _value; } } ///

/// Renvoie le zero absolu. ///

public <#= unit.TypeName #> AbsoluteZero { get { return new <#= unit.TypeName #>(<#= unit.AbsoluteZero #>); } } #region Operators ///

/// Effectue une conversion implicite de vers . ///

/// Valeur en <#= unit.DisplayName #>. /// /// Résultat de la conversion. /// public static implicit operator <#= unit.TypeName #>(double value) { return new <#= unit.TypeName #>(value); } ///

/// Effectue une conversion explicite de vers . ///

/// Temperature /// /// Résultat de la conversion. /// public static explicit operator double(<#= unit.TypeName #> temperature) { return temperature.Value; } ///

/// Teste l'égalité de deux températures. ///

/// Première température /// Deuxième température /// /// true si les deux températures sont égales, false sinon. /// public static bool operator ==(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.Equals(b); } ///

/// Teste la non-égalité de deux températures. ///

/// Première température /// Deuxième température /// /// true si les deux températures sont différentes, false sinon. /// public static bool operator !=(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return !(a == b); } ///

/// Teste si la première température est inférieure à la deuxième. ///

/// Première température /// Deuxième température /// /// true si la première température est inférieure à la deuxième, false sinon. /// public static bool operator <(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) < 0; } ///

/// Teste si la première température est supérieure à la deuxième. ///

/// Première température /// Deuxième température /// /// true si la première température est supérieure à la deuxième, false sinon. /// public static bool operator >(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) > 0; } ///

/// Teste si la première température est inférieure ou égale à la deuxième. ///

/// Première température /// Deuxième température /// /// true si la première température est inférieure ou égale à la deuxième, false sinon. /// public static bool operator <=(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) <= 0; } ///

/// Teste si la première température est supérieure ou égale à la deuxième. ///

/// Première température /// Deuxième température /// /// true si la première température est supérieure ou égale à la deuxième, false sinon. /// public static bool operator >=(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) >= 0; } ///

/// Additionne deux températures. ///

/// Première température /// Deuxième température /// /// La somme des deux températures. /// public static <#= unit.TypeName #> operator +(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return new <#= unit.TypeName #>(a.Value + b.Value); } ///

/// Soustrait la deuxième température de la première ///

/// Première température /// Deuxième température /// /// La différence entre les deux températures. /// public static <#= unit.TypeName #> operator -(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return new <#= unit.TypeName #>(a.Value - b.Value); } ///

/// Multiplie une température par un nombre. ///

/// Température /// Multiplicateur /// /// Le résultat de la multiplication. /// public static <#= unit.TypeName #> operator *(<#= unit.TypeName #> temperature, double multiplier) { return new <#= unit.TypeName #>(temperature.Value*multiplier); } ///

/// Divise une température par un nombre. ///

/// Température /// Diviseur /// /// Le résultat de la division. /// public static <#= unit.TypeName #> operator /(<#= unit.TypeName #> temperature, double divisor) { return new <#= unit.TypeName #>(temperature.Value/divisor); } #endregion #region Methods ///

/// Compare cette instance avec un objet du même type. ///

/// Objet à comparer avec cette instance. /// Nombre signé indiquant les valeurs relatives de cette instance et other /// /// /// Valeur de retour /// Description /// /// /// Inférieure à zéro /// Cette instance est inférieure à other. /// /// /// Zéro /// Cette instance est égale à other. /// /// /// Supérieure à zéro /// Cette instance est supérieure à other. /// /// /// public int CompareTo(<#= unit.TypeName #> other) { return Value.CompareTo(other.Value); } ///

/// Retourne une représentation textuelle de l'instance actuelle ///

/// une représentation textuelle de l'instance actuelle public override string ToString() { return ToString(null, null); } ///

/// Retourne une représentation textuelle de l'instance actuelle ///

/// Le format à utiliser /// une représentation textuelle de l'instance actuelle public string ToString(string format) { return ToString(format, null); } ///

/// Retourne une représentation textuelle de l'instance actuelle ///

/// Le format à utiliser /// Le fournisseur à utiliser pour formater la valeur /// une représentation textuelle de l'instance actuelle public string ToString(string format, IFormatProvider formatProvider) { var value = Value.ToString(format, formatProvider); return string.Format("<#= unit.StringFormat #>", value); } ///

/// Essaye de parser le texte. ///

/// Texte à parser. /// Temperature. /// true, si le parsing est réussi; sinon false. public static bool TryParse(string text, out <#= unit.TypeName #> temperature) { var regex = new Regex(@"<#= unit.ParseRegex #>"); if (regex.IsMatch(text) && regex.Match(text).Groups["value"].Success) { string valueText = regex.Match(text).Groups["value"].Value; double value; if (double.TryParse(valueText, out value)) { temperature = new <#= unit.TypeName #>(value); return true; } } temperature = new <#= unit.TypeName #>(0); return false; } ///

/// Indique si l'instance courante de l'objet est égal à un autre objet du même type. ///

/// Objet à comparer avec cette instance. /// /// true si l'instance courante est égale au paramètre ; sinon, false. /// public bool Equals(<#= unit.TypeName #> other) { return Value.Equals(other.Value); } ///

/// Determine si l' spécifié est égal à l'instance courante. ///

/// L' à comparer avec l'instance courante. /// /// true si l' spécifié est égal à cette instance ; sinon, false. /// public override bool Equals(object obj) { if (obj is <#= unit.TypeName #>) return Equals((<#= unit.TypeName #>) obj); return false; } ///

/// Retourne le hash code de cette instance ///

/// /// Code de hashage de l'instance actuelle. /// public override int GetHashCode() { unchecked { return Value.GetHashCode(); } } #endregion #region Implementation of ITemperature ///

/// Obtient la valeur de cette température en kelvins ///

double ITemperature.ValueInKelvins { get { return <#= string.Format(unit.ConversionToKelvin, "_value") #>; } } #endregion } <# } #> ///

/// Fournit des méthodes d'extension pour les températures ///

public static class TemperatureExtensions { <# foreach (var unit in units) { #> ///

/// Convertit une température en <#= unit.DisplayName #> ///

/// Le type de l'unité d'origine /// Température à convertir /// Valeur en <#= unit.DisplayName #> public static <#= unit.TypeName #> To<#= unit.TypeName #>(this T temperature) where T : ITemperature { return <#= string.Format(unit.ConversionFromKelvin, "temperature.ValueInKelvins") #>; } <# }#> } }