C# || How To Convert Bytes To Kilobytes, Megabytes, Gigabytes, Terabytes Using C#

May 14, 2021 admin No comments

The following is a module with functions which demonstrates how to convert bytes to decimal formats like kilobytes, megabytes, gigabytes, terabytes, petabytes, exabytes, zettabytes, and yottabytes, as well as binary formats like kibibytes, mebibytes, gibibytes, tebibytes, pebibytes, exbibytes, zebibytes, and yobibytes using C#.

The function demonstrated on this page follows the IEC standard, which means:

• 1 kilobyte = 1000 bytes (Decimal) • 1 kibibyte = 1024 bytes (Binary)

This function allows you to convert bytes to a measurement unit, a measurement unit to bytes, and allows to convert from one measurement unit to another measurement unit.

1. Convert Bytes To Measurement Unit

The example below demonstrates the use of ‘Utils.Bytes.FromTo‘ to convert bytes to a measurement unit.

The optional function parameter allows you to specify the decimal places.





		
		
			1. Convert Bytes To Measurement Unit
			
C#
			
			// Convert Bytes To Measurement Unit

// Declare values to convert
var values = new[] { 2287879, 536870912, 1073741824 };

// Convert values
foreach (var value in values) {
    // Convert bytes to megabyte
    var mb = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Megabyte);

    // Convert bytes to mebibyte
    var mib = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Mebibyte);

    // Display the converted values
    Console.WriteLine($"Bytes: {value}, Megabyte: {mb}, Mebibyte: {mib}");
}

// expected output:
/*
    Bytes: 2287879, Megabyte: 2.287879, Mebibyte: 2.18189144134521484375
    Bytes: 536870912, Megabyte: 536.870912, Mebibyte: 512
    Bytes: 1073741824, Megabyte: 1073.741824, Mebibyte: 1024
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						// Convert Bytes To Measurement Unit
 
// Declare values to convert
var values = new[] { 2287879, 536870912, 1073741824 };
 
// Convert values
foreach (var value in values) {
    // Convert bytes to megabyte
    var mb = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Megabyte);
 
    // Convert bytes to mebibyte
    var mib = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Mebibyte);
 
    // Display the converted values
    Console.WriteLine($"Bytes: {value}, Megabyte: {mb}, Mebibyte: {mib}");
}
 
// expected output:
/*
    Bytes: 2287879, Megabyte: 2.287879, Mebibyte: 2.18189144134521484375
    Bytes: 536870912, Megabyte: 536.870912, Mebibyte: 512
    Bytes: 1073741824, Megabyte: 1073.741824, Mebibyte: 1024
*/

2. Convert Measurement Unit To Bytes

The example below demonstrates the use of ‘Utils.Bytes.FromTo‘ to convert a measurement unit to bytes.

The optional function parameter allows you to specify the decimal places.





		
		
			2. Convert Measurement Unit To Bytes
			
C#
			
			// Convert Measurement Unit To Bytes

// Declare values to convert
var values = new[] { 1, 0.5M, 10.75M };

// Convert values
foreach (var value in values) {
    // Convert gibibyte to byte
    var bytes = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gibibyte, value, Utils.Bytes.Unit.Byte);

    // Display the converted values
    Console.WriteLine($"Gibibyte: {value}, Bytes: {bytes}");
}

// expected output:
/*
    Gibibyte: 1, Bytes: 1073741824
    Gibibyte: 0.5, Bytes: 536870912.0
    Gibibyte: 10.75, Bytes: 11542724608.00
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						// Convert Measurement Unit To Bytes
 
// Declare values to convert
var values = new[] { 1, 0.5M, 10.75M };
 
// Convert values
foreach (var value in values) {
    // Convert gibibyte to byte
    var bytes = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gibibyte, value, Utils.Bytes.Unit.Byte);
 
    // Display the converted values
    Console.WriteLine($"Gibibyte: {value}, Bytes: {bytes}");
}
 
// expected output:
/*
    Gibibyte: 1, Bytes: 1073741824
    Gibibyte: 0.5, Bytes: 536870912.0
    Gibibyte: 10.75, Bytes: 11542724608.00
*/

