Archive for the 'Opensource' Category



C# How to: Implementing Generic Xml Deserialization by extending the string class

Article purpose

The purpose of this article is to illustrate Deserializing Xml data to object data that resides in application memory. Additionally this article details implementing generics, resulting in a single method being able to deserialize multiple object types.

This article relates to the article “C# How to: Implementing Xml Serialization through a generic extension method

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Example custom data type

The sample source code provided with this article provides a user defined data type, the CustomDataType class of which the code snippet is listed below.

 public class  CustomDataType
 {
     private  int intMember = 0;
     public  int IntMember
     {
         get  { return intMember; }
         set  { intMember = value ; }
     }
 
     private  string  stringMember = String.Empty;
     public  string  StringMember
     {
         get { return stringMember; }
         set { stringMember = value ; }
     }
 
     private  DateTime dateTimeMember = DateTime.MinValue;
     public  DateTime  DateTimeMember
     {
         get { return  dateTimeMember; }
         set { dateTimeMember = value ; }
     }
 }

Also included is sample Xml markup which will be used in deserialization. The included Xml was generated by the serialization code sample “C# How to: Implementing Xml Serialization through a generic extension method

 <?xml version= "1.0" encoding="utf-16"?>
 <CustomDataType xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd= "http://www.w3.org/2001/XMLSchema">
   <IntMember>42</IntMember>
   <StringMember>Some random string</StringMember>
   <DateTimeMember>2013-02-09T19:20:24.4654399+02:00</DateTimeMember>
 </CustomDataType>

The deserialization method – Implemented as a String type extension method with generic type support

Extension method architecture enables developers to create methods which, from a syntactic and implementation point of view appear to be part of an existing data type. Extension methods create the perception of being updates or additions, literarily extending a data type as the name implies. Extension methods do not require access to the source code of the particular types being extended, nor does the implementation thereof require recompilation of the referenced types.

This article illustrates a combined implementation of extending the string type whilst specifying the generic type to deserialize to. The following code snippet provides the extension method definition.

 public static class ExtString 
 {
     public static T DeserializeXML<T>(this string xmlString)
     {
         T returnValue = default (T);
 
         XmlSerializer serial = new XmlSerializer(typeof (T));
         StringReader reader = new StringReader(xmlString);
         object result = serial.Deserialize(reader);
 
         if (result != null && result is T)
         {
             returnValue = ((T)result);
         }
 
         reader.Close();
 
         return returnValue;
     }
 }

The DeserializeXML method satisfies the requirements of the extension method architecture by being defined as a static method, implemented as a member method of a statically defined class. In addition the method signature features the this keyword preceding all other method parameters. The seemingly contradicting statement of specifying the this keyword in a static context usually serves as a quick indication that a method is implemented as an extension method. Remember that the this keyword provides a reference to the current instance, whereas in the case of static methods and classes there is no current instance, being static results in limiting a type to only one instance accessed as a shared reference.

The DeserializeXML method specifies as a parameter xmlString of type string. When defining an extension method the first parameter specified indicates the type being extended. This method’s definition therefore indicates that the extension method extends the string type.

DeserializeXML’s method definition implements a generic type <T>. The calling code will specify the required type substitute for <T>, which in turn will determine the method’s return type.

The implementation

The DeserializeXML method discussed above will appear as a non-static member method to all objects of type string.

 static  void  Main(string [] args)
 {
     if  (File.Exists("CustomDataType.xml") == true)
     {
         string  xmlString = File .ReadAllText("CustomDataType.xml");
         CustomDataType  objectData = xmlString.DeserializeXML<CustomDataType>();
 
         Console.WriteLine("CustomDataType.DateTimeMember: "  + objectData.DateTimeMember);
         Console.WriteLine("CustomDataType.IntMember: "  + objectData.IntMember.ToString());
         Console.WriteLine("CustomDataType.StringMember: "  + objectData.StringMember);
 
         Console.WriteLine();
         Console.WriteLine("Press any key to exit...");
         Console.ReadKey();
     }
 }

