C# file size formatting library PrettySize 3.1 released

Hot on the heels of an update to our rust port of PrettySize we have a new release of PrettySize.NET that brings new features and capabilities to the best .NET library for formatting file sizes for human-readable output and display.

PrettySize 3.1, available on GitHub and via Nuget, has just been released and contains a number of improvements and requested features and newfound abilities to make handling file sizes (and not just formatting them) easier and more enjoyable.

Starting with a quick recap of PrettySize’s abilities for those of you that haven’t heard of it before:

using NeoSmart.PrettySize;

public void Main() {
    // Initializing directly with a raw byte count:
    var size = new PrettySize(bytes: 200);
    Console.WriteLine($"Size: {size}"); 
    // Prints "Size: 200 bytes"

    // Initializing via a unit-based helper function:
    var size1 = PrettySize.KiB(28);
    var size2 = PrettySize.Bytes(14336);
    var sum = size1 + size2;
    Console.WriteLine($"The total size is {sum}");
    // Prints "The total size is 42.00 KiB"
}

As you can see, PrettySize takes any arbitrary file size (in whatever unit you happen to have on hand) and automatically figures out how it should be displayed, figuring out

• What the result of any mathematical operations on strongly-typed PrettySize values (wrapping file sizes) are
• What unit to display the final size in (bytes, kilobytes, megabytes, etc)
• What precision to use for the shown numeric size (just enough, but not too much)

New to version 3.x are the following:

• The ability to perform math directly on PrettySize types, including adding or subtracting PrettySize values and multiplying or dividing a PrettySize value by a scalar numeric value.¹
• The ability to encapsulate/express negative sizes (such as the negative result of 4KiB - 8KiB),
• The ability to format/print negative results, previously only available for unsigned values,
• Comparison and equality operators for directly comparing PrettySize values rather than having to compare their underlying byte count (as exposed via the PrettySize.TotalBytes property).

There are some more improvements and enhancements under the hood, and a number of new helper functions modeled after the unit names to make it easier to instantiate PrettySize instances from non-byte file size values (e.g. directly from kilobytes). The interface should be more natural and ergonomic, and hopefully developers should find themselves reaching for PrettySize.TotalBytes far less than before.

Remember that PrettySize supports custom formatting of file sizes and has full support for both base-10 (kilobyte, megabyte, gigabyte) and base-2 (kibibyte, mebibyte, gibibyte — more often referred to as KiB, MiB, GiB, etc) units and you can choose between them, as well as determine how the unit names are styled and more:

// using NeoSmart.PrettySize

var size = PrettySize.Bytes(2048);

var formatted = size.Format(UnitBase.Base2, UnitStyle.Full);
Console.WriteLine(formatted); // Prints "2.00 Kebibytes"

var formatted2 = size.Format(UnitBase.Base10, UnitStyle.FullLower);
Console.WriteLine(formatted2); // Prints "2.05 kilobytes"

Minor Update
Version 3.1.1 is available on NuGet and includes a [Obsolete] backwards compatibility shim for a member that was misspelled in an earlier release.

The code is released as open source under the MIT license and the library is available free of charge for all uses, commercial or otherwise. Contributions to the GitHub repository are welcome.

Get PrettySize (free, cross-platform)

If you want to hear more from me about dotnet dev, follow me on twitter. To express your thanks or support, please star the repo on GitHub or retweet below:

Just released PrettySize v3, my #opensource C# and @dotnet library for calculating and pretty-printing file sizes. https://t.co/Dx2I7gqAMC #nuget

— Mahmoud Al-Qudsi (@mqudsi) June 27, 2022

1. In the case of multiplication, the commutative inverse (multiplying a scalar numeric value by a strongly-typed PrettySize value) is also supported. For more about the caveats when implementing commutative mathematical operations on or between arbitrary types, read last week’s article on the rust release of PrettySize for some PLT-related matters. ↩