Name: UnitsNet
Author: Andreas Gullberg Larsen

UnitsNet v5.66.0 — nugetz

dotnet add package UnitsNet

// Construct
Length meter = Length.FromMeters(1);
Length twoMeters = new Length(2, LengthUnit.Meter);

// Convert
double cm = meter.Centimeters;         // 100
double yards = meter.Yards;            // 1.09361
double feet = meter.Feet;              // 3.28084
double inches = meter.Inches;          // 39.3701

// Pass quantity types instead of values to avoid conversion mistakes and communicate intent
string PrintPersonWeight(Mass weight)
{
    // Compile error! Newtons belong to Force, not Mass. A common source of confusion.
    double weightNewtons = weight.Newtons;

    // Convert to the unit of choice - when you need it
    return $"You weigh {weight.Kilograms:F1} kg.";
}

// Arithmetic
Length l1 = 2 * Length.FromMeters(1);
Length l2 = Length.FromMeters(1) / 2;
Length l3 = l1 + l2;

// Construct between units
Length distance = Speed.FromKilometersPerHour(80) * TimeSpan.FromMinutes(30);
Acceleration a1 = Speed.FromKilometersPerHour(80) / TimeSpan.FromSeconds(2);
Acceleration a2 = Force.FromNewtons(100) / Mass.FromKilograms(20);
RotationalSpeed r = Angle.FromDegrees(90) / TimeSpan.FromSeconds(2);

var usEnglish = new CultureInfo("en-US");
var russian = new CultureInfo("ru-RU");
var oneKg = Mass.FromKilograms(1);

// ToString() uses CurrentCulture for abbreviation language number formatting. This is consistent with the behavior of the .NET Framework,
// where DateTime.ToString() uses CurrentCulture for the whole string, likely because mixing an english date format with a russian month name might be confusing.
CultureInfo.CurrentCulture = russian;
string kgRu = oneKg.ToString(); // "1 кг"

// ToString() with specific culture and custom string format pattern
string mgUs = oneKg.ToUnit(MassUnit.Milligram).ToString(usEnglish, "unit: {1}, value: {0:F2}"); // "unit: mg, value: 1.00"
string mgRu = oneKg.ToUnit(MassUnit.Milligram).ToString(russian, "unit: {1}, value: {0:F2}"); // "unit: мг, value: 1,00"

// Parse measurement from string
Mass kg = Mass.Parse("1.0 kg", usEnglish);

// Parse unit from string, a unit can have multiple abbreviations
RotationalSpeedUnit rpm1 = RotationalSpeed.ParseUnit("rpm"); // RotationalSpeedUnit.RevolutionPerMinute
RotationalSpeedUnit rpm2 = RotationalSpeed.ParseUnit("r/min");  // RotationalSpeedUnit.RevolutionPerMinute

// Get default abbreviation for a unit, the first if more than one is defined in Length.json for Kilogram unit
string kgAbbreviation = Mass.GetAbbreviation(MassUnit.Kilogram); // "kg"

string[] names = Quantity.Names;     // ["Length", "Mass", ...]
QuantityInfo[] qis = Quantity.Infos; // All quantities and their units, types, values.

// Look up quantity by name.
QuantityInfo lengthInfo = Quantity.ByName["Length"];
UnitInfo[] lengthUnits = lengthInfo.UnitInfos;

// Look up unit by enum value (note: for extensibility, will instead look up by name in the future)
UnitInfo cmInfo = Quantity.GetUnitInfo(LengthUnit.Centimeter);

// Different ways to look up the quantity info.
QuantityInfo lengthInfo = Quantity.ByName["Length"];
lengthInfo = Length.Info;
lengthInfo = Length.FromMeters(1).QuantityInfo;

// The quantity information.
lengthInfo.Name;            // "Length"
lengthInfo.UnitInfos;       // UnitInfo[] for its units Centimeter, Meter, etc.
lengthInfo.BaseUnitInfo;    // UnitInfo for LengthUnit.Meter
lengthInfo.BaseDimensions;  // {"Length": 1, "Mass": 0, ...}
lengthInfo.UnitType;        // typeof(LengthUnit)
lengthInfo.ValueType;       // typeof(Length)
lengthInfo.Zero;            // Length.Zero