DeserializationGenericExtension

The code snippet listed above illustrates how the DeserializeXML extension discussed earlier now appears as a member method of the string type. Xml data read from the file system is “passed” to the DeserializeXML extension method, specifying <CustomDataType> is to be used as the generic type parameter implemented when performing deserialization.

C# How to: Implementing Xml Serialization through a generic extension method

Article purpose

The purpose of this article is to explore the implementation of object Xml serialization by means of a single extension method supporting generic types.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Example custom data type

The sample source code provided with this article provides a user defined data type, the CustomDataType class of which the code snippet is listed below.

 public class  CustomDataType
 {
     private  int intMember = 0;
     public  int IntMember
     {
         get  { return intMember; }
         set  { intMember = value ; }
     }
 
     private  string  stringMember = String.Empty;
     public  string  StringMember
     {
         get { return stringMember; }
         set { stringMember = value ; }
     }
 
     private  DateTime dateTimeMember = DateTime.MinValue;
     public  DateTime  DateTimeMember
     {
         get { return  dateTimeMember; }
         set { dateTimeMember = value ; }
     }
 }

This article’s accompanying sample source code was implemented to serialize an object instance of type CustomDataType. The resulting Xml markup representation is listed below.

 <?xml version= "1.0" encoding="utf-16"?>
 <CustomDataType xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd= "http://www.w3.org/2001/XMLSchema">
   <IntMember>42</IntMember>
   <StringMember>Some random string</StringMember>
   <DateTimeMember>2013-02-03T17:01:32.9799772+02:00</DateTimeMember>
 </CustomDataType>

The serialization method – Implementation as an extension method with generic type support

Extension method architecture enables developers to create methods which, from a syntactic and implementation point of view appear to be part of an existing data type. Extension methods create the perception of being updates or additions, literarily extending a data type as the name implies. Extension methods do not require access to the source code of the particular types being extended, nor does the implementation thereof require recompilation of the referenced types.

This article illustrates a combined implementation of extension methods extending the functionality of generic types. The following code snippet provides the extension method definition.

 public static class  ExtObject
 {
     public static string XmlSerialize<T>(this T objectToSerialize)
     {
         XmlSerializer xmlSerializer = new XmlSerializer(typeof (T));
 
         StringWriter  stringWriter = new  StringWriter ();
         XmlTextWriter  xmlWriter = new  XmlTextWriter(stringWriter);
 
         xmlWriter.Formatting = Formatting.Indented;
         xmlSerializer.Serialize(xmlWriter, objectToSerialize);
 
         return  stringWriter.ToString();
     }
 }

The XmlSerialize method satisfies the requirements of the extension method architecture by being defined as a static method, implemented as a member method of a statically defined class. In addition the method signature features the this keyword preceding all other method parameters. The seemingly contradicting statement of specifying the this keyword in a static context usually serves as a quick indication that a method is implemented as an extension method. Remember that the this keyword provides a reference to the current instance, whereas in the case of static methods and classes there is no current instance, being static results in limiting a type to only one instance accessed as a shared reference.

The definition of the XmlSerialize method also specifies the definition of a generic type <T>. When defining an extension method the first parameter specified indicates the type being extended. As an example, if an extension method definition specifies as a first parameter a variable of type string, the extension method will operate as an extension to the String class. Notice that extending a native value type is possible as a result of .net’s boxing and unboxing functionality.

The XmlSerialize method defines as a first parameter a variable of generic type <T>. Extending a generic type allows the implementing code access to the XmlSerialize method as a member of all data types, except static types. It is not possible to extend a static type.

The implementation

