### UnitFormatOptions - Customizing Output Formatting in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Explains how to use the UnitFormatOptions class to customize the display formatting of unit values. This includes setting number format patterns, choosing between symbol and full name styles, and specifying culture-specific formatting providers. Examples show custom formatting for power, temperature, and length units, as well as data tables.

```csharp
using Codebelt.Unitify;
using System.Globalization;

// Create unit with custom formatting
var power = UnitFactory.CreateWatt(1234.5678, DecimalPrefix.Kilo, options =>
{
    options.NumberFormat = "0.00";
    options.Style = NamingStyle.Symbol;
    options.FormatProvider = CultureInfo.InvariantCulture;
});
Console.WriteLine(power.ToString()); // Output: 1234.57 kW

// Use full name style
var temperature = UnitFactory.CreateCelsius(23.5, null, options =>
{
    options.Style = NamingStyle.Name;
    options.NumberFormat = "0.0";
});
Console.WriteLine(temperature.ToString()); // Output: 23.5 Celsius

// Use compound style (includes category)
var length = UnitFactory.CreateMeter(100, DecimalPrefix.Kilo, options =>
{
    options.Style = NamingStyle.Compound;
});
Console.WriteLine(length.ToString()); // Output: 100 km Length

// Custom number formatting for data tables
var data = DataPrefixTable.CreateByteTableFromBytes(1234567890, options =>
{
    options.NumberFormat = "#,##0.000";
});
Console.WriteLine(data.ToString()); // Output: 1.150 GiB
```

--------------------------------

### PrefixUnit Extensions - Value Conversions in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Demonstrates how to use PrefixUnitExtensions for converting between prefix and base values, and for generating formatted output strings. It covers creating units with prefixes, retrieving prefix and base values, converting to base units, and generating string representations with automatic prefix selection.

```csharp
using Codebelt.Unitify;

// Create a unit with a prefix
var storage = UnitFactory.CreateByte(500, BinaryPrefix.Gibi);

// Get prefix value (the display value)
Console.WriteLine(storage.ToPrefixValue()); // Output: 500

// Get base value (the actual bytes)
Console.WriteLine(storage.ToBaseValue()); // Output: 536870912000

// Convert to base unit (removes prefix context)
var baseUnit = storage.ToBaseUnit();
Console.WriteLine(baseUnit.Value); // Output: 536870912000
Console.WriteLine(baseUnit.ToString()); // Output: 536,870,912,000 B

// Get string representation with automatic prefix selection
var largeValue = UnitFactory.CreateByte(1500000000);
Console.WriteLine(largeValue.ToPrefixString()); // Output: 1.396984 GiB (binary default)

// Convert to tables for full prefix access
var metricTable = largeValue.ToMetricPrefixTable();
var dataTable = largeValue.ToDataPrefixTable();
```

--------------------------------

### BinaryPrefix - IEC Binary Prefixes in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Illustrates the use of the BinaryPrefix class for IEC binary prefixes (powers of 2) in C#. It covers accessing prefixes like kibi, mebi, and gibi, creating byte units, and performing conversions between bits and bytes.

```csharp
using Codebelt.Unitify;

// Available binary prefixes (powers of 2)
var kibi = BinaryPrefix.Kibi; // 2^10 = 1,024
var mebi = BinaryPrefix.Mebi; // 2^20 = 1,048,576
var gibi = BinaryPrefix.Gibi; // 2^30 = 1,073,741,824
var tebi = BinaryPrefix.Tebi; // 2^40
var pebi = BinaryPrefix.Pebi; // 2^50
var exbi = BinaryPrefix.Exbi; // 2^60

// Create byte unit with binary prefix
var ramSize = UnitFactory.CreateByte(16, BinaryPrefix.Gibi);
Console.WriteLine(ramSize.ToString()); // Output: 16 GiB
Console.WriteLine(ramSize.ToBaseValue()); // Output: 17179869184 (bytes)

// Convert bits to bytes and vice versa
var bits = BinaryPrefix.ConvertBytesToBits(1024); // 8192 bits
var bytes = BinaryPrefix.ConvertBitsToBytes(8192); // 1024 bytes
Console.WriteLine($"{bits} bits = {bytes} bytes");

// Prefix properties
Console.WriteLine(gibi.Name);       // Output: gibi
Console.WriteLine(gibi.Symbol);     // Output: Gi
Console.WriteLine(gibi.Base);       // Output: 2
Console.WriteLine(gibi.Exponent);   // Output: 30
Console.WriteLine(gibi.Multiplier); // Output: 1073741824
```