// Different ways to look up the unit info.
var cm = Quantity.GetUnitInfo(LengthUnit.Centimeter);

if (Quantity.TryGetUnitInfo(LengthUnit.Centimeter, out UnitInfo tryGetCm)) {
    cm = tryGetCm;
}

// The unit information.
cm.Value;       // Enum value: LengthUnit.Centimeter
cm.Name;        // "Centimeter"
cm.PluralName;  // "Centimeters"
cm.BaseUnits;   // {"Length": Centimeter, "Mass": null, "Time": null, ...}

IQuantity quantity = Quantity.From(3, LengthUnit.Centimeter); // Length

if (Quantity.TryFrom(3, LengthUnit.Centimeter, out IQuantity quantity2))
{
}

IQuantity quantity = Quantity.From(value: 3, quantityName: "Length", unitName: "Centimeter");

if (Quantity.TryFrom(value: 3, quantityName: "Length", unitName: "Centimeter", out IQuantity? quantity2))
{
}

// Length with unit LengthUnit.Centimeter
IQuantity quantity = Quantity.FromUnitAbbreviation(3, "cm");

if (Quantity.TryFromUnitAbbreviation(3, "cm", out IQuantity? quantity2))
{
}

IQuantity quantity = Quantity.Parse(typeof(Length), "3 cm"); // Length

if (Quantity.TryParse(typeof(Length), "3cm", out IQuantity quantity2)
{
}

Enum unit = UnitsNetSetup.Default.UnitParser.Parse("cm", typeof(LengthUnit)); // LengthUnit.Centimeter

if (UnitsNetSetup.Default.UnitParser.TryParse("cm", typeof(LengthUnit), out Enum unit2))
{
    // Use unit2 as LengthUnit.Centimeter
}

// Assume these are passed in at runtime, we don't know their values or type
Enum userSelectedUnit = LengthUnit.Millimeter;
IQuantity quantity = Length.FromCentimeters(3);

// Later we convert to a unit
quantity.ToUnit(userSelectedUnit).Value;      // 30
quantity.ToUnit(userSelectedUnit).Unit;       // LengthUnit.Millimeter
quantity.ToUnit(userSelectedUnit).ToString(); // "30 mm"
quantity.ToUnit(PressureUnit.Pascal);         // Throws exception, not compatible
quantity.As(userSelectedUnit);                // 30

UnitConverter.Convert(1, LengthUnit.Centimeter, LengthUnit.Millimeter); // 10 mm

UnitConverter.ConvertByName(1, "Length", "Centimeter", "Millimeter"); // 10 mm
UnitConverter.ConvertByAbbreviation(1, "Length", "cm", "mm"); // 10 mm

// Map unit enum values to unit abbreviations
var unitAbbreviations = UnitsNetSetup.Default.UnitAbbreviations;
unitAbbreviations.MapUnitToDefaultAbbreviation(HowMuchUnit.Some, "sm");
unitAbbreviations.GetDefaultAbbreviation(HowMuchUnit.Some); // "sm"

UnitsNetSetup.Default.UnitParser.Parse<HowMuchUnit>("sm");  // HowMuchUnit.Some

var unitConverter = UnitsNetSetup.Default.UnitConverter;
unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Lots, HowMuchUnit.Some, x => new HowMuch(x.Value * 2, HowMuchUnit.Some));
unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Tons, HowMuchUnit.Lots, x => new HowMuch(x.Value * 10, HowMuchUnit.Lots));
unitConverter.SetConversionFunction<HowMuch>(HowMuchUnit.Tons, HowMuchUnit.Some, x => new HowMuch(x.Value * 20, HowMuchUnit.Some));

var from = new HowMuch(10, HowMuchUnit.Tons);
IQuantity Convert(HowMuchUnit toUnit) => unitConverter.GetConversionFunction<HowMuch>(from.Unit, toUnit)(from);