The XmlSerialize method discussed in the previous section appears as a member method to all non static types, provided that the implementing code applies the relevant namespace resolution by specifying the using statement where needed.

 static void Main(string [] args)
 {
     CustomDataType objectInstance = new CustomDataType();
     objectInstance.DateTimeMember = DateTime.Now;
     objectInstance.IntMember = 42;
     objectInstance.StringMember = "Some random string";
 
     string xmlString = objectInstance.XmlSerialize();
 
     Console.WriteLine(xmlString);
 
     Console.WriteLine();
     Console.WriteLine();
     Console.WriteLine("Press any key..." );
     Console.ReadKey();
 }

SerializationGenericExtension

From the code listed above the XmlSerialize method appears as a member of the CustomDataType class but in reality CustomDataType does not define the XmlSerialize method. The type being extended functions as per normal, not being aware of the extension method XmlSerialize.

The extension method now provides a uniform implementation enabling objects to be serialized to an Xml string, regardless of type.

Note: Not all types can be serialized! A commonly repeated mistake regarding object Xml serialization being that serialization will fail if a type does not provide a constructor with no parameters.

C# How to: Changing a File’s read only attribute

When working on certain types of projects you might find a commonly used/repeated task being able to determine and manipulate a file’s read only attribute. This article provides a discussion on how to determine whether a file is read only or not, provides three different methods of setting a file to read only and provides three different methods of negating a file’s read only status.

The topics discussed in this article is focussed around a Console based sample application. You can download the complete Visual Studio project source code here.

How to determine if a file is read only or not

The System.IO.FileInfo class exposes the Boolean property IsReadOnly. It is important to note that the FileInfo.IsReadOnly property reflects a file’s read only status at the point in time when the FileInfo object was instantiated or the last time the FileInfo.Refresh() method was invoked. The ReadOnly property reflects a snapshot of a file’s read only status. If a file’s read only attribute is manipulated after FileInfo object instantiation or after invoking the Refresh() method the ReadOnly property will not reflect any changes that may have occurred subsequently. It is therefore good practice to invoke FileInfo.Refresh() before accessing the ReadOnly property in order to safeguard against file attribute changes your application may be unaware of.

 private static void DisplayFileStatus(FileInfo fileInfo)
 {
     fileInfo.Refresh();
 
     Console.WriteLine("File read only: " +
         (fileInfo.IsReadOnly ? "Yes" : "No" ));
 }

The sample code provided with this article implements the DisplayFileStatus method as an easily reusable method of determining a file’s read only status and displaying the result to the Console.

Creating a new file

 Console.WriteLine("Creating new file...");
 StreamWriter streamWriter = File.CreateText("ReadOnlyFile.txt");
 streamWriter.WriteLine("This is a code sample from http://softwarebydefault.com");
 streamWriter.Close();
 Console.WriteLine("File Created.");
 
 FileInfo fileInfo = new FileInfo("ReadOnlyFile.txt");
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

The code snippet listed above creates a new file called “ReadOnlyFile.txt” by implementing the File.CreateText(string) method. The CreateText() method returns an object of type StreamWriter, which is then used to write a text string to the newly created file, after which the open file handle is released by invoking StreamWriter.Close().

Furthermore the code snippet illustrates instantiating an object of type FileInfo, which is specified to reference the previously newly created file. The file’s read only attribute gets output to the Console by invoking the DisplayFileStatus() method discussed earlier.

Setting a file to read only – Method 1

 Console.WriteLine("Attempting to set read only: method 1");
 fileInfo.IsReadOnly = true;
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

This method simply sets the property FileInfo.IsReadOnly to true and then determines and output the file’s read only attribute.

Setting a file to read only – Method 2

 Console.WriteLine("Attempting to set read only: method 2");
 File.SetAttributes("ReadOnlyFile.txt", FileAttributes.ReadOnly);
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

Method 2 invokes the File class’ SetAttributes method, passing as parameters the name of the file created earlier and the enumeration value FileAttributes.ReadOnly.

Setting a file to read only – Method 3

 Console.WriteLine("Attempting to set read only: method 3");
 fileInfo.Attributes = fileInfo.Attributes | FileAttributes.ReadOnly;
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