3. Convert Measurement Unit To Measurement Unit

The example below demonstrates the use of ‘Utils.Bytes.FromTo‘ to convert a measurement unit to another measurement unit.

The optional function parameter allows you to specify the decimal places.





		
		
			3. Convert Measurement Unit To Measurement Unit
			
C#
			
			// Convert Measurement Unit To Measurement Unit

// Declare values to convert
var values = new[] { 1991, 1987, 28.31M, 19.22M };

// Convert values
foreach (var value in values) {
    // Convert value from one unit to another
    var size = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gigabyte, value, Utils.Bytes.Unit.Terabyte);

    // Display the converted values
    Display($"Gigabyte: {value}, Terabyte: {size}");
}

// expected output:
/*
    Gigabyte: 1991, Terabyte: 1.991
    Gigabyte: 1987, Terabyte: 1.987
    Gigabyte: 28.31, Terabyte: 0.02831
    Gigabyte: 19.22, Terabyte: 0.01922
*/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						// Convert Measurement Unit To Measurement Unit
 
// Declare values to convert
var values = new[] { 1991, 1987, 28.31M, 19.22M };
 
// Convert values
foreach (var value in values) {
    // Convert value from one unit to another
    var size = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gigabyte, value, Utils.Bytes.Unit.Terabyte);
 
    // Display the converted values
    Display($"Gigabyte: {value}, Terabyte: {size}");
}
 
// expected output:
/*
    Gigabyte: 1991, Terabyte: 1.991
    Gigabyte: 1987, Terabyte: 1.987
    Gigabyte: 28.31, Terabyte: 0.02831
    Gigabyte: 19.22, Terabyte: 0.01922
*/

4. Utils Namespace

The following is the Utils Namespace. Include this in your project to start using!





		
		
			Utils Namespace
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 14, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Utils.cs
//    Description: Handles general utility functions
// ============================================================================
using System;
using System.Collections.Generic;

namespace Utils {
    public static class Bytes {
        public enum Unit {
            Byte,

            // Decimal 
            Kilobyte,
            Megabyte,
            Gigabyte,
            Terabyte,
            Petabyte,
            Exabyte,
            Zettabyte,
            Yottabyte,

            // Binary 
            Kibibyte,
            Mebibyte,
            Gibibyte,
            Tebibyte,
            Pebibyte,
            Exbibyte,
            Zebibyte,
            Yobibyte
        }

        /// <summary>
        /// Converts a measurement 'Unit' to another measurement 'Unit'
        /// </summary>
        /// <param name="unitFrom">The measurement unit converting from</param> 
        /// <param name="sizeFrom">The size of the 'from' measurement unit</param> 
        /// <param name="unitTo">The measurement unit to convert to</param> 
        /// <param name="decimalPlaces">The decimal places to round to</param> 
        /// <returns>The value converted to the specified measurement unit</returns>
        public static decimal FromTo(Unit unitFrom, decimal sizeFrom, Unit unitTo
                    , int? decimalPlaces = null) {
            var result = sizeFrom;
            if (unitFrom != unitTo) {
                if (unitFrom == Unit.Byte) {
                    result = ConvertTo(unitTo, sizeFrom, decimalPlaces);
                } else if (unitTo == Unit.Byte) {
                    result = ConvertFrom(unitFrom, sizeFrom, decimalPlaces);
                } else {
                    result = ConvertTo(unitTo, ConvertFrom(unitFrom, sizeFrom), decimalPlaces);
                }
            }
            return result;
        }

        private enum Conversion {
            From,
            To
        }

        // Converts bytes to a measurement unit
        private static decimal ConvertTo(Unit unit, decimal bytes
                    , int? decimalPlaces = null) {
            return Convert(Conversion.To, bytes, unit, decimalPlaces);
        }

        // Converts a measurement unit to bytes
        private static decimal ConvertFrom(Unit unit, decimal bytes
                    , int? decimalPlaces = null) {
            return Convert(Conversion.From, bytes, unit, decimalPlaces);
        }