Console.WriteLine($"Convert 10 tons to:");
Console.WriteLine(Convert(HowMuchUnit.Some)); // 200 sm
Console.WriteLine(Convert(HowMuchUnit.Lots)); // 100 lts
Console.WriteLine(Convert(HowMuchUnit.Tons)); // 10 tns

// Map custom units to abbreviations
var unitAbbreviationsCache = UnitsNetSetup.Default.UnitAbbreviations;
unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.ATon, "tn");

var quantityParser = UnitsNetSetup.Default.QuantityParser;

// "1 sm" => new HowMuch(1, HowMuchUnit.Some)
HowMuch q = quantityParser.Parse<HowMuch, HowMuchUnit>(
    str: "1 sm",
    formatProvider: null,
    fromDelegate: (value, unit) => new HowMuch((double) value, unit));

// Alternatively, create your own instances to not change the global singleton instances.
var unitAbbreviationsCache = UnitAbbreviationsCache.CreateDefault(); // or .CreateEmpty()
unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.Some, "sm");
unitAbbreviationsCache.MapUnitToAbbreviation(HowMuchUnit.ATon, "tn");

var quantityParser = new QuantityParser(unitAbbreviationsCache);

this.Quantities = Quantity.Names; // string[]

// or
this.Quantities = Quantity.Infos.Select(i => i.Name).ToList();

QuantityInfo quantityInfo = Quantity.ByName[quantityName];

_units.Clear();
foreach (Enum unitValue in quantityInfo.UnitInfos.Select(ui => ui.Value))
{
    _units.Add(new UnitListItem(unitValue));
}

double convertedValue = UnitConverter.Convert(
    FromValue,                      // numeric value
    SelectedFromUnit.UnitEnumValue, // Enum, such as LengthUnit.Meter
    SelectedToUnit.UnitEnumValue);  // Enum, such as LengthUnit.Centimeter

Repo	Stars
https://github.com/microsoft/PowerToys	105K
https://github.com/dotnet/iot	2.1K
https://github.com/genielabs/HomeGenie	388
https://github.com/raspberry-sharp/raspberry-sharp-io	340
https://github.com/nanoframework/nanoFramework.IoT.Device	202
https://github.com/porrey/Virtual-ZPL-Printer	166
https://github.com/chino-os/chino-os	147
https://github.com/BriefFiniteElementNet/BriefFiniteElement.Net	143
https://github.com/WhiteBlackGoose/UnitsOfMeasure	57
https://github.com/pi-top/pi-top-4-.NET-SDK	48

Language	Name	Package	Repository	Maintainers
JavaScript / TypeScript	unitsnet-js	npm	github	@haimkastner
Python	unitsnet-py	pypi	github	@haimkastner
Golang	unitsnet-go	pkg.go.dev	github	@haimkastner

angularsen/UnitsNetv5.66.0

Get Started

Readme

Units.NET

Overview

Installing via NuGet

Build Targets

Static Typing

Operator Overloads

Culture and Localization

Gotcha: AmbiguousUnitParseException

Dynamically Parse Quantities and Convert to Units

Quantity - Enumerate quantities and units at runtime

QuantityInfo - Information about a quantity

UnitInfo - Information about a unit

Construct quantity

Parse quantity

Parse unit

Convert quantity to unit - IQuantity and Enum

Convert quantity to unit - From/To Enums

Convert quantity to unit - Names or abbreviation strings

Custom units

Map between unit enum values and unit abbreviations

Convert between units of custom quantity

Parse custom quantity

Example: Unit converter app

Populate quantity selector

Update unit lists when selecting new quantity

Update calculation on unit selection changed

Example: WPF app using IValueConverter to parse input

Precision and Accuracy

Serialize to JSON, XML and more

Want To Contribute?

Continuous Integration

Who are Using UnitsNet?

Swing Catalyst and Motion Catalyst, Norway

PK Sound, Canada

Microsoft.IoT.Devices

Crawlspace

ANSYS, Inc. (ANSYS Discovery Live)

Primoris Sigma Stargen

Harrington Hoists, Inc. (A Subsidiary of KITO Americas, Inc.)

Structural Analysis Format - SDK project

Top Usages by GitHub Repos

Units.NET on other platforms