The third method, shown in the code snippet above, updates the value of the FileInfo class’ FileInfo.Attributes property, which is an enumeration of type System.IO.FileAttributes. The FileAttributes enumeration as part of its declaration implements [FlagsAttribute].

When an enumeration’s declaration includes the attribute FlagsAttribute, it is an indication that the enumeration is to be used as a bit field, also commonly referred to as flags. When regarding the FileInfo.Attributes property as a bit field it logically follows that bitwise operations can be performed.

The code snippet performs a bitwise OR operation specifying the enumeration value FileAttributes.ReadOnly. If the FileInfo.Attributes bit field property is already set to include FileAttributes.ReadOnly, performing a bitwise OR operation will have no effect. Inversely, if  FileInfo.Attributes is not set to include FileAttributes.ReadOnly, the bitwise OR operation will set the flag to true. 

Removing a file’s read only attribute – Method 1

 Console.WriteLine("Attempting to undo read only: method 1");
 fileInfo.IsReadOnly = false;
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

The first method shown to remove a file’s read only attribute functions by achieving the exact opposite of the first method shown in setting a file to read only. Updating the value of the FileInfo.IsReadOnly Boolean property to false results in the referenced file no longer being read only.

Removing a file’s read only attribute – Method 2

 Console.WriteLine("Attempting to undo read only method 2");
 File.SetAttributes("ReadOnlyFile.txt", ~FileAttributes.ReadOnly);
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

The code snippet above illustrates the second method of updating a file to not include the read only attribute. In a similar fashion to the first method described the second method implements the code required to achieve an effect opposite to that of the second method of setting a file to read only. By making use of the ~ operator a bitwise compliment operation is performed on FileAttributes.ReadOnly, the result of which is passed as a parameter to the File.SetAttributes method. An alternative explanation could be stated as reversing the bit values represented by the enumeration member FileAttributes.ReadOnly before applying the reversed bit values as a parameter to the File.SetAttributes method.

Removing a file’s read only attribute – Method 3

 Console.WriteLine("Attempting to undo read only: method 3");
 fileInfo.Attributes = fileInfo.Attributes & ~FileAttributes.ReadOnly;
 DisplayFileStatus(fileInfo);
 Console.WriteLine();

The third method, as listed above, updates FileInfo.Attributes, which is an enumeration property of type System.IO.FileAttributes, but also a bit field as discussed earlier. Based on the rules of operator precedence the bitwise compliment (~ operator) will be evaluated first, thereafter the bitwise AND operation will be executed. Reversing the bit values of FileAttributes.ReadOnly then applying the resulting values as an operand to a bitwise AND operation results in removing FileAttributes.ReadOnly as a flag set on the FileInfo.Attributes property.

Complete Sample Code

The code listing below represents the entire code sample. You can also download the complete Visual Studio project source code here.

 /*
  * The Following Code was developed by Dewald Esterhuizen
  * View Documentation at: http://softwarebydefault.com
  * Licensed under Ms-PL 
 */
 using  System;
 using  System.Collections.Generic;
 using  System.Linq;
 using  System.Text;
 using  System.IO;
 
 namespace ReadOnlyFiles
 {
     class Program
     {
         static void Main(string [] args)
         {
             Console.WriteLine("Creating new file...");
             StreamWriter streamWriter = File.CreateText("ReadOnlyFile.txt");
             streamWriter.WriteLine("This is a code sample from http://softwarebydefault.com");
             streamWriter.Close();
             Console.WriteLine("File Created.");
 
             FileInfo fileInfo = new FileInfo("ReadOnlyFile.txt");
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Attempting to set read only: method 1");
             fileInfo.IsReadOnly = true;
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Attempting to undo read only: method 1");
             fileInfo.IsReadOnly = false;
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Attempting to set read only: method 2");
             File.SetAttributes("ReadOnlyFile.txt", FileAttributes.ReadOnly);
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Attempting to undo read only method 2");
             File.SetAttributes("ReadOnlyFile.txt", ~FileAttributes.ReadOnly);
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Attempting to set read only: method 3");
             fileInfo.Attributes = fileInfo.Attributes | FileAttributes.ReadOnly;
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Attempting to undo read only: method 3");
             fileInfo.Attributes = fileInfo.Attributes & ~FileAttributes.ReadOnly;
             DisplayFileStatus(fileInfo);
             Console.WriteLine();
 
             Console.WriteLine("Press any key...");
             Console.ReadKey();
 
             File.Delete("ReadOnlyFile.txt");
         }
 
         private static void DisplayFileStatus(FileInfo fileInfo)
         {
             fileInfo.Refresh();
 
             Console.WriteLine("File read only: "+
                 (fileInfo.IsReadOnly ? "Yes" : "No"));
         }
     }
 }