--------------------------------

### DecimalPrefix - SI Metric Prefixes in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Demonstrates the usage of the DecimalPrefix class for SI metric prefixes (powers of 10) in C#. It shows how to access prefixes, create units using UnitFactory, and perform conversions between base and prefixed values.

```csharp
using Codebelt.Unitify;

// Available decimal prefixes (powers of 10)
var kilo = DecimalPrefix.Kilo;   // 10^3 = 1,000
var mega = DecimalPrefix.Mega;   // 10^6 = 1,000,000
var giga = DecimalPrefix.Giga;   // 10^9 = 1,000,000,000
var tera = DecimalPrefix.Tera;   // 10^12
var peta = DecimalPrefix.Peta;   // 10^15
var exa = DecimalPrefix.Exa;     // 10^18

// Submultiples
var milli = DecimalPrefix.Milli; // 10^-3 = 0.001
var micro = DecimalPrefix.Micro; // 10^-6 = 0.000001
var nano = DecimalPrefix.Nano;   // 10^-9
var pico = DecimalPrefix.Pico;   // 10^-12

// Create units with decimal prefixes
var frequency = UnitFactory.CreateHertz(2.4, DecimalPrefix.Giga);
Console.WriteLine(frequency.ToString()); // Output: 2.4 GHz

var capacitance = UnitFactory.CreateFarad(6, DecimalPrefix.Micro);
Console.WriteLine(capacitance.ToString()); // Output: 6 μF

// Convert between base and prefix values
Console.WriteLine(kilo.Multiplier);           // Output: 1000
Console.WriteLine(kilo.ToPrefixValue(5000));  // Output: 5 (5000 base = 5 kilo)
Console.WriteLine(kilo.ToBaseValue(5));       // Output: 5000 (5 kilo = 5000 base)
```

--------------------------------

### UnitFactory.CreateMeter - Create Length Units in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Shows how to create SI base units for length using `UnitFactory.CreateMeter` in C#. It demonstrates creating meters with various decimal prefixes and converting them to a metric prefix table for different representations.

```csharp
using Codebelt.Unitify;

// Create meter units with various prefixes
var distance = UnitFactory.CreateMeter(42.195, DecimalPrefix.Kilo);
Console.WriteLine(distance.ToString()); // Output: 42.195 km

var wavelength = UnitFactory.CreateMeter(550, DecimalPrefix.Nano);
Console.WriteLine(wavelength.ToString()); // Output: 550 nm

var thickness = UnitFactory.CreateMeter(0.1, DecimalPrefix.Milli);
Console.WriteLine(thickness.ToString()); // Output: 0.1 mm

// Convert to metric prefix table for all representations
var length = UnitFactory.CreateMeter(1500);
var table = length.ToMetricPrefixTable();
Console.WriteLine(table.ToString()); // Output: 1.5 km (largest prefix >= 1)
```

--------------------------------

### UnitFactory.CreateGram / CreateKilogram - Create Mass Units in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Explains the creation of mass units using `UnitFactory.CreateGram` and `UnitFactory.CreateKilogram` in C#. It covers creating grams with and without prefixes, using the convenience `CreateKilogram` method, and generating a metric prefix table for mass.

```csharp
using Codebelt.Unitify;

// Create mass in grams
var mass = UnitFactory.CreateGram(500);
Console.WriteLine(mass.ToString()); // Output: 500 g

// Create with prefix
var milligrams = UnitFactory.CreateGram(250, DecimalPrefix.Milli);
Console.WriteLine(milligrams.ToString()); // Output: 250 mg

// Create kilograms directly (convenience method)
var weight = UnitFactory.CreateKilogram(75);
Console.WriteLine(weight.ToString()); // Output: 75 kg
Console.WriteLine(weight.Prefix.Name); // Output: kilo
Console.WriteLine(weight.ToBaseValue()); // Output: 75000 (grams)

// Create metric prefix table for mass
var sample = UnitFactory.CreateGram(0.000005);
var table = sample.ToMetricPrefixTable();
Console.WriteLine(table.ToString()); // Output: 5 μg
```

