Wie erstelle ich eine generische Konverter für Maßeinheiten in C#?

Haben Sie einen guten start, aber wie Jon schon sagte, es ist derzeit nicht Typ-sicher; der Konverter hat keine Fehler-überprüfung zur Sicherstellung, dass die dezimale wird es ist ein Celsius-Wert.

So, an dieser weiter, würde ich anfangen, die Einführung von struct-Typen, nehmen Sie den numerischen Wert ein, und wenden Sie es auf eine Mengeneinheit. In den Mustern der Enterprise-Architektur (auch bekannt als die Gang of Four-design Pattern), das nennt man das "Geld" - Muster, nach der häufigsten Verwendung, zu bezeichnen, dass eine Menge von einer Art von Währung. Das Muster gilt für alle numerischen Betrag, der benötigt eine Maßeinheit sinnvoll sein.

Beispiel:

public enum TemperatureScale
{
   Celsius,
   Fahrenheit,
   Kelvin
}

public struct Temperature
{
   decimal Degrees {get; private set;}
   TemperatureScale Scale {get; private set;}

   public Temperature(decimal degrees, TemperatureScale scale)
   {
       Degrees = degrees;
       Scale = scale;
   }

   public Temperature(Temperature toCopy)
   {
       Degrees = toCopy.Degrees;
       Scale = toCopy.Scale;
   }
}

Nun, haben Sie eine einfache Art, die Sie verwenden können, um zu erzwingen, dass die Umsätze, die Sie machen, nehmen Sie eine Temperatur, dass ist der richtige Maßstab, und ein Ergebnis zurückgeben Temperatur bekannt sein, in die andere Waagschale.

Ihre Funcs müssen eine zusätzliche Zeile, um zu überprüfen, dass die Eingabe entspricht den Ausgang; Sie können weiterhin verwenden, lambdas, oder Sie können es nehmen einen Schritt weiter mit einer einfachen Strategie-Muster:

public interface ITemperatureConverter
{
   public Temperature Convert(Temperature input);
}

public class FahrenheitToCelsius:ITemperatureConverter
{
   public Temperature Convert(Temperature input)
   {
      if (input.Scale != TemperatureScale.Fahrenheit)
         throw new ArgumentException("Input scale is not Fahrenheit");

      return new Temperature(input.Degrees * 5m / 9m - 32, TemperatureScale.Celsius);
   }
}

//Implement other conversion methods as ITemperatureConverters

public class TemperatureConverter
{
   public Dictionary<Tuple<TemperatureScale, TemperatureScale>, ITemperatureConverter> converters = 
      new Dictionary<Tuple<TemperatureScale, TemperatureScale>, ITemperatureConverter>
      {
         {Tuple.Create<TemperatureScale.Fahrenheit, TemperatureScale.Celcius>,
            new FahrenheitToCelsius()},
         {Tuple.Create<TemperatureScale.Celsius, TemperatureScale.Fahrenheit>,
            new CelsiusToFahrenheit()},
         ...
      }