[tweetmeme source=”DefaultSoftware” only_single=”false”]

C# How to: Drawing in GDI with Opacity/Alpha components

Article Purpose

In this article we explore GDI+ drawing operations implementing opacity, also known as alpha blending.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here

C# How to: Drawing in GDI with Opacity/Alpha components

Using the Sample Application

The following is a screenshot of the included sample application:

GDIOpacityDrawing

The screenshot illustrates drawing text and a rectangle onto a Windows Form in Color.SteelBlue with an alpha component of 100.

GDI+ Drawing

In C# it is possible and relatively easy to draw text and two dimensional shapes in GDI+ that support a level of opacity or transparency. The well known abbreviation RGB abbreviates the term Red, Green and Blue. C# supports RGB colours but also what is known as ARGB colours. In the case of ARGB the A abbreviates the word Alpha, in other words an RGB colour with a specified alpha component.

An alpha component specifies a colour’s opacity or transparency. Possible values range from 0 to 255 inclusive, where 0 would represent full transparency and 255 no level of transparency. If a consists of 8 bits and an ARGB colour is composed of 4 components ranging from 0 to 255 each representing a or 8 bits, then an ARGB colour is therefore a 32 bit colour.

The Color structure

The System.Drawing namespace defines the Color structure, which exposes several functions aimed at creating an ARGB Color object instance:

The Paint Event Handler

The bulk of this example’s functionality occurs within the main Form’s handler, as detailed by the following code snippet:

private void MainFormPaintEventHandler(object sender, PaintEventArgs e) 
{ 
    Color alphaForeColor = Color.FromArgb(this.foreColorAlphaValue, this.ForeColor); 
    Pen rectanglePen = new Pen(alphaForeColor, 2.0f); 
    SolidBrush textBrush = new SolidBrush(alphaForeColor); 

float x = this.ClientRectangle.Width / 2.0f; x -= e.Graphics.MeasureString(textToDisplay, this .Font).Width / 2.0f;
float y = this.ClientRectangle.Height / 2.0f; y -= e.Graphics.MeasureString(textToDisplay, this.Font).Height / 2.0f;
e.Graphics.DrawString(textToDisplay, this.Font, textBrush, new PointF(x, y));
e.Graphics.DrawRectangle(rectanglePen, 25, 25, this.ClientRectangle.Width - 50, this.ClientRectangle.Height - 50); }

The main Form defines two member variables used in the handler:

 private byte foreColorAlphaValue = 100;
 textToDisplay = "http://softwarebydefault.com";

In the handler an instance of the structure is created implementing an alpha component defined by the ’s member variable. The object declaration is followed by an ARGB   Pen and SolidBrush declaration.

Next the code determines the X and Y coordinates that would result in drawing the ’s string member variable in the middle of the , after which the actual drawing occurs.

Using the Pen object declared earlier a rectangle is drawn 25 pixels inside the ’s ClientRectangle.

C# How to: Determine free space on a drive