--------------------------------

### DecimalPrefix - Metric (SI) Prefixes

Source: https://context7.com/codebeltnet/unitify/llms.txt

The DecimalPrefix class provides standard SI metric prefixes from quecto (10^-30) to quetta (10^30), based on powers of 10. It allows for creating units with these prefixes and converting between base and prefixed values.

```APIDOC
## DecimalPrefix - Metric (SI) Prefixes

### Description
Provides standard SI metric prefixes (powers of 10) from quecto (10^-30) to quetta (10^30).

### Usage
Instantiate prefixes like `DecimalPrefix.Kilo`, `DecimalPrefix.Mega`, etc.
Use `UnitFactory` to create units with these prefixes.
Access `Multiplier`, `ToPrefixValue()`, and `ToBaseValue()` for conversions.

### Example
```csharp
using Codebelt.Unitify;

var kilo = DecimalPrefix.Kilo;   // 10^3 = 1,000
var milli = DecimalPrefix.Milli; // 10^-3 = 0.001

// Create units
var frequency = UnitFactory.CreateHertz(2.4, DecimalPrefix.Giga);
Console.WriteLine(frequency.ToString()); // Output: 2.4 GHz

// Conversions
Console.WriteLine(kilo.Multiplier);           // Output: 1000
Console.WriteLine(kilo.ToPrefixValue(5000));  // Output: 5
Console.WriteLine(kilo.ToBaseValue(5));       // Output: 5000
```
```

--------------------------------

### Create SI Derived Units with UnitFactory

Source: https://context7.com/codebeltnet/unitify/llms.txt

Factory methods for creating SI derived units like Volt, Ampere, Ohm, Watt, Hertz, Celsius, Kelvin, Pascal, and Joule. Supports decimal prefixes for precise measurements.

```csharp
using Codebelt.Unitify;

// Electrical units
var voltage = UnitFactory.CreateVolt(220);
Console.WriteLine(voltage.ToString()); // Output: 220 V

var current = UnitFactory.CreateAmpere(15, DecimalPrefix.Milli);
Console.WriteLine(current.ToString()); // Output: 15 mA

var resistance = UnitFactory.CreateOhm(4.7, DecimalPrefix.Kilo);
Console.WriteLine(resistance.ToString()); // Output: 4.7 kΩ

var power = UnitFactory.CreateWatt(1500);
Console.WriteLine(power.ToString()); // Output: 1,500 W

// Frequency
var cpuFreq = UnitFactory.CreateHertz(3.5, DecimalPrefix.Giga);
Console.WriteLine(cpuFreq.ToString()); // Output: 3.5 GHz

// Temperature
var temp = UnitFactory.CreateCelsius(25);
Console.WriteLine(temp.ToString()); // Output: 25 °C

var kelvin = UnitFactory.CreateKelvin(298.15);
Console.WriteLine(kelvin.ToString()); // Output: 298.15 K

// Pressure
var pressure = UnitFactory.CreatePascal(101325);
Console.WriteLine(pressure.ToString()); // Output: 101,325 Pa

// Energy
var energy = UnitFactory.CreateJoule(3600, DecimalPrefix.Kilo);
Console.WriteLine(energy.ToString()); // Output: 3,600 kJ
```

--------------------------------

### BinaryPrefix - Binary (IEC) Prefixes

Source: https://context7.com/codebeltnet/unitify/llms.txt

The BinaryPrefix class offers binary prefixes (powers of 2) as defined by IEC standards, crucial for digital storage where 1 KiB = 1024 bytes. It includes methods for conversion and accessing prefix properties.

```APIDOC
## BinaryPrefix - Binary (IEC) Prefixes

### Description
Provides binary prefixes (powers of 2) based on IEC standards (e.g., KiB, MiB).

### Usage
Instantiate prefixes like `BinaryPrefix.Kibi`, `BinaryPrefix.Mebi`, etc.
Use `UnitFactory` to create units with these prefixes.
Utilize `ConvertBytesToBits()` and `ConvertBitsToBytes()` for conversions.
Access `Name`, `Symbol`, `Base`, `Exponent`, and `Multiplier` properties.

### Example
```csharp
using Codebelt.Unitify;