        private static decimal Convert(Conversion operation, decimal bytes, Unit unit
                    , int? decimalPlaces) {
            // Get the unit type definition
            var definition = GetDefinition(unit);
            if (definition == null) {
                throw new ArgumentException($"Unknown unit type: {unit}", nameof(unit));
            }

            // Get the unit value
            var value = definition.Value;

            // Calculate the result
            var result = operation == Conversion.To ? bytes / value : bytes * value;
            if (decimalPlaces.HasValue) {
                result = Math.Round(result, decimalPlaces.Value, MidpointRounding.AwayFromZero);
            }
            return result;
        }

        public enum Prefix {
            Decimal,
            Binary
        }

        public class Definition {
            public Prefix Prefix { get; set; }
            public int OrderOfMagnitude { get; set; }
            public decimal Multiple {
                get {
                    return Prefix == Prefix.Decimal ? 1000 : 1024;
                }
            }
            public decimal Value {
                get {
                    return System.Convert.ToDecimal(Math.Pow((double)Multiple, OrderOfMagnitude));
                }
            }
        }

        public static Definition GetDefinition(Unit unit) {
            var definitions = GetDefinitions();
            return definitions.ContainsKey(unit) ? definitions[unit] : null;
        }

        public static Dictionary<Unit, Definition> GetDefinitions() {            
            if (definitions == null) {
                definitions = new Dictionary<Unit, Definition>();
                // Place units in order of magnitude

                // Decimal units
                var decimals = new[] {
                    Unit.Kilobyte,
                    Unit.Megabyte,
                    Unit.Gigabyte,
                    Unit.Terabyte,
                    Unit.Petabyte,
                    Unit.Exabyte,
                    Unit.Zettabyte,
                    Unit.Yottabyte
                };
                // Binary units
                var binary = new[] {
                    Unit.Kibibyte,
                    Unit.Mebibyte,
                    Unit.Gibibyte,
                    Unit.Tebibyte,
                    Unit.Pebibyte,
                    Unit.Exbibyte,
                    Unit.Zebibyte,
                    Unit.Yobibyte
                };
                AddDefinitions(definitions, Prefix.Decimal, decimals);
                AddDefinitions(definitions, Prefix.Binary, binary);
            }
            return definitions;
        }
        private static Dictionary<Unit, Definition> definitions = null;

        private static void AddDefinitions(Dictionary<Unit, Definition> definitions
                                    , Prefix prefix, IEnumerable<Unit> units) {
            int index = 1;
            foreach (var unit in units) {
                if (!definitions.ContainsKey(unit)) {
                    definitions.Add(unit, new Definition() {
                        Prefix = prefix,
                        OrderOfMagnitude = index
                    });
                }
                ++index;
            }
        }
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 14, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Utils.cs
//    Description: Handles general utility functions
// ============================================================================
using System;
using System.Collections.Generic;
 
namespace Utils {
    public static class Bytes {
        public enum Unit {
            Byte,
 
            // Decimal 
            Kilobyte,
            Megabyte,
            Gigabyte,
            Terabyte,
            Petabyte,
            Exabyte,
            Zettabyte,
            Yottabyte,
 
            // Binary 
            Kibibyte,
            Mebibyte,
            Gibibyte,
            Tebibyte,
            Pebibyte,
            Exbibyte,
            Zebibyte,
            Yobibyte
        }
 
        /// <summary>
        /// Converts a measurement 'Unit' to another measurement 'Unit'
        /// </summary>
        /// <param name="unitFrom">The measurement unit converting from</param> 
        /// <param name="sizeFrom">The size of the 'from' measurement unit</param> 
        /// <param name="unitTo">The measurement unit to convert to</param> 
        /// <param name="decimalPlaces">The decimal places to round to</param> 
        /// <returns>The value converted to the specified measurement unit</returns>
        public static decimal FromTo(Unit unitFrom, decimal sizeFrom, Unit unitTo
                    , int? decimalPlaces = null) {
            var result = sizeFrom;
            if (unitFrom != unitTo) {
                if (unitFrom == Unit.Byte) {
                    result = ConvertTo(unitTo, sizeFrom, decimalPlaces);
                } else if (unitTo == Unit.Byte) {
                    result = ConvertFrom(unitFrom, sizeFrom, decimalPlaces);
                } else {
                    result = ConvertTo(unitTo, ConvertFrom(unitFrom, sizeFrom), decimalPlaces);
                }
            }
            return result;
        }
 
