C# IO.DriveInfo类代码示例

        protected AbstractHarddrive(ISmart smart, string name, 
      string firmwareRevision, int index, 
      IEnumerable<SmartAttribute> smartAttributes, ISettings settings)
            : base(name, new Identifier("hdd",
        index.ToString(CultureInfo.InvariantCulture)), settings)
        {
            this.firmwareRevision = firmwareRevision;
              this.smart = smart;
              handle = smart.OpenDrive(index);

              if (handle != smart.InvalidHandle)
            smart.EnableSmart(handle, index);

              this.index = index;
              this.count = 0;

              this.smartAttributes = new List<SmartAttribute>(smartAttributes);

              string[] logicalDrives = smart.GetLogicalDrives(index);
              List<DriveInfo> driveInfoList = new List<DriveInfo>(logicalDrives.Length);
              foreach (string logicalDrive in logicalDrives) {
            try {
              DriveInfo di = new DriveInfo(logicalDrive);
              if (di.TotalSize > 0)
            driveInfoList.Add(new DriveInfo(logicalDrive));
            } catch (ArgumentException) { } catch (IOException) { }
              }
              driveInfos = driveInfoList.ToArray();

              CreateSensors();
        }

		public static string GetUNCPath(DriveInfo drive)
		{
			var sb = new StringBuilder(512);
			var size = sb.Capacity;
			var error = WNetGetConnection(drive.Name.Substring(0, 2), sb, ref size);
			return sb.ToString().TrimEnd();
		}

        /// <summary>
        /// Constructor for NtfsUsnJournal class.  If no exception is thrown, _usnJournalRootHandle and
        /// _volumeSerialNumber can be assumed to be good. If an exception is thrown, the NtfsUsnJournal
        /// object is not usable.
        /// </summary>
        /// <param name="driveInfo">DriveInfo object that provides access to information about a volume</param>
        /// <remarks> 
        /// An exception thrown if the volume is not an 'NTFS' volume or
        /// if GetRootHandle() or GetVolumeSerialNumber() functions fail. 
        /// Each public method checks to see if the volume is NTFS and if the _usnJournalRootHandle is
        /// valid.  If these two conditions aren't met, then the public function will return a UsnJournalReturnCode
        /// error.
        /// </remarks>
        public UsnJournal(DriveInfo driveInfo)
        {
            _driveInfo = driveInfo;

            if (0 != string.Compare(_driveInfo.DriveFormat, "ntfs", true))
            {
                throw new Exception(string.Format("{0} is not an 'NTFS' volume.", _driveInfo.Name));
            }

            IsNtfsVolume = true;

            IntPtr rootHandle;

            var returnCode = GetRootHandle(out rootHandle);

            if (returnCode != UsnJournalReturnCode.USN_JOURNAL_SUCCESS)
            {
                throw new Win32Exception((int)returnCode);
            }

            _usnJournalRootHandle = rootHandle;

            returnCode = GetVolumeSerialNumber(_driveInfo, out _volumeSerialNumber);

            if (returnCode != UsnJournalReturnCode.USN_JOURNAL_SUCCESS)
            {
                throw new Win32Exception((int)returnCode);
            }
        }

 private string CheckDiskStatus(DriveInfo drive)
 {
     double spaceUsed = drive.TotalFreeSpace / drive.TotalSize;
     if (spaceUsed < 0.6) { return "OK"; }
     else if (spaceUsed < 0.8) { return "Warning"; }
     else { return "Error"; }
 }

        public DriveButton(DriveInfo drive)
        {
            InitializeComponent();

            this.currentDrive = drive;

            txtDriveName.Text = drive.Name[0].ToString();

            ShowDriveData(drive);

            //switch (drive.DriveType)
            //{
            //    case DriveType.CDRom:
            //        imgDriveType.Source = new BitmapImage(new Uri("/Icons/drive_cdrom.ico", UriKind.Relative));
            //        break;
            //    case DriveType.Fixed:
            //        imgDriveType.Source = new BitmapImage(new Uri("/Icons/drive_fixed.ico", UriKind.Relative));
            //        break;
            //    case DriveType.Network:
            //        imgDriveType.Source = new BitmapImage(new Uri("/Icons/drive_network.ico", UriKind.Relative));
            //        break;
            //    case DriveType.NoRootDirectory:
            //        break;
            //    case DriveType.Ram:
            //        break;
            //    case DriveType.Removable:
            //        imgDriveType.Source = new BitmapImage(new Uri("/Icons/drive_removable.ico", UriKind.Relative));
            //        break;
            //    case DriveType.Unknown:
            //        imgDriveType.Source = new BitmapImage(new Uri("/Icons/drive_unknown.ico", UriKind.Relative));
            //        break;
            //    default:
            //        break;
            //}
        }

 public Boolean IsCdRom()
 {
     DriveInfo monDriveInfo = new DriveInfo(this._path);
     if (monDriveInfo.DriveType == DriveType.CDRom)
         return (true);
     return (false);
 }

 public Boolean IsRemovableMedia()
 {
     DriveInfo monDriveInfo = new DriveInfo(this._path);
     if (monDriveInfo.DriveType == DriveType.Removable)
         return (true);
     return (false);
 }

        private static void Main()
        {
            // Start with drives if you have to search the entire computer.
            string[] drives = Environment.GetLogicalDrives();

            foreach (string dr in drives)
            {
                DriveInfo di = new DriveInfo(dr);

                // Here we skip the drive if it is not ready to be read. This
                // is not necessarily the appropriate action in all scenarios.
                if (!di.IsReady)
                {
                    Console.WriteLine("The drive {0} could not be read", di.Name);
                    continue;
                }

                DirectoryInfo rootDir = di.RootDirectory;
                WalkDirectoryTree(rootDir);
            }

            // Write out all the files that could not be processed.
            Console.WriteLine("Files with restricted access:");
            foreach (string s in log)
            {
                Console.WriteLine(s);
            }

            // Keep the console window open in debug mode.
            Console.WriteLine("Press any key");
            Console.ReadKey();
        }

 public override void Run()
 {
     DriveInfo d = new DriveInfo(Drive);
     long actual = d.AvailableFreeSpace / 1024;
     if (actual < RequiredMegabytes)
         throw new AssertionException<long>(RequiredMegabytes, actual, string.Format("Insufficient space on drive {0}",Drive));
 }

        void tvExplorer_AfterSelect(object sender, TreeViewEventArgs e)
        {
            btnOK.Enabled = false;
            btnNewFolder.Enabled = false;

            DirectoryInfo di = new DirectoryInfo(tvExplorer.SelectedNodePath);
            if (di.Exists)
            {
                btnOK.Enabled = (PerformPathValidation == null || PerformPathValidation(tvExplorer.SelectedNodePath));

                try
                {
                    DriveInfo drvInvo = new DriveInfo(di.Root.FullName);
                    btnNewFolder.Enabled = (drvInvo.AvailableFreeSpace > 0 && drvInvo.IsReady);
                }
                catch { }
            }

            if (btnOK.Enabled)
            {
                this.SelectedPath = tvExplorer.SelectedNodePath;
            }
            else
            {
                this.SelectedPath = string.Empty;
            }
        }

        public bool isDBSizeOk()
        {
            bool returnValue = true;

            try
            {
                conn.Open();
                DriveInfo diskInfo = new DriveInfo("C");
                if (diskInfo.IsReady == true)
                {
                    long diskFreeSpace = diskInfo.TotalFreeSpace;

                    long dbSize = GetDBSize();
                    double lowerThreshold = DB_SIZE_LOWER_THRESHOLD * maxDBSize;

                    CLogger.WriteLog(ELogLevel.DEBUG, "THe free space on disk is" + diskFreeSpace +
                        " dbSize: " + dbSize + " maxDBSize -dbSize : " + (maxDBSize - dbSize));

                    if (dbSize >= maxDBSize)
                    {
                        CLogger.WriteLog(ELogLevel.DEBUG, "Setting return val to false");
                        returnValue = false;
                    }
                }
                conn.Close();
            }
            catch (Exception exc)
            {
                CLogger.WriteLog(ELogLevel.DEBUG, "Exception while retreiving diskinfo " + exc.Message);
            }
            return returnValue;
        }

		private void DoBackup(DriveInfo info)
		{
			_checkForUsbKeyTimer.Enabled = false;
			_noteLabel.Visible = false;
			_topLabel.Text = "~Backing Up...";
			Refresh();
			try
			{
				string dest = Path.Combine(info.RootDirectory.FullName,
										   _projectInfo.Name + "_wesay.zip");
				BackupMaker.BackupToExternal(_projectInfo.PathToTopLevelDirectory,
											 dest,
											 _projectInfo.FilesBelongingToProject);
				_topLabel.Text = "~Backup Complete";
				_noteLabel.Visible = true;
				_noteLabel.Text = String.Format("~Files backed up to {0}", dest);
			}
			catch (Exception e)
			{
				ErrorReport.ReportNonFatalMessage(
						"WeSay could to perform the backup.  Reason: {0}", e.Message);
				_topLabel.Text = "~Files were not backed up.";
				_topLabel.ForeColor = Color.Red;
			}

			_cancelButton.Text = "&OK";
		}

 protected virtual void OnRemovableDrivePulled(DriveInfo d)
 {
     if (this.RemovableDrivePulled != null)
     {
         this.RemovableDrivePulled(this, new RemovableDriveEventArgs(d));
     }
 }

        /// <summary>
        /// Returns a response from the message received.
        /// The response comes from our AIML chat bot or from our own custom processing.
        /// </summary>
        /// <param name="message">string</param>
        /// <param name="user">User (for context)</param>
        /// <returns>string</returns>
        private static string HandleMessage(string message, User user)
        {
            string output = "";

            if (!string.IsNullOrEmpty(message))
            {
                // Provide custom commands for our chat bot, such as disk space, utility functions, typical IRC bot features, etc.
                if (message.ToUpper().IndexOf("DISK SPACE") != -1)
                {
                    DriveInfo driveInfo = new DriveInfo("C");
                    output = "Available disk space on " + driveInfo.Name + " is " + driveInfo.AvailableFreeSpace + ".";
                }
                else if (message.ToUpper().IndexOf("DISK SIZE") != -1)
                {
                    DriveInfo driveInfo = new DriveInfo("C");
                    output = "The current disk size on " + driveInfo.Name + " is " + driveInfo.TotalSize + ".";
                }
                else
                {
                    // No recognized command. Let our chat bot respond.
                    output = _bot.getOutput(message, user);
                }
            }

            return output;
        }

 /// <summary>
 /// 获取程序运行的磁盘的空闲容量
 /// </summary>
 /// <returns>空间空闲容量</returns>
 private long GetDriverFreeSpace(string strPath)
 {
     string strDriverName = Directory.GetDirectoryRoot(strPath);
     DriveInfo dInfo = new DriveInfo(strDriverName);
     long lSum = dInfo.AvailableFreeSpace;    //磁盘空闲容量
     return lSum;
 }