DriveInfo Class

Being able to determine the amount of space not in use on a particular drive from C# code is very easy and straight forward. Various properties relating to a logical Windows drive can be determined by implementing the System.IO.DriveInfo class.

The DriveInfo class exposes two public properties relating to drive space not in use:

The difference between these two properties is that AvailableFreeSpace takes into account user configured disk quotas in Windows. AvailableFreeSpace therefore represents the total amount of free space available to the currently logged in user. In contrast TotalFreeSpace represents the total amount of space free on the specified drive, regardless of restrictions/quotas on the currently logged in user’s account.

To be safe use AvailableFreeSpace when doing file IO operations such as copying, downloading or creating new files.

I have written an example application that implements two extension methods which allows the calling code to specify the measurement unit (Bytes, Kilobytes, Megabytes, Gigabytes and Terabytes) in which to return TotalFreeSpace or AvailableFreeSpace.

Code Sample

Download the source code here

This code sample implements the DriveInfo Class’ AvailableFreeSpace  and TotalFreeSpace properties and creates two extension methods allowing the calling code to specify the measurement unit (Bytes, Kilobytes, Megabytes, Gigabytes and Terabytes)

DiskSizeUnit enum

Both extension methods expects as a parameter an enum value of type DiskSizeUnit. The value will determine the unit in which AvailableFreeSpace or TotalFreeSpace gets returned.

1: public  enum  DiskSizeUnit
2: {
3:     Bytes = 0,
4:     KiloBytes = 1,
5:     MegaBytes = 2,
6:     GigaBytes = 3,
7:     TeraBytes = 4
8: }
9:

Total Free Space

The TotalFreeSpaceFormatted extension method accepts as its first parameter an object of type DriveInfo, indicating that this method acts as an extension method to the DriveInfo Class. The second parameter is an enum instance of type DiskSizeUnit, which is used to determine the measurement unit in which to return the DriveInfo class’ TotalFreeSpace property.

1: public  static  double  TotalFreeSpaceFormatted(this DriveInfo  driveInfo, DiskSizeUnit  sizeUnit)
2: {
3:     double  freeSpace = -1;
4:     double  formatDivideBy = 1;
5:
6:     if  (driveInfo != null )
7:     {
8:         long  freeSpaceNative = driveInfo.TotalFreeSpace;
9:         formatDivideBy = Math.Pow(1024, (int )sizeUnit);
10:
11:         freeSpace = freeSpaceNative / formatDivideBy;
12:     }
13:
14:     return  freeSpace;
15: }

The method first checks if the DriveInfo object has been instantiated (line 6). In order to convert TotalFreeSpace, which is expressed in bytes, the value is divided based on the value of the DiskSizeUnit enum parameter passed to this method. As an example if DiskSizeUnit.MegaBytes is specified, the Math.Pow() method will return 1048576 (1024 * 1024), as shown on line 9. Dividing a value expressed in bytes by 1024 and again by 1024 will return a value representing the original byte value expressed in megabytes.

Note: DriveInfo.TotalFreeSpace will return the number of bytes not in use on a particular drive. This property does not take into account limitations/restrictions on the currently logged in user such as Disk Quotas defined by Windows User Accounts.

Available Free Space

The AvailableFreeSpaceFormatted extension method accepts as its first parameter an object of type DriveInfo, indicating that this method acts as an extension method to the DriveInfo Class. The second parameter is an enum instance of type DiskSizeUnit, which is used to determine the measurement unit in which to return the DriveInfo class’ AvailableFreeSpace property.

1: public  static  double  AvailableFreeSpaceFormatted(this  DriveInfo  driveInfo, DiskSizeUnit  sizeUnit)
2: {
3:     double  freeSpace = -1;
4:     double  formatDivideBy = 1;
5:
6:     if  (driveInfo != null )
7:     {
8:         long  freeSpaceNative = driveInfo.AvailableFreeSpace;
9:         formatDivideBy = Math .Pow(1024, (int )sizeUnit);
10:
11:         freeSpace = freeSpaceNative / formatDivideBy;
12:     }
13:
14:     return  freeSpace;
15: }

