<#@ 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 = "CubeMeter", DisplayName = "mètres cubes", ConversionToCubeMeters = "{0}", ConversionFromCubeMeters = "{0}", ParseRegex = "(?.*) ?m³", StringFormat = "{0} m³", }, new { TypeName = "Liter", DisplayName = "litres", ConversionToCubeMeters = "{0} * .001", ConversionFromCubeMeters = "{0} / .001", ParseRegex = "(?.*) ?l", StringFormat = "{0} l", }, new { TypeName = "Pint", DisplayName = "pintes", ConversionToCubeMeters = "{0} * .00056826125", ConversionFromCubeMeters = "{0} / .00056826125", ParseRegex = "(?.*) ?pt", StringFormat = "{0} pt", }, new { TypeName = "Gallon", DisplayName = "gallons impériaux", ConversionToCubeMeters = "{0} * .00454609", ConversionFromCubeMeters = "{0} / .00454609", ParseRegex = "(?.*) ?gal GB", StringFormat = "{0} gal GB", }, new { TypeName = "USGallon", DisplayName = "gallons US", ConversionToCubeMeters = "{0} * .003785411784", ConversionFromCubeMeters = "{0} / .003785411784", ParseRegex = "(?.*) ?gal US", StringFormat = "{0} gal US", }, new { TypeName = "FluidOunce", DisplayName = "onces liquides impériales", ConversionToCubeMeters = "{0} * .0000284130625", ConversionFromCubeMeters = "{0} / .0000284130625", ParseRegex = "(?.*) ?fl oz", StringFormat = "{0} fl oz", }, new { TypeName = "USFluidOunce", DisplayName = "onces liquides US", ConversionToCubeMeters = "{0} * .0000295735295625", ConversionFromCubeMeters = "{0} / .0000295735295625", ParseRegex = "(?.*) ?fl oz", StringFormat = "{0} fl oz", }, }; foreach (var unit in units) { #> ///

/// Représente un volume en <#= unit.DisplayName #> ///

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

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

/// La valeur de ce volume en <#= unit.DisplayName #> public <#= unit.TypeName #>(double value) { _value = value; } ///

/// Obtient la valeur de ce volume. ///

/// /// La valeur de ce volume en <#= unit.DisplayName #> /// public double Value { get { return _value; } } #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 . ///

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

/// Teste l'égalité de deux volumes. ///

/// Premier volume /// Deuxième volume /// /// true si les deux volumes sont égaux, false sinon. /// public static bool operator ==(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.Equals(b); } ///

/// Teste la non-égalité de deux volumes. ///

/// Premier volume /// Deuxième volume /// /// true si les deux volumes sont différents, false sinon. /// public static bool operator !=(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return !(a == b); } ///

/// Teste si le premier volume est inférieur au deuxième. ///

/// Premier volume /// Deuxième volume /// /// true si le premier volume est inférieur au deuxième, false sinon. /// public static bool operator <(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) < 0; } ///

/// Teste si le premier volume est supérieur au deuxième. ///

/// Premier volume /// Deuxième volume /// /// true si le premier volume est supérieur au deuxième, false sinon. /// public static bool operator >(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) > 0; } ///

/// Teste si le premier volume est inférieur ou égal au deuxième. ///

/// Premier volume /// Deuxième volume /// /// true si le premier volume est inférieur ou égal au deuxième, false sinon. /// public static bool operator <=(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) <= 0; } ///

/// Teste si le premier volume est supérieur ou égal au deuxième. ///

/// Premier volume /// Deuxième volume /// /// true si le premier volume est supérieur ou égal au deuxième, false sinon. /// public static bool operator >=(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return a.CompareTo(b) >= 0; } ///

/// Additionne deux volumes. ///

/// Premier volume /// Deuxième volume /// /// La somme des deux volumes. /// public static <#= unit.TypeName #> operator +(<#= unit.TypeName #> a, <#= unit.TypeName #> b) { return new <#= unit.TypeName #>(a.Value + b.Value); } ///

/// Soustrait le deuxième volume du premier ///

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

/// Multiplie un volume par un nombre. ///

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

/// Divise un volume par un nombre. ///

/// volume /// Diviseur /// /// Le résultat de la division. /// public static <#= unit.TypeName #> operator /(<#= unit.TypeName #> volume, double divisor) { return new <#= unit.TypeName #>(volume.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érieur à zéro /// Cette instance est inférieure à other. /// /// /// Zéro /// Cette instance est égale à other. /// /// /// supérieur à 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. /// volume. /// true, si le parsing est réussi; sinon false. public static bool TryParse(string text, out <#= unit.TypeName #> volume) { 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)) { volume = new <#= unit.TypeName #>(value); return true; } } volume = 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 IVolume ///

/// Obtient la valeur de cette volume en mètres cubes ///

double IVolume.ValueInCubeMeters { get { return <#= string.Format(unit.ConversionToCubeMeters, "_value") #>; } } #endregion } <# } #> ///

/// Fournit des méthodes d'extension pour les volumes ///

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

/// Convertit un volume en <#= unit.DisplayName #> ///

/// Le type de l'unité d'origine /// volume à convertir /// Valeur en <#= unit.DisplayName #> public static <#= unit.TypeName #> To<#= unit.TypeName #>(this T volume) where T : IVolume { return <#= string.Format(unit.ConversionFromCubeMeters, "volume.ValueInCubeMeters") #>; } <# }#> } }