// 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
{
    /// <summary>
    /// Représente une mesure de surface
    /// </summary>
    public interface IArea
    {
        /// <summary>
        /// Obtient la valeur de cette longueur en mètres carrés
        /// </summary>
        double ValueInSquareMeters { get; }
    }

    /// <summary>
    /// Représente une surface en mètres carrés
    /// </summary>
    public struct SquareMeter : IArea, IComparable<SquareMeter>, IEquatable<SquareMeter>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="SquareMeter"/>.
        /// </summary>
        /// <param name="value">La valeur de cette surface en mètres carrés</param>
        public SquareMeter(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cette surface.
        /// </summary>
        /// <value>
        /// La valeur de cette surface
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.SquareMeter"/>.
        /// </summary>
        /// <param name="value">Valeur en mètres carrés.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator SquareMeter(double value)
        {
            return new SquareMeter(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.SquareMeter"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="area">Surface</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(SquareMeter area)
        {
            return area.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont égales, false sinon.
        /// </returns>
        public static bool operator ==(SquareMeter a, SquareMeter b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(SquareMeter a, SquareMeter b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première surface est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(SquareMeter a, SquareMeter b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(SquareMeter a, SquareMeter b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première surface est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(SquareMeter a, SquareMeter b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(SquareMeter a, SquareMeter b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La somme des deux surfaces.
        /// </returns>
        public static SquareMeter operator +(SquareMeter a, SquareMeter b)
        {
            return new SquareMeter(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième surface de la première
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La différence entre les deux surfaces.
        /// </returns>
        public static SquareMeter operator -(SquareMeter a, SquareMeter b)
        {
            return new SquareMeter(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static SquareMeter operator *(SquareMeter area, double multiplier)
        {
            return new SquareMeter(area.Value*multiplier);
        }

        /// <summary>
        /// Divise une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static SquareMeter operator /(SquareMeter area, double divisor)
        {
            return new SquareMeter(area.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(SquareMeter other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} m²", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="area">Surface.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out SquareMeter area)
        {
            var regex = new Regex(@"(?<value>.*) ?m²");

            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))
                {
                    area = new SquareMeter(value);
                    return true;
                }
            }

            area = new SquareMeter(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(SquareMeter other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is SquareMeter)
                return Equals((SquareMeter) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IArea

        /// <summary>
        /// Obtient la valeur de cette surface en mètres carrés
        /// </summary>
        double IArea.ValueInSquareMeters
        {
            get { return _value; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une surface en pieds carrés
    /// </summary>
    public struct SquareFoot : IArea, IComparable<SquareFoot>, IEquatable<SquareFoot>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="SquareFoot"/>.
        /// </summary>
        /// <param name="value">La valeur de cette surface en pieds carrés</param>
        public SquareFoot(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cette surface.
        /// </summary>
        /// <value>
        /// La valeur de cette surface
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.SquareFoot"/>.
        /// </summary>
        /// <param name="value">Valeur en pieds carrés.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator SquareFoot(double value)
        {
            return new SquareFoot(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.SquareFoot"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="area">Surface</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(SquareFoot area)
        {
            return area.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont égales, false sinon.
        /// </returns>
        public static bool operator ==(SquareFoot a, SquareFoot b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(SquareFoot a, SquareFoot b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première surface est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(SquareFoot a, SquareFoot b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(SquareFoot a, SquareFoot b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première surface est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(SquareFoot a, SquareFoot b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(SquareFoot a, SquareFoot b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La somme des deux surfaces.
        /// </returns>
        public static SquareFoot operator +(SquareFoot a, SquareFoot b)
        {
            return new SquareFoot(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième surface de la première
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La différence entre les deux surfaces.
        /// </returns>
        public static SquareFoot operator -(SquareFoot a, SquareFoot b)
        {
            return new SquareFoot(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static SquareFoot operator *(SquareFoot area, double multiplier)
        {
            return new SquareFoot(area.Value*multiplier);
        }

        /// <summary>
        /// Divise une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static SquareFoot operator /(SquareFoot area, double divisor)
        {
            return new SquareFoot(area.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(SquareFoot other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} sq ft", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="area">Surface.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out SquareFoot area)
        {
            var regex = new Regex(@"(?<value>.*) ?sq ft");

            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))
                {
                    area = new SquareFoot(value);
                    return true;
                }
            }

            area = new SquareFoot(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(SquareFoot other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is SquareFoot)
                return Equals((SquareFoot) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IArea

        /// <summary>
        /// Obtient la valeur de cette surface en mètres carrés
        /// </summary>
        double IArea.ValueInSquareMeters
        {
            get { return _value * .09290304; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une surface en pouces carrés
    /// </summary>
    public struct SquareInch : IArea, IComparable<SquareInch>, IEquatable<SquareInch>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="SquareInch"/>.
        /// </summary>
        /// <param name="value">La valeur de cette surface en pouces carrés</param>
        public SquareInch(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cette surface.
        /// </summary>
        /// <value>
        /// La valeur de cette surface
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.SquareInch"/>.
        /// </summary>
        /// <param name="value">Valeur en pouces carrés.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator SquareInch(double value)
        {
            return new SquareInch(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.SquareInch"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="area">Surface</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(SquareInch area)
        {
            return area.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont égales, false sinon.
        /// </returns>
        public static bool operator ==(SquareInch a, SquareInch b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(SquareInch a, SquareInch b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première surface est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(SquareInch a, SquareInch b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(SquareInch a, SquareInch b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première surface est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(SquareInch a, SquareInch b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(SquareInch a, SquareInch b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La somme des deux surfaces.
        /// </returns>
        public static SquareInch operator +(SquareInch a, SquareInch b)
        {
            return new SquareInch(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième surface de la première
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La différence entre les deux surfaces.
        /// </returns>
        public static SquareInch operator -(SquareInch a, SquareInch b)
        {
            return new SquareInch(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static SquareInch operator *(SquareInch area, double multiplier)
        {
            return new SquareInch(area.Value*multiplier);
        }

        /// <summary>
        /// Divise une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static SquareInch operator /(SquareInch area, double divisor)
        {
            return new SquareInch(area.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(SquareInch other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <param name="formatProvider">Le fournisseur à utiliser pour formater la valeur</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format, IFormatProvider formatProvider)
        {
            var value = Value.ToString(format, formatProvider);
            return string.Format("{0} sq in", value);
        }

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="area">Surface.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out SquareInch area)
        {
            var regex = new Regex(@"(?<value>.*) ?sq in");

            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))
                {
                    area = new SquareInch(value);
                    return true;
                }
            }

            area = new SquareInch(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(SquareInch other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is SquareInch)
                return Equals((SquareInch) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IArea

        /// <summary>
        /// Obtient la valeur de cette surface en mètres carrés
        /// </summary>
        double IArea.ValueInSquareMeters
        {
            get { return _value * .00064516; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une surface en acres
    /// </summary>
    public struct Acre : IArea, IComparable<Acre>, IEquatable<Acre>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Acre"/>.
        /// </summary>
        /// <param name="value">La valeur de cette surface en acres</param>
        public Acre(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cette surface.
        /// </summary>
        /// <value>
        /// La valeur de cette surface
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Acre"/>.
        /// </summary>
        /// <param name="value">Valeur en acres.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Acre(double value)
        {
            return new Acre(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Acre"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="area">Surface</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Acre area)
        {
            return area.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Acre a, Acre b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Acre a, Acre b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première surface est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Acre a, Acre b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Acre a, Acre b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première surface est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Acre a, Acre b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Acre a, Acre b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La somme des deux surfaces.
        /// </returns>
        public static Acre operator +(Acre a, Acre b)
        {
            return new Acre(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième surface de la première
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La différence entre les deux surfaces.
        /// </returns>
        public static Acre operator -(Acre a, Acre b)
        {
            return new Acre(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Acre operator *(Acre area, double multiplier)
        {
            return new Acre(area.Value*multiplier);
        }

        /// <summary>
        /// Divise une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Acre operator /(Acre area, double divisor)
        {
            return new Acre(area.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Acre other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

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

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="area">Surface.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Acre area)
        {
            var regex = new Regex(@"(?<value>.*) ?ac");

            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))
                {
                    area = new Acre(value);
                    return true;
                }
            }

            area = new Acre(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Acre other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Acre)
                return Equals((Acre) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IArea

        /// <summary>
        /// Obtient la valeur de cette surface en mètres carrés
        /// </summary>
        double IArea.ValueInSquareMeters
        {
            get { return _value * 4046.8564224; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une surface en ares
    /// </summary>
    public struct Are : IArea, IComparable<Are>, IEquatable<Are>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Are"/>.
        /// </summary>
        /// <param name="value">La valeur de cette surface en ares</param>
        public Are(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cette surface.
        /// </summary>
        /// <value>
        /// La valeur de cette surface
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Are"/>.
        /// </summary>
        /// <param name="value">Valeur en ares.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Are(double value)
        {
            return new Are(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Are"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="area">Surface</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Are area)
        {
            return area.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Are a, Are b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Are a, Are b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première surface est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Are a, Are b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Are a, Are b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première surface est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Are a, Are b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Are a, Are b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La somme des deux surfaces.
        /// </returns>
        public static Are operator +(Are a, Are b)
        {
            return new Are(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième surface de la première
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La différence entre les deux surfaces.
        /// </returns>
        public static Are operator -(Are a, Are b)
        {
            return new Are(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Are operator *(Are area, double multiplier)
        {
            return new Are(area.Value*multiplier);
        }

        /// <summary>
        /// Divise une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Are operator /(Are area, double divisor)
        {
            return new Are(area.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Are other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

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

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="area">Surface.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Are area)
        {
            var regex = new Regex(@"(?<value>.*) ?a");

            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))
                {
                    area = new Are(value);
                    return true;
                }
            }

            area = new Are(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Are other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Are)
                return Equals((Are) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IArea

        /// <summary>
        /// Obtient la valeur de cette surface en mètres carrés
        /// </summary>
        double IArea.ValueInSquareMeters
        {
            get { return _value * 100; }
        }

        #endregion
    }

    /// <summary>
    /// Représente une surface en hectares
    /// </summary>
    public struct Hectare : IArea, IComparable<Hectare>, IEquatable<Hectare>, IFormattable
    {
        private readonly double _value;

        /// <summary>
        /// Initialise une nouvelle instance de la structure <see cref="Hectare"/>.
        /// </summary>
        /// <param name="value">La valeur de cette surface en hectares</param>
        public Hectare(double value)
        {
            _value = value;
        }

        /// <summary>
        /// Obtient la valeur ce cette surface.
        /// </summary>
        /// <value>
        /// La valeur de cette surface
        /// </value>
        public double Value
        {
            get { return _value; }
        }

        #region Operators

        /// <summary>
        /// Effectue une conversion implicite de <see cref="double"/> vers <see cref="Developpez.Dotnet.Measures.Hectare"/>.
        /// </summary>
        /// <param name="value">Valeur en hectares.</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static implicit operator Hectare(double value)
        {
            return new Hectare(value);
        }

        /// <summary>
        /// Effectue une conversion explicite de <see cref="Developpez.Dotnet.Measures.Hectare"/> vers <see cref="double"/>.
        /// </summary>
        /// <param name="area">Surface</param>
        /// <returns>
        /// Résultat de la conversion.
        /// </returns>
        public static explicit operator double(Hectare area)
        {
            return area.Value;
        }

        /// <summary>
        /// Teste l'égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont égales, false sinon.
        /// </returns>
        public static bool operator ==(Hectare a, Hectare b)
        {
            return a.Equals(b);
        }

        /// <summary>
        /// Teste la non-égalité de deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si les deux surfaces sont différentes, false sinon.
        /// </returns>
        public static bool operator !=(Hectare a, Hectare b)
        {
            return !(a == b);
        }

        /// <summary>
        /// Teste si la première surface est inférieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator <(Hectare a, Hectare b)
        {
            return a.CompareTo(b) < 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure à la deuxième, false sinon.
        /// </returns>
        public static bool operator >(Hectare a, Hectare b)
        {
            return a.CompareTo(b) > 0;
        }

        /// <summary>
        /// Teste si la première surface est inférieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est inférieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator <=(Hectare a, Hectare b)
        {
            return a.CompareTo(b) <= 0;
        }

        /// <summary>
        /// Teste si la première surface est supérieure ou égale à la deuxième.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// true si la première surface est supérieure ou égale à la deuxième, false sinon.
        /// </returns>
        public static bool operator >=(Hectare a, Hectare b)
        {
            return a.CompareTo(b) >= 0;
        }

        /// <summary>
        /// Additionne deux surfaces.
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La somme des deux surfaces.
        /// </returns>
        public static Hectare operator +(Hectare a, Hectare b)
        {
            return new Hectare(a.Value + b.Value);
        }

        /// <summary>
        /// Soustrait la deuxième surface de la première
        /// </summary>
        /// <param name="a">Première surface</param>
        /// <param name="b">Deuxième surface</param>
        /// <returns>
        /// La différence entre les deux surfaces.
        /// </returns>
        public static Hectare operator -(Hectare a, Hectare b)
        {
            return new Hectare(a.Value - b.Value);
        }

        /// <summary>
        /// Multiplie une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="multiplier">Multiplicateur</param>
        /// <returns>
        /// Le résultat de la multiplication.
        /// </returns>
        public static Hectare operator *(Hectare area, double multiplier)
        {
            return new Hectare(area.Value*multiplier);
        }

        /// <summary>
        /// Divise une surface par un nombre.
        /// </summary>
        /// <param name="area">surface</param>
        /// <param name="divisor">Diviseur</param>
        /// <returns>
        /// Le résultat de la division.
        /// </returns>
        public static Hectare operator /(Hectare area, double divisor)
        {
            return new Hectare(area.Value/divisor);
        }

        #endregion

        #region Methods

        /// <summary>
        /// Compare cette instance avec un objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>Nombre signé indiquant les valeurs relatives de cette instance et other
        /// <list type="table">
        /// <listheader>
        /// <term>Valeur de retour</term>
        /// <description>Description</description>
        /// </listheader>
        /// <item>
        /// <term>Inférieure à zéro </term>
        /// <description>Cette instance est inférieure à other.</description>
        /// </item>
        /// <item>
        /// <term>Zéro</term>
        /// <description>Cette instance est égale à other.</description>
        /// </item>
        /// <item>
        /// <term>Supérieure à zéro</term>
        /// <description>Cette instance est supérieure à other.</description>
        /// </item>
        /// </list>
        /// </returns>
        public int CompareTo(Hectare other)
        {
            return Value.CompareTo(other.Value);
        }

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

        /// <summary>
        /// Retourne une représentation textuelle de l'instance actuelle
        /// </summary>
        /// <param name="format">Le format à utiliser</param>
        /// <returns>une représentation textuelle de l'instance actuelle</returns>
        public string ToString(string format)
        {
            return ToString(format, null);
        }

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

        /// <summary>
        /// Essaye de parser le texte.
        /// </summary>
        /// <param name="text">Texte à parser.</param>
        /// <param name="area">Surface.</param>
        /// <returns>true, si le parsing est réussi; sinon false.</returns>
        public static bool TryParse(string text, out Hectare area)
        {
            var regex = new Regex(@"(?<value>.*) ?ha");

            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))
                {
                    area = new Hectare(value);
                    return true;
                }
            }

            area = new Hectare(0);
            return false;
        }

        /// <summary>
        /// Indique si l'instance courante de l'objet est égal à un autre objet du même type.
        /// </summary>
        /// <param name="other">Objet à comparer avec cette instance.</param>
        /// <returns>
        /// true si l'instance courante est égale au paramètre <paramref name="other"/> ; sinon, false.
        /// </returns>
        public bool Equals(Hectare other)
        {
            return Value.Equals(other.Value);
        }

        /// <summary>
        /// Determine si l'<see cref="System.Object"/> spécifié est égal à l'instance courante.
        /// </summary>
        /// <param name="obj">L' <see cref="System.Object"/> à comparer avec l'instance courante.</param>
        /// <returns>
        ///   <c>true</c> si l'<see cref="System.Object"/> spécifié est égal à cette instance ; sinon, <c>false</c>.
        /// </returns>
        public override bool Equals(object obj)
        {
            if (obj is Hectare)
                return Equals((Hectare) obj);
            return false;
        }

        /// <summary>
        /// Retourne le hash code de cette instance
        /// </summary>
        /// <returns>
        /// Code de hashage de l'instance actuelle. 
        /// </returns>
        public override int GetHashCode()
        {
            unchecked
            {
                return Value.GetHashCode();
            }
        }

        #endregion

        #region Implementation of IArea

        /// <summary>
        /// Obtient la valeur de cette surface en mètres carrés
        /// </summary>
        double IArea.ValueInSquareMeters
        {
            get { return _value * 10000; }
        }

        #endregion
    }

    /// <summary>
    /// Fournit des méthodes d'extension pour les surfaces
    /// </summary>
    public static class AreaExtensions
    {
        /// <summary>
        /// Convertit une surface en mètres carrés
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="area">Surface à convertir</param>
        /// <returns>Valeur en mètres carrés</returns>
        public static SquareMeter ToSquareMeter<T>(this T area)
            where T : IArea
        {
            return area.ValueInSquareMeters;
        }

        /// <summary>
        /// Convertit une surface en pieds carrés
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="area">Surface à convertir</param>
        /// <returns>Valeur en pieds carrés</returns>
        public static SquareFoot ToSquareFoot<T>(this T area)
            where T : IArea
        {
            return area.ValueInSquareMeters / .09290304;
        }

        /// <summary>
        /// Convertit une surface en pouces carrés
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="area">Surface à convertir</param>
        /// <returns>Valeur en pouces carrés</returns>
        public static SquareInch ToSquareInch<T>(this T area)
            where T : IArea
        {
            return area.ValueInSquareMeters / .00064516;
        }

        /// <summary>
        /// Convertit une surface en acres
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="area">Surface à convertir</param>
        /// <returns>Valeur en acres</returns>
        public static Acre ToAcre<T>(this T area)
            where T : IArea
        {
            return area.ValueInSquareMeters / 4046.8564224;
        }

        /// <summary>
        /// Convertit une surface en ares
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="area">Surface à convertir</param>
        /// <returns>Valeur en ares</returns>
        public static Are ToAre<T>(this T area)
            where T : IArea
        {
            return area.ValueInSquareMeters / 100;
        }

        /// <summary>
        /// Convertit une surface en hectares
        /// </summary>
        /// <typeparam name="T">Le type de l'unité d'origine</typeparam>
        /// <param name="area">Surface à convertir</param>
        /// <returns>Valeur en hectares</returns>
        public static Hectare ToHectare<T>(this T area)
            where T : IArea
        {
            return area.ValueInSquareMeters / 10000;
        }

    }
}