When our C# application fetches computer drive information, data about the disk"s size and free space is returned in bytes. While precise, those values are not easy to read and understand for our users. Other ways to show disk information is the percentage of free disk space or to report sizes in megabytes (MBs) or gigabytes (GBs). Let"s see how we get those values in C#.

To get drive information in our C# application we use the DriveInfo class from the System.IO namespace (Asad & Ali, 2017; Stephens, 2014). A single DriveInfo object models one computer drive (Stephens, 2014). Through that object we can access the drive"s information, like its name label, type of drive, and the drive"s root directory.

Other data we can fetch from the DriveInfo class is the drive"s capacity, like free space amount or total size. We use the following three properties for that (Microsoft Docs, n.d.; Stephens, 2014):

• The AvailableFreeSpace returns the drive"s available free space in bytes.
• The TotalFreeSpace property returns the drive"s total free space.
• And the TotalSize property returns the drive"s total capacity (that is, used and free space) in bytes.

To make sense of the above three properties and see how we can use them in our application"s code, let"s explore two examples. The first console application below calculates the percentage of free disk space a drive has. In the second example we convert a drive"s free disk space in bytes into megabytes (MBs) and gigabytes (GBs).

To calculate the percentage of free space a computer drive has, we have to do a couple of things:

• Create an instance for that drive with the DriveInfo class from the System.IO namespace.
• Fetch the drive"s total size, which we get with the TotalSize property from that class.
• Then get the drive"s free space, for which we can use the AvailableFreeSpace property.
• After that we divide the free space by the drive"s total size to see what percentage of free disk space we have.

The console application example below shows how we implement these steps in C# code:

On my computer this example program shows that the D:\ drive has just over two thirds of free space:

Now let"s see how we got this output. First we make an instance of the DriveInfo class for the D:\ drive:

Then we check whether the computer drive is ready with an if statement. If it is, we query the drive"s properties for information:

The IsReady property returns true when a drive is ready and accessible. We check its value before we fetch other DriveInfo properties because some of those properties depend on a ready drive. If the drive is not ready to be queried, those properties trigger an inaccessible drive exception.

The first thing we do inside the if statement is calculate the percentage of free disk space. For that we divide the drive"s available free space (AvailableFreeSpace) with its total size (TotalSize). Then we multiple that value with 100 to get the percentage, and then store it in the freeSpacePerc double variable.

Note that we explicitly cast the TotalSize property to a float value. The reason for this is that both AvailableFreeSpace and TotalSize return an integer, and with integer division C# throws away the remainder of division (Liberty & MacDonald, 2009). Else when AvailableFreeSpace / TotalSize would normally be 0.45, C# returns 0 instead.

After we calculated the percentage of free space we call the Console.WriteLine() method to print the drive"s name (Name), file system format (DriveFormat), and kind of drive (DriveType). We also output the number of bytes returned by the AvailableFreeSpace and TotalSize properties. Then in the last line of the if statement we print the percentage of free disk space (freeSpacePerc).

When we calculate the percentage of free space more than once in our application, writing the above code over and over becomes a bore. Plus it doesn"t give code that"s easy to maintain. An alternative is to rewrite the code into a method that we can simply call to get a drive"s free space percentage.

Here"s how that method can look:

This method returns the percentage of free space for the driveLetter string argument we pass it. Inside the method there"s a try/catch code to block handle inaccessible computer drives. In the try portion we make an instance of the DriveInfo class with DriveInfo(). Then we calculate that drive"s percentage of free space and return the outcome.

By the way, this method does assume that your code already referenced the System.IO namespace. If that isn"t the case, you"ll need to prefix the DriveInfo class with that namespace.

Here"s how we use this method to get the free space percentage of the C:\ drive:

An alternative to the above method is to create an extension method that returns the percentage of free a particular DriveInfo instance has. That makes it possible to fetch a drive"s free disk space like any other property from the DriveInfo class.

Here"s how such an extension method looks:

To use this method we first create a DriveInfo object. Then we call that method on the object, provided the drive is ready:

Let"s look at another way to use a drive"s space information. The AvailableFreeSpace, TotalFreeSpace, and TotalSize properties from the DriveInfo class return their values in bytes (Microsoft Docs, n.d.). But easier-to-understand values would be megabytes (MBs) and gigabytes (GBs). So let"s turn those bytes into MBs and GBs.

To go from bytes to other measurement units for computer space, we"ll need to consider the following (Wikipedia, 2017):

• One terabyte (TB) is 1024 gigabytes. One of those gigabytes (GBs) is 1024 megabytes big. A single megabyte (MB) is 1024 kilobytes. And each kilobyte (KB) contains 1024 bytes.
• Or in other words: 1 terabyte contains 1024^4 bytes. One gigabyte holds 1024^3 bytes, and 1024^2 bytes go into a single megabyte. And a single kilobyte contains 1024 bytes.

Say our computer drive has 20,000,000 bytes of free space. Because 1,048,576 (1024 * 1024) bytes go in a megabyte, our disk has 20,000,000 / 1,048,576 = 19.07 MB of free disk space. In the same way we can calculate how many kilobytes, gigabytes, and terabytes there are in a certain amount of bytes.

Now let"s translate this information into actual C# code. The console application example below outputs a drive"s used and total space in GBs and MBs:

The output that this application generates on my computer is:

Now let"s explore the program"s code. First we make two constants:

The BytesInMB constant tells how many bytes go in a megabyte, while BytesInGB says how many bytes we need for one GB.

We declare these constants as double values even though they hold integers. We do so because we"ll use these values later when we divide an integer value. And when we divide two integers, C# throws away the fractional portion of the outcome. To prevent that from happening we make double constants instead of int ones.

The next piece of program code iterates through the computer"s drives:

This foreach loop goes through all elements returned by DriveInfo.GetDrives(). That method returns an array with all drives the computer has. With the drive DriveInfo loop variable we represent a single drive during each iteration through the loop.

In the loop we first have an if statement see whether the current drive is not (!) ready. We get that drive state with the IsReady property. When the drive is not ready to be queried and accessed, we execute the continue keyword to skip the current loop cycle. That also means that later code in the loop works with a ready computer drive.

That other code first has the Console.WriteLine() method print the drive"s name (Name), kind of drive (DriveType), and its file system format (DriveFormat).

Then we output the drive"s used space in MBs and GBs. After that we output the drive"s used space in MBs and GBs. For that we first subtract the drive"s free space (TotalFreeSpace) from its total size (TotalSize). Then we divide that byte amount with the BytesInMB or BytesInGB constant. Next we have Console.WriteLine() print those used disk spaces with two decimals.

The last bit of loop code output the drive"s total size. For that we divide the drive"s TotalSize property with the BytesInMB or BytesInGB constant to get the total space in MBs and GBs. Then we print that information to the console window with Console.WriteLine().

We access computer drive information in C# with an instance of the DriveInfo class. Once we have such an object we can query various properties for drive information. TotalSize, for instance, returns the drive"s total capacity in bytes. And with the AvailableFreeSpace and TotalFreeSpace properties we get the drive"s free space in bytes.

A large bytes value is, however, hard to read and comprehend. Luckily we can also represent a drive"s space in other ways. To see a computer drive"s free space percentage we divide AvailableFreeSpace with TotalSize. And to know the number of megabytes (MBs) or gigabytes (GBs) used we can divide one of those DriveInfo properties with 1,048,576 or 1,073,741,824. Keep in mind that when we divide two integers, C# throws away the decimal value. The solution to that is to cast to a float or double.