        private enum Conversion {
            From,
            To
        }
 
        // Converts bytes to a measurement unit
        private static decimal ConvertTo(Unit unit, decimal bytes
                    , int? decimalPlaces = null) {
            return Convert(Conversion.To, bytes, unit, decimalPlaces);
        }
 
        // Converts a measurement unit to bytes
        private static decimal ConvertFrom(Unit unit, decimal bytes
                    , int? decimalPlaces = null) {
            return Convert(Conversion.From, bytes, unit, decimalPlaces);
        }
 
        private static decimal Convert(Conversion operation, decimal bytes, Unit unit
                    , int? decimalPlaces) {
            // Get the unit type definition
            var definition = GetDefinition(unit);
            if (definition == null) {
                throw new ArgumentException($"Unknown unit type: {unit}", nameof(unit));
            }
 
            // Get the unit value
            var value = definition.Value;
 
            // Calculate the result
            var result = operation == Conversion.To ? bytes / value : bytes * value;
            if (decimalPlaces.HasValue) {
                result = Math.Round(result, decimalPlaces.Value, MidpointRounding.AwayFromZero);
            }
            return result;
        }
 
        public enum Prefix {
            Decimal,
            Binary
        }
 
        public class Definition {
            public Prefix Prefix { get; set; }
            public int OrderOfMagnitude { get; set; }
            public decimal Multiple {
                get {
                    return Prefix == Prefix.Decimal ? 1000 : 1024;
                }
            }
            public decimal Value {
                get {
                    return System.Convert.ToDecimal(Math.Pow((double)Multiple, OrderOfMagnitude));
                }
            }
        }
 
        public static Definition GetDefinition(Unit unit) {
            var definitions = GetDefinitions();
            return definitions.ContainsKey(unit) ? definitions[unit] : null;
        }
 
        public static Dictionary<Unit, Definition> GetDefinitions() {            
            if (definitions == null) {
                definitions = new Dictionary<Unit, Definition>();
                // Place units in order of magnitude
 
                // Decimal units
                var decimals = new[] {
                    Unit.Kilobyte,
                    Unit.Megabyte,
                    Unit.Gigabyte,
                    Unit.Terabyte,
                    Unit.Petabyte,
                    Unit.Exabyte,
                    Unit.Zettabyte,
                    Unit.Yottabyte
                };
                // Binary units
                var binary = new[] {
                    Unit.Kibibyte,
                    Unit.Mebibyte,
                    Unit.Gibibyte,
                    Unit.Tebibyte,
                    Unit.Pebibyte,
                    Unit.Exbibyte,
                    Unit.Zebibyte,
                    Unit.Yobibyte
                };
                AddDefinitions(definitions, Prefix.Decimal, decimals);
                AddDefinitions(definitions, Prefix.Binary, binary);
            }
            return definitions;
        }
        private static Dictionary<Unit, Definition> definitions = null;
 
        private static void AddDefinitions(Dictionary<Unit, Definition> definitions
                                    , Prefix prefix, IEnumerable<Unit> units) {
            int index = 1;
            foreach (var unit in units) {
                if (!definitions.ContainsKey(unit)) {
                    definitions.Add(unit, new Definition() {
                        Prefix = prefix,
                        OrderOfMagnitude = index
                    });
                }
                ++index;
            }
        }
    }
}// http://programmingnotes.org/

5. More Examples

Below are more examples demonstrating the use of the ‘Utils‘ Namespace. Don’t forget to include the module when running the examples!





		
		
			More Examples
			
C#
			
			// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 14, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Program.cs
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
using System;
using System.Diagnostics;

public class Program {
    static void Main(string[] args) {
        try {
            // Declare values to convert
            var values = new[] { 2287879, 536870912, 1073741824 };

            // Convert values
            foreach (var value in values) {
                // Convert bytes to megabyte
                var mb = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Megabyte);

                // Convert bytes to mebibyte
                var mib = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Mebibyte);

                // Display the converted values
                Display($"Bytes: {value}, Megabyte: {mb}, Mebibyte: {mib}");
            }

            Display("");

            // Declare values to convert
            var values2 = new[] { 1, 0.5M, 10.75M };

            // Convert values
            foreach (var value in values2) {
                // Convert gibibyte to byte
                var bytes = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gibibyte, value, Utils.Bytes.Unit.Byte);

                // Display the converted values
                Display($"Gibibyte: {value}, Bytes: {bytes}");
            }

            Display("");

            // Declare values to convert
            var values3 = new[] { 1991, 1987, 28.31M, 19.22M };

            // Convert values
            foreach (var value in values3) {
                // Convert value from one unit to another
                var size = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gigabyte, value, Utils.Bytes.Unit.Terabyte);

                // Display the converted values
                Display($"Gigabyte: {value}, Terabyte: {size}");
            }
        } catch (Exception ex) {
            Display(ex.ToString());
        } finally {
            Console.ReadLine();
        }
    }

    static void Display(string message) {
        Console.WriteLine(message);
        Debug.Print(message);
    }
}// http://programmingnotes.org/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
				
						// ============================================================================
//    Author: Kenneth Perkins
//    Date:   May 14, 2021
//    Taken From: http://programmingnotes.org/
//    File:  Program.cs
//    Description: The following demonstrates the use of the Utils Namespace
// ============================================================================
using System;
using System.Diagnostics;
 
public class Program {
    static void Main(string[] args) {
        try {
            // Declare values to convert
            var values = new[] { 2287879, 536870912, 1073741824 };
 
            // Convert values
            foreach (var value in values) {
                // Convert bytes to megabyte
                var mb = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Megabyte);
 
                // Convert bytes to mebibyte
                var mib = Utils.Bytes.FromTo(Utils.Bytes.Unit.Byte, value, Utils.Bytes.Unit.Mebibyte);
 
                // Display the converted values
                Display($"Bytes: {value}, Megabyte: {mb}, Mebibyte: {mib}");
            }
 
            Display("");
 
            // Declare values to convert
            var values2 = new[] { 1, 0.5M, 10.75M };
 
            // Convert values
            foreach (var value in values2) {
                // Convert gibibyte to byte
                var bytes = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gibibyte, value, Utils.Bytes.Unit.Byte);
 
                // Display the converted values
                Display($"Gibibyte: {value}, Bytes: {bytes}");
            }
 
            Display("");
 
            // Declare values to convert
            var values3 = new[] { 1991, 1987, 28.31M, 19.22M };
 
            // Convert values
            foreach (var value in values3) {
                // Convert value from one unit to another
                var size = Utils.Bytes.FromTo(Utils.Bytes.Unit.Gigabyte, value, Utils.Bytes.Unit.Terabyte);
 
                // Display the converted values
                Display($"Gigabyte: {value}, Terabyte: {size}");
            }
        } catch (Exception ex) {
            Display(ex.ToString());
        } finally {
            Console.ReadLine();
        }
    }
 
    static void Display(string message) {
        Console.WriteLine(message);
        Debug.Print(message);
    }
}// http://programmingnotes.org/

QUICK NOTES:
The highlighted lines are sections of interest to look out for.

The code is heavily commented, so no further insight is necessary. If you have any questions, feel free to leave a comment below.

Was this article helpful?

👍 YesNo

Posted in: C#, Console Tags: c-sharp, convert bytes

C# || How To Convert Bytes To Kilobytes, Megabytes, Gigabytes, Terabytes Using C#

Related

Leave a ReplyCancel reply

Search

Compile Your Code Now

Translate Page

Popular Pages

Recent

Archives

Categories