学步园

//----------------------------------------------------------------------------
//  Autor  : ChenYongQiang
//  Date  : 2005-10-06                                     
//  LastModified: 2005-10-06   
//  Description : This code is used to mamage with system disks
//  CopyRight : CopyRight(C)2005 ChenYongQiang. All rights reserved!
//  Email  : aishen944-sohu.com
//----------------------------------------------------------------------------

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace DiskManager
{
 public enum DiskType
 {
  Unknown=100,
  Invalid=101,
  Removable=102,
  Fixed=103,
  Remote=104,
  CDROM=105,
  RAMDISK=106
 }

 public class DiskUtility
 {
  #region declarate variables
  //disk types
  private const int DRIVE_UNKNOWN     =0;
  private const int DRIVE_NO_ROOT_DIR =1;
  private const int DRIVE_REMOVABLE   =2;
  private const int DRIVE_FIXED       =3;
  private const int DRIVE_REMOTE      =4;
  private const int DRIVE_CDROM       =5;
  private const int DRIVE_RAMDISK     =6;

  //disk propertys
  private DiskType _diskType=0;
  private long  _diskSize=0;
  private long  _diskFreeSpace=0;
  private long  _diskFreeSpaceAvailable=0;
  private bool  _isReady=false;
  private string  _diskPath=null;
  private string      _volumeName=null;
  private int   _serialNumber=0;
  private string  _fileSystemName=null;
  private bool  _isInvalid=true;
  private int   _maximumComponentLength=0;
  private int   _fileSystemFlag=0;
  #endregion

  public DiskUtility(string diskPath)
  {
   getDiskInfor(diskPath);
  }

  #region native disk functions
  [DllImport("Kernel32.dll",SetLastError=true)]
   private static extern bool GetDiskFreeSpaceEx(string   lpDirecotryName,
                ref long lpFreeBytesAvailable,
                   ref long lpTotalNumberOfBytes,
                   ref long lpTotalNumberOfFreeBytes);

  [DllImport("Kernel32.dll",SetLastError=true)]
   private static extern int GetDriveType(string lpRootPathName);

  [DllImport("Kernel32.dll",SetLastError=true)]
   private static extern bool GetVolumeInformation(string lpRootPathName,
               [MarshalAs(UnmanagedType.LPArray)]byte[] lpVolumeNameBuffer,
               int  nVolumeNameSize,
               ref int lpVolumeSerialNumber,
               ref int lpMaximumComponentLength,
               ref int lpFileSystemFlags,
               [MarshalAs(UnmanagedType.LPArray)]byte[] lpFileSystemNameBuffer,
               int nFileSystemNameSize);
  #endregion

  #region disk propertys
  public DiskType DiskType
  {
   get{return _diskType;}
  }

  public long DiskSize
  {
   get{return _diskSize;}
  }

  public long DiskFreeSpace
  {
   get{return _diskFreeSpace;}
  }

  public long DiskFreeSpaceAvailable
  {
   get{return _diskFreeSpaceAvailable;}
  }

  public bool IsReady
  {
   get{return _isReady;}
  }

  public string DiskPath
  {
   get{return _diskPath;}
  }

  public string VolumeName
  {
   get{return _volumeName;}
  }

  public int SerialNumber
  {
   get{return _serialNumber;}
  }

  public string FileSystemName
  {
   get{return _fileSystemName;}
  }

  public bool IsInvalid
  {
   get{return _isInvalid;}
  }

  public int MaximumComponentLength
  {
   get{return _maximumComponentLength;}
  }

  public int FileSystemFlag
  {
   get{return _fileSystemFlag;}
  }
  #endregion

  #region common disk functions
  private void getDiskInfor(string diskPath)
  {
   //get disk type
   int   dType=GetDriveType(diskPath);
   switch(dType)
   {
    case DRIVE_UNKNOWN:
     _diskType=DiskType.Unknown;
     return;
    case DRIVE_NO_ROOT_DIR:
     _diskType=DiskType.Invalid;
     return;
    case DRIVE_REMOVABLE:
     _diskType=DiskType.Removable;
     break;
    case DRIVE_FIXED:
     _diskType=DiskType.Fixed;
     break;
    case DRIVE_REMOTE:
     _diskType=DiskType.Remote;
     break;
    case DRIVE_CDROM:
     _diskType=DiskType.CDROM;
     break;
    case DRIVE_RAMDISK:
     _diskType=DiskType.RAMDISK;
     break;
   }

   _diskPath=diskPath;

   //get disk size and free space
   long freeAvlSize=0;
   long totalSize =0;
   long freeSize =0;

   _isReady=GetDiskFreeSpaceEx(diskPath,ref freeAvlSize,ref totalSize,ref freeSize);

   if(_isReady)
   {
    _diskSize=totalSize;
    _diskFreeSpace=freeSize;
    _diskFreeSpaceAvailable=freeAvlSize;
   }

   //get volume propertys
   byte[]    volumeName=new byte[200];
   int     serialNumber=0;
   int     compLength=0;
   int     fileSystemFlag=0;
   byte[]    fileSystemName=new byte[200];

   _isInvalid=!GetVolumeInformation(diskPath,volumeName,200,ref serialNumber,ref compLength,ref fileSystemFlag,fileSystemName,200);

   if(!_isInvalid)
   {
    _volumeName=Encoding.Default.GetString(volumeName);
    _serialNumber=serialNumber;
    _maximumComponentLength=compLength;
    _fileSystemFlag=fileSystemFlag;
    _fileSystemName=Encoding.Default.GetString(fileSystemName);
   }
  }
  #endregion

  #region public functions
  public DirectoryInfo[] GetDirectorys()
  {
   DirectoryInfo[] dirs=new DirectoryInfo[0];
   if(_isReady)
    dirs=new DirectoryInfo(_diskPath).GetDirectories();
   
   return dirs;
  }
  #endregion
 }
}