C# String.ThrowIfNullOrWhiteSpace方法代码示例

 /// <include file='.\BusyBox.xml' path='/BusyBox/ExecuteRootShellCommand/*'/>
 public void ExecuteRootShellCommand( String command, IShellOutputReceiver receiver, params object[] commandArgs )
 {
     command.ThrowIfNullOrWhiteSpace ( "command" );
     var cmd = String.Format ( "{0} {1}", BUSYBOX_COMMAND, String.Format ( command, commandArgs ) );
     Log.d ( "executing (su): {0}", cmd );
     Device.ExecuteRootShellCommand(cmd, receiver );
 }

        /// <summary>
        /// Chmods the specified path.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="permissions">The permissions.</param>
        public void Chmod( String path, FilePermissions permissions )
        {
            Device.ThrowIfNull ( "Device" );
            path.ThrowIfNullOrWhiteSpace ( "path" );
            permissions.ThrowIfNull ( "permissions" );

            FileEntry entry = Device.FileListingService.FindFileEntry ( path );
            CommandErrorReceiver cer = new CommandErrorReceiver ( );
            Device.ExecuteShellCommand ( "chmod {0} {1}", cer, permissions.ToChmod ( ), entry.FullEscapedPath );
        }

 /// <summary>
 /// Executes a busybox command on the device as root
 /// </summary>
 /// <param name="command">The command.</param>
 /// <param name="receiver">The receiver.</param>
 /// <param name="commandArgs">The command args.</param>
 public void ExecuteRootShellCommand( String command, IShellOutputReceiver receiver, params object[] commandArgs )
 {
     command.ThrowIfNullOrWhiteSpace ( "command" );
     var cmd = String.Format ( "{0} {1}", BUSYBOX_COMMAND, String.Format ( command, commandArgs ) );
     Log.d ( "executing (su): {0}", cmd );
     AdbHelper.Instance.ExecuteRemoteRootCommand ( AndroidDebugBridge.SocketAddress, cmd, this.Device, receiver );
 }

        /// <summary>
        /// Gets if the specified command name is supported by this version of busybox
        /// </summary>
        /// <param name="command">The command name to check</param>
        /// <returns><c>true</c>, if supported; otherwise, <c>false</c>.</returns>
        public bool Supports( String command )
        {
            command.ThrowIfNullOrWhiteSpace ( "command" );

            if ( Available && ( Commands == null || Commands.Count == 0 ) ) {
                CheckForBusyBox ( );
            }

            return Commands.Where( c => String.Compare(c,command,false) == 0).FirstOrDefault() != null;
        }

        /// <summary>
        /// Attempts to install on the device
        /// </summary>
        /// <param name="busybox">The path to the busybox binary to install.</param>
        /// <returns><c>true</c>, if successful; otherwise, <c>false</c></returns>
        public bool Install( String busybox )
        {
            busybox.ThrowIfNullOrWhiteSpace ( "busybox" );

            FileEntry bb = null;

            try {
                Device.ExecuteShellCommand ( BUSYBOX_COMMAND, NullOutputReceiver.Instance );
                return true;
            } catch {
                // we are just checking if it is already installed so we really expect it to wind up here.
            }

            try {
                MountPoint mp = Device.MountPoints["/data"];
                bool isRO = mp.IsReadOnly;
                Device.RemountMountPoint ( Device.MountPoints["/data"], false );

                FileEntry path = null;
                try {
                    path = Device.FileListingService.FindFileEntry ( BUSYBOX_BIN );
                } catch ( FileNotFoundException ) {
                    // path doesn't exist, so we make it.
                    Device.FileSystem.MakeDirectory ( BUSYBOX_BIN );
                    // attempt to get the FileEntry after the directory has been made
                    path = Device.FileListingService.FindFileEntry ( BUSYBOX_BIN );
                }

                Device.FileSystem.Chmod ( path.FullPath, "0755" );

                String bbPath = LinuxPath.Combine ( path.FullPath, BUSYBOX_COMMAND );

                Device.FileSystem.Copy ( busybox, bbPath );

                bb = Device.FileListingService.FindFileEntry ( bbPath );
                Device.FileSystem.Chmod ( bb.FullPath, "0755" );

                Device.ExecuteShellCommand ( "{0}/busybox --install {0}", new ConsoleOutputReceiver ( ), path.FullPath );

                // check if this path exists in the path already
                if ( Device.EnvironmentVariables.ContainsKey ( "PATH" ) ) {
                    var paths = Device.EnvironmentVariables["PATH"].Split ( ':' );
                    var found = paths.Where ( p => String.Compare ( p, BUSYBOX_BIN, false ) == 0 ).Count ( ) > 0;

                    // we didnt find it, so add it.
                    if ( !found ) {
                        // this doesn't seem to actually work
                        Device.ExecuteShellCommand ( @"echo \ Mad Bee buxybox >> /init.rc", NullOutputReceiver.Instance );
                        Device.ExecuteShellCommand ( @"echo export PATH={0}:\$PATH >> /init.rc", NullOutputReceiver.Instance, BUSYBOX_BIN );
                    }
                }

                if ( mp.IsReadOnly != isRO ) {
                    // Put it back, if we changed it
                    Device.RemountMountPoint ( mp, isRO );
                }

                Device.ExecuteShellCommand ( "sync", NullOutputReceiver.Instance );
            } catch ( Exception ) {
                throw;
            }

            CheckForBusyBox ( );
            return true;
        }

        /// <summary>
        /// Copies the specified source to the specified destination.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="destination">The destination.</param>
        public void Copy( String source, String destination )
        {
            Device.ThrowIfNull ( "Device" );
            source.ThrowIfNullOrWhiteSpace ( "source" );
            destination.ThrowIfNullOrWhiteSpace ( "destination" );

            CommandErrorReceiver cer = new CommandErrorReceiver ( );
            FileEntry sfe = Device.FileListingService.FindFileEntry ( source );

            Device.ExecuteShellCommand ( "cat {0} > {1}", cer, sfe.FullEscapedPath, destination );
            if ( !String.IsNullOrEmpty ( cer.ErrorMessage ) ) {
                throw new IOException ( cer.ErrorMessage );
            }
        }

        /// <summary>
        /// Makes the directory.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="forceDeviceMethod">if set to <c>true</c> forces the use of the "non-busybox" method.</param>
        public void MakeDirectory( String path, bool forceDeviceMethod )
        {
            Device.ThrowIfNull ( "Device" );
            path.ThrowIfNullOrWhiteSpace ( "path" );

            CommandErrorReceiver cer = new CommandErrorReceiver ( );
            try {
                //var fileEntry = FileEntry.FindOrCreate ( Device, path );
                // if we have busybox we can use the mkdir in there as it supports --parents
                if ( Device.BusyBox.Available && !forceDeviceMethod ) {
                    try {
                        Device.BusyBox.ExecuteShellCommand ( "mkdir -p {0}", cer, path );
                    } catch {
                        try {
                            // if there was an error, then fallback too.
                            MakeDirectoryFallbackInternal ( path, cer );
                        } catch { }
                    }
                } else {
                    // if busybox is not available then we have to fallback
                    MakeDirectoryFallbackInternal ( path, cer );
                }
            } catch {

            }
            if ( !String.IsNullOrEmpty ( cer.ErrorMessage ) ) {
                throw new IOException ( cer.ErrorMessage );
            }
        }

        /// <summary>
        /// Gets if the specified mount point is read-only
        /// </summary>
        /// <param name="mount"></param>
        /// <returns><code>true</code>, if read-only; otherwise, <code>false</code></returns>
        /// <exception cref="IOException">If mount point doesnt exist</exception>
        public bool IsMountPointReadOnly( String mount )
        {
            Device.ThrowIfNull ( "Device" );
            mount.ThrowIfNullOrWhiteSpace ( mount );

            if ( !Device.MountPoints.ContainsKey ( mount ) ) {
                throw new IOException ( "Invalid mount point" );
            }

            return Device.MountPoints[mount].IsReadOnly;
        }

        /// <summary>
        /// Gets if the specified path exists on the device.
        /// </summary>
        /// <param name="path">the path to check</param>
        /// <returns><c>true</c>, if the path exists; otherwise, <c>false</c></returns>
        /// <exception cref="IOException">If the device is not connected.</exception>
        /// <exception cref="ArgumentNullException">If the device or path is null.</exception>
        public bool Exists( String path )
        {
            Device.ThrowIfNull ( "Device" );
            path.ThrowIfNullOrWhiteSpace ( "path" );

            if ( !Device.IsOffline ) {
                try {
                    FileEntry fe = Device.FileListingService.FindFileEntry ( path );
                    return fe != null;
                } catch ( FileNotFoundException e ) {
                    return false;
                }
            } else {
                throw new IOException ( "Device is not online" );
            }
        }

        /// <summary>
        /// Deletes the specified path.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <exception cref="System.ArgumentNullException">
        /// If device is null
        /// or
        /// If path is null or empty.
        /// </exception>
        /// <gist id="adee6a11c5441da61af8" />
        /// <exception cref="System.IO.IOException">If the command fails.</exception>
        public void Delete(String path)
        {
            Device.ThrowIfNull ( "Device" );
            path.ThrowIfNullOrWhiteSpace ( "path" );
            FileEntry entry = Device.FileListingService.FindFileEntry ( path );

            Delete ( entry );
        }

        /// <summary>
        /// Creates the specified path.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <returns></returns>
        public FileEntry Create( String path )
        {
            Device.ThrowIfNull ( "Device" );

            path.ThrowIfNullOrWhiteSpace ( "path" );

            if ( !Device.IsOffline ) {
                if ( Exists ( path ) ) {
                    throw new ArgumentException ( "The specified path already exists." );
                } else {
                    var cer = new CommandErrorReceiver ( );
                    var escaped = LinuxPath.Escape ( path );
                    // use native touch command if its available.
                    var cmd = Device.BusyBox.Available ? "touch" : ">";
                    var command = String.Format ( "{0} {1}", cmd, escaped );
                    if ( Device.CanSU ( ) ) {
                        Device.ExecuteRootShellCommand ( command, cer );
                    } else {
                        Device.ExecuteShellCommand ( command, cer );
                    }
                    if ( !String.IsNullOrEmpty ( cer.ErrorMessage ) ) {
                        throw new IOException ( String.Format ( "Error creating file: {0}", cer.ErrorMessage ) );
                    } else {
                        // at this point, the newly created file should exist.
                        return Device.FileListingService.FindFileEntry ( path );
                    }
                }
            } else {
                throw new IOException ( "Device is not online" );
            }
        }

        /// <summary>
        /// Makes the directory.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="forceDeviceMethod">if set to <see langword="true"/> forces the use of the "non-busybox" method.</param>
        public void MakeDirectory(String path, bool forceDeviceMethod)
        {
            Device.ThrowIfNull("Device");
            path.ThrowIfNullOrWhiteSpace("path");

            CommandErrorReceiver cer = new CommandErrorReceiver();
            try
            {
                // if busybox is not available then we have to fallback
                MakeDirectoryFallbackInternal(path, cer);
            }
            catch
            {

            }
            if (!String.IsNullOrEmpty(cer.ErrorMessage))
            {
                throw new IOException(cer.ErrorMessage);
            }
        }

 /// <include file='.\BusyBox.xml' path='/BusyBox/ExecuteShellCommand/*'/>
 public void ExecuteShellCommand( String command, IShellOutputReceiver receiver, params object[] commandArgs )
 {
     command.ThrowIfNullOrWhiteSpace ( "command" );
     var cmd = String.Format ( "{0} {1}", BUSYBOX_COMMAND, String.Format ( command, commandArgs ) );
     Log.d ( "executing: {0}", cmd );
     AdbClient.Instance.ExecuteRemoteCommand(cmd, this.Device.DeviceData, receiver);
 }

        /// <summary>
        /// Deletes the specified path.
        /// </summary>
        /// <param name="path">The path.</param>
        public void Delete( String path )
        {
            Device.ThrowIfNull ( "Device" );
            path.ThrowIfNullOrWhiteSpace ( "path" );

            CommandErrorReceiver cer = new CommandErrorReceiver ( );
            FileEntry entry = Device.FileListingService.FindFileEntry ( path );

            Delete ( entry );
        }