public static string GetAbbreviation(DynamicViscosityUnit unit, [CanBeNull] string cultureName)
{
// Windows Runtime Component does not support CultureInfo and IFormatProvider types, so we use culture name for public methods: https://msdn.microsoft.com/en-us/library/br230301.aspx
IFormatProvider provider = cultureName == null ? UnitSystem.DefaultCulture : new CultureInfo(cultureName);
return(UnitSystem.GetCached(provider).GetDefaultAbbreviation(unit));
}
// Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
/// <summary>
/// Dynamically convert from value and unit enum <see cref="DynamicViscosityUnit" /> to <see cref="DynamicViscosity" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>DynamicViscosity unit value.</returns>
public static DynamicViscosity?From(QuantityValue?value, DynamicViscosityUnit fromUnit)
{
if (!value.HasValue)
{
return(null);
}
switch (fromUnit)
{
case DynamicViscosityUnit.Centipoise:
return(FromCentipoise(value.Value));
case DynamicViscosityUnit.MicropascalSecond:
return(FromMicropascalSeconds(value.Value));
case DynamicViscosityUnit.MillipascalSecond:
return(FromMillipascalSeconds(value.Value));
case DynamicViscosityUnit.NewtonSecondPerMeterSquared:
return(FromNewtonSecondsPerMeterSquared(value.Value));
case DynamicViscosityUnit.PascalSecond:
return(FromPascalSeconds(value.Value));
case DynamicViscosityUnit.Poise:
return(FromPoise(value.Value));
default:
throw new NotImplementedException("fromUnit: " + fromUnit);
}
}
//HeatFluxDensityUnit heatTransferCoefficient;
//ForceUnit force;
//SurfaceTensionUnit surfaceTension;
public UnitSystem(TemperatureUnit temperature, PressureUnit pressure, MassFlowRateUnit massFlowRate,
VolumeFlowRateUnit volumeFlowRate, MoistureContentUnit moistureContent,
RatioUnit relativeHumidity, SpecificEnergyUnit enthalpy,
SpecificHeatUnit specificHeat, EnergyUnit energy, PowerUnit power, DensityUnit density,
DynamicViscosityUnit dynamicViscosity, KinematicViscosityUnit kinematicViscosity,
ThermalConductivityUnit conductivity, DiffusivityUnit diffusivity, MassUnit mass,
LengthUnit length, AreaUnit area, VolumeUnit volume, TimeUnit Time, string name) //ep
{
this.temperature = temperature;
this.pressure = pressure;
this.massFlowRate = massFlowRate;
this.volumeFlowRate = volumeFlowRate;
this.moistureContent = moistureContent;
this.relativeHumidity = relativeHumidity;
this.enthalpy = enthalpy;
this.specificHeat = specificHeat;
this.energy = energy;
this.power = power;
this.density = density;
this.dynamicViscosity = dynamicViscosity;
this.kinematicViscosity = kinematicViscosity;
this.conductivity = conductivity;
this.diffusivity = diffusivity;
this.mass = mass;
this.length = length;
this.area = area;
this.volume = volume;
this.time = time;
this.Name = name; //ep
this.readOnly = false; //ep
}
public UnitSystem()
{
this.temperature = TemperatureUnit.Celsius;
this.pressure = PressureUnit.Pascal;
this.massFlowRate = MassFlowRateUnit.KgPerSec;
this.volumeFlowRate = VolumeFlowRateUnit.CubicMeterPerSec;
this.moistureContent = MoistureContentUnit.KgPerKg;
this.relativeHumidity = RatioUnit.Percent;
this.enthalpy = SpecificEnergyUnit.JoulePerKg;
this.specificHeat = SpecificHeatUnit.JoulePerKgKelvin;
this.energy = EnergyUnit.Joule;
this.power = PowerUnit.JoulePerSec;
this.density = DensityUnit.KgPerCubicMeter;
this.dynamicViscosity = DynamicViscosityUnit.PascalSecond;
this.kinematicViscosity = KinematicViscosityUnit.SquareMeterPerSec;
this.conductivity = ThermalConductivityUnit.WattPerMeterKelvin;
this.diffusivity = DiffusivityUnit.SquareMeterPerSec;
this.mass = MassUnit.Kilogram;
this.length = LengthUnit.Meter;
this.area = AreaUnit.SquareMeter;
this.volume = VolumeUnit.CubicMeter;
this.time = TimeUnit.Second;
this.Name = "SI"; //ep
this.readOnly = true;
}
public string ToString(DynamicViscosityUnit unit, [CanBeNull] Culture culture, int significantDigitsAfterRadix)
{
double value = As(unit);
string format = UnitFormatter.GetFormat(value, significantDigitsAfterRadix);
return(ToString(unit, culture, format));
}
private double AsBaseNumericType(DynamicViscosityUnit unit)
{
if (Unit == unit)
{
return(_value);
}
var baseUnitValue = AsBaseUnit();
switch (unit)
{
case DynamicViscosityUnit.Centipoise: return((baseUnitValue * 10) / 1e-2d);
case DynamicViscosityUnit.MicropascalSecond: return((baseUnitValue) / 1e-6d);
case DynamicViscosityUnit.MillipascalSecond: return((baseUnitValue) / 1e-3d);
case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return(baseUnitValue);
case DynamicViscosityUnit.PascalSecond: return(baseUnitValue);
case DynamicViscosityUnit.Poise: return(baseUnitValue * 10);
default:
throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
}
}
private decimal AsBaseNumericType(DynamicViscosityUnit unit)
{
if (Unit == unit)
{
return(_value);
}
var baseUnitValue = AsBaseUnit();
switch (unit)
{
case DynamicViscosityUnit.Centipoise: return((baseUnitValue * 10m) / 1e-2m);
case DynamicViscosityUnit.MicropascalSecond: return((baseUnitValue) / 1e-6m);
case DynamicViscosityUnit.MillipascalSecond: return((baseUnitValue) / 1e-3m);
case DynamicViscosityUnit.NewtonSecondPerMeterSquared: return(baseUnitValue);
case DynamicViscosityUnit.PascalSecond: return(baseUnitValue);
case DynamicViscosityUnit.Poise: return(baseUnitValue * 10m);
case DynamicViscosityUnit.PoundForceSecondPerSquareFoot: return(baseUnitValue / 4.7880258980335843e1m);
case DynamicViscosityUnit.PoundForceSecondPerSquareInch: return(baseUnitValue / 6.8947572931683613e3m);
case DynamicViscosityUnit.PoundPerFootSecond: return(baseUnitValue / 1.4881639m);
case DynamicViscosityUnit.Reyn: return(baseUnitValue / 6.8947572931683613e3m);
default:
throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
}
}
/// <summary>
/// Convert to the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>Value in new unit if successful, exception otherwise.</returns>
/// <exception cref="NotImplementedException">If conversion was not successful.</exception>
public double As(DynamicViscosityUnit unit)
{
switch (unit)
{
case DynamicViscosityUnit.Centipoise:
return(Centipoise);
case DynamicViscosityUnit.MicropascalSecond:
return(MicropascalSeconds);
case DynamicViscosityUnit.MillipascalSecond:
return(MillipascalSeconds);
case DynamicViscosityUnit.NewtonSecondPerMeterSquared:
return(NewtonSecondsPerMeterSquared);
case DynamicViscosityUnit.PascalSecond:
return(PascalSeconds);
case DynamicViscosityUnit.Poise:
return(Poise);
default:
throw new NotImplementedException("unit: " + unit);
}
}
// Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
#if !WINDOWS_UWP
/// <summary>
/// Dynamically convert from value and unit enum <see cref="DynamicViscosityUnit" /> to <see cref="DynamicViscosity" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>DynamicViscosity unit value.</returns>
public static DynamicViscosity?From(QuantityValue?value, DynamicViscosityUnit fromUnit)
{
if (!value.HasValue)
{
return(null);
}
return(new DynamicViscosity((double)value.Value, fromUnit));
}
/// <summary>
/// Creates the quantity with the given numeric value and unit.
/// </summary>
/// <param name="value">The numeric value to construct this quantity with.</param>
/// <param name="unit">The unit representation to construct this quantity with.</param>
/// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks>
/// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
private DynamicViscosity(decimal value, DynamicViscosityUnit unit)
{
if (unit == DynamicViscosityUnit.Undefined)
{
throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
}
_value = value;
_unit = unit;
}
/// <summary>
/// Creates the quantity with the given numeric value and unit.
/// </summary>
/// <param name="value">The numeric value to construct this quantity with.</param>
/// <param name="unit">The unit representation to construct this quantity with.</param>
/// <remarks>Value parameter cannot be named 'value' due to constraint when targeting Windows Runtime Component.</remarks>
/// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
private DynamicViscosity(double value, DynamicViscosityUnit unit)
{
if (unit == DynamicViscosityUnit.Undefined)
{
throw new ArgumentException("The quantity can not be created with an undefined unit.", nameof(unit));
}
_value = Guard.EnsureValidNumber(value, nameof(value));
_unit = unit;
}
/// <summary>
/// Convert to the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>Value converted to the specified unit.</returns>
public decimal As(DynamicViscosityUnit unit)
{
if (Unit == unit)
{
return(Convert.ToDecimal(Value));
}
var converted = AsBaseNumericType(unit);
return(Convert.ToDecimal(converted));
}
/// <summary>
/// Parse a string given a particular regular expression.
/// </summary>
/// <exception cref="UnitsNetException">Error parsing string.</exception>
private static List <DynamicViscosity> ParseWithRegex(string regexString, string str, IFormatProvider formatProvider = null)
{
var regex = new Regex(regexString);
MatchCollection matches = regex.Matches(str.Trim());
var converted = new List <DynamicViscosity>();
foreach (Match match in matches)
{
GroupCollection groups = match.Groups;
var valueString = groups["value"].Value;
var unitString = groups["unit"].Value;
if (groups["invalid"].Value != "")
{
var newEx = new UnitsNetException("Invalid string detected: " + groups["invalid"].Value);
newEx.Data["input"] = str;
newEx.Data["matched value"] = valueString;
newEx.Data["matched unit"] = unitString;
newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
throw newEx;
}
if (valueString == "" && unitString == "")
{
continue;
}
try
{
DynamicViscosityUnit unit = ParseUnit(unitString, formatProvider);
double value = double.Parse(valueString, formatProvider);
converted.Add(From(value, unit));
}
catch (AmbiguousUnitParseException ambiguousException)
{
throw;
}
catch (Exception ex)
{
var newEx = new UnitsNetException("Error parsing string.", ex);
newEx.Data["input"] = str;
newEx.Data["matched value"] = valueString;
newEx.Data["matched unit"] = unitString;
newEx.Data["formatprovider"] = formatProvider == null ? null : formatProvider.ToString();
throw newEx;
}
}
return(converted);
}
// ReSharper restore VirtualMemberNeverOverriden.Global
protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor(DynamicViscosityUnit unit)
{
return(unit switch
{
DynamicViscosityUnit.Centipoise => (CentipoiseInOneNewtonSecondPerMeterSquared, CentipoiseTolerance),
DynamicViscosityUnit.MicropascalSecond => (MicropascalSecondsInOneNewtonSecondPerMeterSquared, MicropascalSecondsTolerance),
DynamicViscosityUnit.MillipascalSecond => (MillipascalSecondsInOneNewtonSecondPerMeterSquared, MillipascalSecondsTolerance),
DynamicViscosityUnit.NewtonSecondPerMeterSquared => (NewtonSecondsPerMeterSquaredInOneNewtonSecondPerMeterSquared, NewtonSecondsPerMeterSquaredTolerance),
DynamicViscosityUnit.PascalSecond => (PascalSecondsInOneNewtonSecondPerMeterSquared, PascalSecondsTolerance),
DynamicViscosityUnit.Poise => (PoiseInOneNewtonSecondPerMeterSquared, PoiseTolerance),
DynamicViscosityUnit.PoundForceSecondPerSquareFoot => (PoundsForceSecondPerSquareFootInOneNewtonSecondPerMeterSquared, PoundsForceSecondPerSquareFootTolerance),
DynamicViscosityUnit.PoundForceSecondPerSquareInch => (PoundsForceSecondPerSquareInchInOneNewtonSecondPerMeterSquared, PoundsForceSecondPerSquareInchTolerance),
DynamicViscosityUnit.PoundPerFootSecond => (PoundsPerFootSecondInOneNewtonSecondPerMeterSquared, PoundsPerFootSecondTolerance),
DynamicViscosityUnit.Reyn => (ReynsInOneNewtonSecondPerMeterSquared, ReynsTolerance),
_ => throw new NotSupportedException()
});
/// <summary>
/// Parse a string with one or two quantities of the format "<quantity> <unit>".
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="provider">Format to use when parsing number and unit. Defaults to <see cref="UnitSystem.DefaultCulture" />.</param>
/// <example>
/// Length.Parse("5.5 m", new CultureInfo("en-US"));
/// </example>
/// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
/// <exception cref="ArgumentException">
/// Expected string to have one or two pairs of quantity and unit in the format
/// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in"
/// </exception>
/// <exception cref="AmbiguousUnitParseException">
/// More than one unit is represented by the specified unit abbreviation.
/// Example: Volume.Parse("1 cup") will throw, because it can refer to any of
/// <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
/// </exception>
/// <exception cref="UnitsNetException">
/// If anything else goes wrong, typically due to a bug or unhandled case.
/// We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
/// Units.NET exceptions from other exceptions.
/// </exception>
public static DynamicViscosity Parse(string str, [CanBeNull] IFormatProvider provider)
{
if (str == null)
{
throw new ArgumentNullException(nameof(str));
}
provider = provider ?? UnitSystem.DefaultCulture;
return(QuantityParser.Parse <DynamicViscosity, DynamicViscosityUnit>(str, provider,
delegate(string value, string unit, IFormatProvider formatProvider2)
{
double parsedValue = double.Parse(value, formatProvider2);
DynamicViscosityUnit parsedUnit = ParseUnit(unit, formatProvider2);
return From(parsedValue, parsedUnit);
}, (x, y) => FromNewtonSecondsPerMeterSquared(x.NewtonSecondsPerMeterSquared + y.NewtonSecondsPerMeterSquared)));
}
public string ToString(DynamicViscosityUnit unit, [CanBeNull] IFormatProvider provider, [NotNull] string format, [NotNull] params object[] args)
{
if (format == null)
{
throw new ArgumentNullException(nameof(format));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
provider = provider ?? UnitSystem.DefaultCulture;
double value = As(unit);
object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, provider, args);
return(string.Format(provider, format, formatArgs));
}
/// <summary>
/// Parse a string with one or two quantities of the format "<quantity> <unit>".
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="UnitSystem" />'s default culture.</param>
/// <example>
/// Length.Parse("5.5 m", new CultureInfo("en-US"));
/// </example>
/// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
/// <exception cref="ArgumentException">
/// Expected string to have one or two pairs of quantity and unit in the format
/// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in"
/// </exception>
/// <exception cref="AmbiguousUnitParseException">
/// More than one unit is represented by the specified unit abbreviation.
/// Example: Volume.Parse("1 cup") will throw, because it can refer to any of
/// <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
/// </exception>
/// <exception cref="UnitsNetException">
/// If anything else goes wrong, typically due to a bug or unhandled case.
/// We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
/// Units.NET exceptions from other exceptions.
/// </exception>
public static DynamicViscosity Parse(string str, [CanBeNull] string cultureName)
{
if (str == null)
{
throw new ArgumentNullException(nameof(str));
}
// Windows Runtime Component does not support CultureInfo and IFormatProvider types, so we use culture name for public methods: https://msdn.microsoft.com/en-us/library/br230301.aspx
IFormatProvider provider = cultureName == null ? UnitSystem.DefaultCulture : new CultureInfo(cultureName);
return(QuantityParser.Parse <DynamicViscosity, DynamicViscosityUnit>(str, provider,
delegate(string value, string unit, IFormatProvider formatProvider2)
{
double parsedValue = double.Parse(value, formatProvider2);
DynamicViscosityUnit parsedUnit = ParseUnit(unit, formatProvider2);
return From(parsedValue, parsedUnit);
}, (x, y) => FromNewtonSecondsPerMeterSquared(x.NewtonSecondsPerMeterSquared + y.NewtonSecondsPerMeterSquared)));
}
public string ToString(DynamicViscosityUnit unit, [CanBeNull] string cultureName, [NotNull] string format, [NotNull] params object[] args)
{
if (format == null)
{
throw new ArgumentNullException(nameof(format));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
// Windows Runtime Component does not support CultureInfo and IFormatProvider types, so we use culture name for public methods: https://msdn.microsoft.com/en-us/library/br230301.aspx
IFormatProvider provider = cultureName == null ? UnitSystem.DefaultCulture : new CultureInfo(cultureName);
double value = As(unit);
object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, provider, args);
return(string.Format(provider, format, formatArgs));
}
/// <summary>
/// Parse a string with one or two quantities of the format "<quantity> <unit>".
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="culture">Format to use when parsing number and unit. If it is null, it defaults to <see cref="NumberFormatInfo.CurrentInfo"/> for parsing the number and <see cref="CultureInfo.CurrentUICulture"/> for parsing the unit abbreviation by culture/language.</param>
/// <example>
/// Length.Parse("5.5 m", new CultureInfo("en-US"));
/// </example>
/// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
/// <exception cref="ArgumentException">
/// Expected string to have one or two pairs of quantity and unit in the format
/// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in"
/// </exception>
/// <exception cref="AmbiguousUnitParseException">
/// More than one unit is represented by the specified unit abbreviation.
/// Example: Volume.Parse("1 cup") will throw, because it can refer to any of
/// <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
/// </exception>
/// <exception cref="UnitsNetException">
/// If anything else goes wrong, typically due to a bug or unhandled case.
/// We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
/// Units.NET exceptions from other exceptions.
/// </exception>
public static DynamicViscosity Parse(string str, [CanBeNull] Culture culture)
{
if (str == null)
{
throw new ArgumentNullException("str");
}
#if WINDOWS_UWP
IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture);
#else
IFormatProvider formatProvider = culture;
#endif
return(UnitParser.ParseUnit <DynamicViscosity>(str, formatProvider,
delegate(string value, string unit, IFormatProvider formatProvider2)
{
double parsedValue = double.Parse(value, formatProvider2);
DynamicViscosityUnit parsedUnit = ParseUnit(unit, formatProvider2);
return From(parsedValue, parsedUnit);
}, (x, y) => FromNewtonSecondsPerMeterSquared(x.NewtonSecondsPerMeterSquared + y.NewtonSecondsPerMeterSquared)));
}
public string ToString(DynamicViscosityUnit unit, [CanBeNull] Culture culture, [NotNull] string format,
[NotNull] params object[] args)
{
if (format == null)
{
throw new ArgumentNullException(nameof(format));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
#if WINDOWS_UWP
IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture);
#else
IFormatProvider formatProvider = culture;
#endif
double value = As(unit);
object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
return(string.Format(formatProvider, format, formatArgs));
}
/// <summary>
/// Parse a string with one or two quantities of the format "<quantity> <unit>".
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="culture">Format to use when parsing number and unit. If it is null, it defaults to <see cref="NumberFormatInfo.CurrentInfo"/> for parsing the number and <see cref="CultureInfo.CurrentUICulture"/> for parsing the unit abbreviation by culture/language.</param>
/// <example>
/// Length.Parse("5.5 m", new CultureInfo("en-US"));
/// </example>
/// <exception cref="ArgumentNullException">The value of 'str' cannot be null. </exception>
/// <exception cref="ArgumentException">
/// Expected string to have one or two pairs of quantity and unit in the format
/// "<quantity> <unit>". Eg. "5.5 m" or "1ft 2in"
/// </exception>
/// <exception cref="AmbiguousUnitParseException">
/// More than one unit is represented by the specified unit abbreviation.
/// Example: Volume.Parse("1 cup") will throw, because it can refer to any of
/// <see cref="VolumeUnit.MetricCup" />, <see cref="VolumeUnit.UsLegalCup" /> and <see cref="VolumeUnit.UsCustomaryCup" />.
/// </exception>
/// <exception cref="UnitsNetException">
/// If anything else goes wrong, typically due to a bug or unhandled case.
/// We wrap exceptions in <see cref="UnitsNetException" /> to allow you to distinguish
/// Units.NET exceptions from other exceptions.
/// </exception>
public static DynamicViscosity Parse(string str, [CanBeNull] Culture culture)
{
if (str == null)
{
throw new ArgumentNullException("str");
}
// Windows Runtime Component does not support CultureInfo type, so use culture name string for public methods instead: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if WINDOWS_UWP
IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture);
#else
IFormatProvider formatProvider = culture;
#endif
return(QuantityParser.Parse <DynamicViscosity, DynamicViscosityUnit>(str, formatProvider,
delegate(string value, string unit, IFormatProvider formatProvider2)
{
double parsedValue = double.Parse(value, formatProvider2);
DynamicViscosityUnit parsedUnit = ParseUnit(unit, formatProvider2);
return From(parsedValue, parsedUnit);
}, (x, y) => FromNewtonSecondsPerMeterSquared(x.NewtonSecondsPerMeterSquared + y.NewtonSecondsPerMeterSquared)));
}
public string ToString(DynamicViscosityUnit unit, [CanBeNull] Culture culture, [NotNull] string format,
[NotNull] params object[] args)
{
if (format == null)
{
throw new ArgumentNullException(nameof(format));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
// Windows Runtime Component does not support CultureInfo type, so use culture name string for public methods instead: https://msdn.microsoft.com/en-us/library/br230301.aspx
#if WINDOWS_UWP
IFormatProvider formatProvider = culture == null ? null : new CultureInfo(culture);
#else
IFormatProvider formatProvider = culture;
#endif
double value = As(unit);
object[] formatArgs = UnitFormatter.GetFormatArgs(unit, value, formatProvider, args);
return(string.Format(formatProvider, format, formatArgs));
}
/// <summary>
/// Dynamically convert from value and unit enum <see cref="DynamicViscosityUnit" /> to <see cref="DynamicViscosity" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>DynamicViscosity unit value.</returns>
public static DynamicViscosity From(double value, DynamicViscosityUnit fromUnit)
{
switch (fromUnit)
{
case DynamicViscosityUnit.Centipoise:
return(FromCentipoise(value));
case DynamicViscosityUnit.MillipascalSecond:
return(FromMillipascalSeconds(value));
case DynamicViscosityUnit.NewtonSecondPerMeterSquared:
return(FromNewtonSecondsPerMeterSquared(value));
case DynamicViscosityUnit.PascalSecond:
return(FromPascalSeconds(value));
case DynamicViscosityUnit.Poise:
return(FromPoise(value));
default:
throw new NotImplementedException("fromUnit: " + fromUnit);
}
}
/// <summary>
/// Converts this DynamicViscosity to another DynamicViscosity with the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>A DynamicViscosity with the specified unit.</returns>
public DynamicViscosity ToUnit(DynamicViscosityUnit unit)
{
var convertedValue = AsBaseNumericType(unit);
return(new DynamicViscosity(convertedValue, unit));
}
/// <summary>
/// Parse a unit string.
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="unit">The parsed unit if successful.</param>
/// <returns>True if successful, otherwise false.</returns>
/// <example>
/// Length.TryParseUnit("m", new CultureInfo("en-US"));
/// </example>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out DynamicViscosityUnit unit)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitParser.Default.TryParse <DynamicViscosityUnit>(str, provider, out unit));
}
public static bool TryParseUnit(string str, out DynamicViscosityUnit unit)
{
return(TryParseUnit(str, null, out unit));
}
public static DynamicViscosity From(decimal value, DynamicViscosityUnit fromUnit)
{
return(new DynamicViscosity((decimal)value, fromUnit));
}
/// <summary>
/// Get unit abbreviation string.
/// </summary>
/// <param name="unit">Unit to get abbreviation for.</param>
/// <returns>Unit abbreviation string.</returns>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
public static string GetAbbreviation(DynamicViscosityUnit unit, [CanBeNull] string cultureName)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider));
}
/// <summary>
/// Get unit abbreviation string.
/// </summary>
/// <param name="unit">Unit to get abbreviation for.</param>
/// <returns>Unit abbreviation string.</returns>
public static string GetAbbreviation(DynamicViscosityUnit unit)
{
return(GetAbbreviation(unit, null));
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="culture">Culture to use for localization and number formatting.</param>
/// <returns>String representation.</returns>
public string ToString(DynamicViscosityUnit unit, [CanBeNull] Culture culture)
{
return(ToString(unit, culture, 2));
}