var kibi = BinaryPrefix.Kibi; // 2^10 = 1,024
var gibi = BinaryPrefix.Gibi; // 2^30 = 1,073,741,824

// Create units
var ramSize = UnitFactory.CreateByte(16, BinaryPrefix.Gibi);
Console.WriteLine(ramSize.ToString()); // Output: 16 GiB

// Conversions
var bits = BinaryPrefix.ConvertBytesToBits(1024); // 8192 bits
var bytes = BinaryPrefix.ConvertBitsToBytes(8192); // 1024 bytes

// Properties
Console.WriteLine(gibi.Name);       // Output: gibi
Console.WriteLine(gibi.Symbol);     // Output: Gi
Console.WriteLine(gibi.Multiplier); // Output: 1073741824
```
```

--------------------------------

### Create Transmission Rate Units (Bits per Second) with UnitFactory

Source: https://context7.com/codebeltnet/unitify/llms.txt

The `UnitFactory.CreateBitPerSecond` method is used to create units for measuring data transmission rates, essential for network bandwidth and transfer speed calculations. It supports conversions to both binary and decimal prefix notations via `DataPrefixTable`.

```csharp
using Codebelt.Unitify;

// Calculate transfer rate
var fileSize = 6412840313; // bits
var seconds = 9.7;
var transferRate = UnitFactory.CreateBitPerSecond(fileSize / seconds);

// Convert to prefix table
var data = transferRate.ToDataPrefixTable();

// Display in decimal format (common for network speeds)
Console.WriteLine(data.ToString(PrefixStyle.Decimal)); // Output: 661.117558 Mbit/s

// Display in binary format
Console.WriteLine(data.ToString(PrefixStyle.Binary)); // Output: 0.615714 Gibit/s

// Show all conversions
Console.WriteLine(data.ToAggregateString());
/* Output:
0.000001 Pibit/s
0.000601 Tibit/s
0.615714 Gibit/s
630.490835 Mibit/s
645,622.615275 Kibit/s
661,117,558.041237 bit/s
0.000001 Pbit/s
0.000661 Tbit/s
0.661118 Gbit/s
661.117558 Mbit/s
661,117.558041 kbit/s
*/
```

--------------------------------

### Create Custom Units with UnitFactory.CreateUnit

Source: https://context7.com/codebeltnet/unitify/llms.txt

Allows the creation of custom units for domain-specific applications. Define category, name, symbol, value, and optionally a decimal prefix.

```csharp
using Codebelt.Unitify;

// Create a custom unit
var customUnit = UnitFactory.CreateUnit(
    category: "Currency",
    name: "Dollar",
    symbol: "$",
    value: 1000000,
    prefix: DecimalPrefix.Mega
);

Console.WriteLine(customUnit.Category); // Output: Currency
Console.WriteLine(customUnit.Name);     // Output: Dollar
Console.WriteLine(customUnit.Symbol);   // Output: $
Console.WriteLine(customUnit.ToString()); // Output: 1 M$

// Create custom measurement unit
var particles = UnitFactory.CreateUnit(
    category: "Count",
    name: "Particles",
    symbol: "p",
    value: 6.022e23,
    prefix: null
);
Console.WriteLine(particles.ToString()); // Output: 602,200,000,000,000,000,000,000 p
```

--------------------------------

### Create Bit Units for Data Measurement with UnitFactory

Source: https://context7.com/codebeltnet/unitify/llms.txt

The `UnitFactory.CreateBit` method creates a unit of measure for data quantity in bits. It allows specifying binary prefixes directly and can convert from byte values using `DataPrefixTable`. This is useful for precise bit-level data measurement and conversions.

```csharp
using Codebelt.Unitify;

// Create bit unit
var bits = UnitFactory.CreateBit(8589934592); // 8 Gibibits
Console.WriteLine(bits.ToString()); // Output: 8,589,934,592 b

// Create bit unit with binary prefix
var gibibits = UnitFactory.CreateBit(8, BinaryPrefix.Gibi);
Console.WriteLine(gibibits.ToString()); // Output: 8 Gib
Console.WriteLine(gibibits.ToBaseValue()); // Output: 8589934592 (base value in bits)

// Convert bytes to bit table
var bitTable = DataPrefixTable.CreateBitTableFromBytes(1073741824); // 1 GiB in bytes
Console.WriteLine(bitTable.ToString()); // Output: 8 Gib
```