   public Temperature Convert(Temperature input, TemperatureScale toScale)
   {
      if(!converters.ContainsKey(Tuple.Create(input.Scale, toScale))
         throw new InvalidOperationException("No converter available for this conversion");

      return converters[Tuple.Create(input.Scale, toScale)].Convert(input);
   }
}

Weil diese Arten von Konvertierungen sind zwei-Wege, können Sie erwägen die Einrichtung einer Schnittstelle zum Griff in beide Richtungen, mit einem "ConvertBack" - Methode oder ähnliches, der eine Temperatur in der Celsius-Skala und konvertieren Fahrenheit. Das reduziert Ihre Klasse zählen. Dann, anstelle der class-Instanzen, Ihre Wörterbuch-Werte könnte sein, Verweise auf Methoden, die auf Instanzen der Wandler. Dies erhöht die Komplexität etwas von der Einrichtung der wichtigsten TemperatureConverter Strategie-picker, aber reduziert die Anzahl der conversion-Strategie-Klassen, die Sie definieren müssen.

Beachten Sie auch, dass die Fehlerüberprüfung erfolgt zur Laufzeit, wenn Sie tatsächlich versuchen, die Konvertierung zu machen, dass dies der code gründlich getestet in allen Verwendungen zu gewährleisten, ist es immer richtig. Um dies zu vermeiden, können Sie die Ableitung der Basis-Temperatur-Klasse zu produzieren CelsiusTemperature und FahrenheitTemperature Strukturen, die würden einfach definieren Sie Ihre Waage als ein konstanter Wert. Dann, die ITemperatureConverter gemacht werden könnten, Generika zu zwei Typen, beide Temperaturen ab, so dass Sie compile-Zeit überprüft haben, dass Sie angeben, die Umwandlung, die Sie denken, Sie sind. die TemperatureConverter können auch gemacht werden, um dynamisch zu finden ITemperatureConverters, bestimmen die Arten, die Sie konvertieren zwischen, und automatisch einrichten das Wörterbuch der Wandler, so dass Sie nie sorgen zu machen über neue hinzufügen. Dies geht allerdings auf Kosten der erhöhten Temperatur-Klasse zählen; Sie müssen vier domain-Klassen (Basis-und drei abgeleitete Klassen) statt. Es wird auch langsam die Schaffung eines TemperatureConverter Klasse wie der Quelltext zu bauen nachdenklich den Konverter Wörterbuch wird ganz ein bisschen nachdenken.

Könnte man auch ändern, in der Enumerationen für die Maßeinheiten zu werden "marker-Klassen"; leere Klassen, die haben keine andere Bedeutung als dass Sie von dieser Klasse ableiten von anderen Klassen. Man könnte dann definieren Sie eine vollständige Hierarchie von "UnitOfMeasure" Klassen repräsentieren die verschiedenen Maßeinheiten und können verwendet werden als generische Typ die Argumente und Zwänge; ITemperatureConverter könnte allgemein auf zwei Arten, beide sind gezwungen zu werden TemperatureScale Klassen, und eine CelsiusFahrenheitConverter Umsetzung würde in der Nähe der generischen Schnittstelle zu den Arten CelsiusDegrees und FahrenheitDegrees beide abgeleitet von TemperatureScale. Das ermöglicht Ihnen setzen die Maßeinheiten aus, die sich als Einschränkungen der Konvertierung, wodurch wiederum Umrechnungen zwischen verschiedenen Maßeinheiten (bestimmten Einheiten bestimmte Materialien haben bekannt Umbauten; 1 britische Imperial Pint Wasser wiegt 1.25 kg).

Alle diese design-Entscheidungen vereinfachen wird eine Art von Veränderung, um das design, aber einige Kosten (entweder machen Sie sonst etwas schwerer tun oder fallender Algorithmus-performance). Es ist bis zu Sie zu entscheiden, was ist wirklich "easy" für Sie, in den Kontext der gesamten Anwendung und Codierung-Umgebung arbeiten Sie in.

EDIT: Die Nutzung Sie wollen, von Ihr zu Bearbeiten, ist extrem einfach für die Temperatur. Allerdings, wenn Sie möchten, eine generische UnitConverter, dass funktioniert mit jedem UnitofMeasure, dann Sie nicht mehr wollen, Enums und bilden Ihre Einheiten Messen, da Enums nicht haben, können Sie eine benutzerdefinierte Hierarchie-Vererbung (Sie stammen direkt aus dem System.Enum).

Können Sie angeben, dass der Standard-Konstruktor akzeptiert alle Enum, aber dann haben Sie, um sicherzustellen, dass die Enum ist einer der Typen, dass ist eine Maßeinheit, sonst könnte passieren, in einen DialogResult-Wert und der Konverter würde ausflippen bei der Laufzeit.

Statt, wenn Sie möchten, eine UnitConverter können, zu konvertieren, um eine UnitOfMeasure gegeben lambdas für andere Einheiten der Messung, ich würde geben die Maßeinheit als "marker-Klassen"; kleine Staatenlose "Token", die nur einen Sinn haben, dass Sie Ihre eigene Art und leiten sich von den Eltern:

//The only functionality any UnitOfMeasure needs is to be semantically equatable
//with any other reference to the same type.
public abstract class UnitOfMeasure:IEquatable<UnitOfMeasure> 
{ 
   public override bool Equals(UnitOfMeasure other)
   {
      return this.ReferenceEquals(other)
         || this.GetType().Name == other.GetType().Name;
   }