Internally this method works almost exactly the same as the TotalFreeSpaceFormatted extension method. The only difference being checking and formatting through division the DriveInfo.AvailableFreeSpace property.

Note: DriveInfo.AvailableFreeSpace takes into account limitations/restrictions on the currently logged in user’s account such as Disk Quotas defined by Windows User Accounts.

Test Application

As part of this code sample a Console based test application is provided.

DriveSpaceAvailable

The test application determines the drive letter of the current directory using Environment.CurrentDirectory and Path.GetPathRoot.

1: if (Environment .CurrentDirectory != String .Empty)
2: {
3:     string  driveLetter = Path .GetPathRoot(Environment .CurrentDirectory);
4:
5:     DriveInfo  drive = new  DriveInfo (driveLetter);
6:
7:     Console .WriteLine("TotalFreeSpace: {0,0:F3} B" ,
8:     drive.TotalFreeSpace);
9:
10:     Console .WriteLine();
11:     Console .WriteLine("TotalFreeSpaceFormatted:" );
12:
13:     Console .WriteLine("{0,0:F3} B" ,
14:     drive.TotalFreeSpaceFormatted(DiskSizeUnit .Bytes));
15:
16:     Console .WriteLine("{0,0:F3} KB" ,
17:     drive.TotalFreeSpaceFormatted(DiskSizeUnit .KiloBytes));
18:
19:     Console .WriteLine("{0,0:F3} MB" ,
20:     drive.TotalFreeSpaceFormatted(DiskSizeUnit .MegaBytes));
21:
22:     Console .WriteLine("{0,0:F3} GB" ,
23:     drive.TotalFreeSpaceFormatted(DiskSizeUnit .GigaBytes));
24:
25:     Console .WriteLine("{0,0:F3} TB" ,
26:     drive.TotalFreeSpaceFormatted(DiskSizeUnit .TeraBytes));
27:
28:     Console .WriteLine();
29:
30:     Console .WriteLine("TotalFreeSpace: {0,0:F3} B" ,
31:    drive.AvailableFreeSpace);
32:
33:     Console .WriteLine();
34:     Console .WriteLine("AvailableFreeSpaceFormatted:" );
35:
36:     Console .WriteLine("{0,0:F3} B" ,
37:     drive.AvailableFreeSpaceFormatted(DiskSizeUnit .Bytes));
38:
39:     Console .WriteLine("{0,0:F3} KB" ,
40:     drive.AvailableFreeSpaceFormatted(DiskSizeUnit .KiloBytes));
41:
42:     Console .WriteLine("{0,0:F3} MB" ,
43:     drive.AvailableFreeSpaceFormatted(DiskSizeUnit .MegaBytes));
44:
45:     Console .WriteLine("{0,0:F3} GB" ,
46:     drive.AvailableFreeSpaceFormatted(DiskSizeUnit .GigaBytes));
47:
48:     Console .WriteLine("{0,0:F3} TB" ,
49:     drive.AvailableFreeSpaceFormatted(DiskSizeUnit .TeraBytes));
50: }
51:
52: Console .WriteLine();
53: Console .WriteLine("Press any key to exit" );
54: Console .ReadKey();
55:

*I want to give credit and say a big thank you to Vitaly Zayko. All the code snippets Html markup in this article was generated using his Visual Studio Extension Code4Blog.

[tweetmeme source=”DefaultSoftware” only_single=”false”]

Dewald Esterhuizen

Unknown's avatar

Blog Stats

  • 893,581 hits

Enter your email address to follow and receive notifications of new posts by email.

Join 91 other subscribers

Archives

RSS SoftwareByDefault on MSDN

  • An error has occurred; the feed is probably down. Try again later.