--------------------------------

### Data Prefix Conversions with DataPrefixTable

Source: https://context7.com/codebeltnet/unitify/llms.txt

Specialized class for data quantity units (bits, bytes). Supports both binary (IEC) and decimal (SI) prefix representations simultaneously.

```csharp
using Codebelt.Unitify;

// Create from raw bytes
var diskSize = DataPrefixTable.CreateByteTableFromBytes(1099511627776); // 1 TiB
Console.WriteLine(diskSize.ToString(PrefixStyle.Binary));  // Output: 1 TiB
Console.WriteLine(diskSize.ToString(PrefixStyle.Decimal)); // Output: 1.099512 TB

// Create from raw bits
var bandwidth = DataPrefixTable.CreateBitTableFromBits(1000000000); // 1 Gbit
Console.WriteLine(bandwidth.ToString(PrefixStyle.Decimal)); // Output: 1 Gb

// Access specific prefix values
var tebi = diskSize.TebiOrDefault();
Console.WriteLine(tebi?.ToString()); // Output: 1 TiB

var gibi = diskSize.GibiOrDefault();
Console.WriteLine(gibi?.ToString()); // Output: 1,024 GiB

// Iterate through all prefixes
foreach (var prefix in diskSize)
{
    Console.WriteLine($"{prefix.Prefix.Name}: {prefix.Value} {prefix.Prefix.Symbol}{prefix.Symbol}");
}
```

--------------------------------

### BaseUnit - Defining Custom Base Units in C#

Source: https://context7.com/codebeltnet/unitify/llms.txt

Details the BaseUnit struct for defining fundamental measurement units, including their category, name, and symbol. It shows how to create custom base units, use them with PrefixUnit for full functionality, compare base units, and access predefined SI base units.

```csharp
using Codebelt.Unitify;

// Create a custom base unit
var customBase = new BaseUnit(
    category: "Illumination",
    name: "Lumen",
    symbol: "lm"
);

Console.WriteLine(customBase.Category); // Output: Illumination
Console.WriteLine(customBase.Name);     // Output: Lumen
Console.WriteLine(customBase.Symbol);   // Output: lm

// Use with PrefixUnit for full functionality
var lumens = new PrefixUnit(customBase, 1000, DecimalPrefix.Kilo);
Console.WriteLine(lumens.ToString()); // Output: 1 klm

// Compare base units
var lumen1 = Unit.Lumen;
var lumen2 = new BaseUnit("Luminous Flux", "Lumen", "lm");
Console.WriteLine(lumen1.Equals(lumen2)); // Output: True

// Access predefined SI base units
Console.WriteLine(Unit.Meter.Symbol);   // Output: m
Console.WriteLine(Unit.Second.Symbol);  // Output: s
Console.WriteLine(Unit.Ampere.Symbol);  // Output: A
Console.WriteLine(Unit.Kelvin.Symbol);  // Output: K
Console.WriteLine(Unit.Mole.Symbol);    // Output: mol
Console.WriteLine(Unit.Candela.Symbol); // Output: cd
Console.WriteLine(Unit.Gram.Symbol);    // Output: g
```

--------------------------------

### Iterate Through SI Prefixes with MetricPrefixTable

Source: https://context7.com/codebeltnet/unitify/llms.txt

Provides a table of SI metric prefix representations for a given unit. Useful for displaying values at the most appropriate scale.

```csharp
using Codebelt.Unitify;

// Create a unit and get its metric prefix table
var frequency = UnitFactory.CreateHertz(2400000000); // 2.4 GHz
var table = frequency.ToMetricPrefixTable();

// Get the most appropriate representation (first prefix >= 1)
Console.WriteLine(table.ToString()); // Output: 2.4 GHz

// Display all prefix representations
Console.WriteLine(table.ToAggregateString(includeMultiples: true, includeSubmultiples: false, includeUnit: true));
/* Output includes:
2.4 GHz
2,400 MHz
2,400,000 kHz
...
*/

// Access specific prefix values via extension methods
var inMega = table.MegaOrDefault();
Console.WriteLine(inMega?.ToString()); // Output: 2,400 MHz

var inKilo = table.KiloOrDefault();
Console.WriteLine(inKilo?.ToString()); // Output: 2,400,000 kHz
```

