View difference between Paste ID: cCzjfPsf and 03BwzVTy

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.IO;
 using System.Diagnostics;
 using System.Threading;
 
 namespace sticky
 {
     internal class Program
     {
         private static void Main(string[] args)
         {
             doStuff();
         }
 
         //volume label to look for. could potentially have it read a text file or something
         private static List<string> validVolumeLabels = new List<string>(){ "helix3pro" };
         private static string uNetBootEXE = "unetbootin-windows-563.exe";
         private static string formatCommandTemplate = "format $DRIVELETTER /FS:FAT32 /V:helix3pro /Q /y";
         private static string unetbootParams =
         "method=diskimage isofile=\"$ISOFILE\" installtype=USB targetdrive=$DRIVELETTER nodistro=y exitoncompletion=y autoinstall=y";
 
         private static void doStuff()
         {
             //locate unetboot
             Console.WriteLine("Looking for unetbootin executable (" + uNetBootEXE + ") in " + Directory.GetCurrentDirectory() + " ...");
             if (!File.Exists(uNetBootEXE))
             {
                 Console.WriteLine(uNetBootEXE + " not found in directory.");
                 Console.ReadLine();
                 Environment.Exit(0);
             }
 
             //identify the ISO
             //string isoFile = @"C:\VMWare_Share\helix3custom\Helix3ProR2Custom-v1_2011-10-27.iso";
             string isoFile = "";
 
             //Another example of locating your ISO file
 
             //IEnumerable<FileInfo> lwFi = new DirectoryInfo(@"\\foo\goase").GetFiles("*.iso", SearchOption.AllDirectories);
             //var lwQry = (from file in lwFi
             //             orderby file.LastWriteTime descending
             //             select file.FullName).SingleOrDefault();
 
             //isoFile = lwQry;
 
 
             Console.WriteLine("Searching \"" + Directory.GetCurrentDirectory() + "\" for ISO files...");
             DirectoryInfo di = new DirectoryInfo(Directory.GetCurrentDirectory());
             IEnumerable<FileInfo> fi = di.GetFiles();
             var isoQry = from file in fi
                          where file.Extension == ".iso"
                          select file.FullName;
 
             if (isoQry.Count() > 1)
             {
                 Console.WriteLine("More than one ISO file found. I'm confused. Please fix and re-run program.");
                 Console.ReadLine();
                 Environment.Exit(0);
             }
             if (isoQry.Count() == 0)
             {
                 Console.WriteLine("No ISO files found. I'm confused. Please fix and re-run program.");
                 Console.ReadLine();
                 Environment.Exit(0);
             }
 
             isoFile = isoQry.FirstOrDefault();
 
             Console.WriteLine("");
             Console.WriteLine("Using ISO: " + isoFile);
             Console.WriteLine("");
 
             //find the drives, confirm with user
             List<string> processTheseDrives = listDrivesToWipe(validVolumeLabels);
             if (processTheseDrives == null || processTheseDrives.Count == 0)
             {
                 Console.WriteLine("No removable drives matching Volume Name Criteria were found!");
                 Console.ReadLine();
                 Environment.Exit(0);
             }
 
             //format drives FAT32
             Console.WriteLine("Okay, good. Starting wiping...");
             Console.WriteLine("");
 
 
             foreach (string driveLetter in processTheseDrives)
             {
                 Console.WriteLine("Formatting drive " + driveLetter);
                 //string formatCommand = @"format " + driveLetter.Replace(@"\", "") + " /FS:FAT32 /V:helix3pro /Q /y";
                 string formatCommand = formatCommandTemplate.Replace("$DRIVELETTER", driveLetter.Replace(@"\", ""));
                 ProcessStartInfo pInfo = new ProcessStartInfo("cmd.exe", "/c " + formatCommand);
                 pInfo.RedirectStandardOutput = true;
                 pInfo.UseShellExecute = false;
                 pInfo.CreateNoWindow = true;
 
                 Process P = new Process();
                 P.StartInfo = pInfo;
                 P.OutputDataReceived += exeOutputEventHandler;
                 P.Start();
 
                 P.BeginOutputReadLine();
                 P.WaitForExit();
                 P.Close();
                 Console.WriteLine();
             }
 
             //run unetbootin
             Console.WriteLine("UNetBootin' ISO image to drives...");
             Console.WriteLine();
 
             foreach (string driveLetter in processTheseDrives)
             {
                 Console.WriteLine("UNetBootin' drive " + driveLetter);
 
                 Thread uNetBootThread = (new Thread(() =>
                                                         {
                                                             ProcessStartInfo p2info =
                                                                 new ProcessStartInfo(uNetBootEXE,
                                                                                      unetbootParams.Replace(
                                                                                          "$DRIVELETTER", driveLetter).
                                                                                          Replace("$ISOFILE", isoFile));
 
                                                             p2info.RedirectStandardOutput = false;
                                                             p2info.UseShellExecute = true;
                                                             p2info.CreateNoWindow = false;
 
                                                             Process p2 = new Process();
                                                             p2.StartInfo = p2info;
                                                             p2.Start();
                                                             p2.WaitForExit();
                                                             p2.Close();
                                                         }) {Name = "UNetBootThread"});
                 uNetBootThread.Start();
                 while (uNetBootThread.IsAlive)
                 {
                     //it's friday, friday, gotta get down on friday.
                 }
 
             }
 
             Console.WriteLine("********** DONE **********");
 
             //Are we done?
             string exitProgram = "";
             while (exitProgram != "y" | exitProgram != "n" | exitProgram != "yes" | exitProgram != "no")
             {
                 Console.Write("Done! Start a new batch? (or exit) [y/n]: ");
                 exitProgram = Console.ReadLine().ToLower();
                 if (exitProgram == "yes" || exitProgram == "y")
                 {
                     doStuff();
                 }
                 else if (exitProgram == "no" || exitProgram == "n")
                 {
                     return;
                 }
             }
 
         }
 
         /// <summary>
         /// Checks logical drives for possible wipe/ISO targets
         /// </summary>
         /// <returns></returns>
         private static List<string> listDrivesToWipe(List<string> validVolumeLabels)
         {
             StringBuilder strValidLabels = new StringBuilder();
             foreach(string validLabel in validVolumeLabels)
             {
                 strValidLabels.Append("\"" + validLabel + "\"" + " ");
             }
 
             Console.WriteLine("Searching for removable drives with volume labels containing: " + strValidLabels);
             List<DriveInfo> drivesAll = DriveInfo.GetDrives().ToList();
             List<string> drivesToProcess = new List<string>();
 
             Console.WriteLine("Listing possible target drives...");
             Console.WriteLine("");
             Console.WriteLine("Drive\tVolume Label\tFS\tType\t\tSize Info");
             Console.WriteLine("-----\t------------\t--\t----\t\t---------");
 
             foreach (var drv in drivesAll)
             {
                 if (drv.IsReady)
                 {
                     if (validVolumeLabels.Contains(drv.VolumeLabel, StringComparer.OrdinalIgnoreCase))
                     {
                         StringBuilder driveInformation = new StringBuilder();
                         driveInformation.Append(drv.Name);
                         driveInformation.Append("\t" + drv.VolumeLabel);
                         driveInformation.Append("\t" + drv.DriveFormat);
                         driveInformation.Append("\t" + drv.DriveType.ToString());
                         driveInformation.Append("\t" + bytesToGB(drv.AvailableFreeSpace).ToString("00.00"));
                         driveInformation.Append(" / ");
                         driveInformation.Append(bytesToGB(drv.TotalSize).ToString("00.00"));
                         driveInformation.Append(" GB");
 
                         Console.WriteLine(driveInformation.ToString());
                         drivesToProcess.Add(drv.Name);
                     }
                 }
             }
             if (drivesToProcess.Count() == 0)
             {
                 Console.WriteLine("No valid removable drives were found matching the volume label criteria.");
                 Console.ReadLine();
                 Environment.Exit(0);
             }
 
             Console.WriteLine("");
             Console.Write("Are these the correct drives? [y/n]");
             string usrInput = Console.ReadLine();
             if (usrInput.Trim().ToLower() != "y")
             {
                 return null;
             }
 
             return drivesToProcess;
         }
 
         /// <summary>
         /// Convert bytes to GB
         /// </summary>
         /// <param name="bytes"></param>
         /// <returns></returns>
         private static double bytesToGB(long bytes)
         {
             double ret = ((bytes/1024f)/1024f)/1024f;
             return ret;
         }
 
         private static int numOutputLines = 0;
 
         /// <summary>
         /// Event handler to redirect out CLI output
         /// </summary>
         /// <param name="sendingProcess"></param>
         /// <param name="outLine"></param>
         private static void exeOutputEventHandler(object sendingProcess,
                                                   DataReceivedEventArgs outLine)
         {
             if (!String.IsNullOrEmpty(outLine.Data))
             {
                 numOutputLines++;
 
                 Console.WriteLine("[" + numOutputLines.ToString("000") + "] - " + outLine.Data);
 
             }
         }
     }
 }