   public override bool Equals(Object other) 
   {
      return other is UnitOfMeasure && this.Equals(other as UnitOfMeasure);
   }    

   public override operator ==(Object other) {return this.Equals(other);}
   public override operator !=(Object other) {return this.Equals(other) == false;}

}

public abstract class Temperature:UnitOfMeasure {
public static CelsiusTemperature Celsius {get{return new CelsiusTemperature();}}
public static FahrenheitTemperature Fahrenheit {get{return new CelsiusTemperature();}}
public static KelvinTemperature Kelvin {get{return new CelsiusTemperature();}}
}
public class CelsiusTemperature:Temperature{}
public class FahrenheitTemperature :Temperature{}
public class KelvinTemperature :Temperature{}

...

public class UnitConverter
{
   public UnitOfMeasure BaseUnit {get; private set;}
   public UnitConverter(UnitOfMeasure baseUnit) {BaseUnit = baseUnit;}

   private readonly Dictionary<UnitOfMeasure, Func<decimal, decimal>> converters
      = new Dictionary<UnitOfMeasure, Func<decimal, decimal>>();

   public void AddConverter(UnitOfMeasure measure, Func<decimal, decimal> conversion)
   { converters.Add(measure, conversion); }

   public void Convert(UnitOfMeasure measure, decimal input)
   { return converters[measure](input); }
}

Kannst du in Fehler-überprüfung (überprüfen, dass die Eingabe-Einheit hat eine Umwandlung angegeben ist, überprüfen Sie, dass eine Konvertierung Hinzugefügt werden, ist für eine ME mit den gleichen Eltern als die Basis-Typ, etc etc) wie Sie sehen, passen. Sie können auch ableiten UnitConverter zu erstellen TemperatureConverter, so dass Sie hinzufügen, statische, compile-time type checks und die Vermeidung der run-time checks, UnitConverter verwenden würde.

Konnte man einen Blick auf Units.NET. Es ist auf GitHub und NuGet. Es bietet die meisten gängigen Einheiten und Umrechnungen, unterstützt sowohl statische Typisierung und Nummerierung der Einheiten und die Analyse/das drucken der Abkürzungen. Sie analysieren nicht Ausdrücken, obwohl, und Sie können nicht erweitern bestehende Klassen von Einheiten, aber Sie können erweitern es mit neuen Einheiten Dritter.

Beispiel Konvertierungen:

Length meter = Length.FromMeters(1);
double cm = meter.Centimeters; //100
double feet = meter.Feet; //3.28084

Kann man definieren eine physikalische Einheiten generischen Typ, so dass, wenn man für jede Einheit einen Typ implementiert new und beinhaltet unter anderem ein translation-Methode zwischen diesem Gerät und "Basisstation" von dieser Art ist, kann man arithmetische Operationen ausgeführt werden, die auf Werte, die in den verschiedenen Einheiten ausgedrückt und habe Sie umgewandelt wie nötig, mit dem Text-system, so dass eine variable vom Typ AreaUnit<LengthUnit.Inches> würde nur Dinge akzeptieren, dimensioniert in square inches, aber wenn man sagte myAreaInSquareInches= AreaUnit<LengthUnit.Inches>.Product(someLengthInCentimeters, someLengthInFathoms); es würde automatisch übersetzen diese andere Einheit, die vor der Durchführung der Multiplikation. Es kann tatsächlich sehr gut funktionieren, wenn mit der Methode-call-syntax, da Methoden wie Product<T1,T2>(T1 p1, T2 p2) Methode akzeptieren können generische Typparameter Ihre Operanden. Leider gibt es keine Möglichkeit, Operatoren, generische, noch ist es für einen Typ wie AreaUnit<T> where T:LengthUnitDescriptor zu definieren, ein Mittel für die Umwandlung in eine oder aus einer anderen beliebigen generischen Typs AreaUnit<U>. Ein AreaUnit<T> definieren könnte, Konvertierungen zu und von z.B. AreaUnit<Angstrom>, aber es gibt keine Möglichkeit dem compiler gesagt werden könnte, dass code, der eine AreaUnit<Centimeters> and wantsAreaUnit` kann konvertieren Zoll zu Angström und dann in Zentimetern.