<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ output extension=".cs" #>
<#@ assembly name="System.Core" #>
<#@ assembly name="System.Xml" #>
<#@ assembly name="System.Xml.Linq" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Xml.Linq" #>
// 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
{
///
/// Représente une mesure de température
///
public interface ITemperature
{
///
/// Obtient la valeur de cette température en kelvins
///
double ValueInKelvins { get; }
}
<#
string fileName = Host.ResolvePath("Units.xml");
var doc = XDocument.Load(fileName);
var units =
from u in doc.Root.Element("Temperature").Elements("Unit")
select new
{
TypeName = u.Element("TypeName").Value,
DisplayName = u.Element("DisplayName").Value,
ConversionToSI = u.Element("ConversionToSI").Value,
ConversionFromSI = u.Element("ConversionFromSI").Value,
ParseRegex = u.Element("ParseRegex").Value,
StringFormat = u.Element("StringFormat").Value,
AbsoluteZero = u.Element("AbsoluteZero").Value,
};
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.ConversionToSI, "_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.ConversionFromSI, "temperature.ValueInKelvins") #>;
}
<# }#>
}
}