--------------------------------

### Create Data Quantity Units (Bytes) with UnitFactory

Source: https://context7.com/codebeltnet/unitify/llms.txt

The `UnitFactory.CreateByte` method generates a unit of measure for data size in bytes. It supports optional binary or decimal prefixes for easy conversion between different data size representations. The output can be formatted using `DataPrefixTable` in binary or decimal styles.

```csharp
using Codebelt.Unitify;

// Create a byte unit from raw value
var fileSize = 3812840313; // bytes
var unit = UnitFactory.CreateByte(fileSize);

// Access unit properties
Console.WriteLine(unit.Category);  // Output: Data Quantity
Console.WriteLine(unit.Name);      // Output: byte
Console.WriteLine(unit.Symbol);    // Output: B
Console.WriteLine(unit.Value);     // Output: 3812840313
Console.WriteLine(unit.ToString()); // Output: 3,812,840,313 B

// Convert to DataPrefixTable for multiple prefix views
var data = unit.ToDataPrefixTable();

// Get formatted output in different prefix styles
Console.WriteLine(data.ToString(PrefixStyle.Binary));   // Output: 3.550984 GiB
Console.WriteLine(data.ToString(PrefixStyle.Decimal));  // Output: 3.81284 GB

// Display all prefix conversions
Console.WriteLine(data.ToAggregateString());
/* Output:
0.000003 PiB
0.003468 TiB
3.550984 GiB
3,636.207879 MiB
3,723,476.868164 KiB
3,812,840,313 B
0.000004 PB
0.003813 TB
3.81284 GB
3,812.840313 MB
3,812,840.313 kB
*/
```

--------------------------------

### UnitFactory.CreateMeter - Length Units

Source: https://context7.com/codebeltnet/unitify/llms.txt

The UnitFactory.CreateMeter method facilitates the creation of SI base units for length. It supports various decimal prefixes, enabling representation from nanometers to kilometers.

```APIDOC
## UnitFactory.CreateMeter - Create Length Units

### Description
Creates SI base units for length (meters), supporting decimal prefixes for a wide range of scales.

### Usage
Call `UnitFactory.CreateMeter(value, [DecimalPrefix])`.
Use `ToMetricPrefixTable()` to get all representations.

### Example
```csharp
using Codebelt.Unitify;

// Create meter units with prefixes
var distance = UnitFactory.CreateMeter(42.195, DecimalPrefix.Kilo); // 42.195 km
var wavelength = UnitFactory.CreateMeter(550, DecimalPrefix.Nano);   // 550 nm

// Get prefix table
var length = UnitFactory.CreateMeter(1500);
var table = length.ToMetricPrefixTable();
Console.WriteLine(table.ToString()); // Output: 1.5 km
```
```

--------------------------------

### UnitFactory.CreateGram / CreateKilogram - Mass Units

Source: https://context7.com/codebeltnet/unitify/llms.txt

The library allows creating mass units using CreateGram (base unit) or CreateKilogram (convenience wrapper for kg). It supports prefixes and conversion to base values.

```APIDOC
## UnitFactory.CreateGram / CreateKilogram - Create Mass Units

### Description
Creates SI base units for mass (grams) or kilograms. `CreateKilogram` automatically applies the 'kilo' prefix.

### Usage
Call `UnitFactory.CreateGram(value, [DecimalPrefix])` or `UnitFactory.CreateKilogram(value)`.
Use `ToMetricPrefixTable()` for various representations.

### Example
```csharp
using Codebelt.Unitify;

// Create grams
var mass = UnitFactory.CreateGram(500); // 500 g

// Create with prefix
var milligrams = UnitFactory.CreateGram(250, DecimalPrefix.Milli); // 250 mg

// Create kilograms
var weight = UnitFactory.CreateKilogram(75); // 75 kg
Console.WriteLine(weight.ToBaseValue()); // Output: 75000 (grams)

// Get prefix table
var sample = UnitFactory.CreateGram(0.000005);
var table = sample.ToMetricPrefixTable();
Console.WriteLine(table.ToString()); // Output: 5 μg
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.