C# FilePath.GetPath方法代码示例

		public SystemProcess Exec (string[] cmd, string[] envp, FilePath dir)
		{
			try {
				ProcessStartInfo psi = new ProcessStartInfo ();
				psi.FileName = cmd[0];
				psi.Arguments = string.Join (" ", cmd, 1, cmd.Length - 1);
				if (dir != null) {
					psi.WorkingDirectory = dir.GetPath ();
				}
				psi.UseShellExecute = false;
				psi.RedirectStandardInput = true;
				psi.RedirectStandardError = true;
				psi.RedirectStandardOutput = true;
				psi.CreateNoWindow = true;
				if (envp != null) {
					foreach (string str in envp) {
						int index = str.IndexOf ('=');
						psi.EnvironmentVariables[str.Substring (0, index)] = str.Substring (index + 1);
					}
				}
				return SystemProcess.Start (psi);
			} catch (System.ComponentModel.Win32Exception ex) {
				throw new IOException (ex.Message);
			}
		}

		private static void RunFileIfExists(Context cx, Scriptable global, FilePath f)
		{
			if (f.IsFile())
			{
				Main.ProcessFileNoThrow(cx, global, f.GetPath());
			}
		}

 public static bool DeleteRecursive (FilePath attachmentsFile)
 {
     var success = true;
     try {
         Directory.Delete (attachmentsFile.GetPath (), true);
     } catch (Exception ex) {
         Log.V(Tag, "Error deleting the '{0}' directory.".Fmt(attachmentsFile.GetAbsolutePath()), ex);
         success = false;
     }
     return success;
 }

		public Process Exec (string[] cmd, string[] envp, FilePath dir)
		{
			Process process = new Process ();
			process.StartInfo.FileName = cmd[0];
			process.StartInfo.Arguments = string.Join (" ", cmd, 1, cmd.Length - 1);
			if (dir != null) {
				process.StartInfo.WorkingDirectory = dir.GetPath ();
			}
			process.StartInfo.UseShellExecute = false;
			if (envp != null) {
				foreach (string str in envp) {
					int index = str.IndexOf ('=');
					process.StartInfo.EnvironmentVariables[str.Substring (0, index)] = str.Substring (index + 1);
				}
			}
			process.Start ();
			return process;
		}

		public RandomAccessFile (FilePath file, string mode) : this(file.GetPath (), mode)
		{
		}

 public FileOutputStream (FilePath file): this (file.GetPath (), false)
 {
 }

		public PrintWriter (FilePath path) : base(path.GetPath ())
		{
		}

        /// <summary>
        /// Updates the file in the working tree with content and mode from an entry
        /// in the index.
        /// </summary>
        /// <remarks>
        /// Updates the file in the working tree with content and mode from an entry
        /// in the index. The new content is first written to a new temporary file in
        /// the same directory as the real file. Then that new file is renamed to the
        /// final filename.
        /// <p>
        /// TODO: this method works directly on File IO, we may need another
        /// abstraction (like WorkingTreeIterator). This way we could tell e.g.
        /// Eclipse that Files in the workspace got changed
        /// </p>
        /// </remarks>
        /// <param name="repo"></param>
        /// <param name="f">
        /// the file to be modified. The parent directory for this file
        /// has to exist already
        /// </param>
        /// <param name="entry">the entry containing new mode and content</param>
        /// <param name="or">object reader to use for checkout</param>
        /// <exception cref="System.IO.IOException">System.IO.IOException</exception>
        public static void CheckoutEntry(Repository repo, FilePath f, DirCacheEntry entry
			, ObjectReader or)
        {
            ObjectLoader ol = or.Open(entry.GetObjectId());
            FilePath parentDir = f.GetParentFile();
            FilePath tmpFile = FilePath.CreateTempFile("._" + f.GetName(), null, parentDir);
            WorkingTreeOptions opt = repo.GetConfig().Get(WorkingTreeOptions.KEY);
            FileOutputStream rawChannel = new FileOutputStream(tmpFile);
            OutputStream channel;
            if (opt.GetAutoCRLF() == CoreConfig.AutoCRLF.TRUE)
            {
                channel = new AutoCRLFOutputStream(rawChannel);
            }
            else
            {
                channel = rawChannel;
            }
            try
            {
                ol.CopyTo(channel);
            }
            finally
            {
                channel.Close();
            }
            FS fs = repo.FileSystem;
            if (opt.IsFileMode() && fs.SupportsExecute())
            {
                if (FileMode.EXECUTABLE_FILE.Equals(entry.RawMode))
                {
                    if (!fs.CanExecute(tmpFile))
                    {
                        fs.SetExecute(tmpFile, true);
                    }
                }
                else
                {
                    if (fs.CanExecute(tmpFile))
                    {
                        fs.SetExecute(tmpFile, false);
                    }
                }
            }
            if (!tmpFile.RenameTo(f))
            {
                // tried to rename which failed. Let' delete the target file and try
                // again
                FileUtils.Delete(f);
                if (!tmpFile.RenameTo(f))
                {
                    throw new IOException(MessageFormat.Format(JGitText.Get().couldNotWriteFile, tmpFile
                        .GetPath(), f.GetPath()));
                }
            }
            entry.LastModified = f.LastModified();
            if (opt.GetAutoCRLF() != CoreConfig.AutoCRLF.FALSE)
            {
                entry.SetLength(f.Length());
            }
            else
            {
                // AutoCRLF wants on-disk-size
                entry.SetLength((int)ol.GetSize());
            }
        }

        /// <summary>
        /// Deletes the %Database%.
        /// </summary>
        /// <exception cref="Couchbase.Lite.CouchbaseLiteException"/>
        public void Delete()
        {
            if (open)
            {
                if (!Close())
                {
                    throw new CouchbaseLiteException("The database was open, and could not be closed", 
                        StatusCode.InternalServerError);
                }
            }

            Manager.ForgetDatabase(this);
            if (!Exists())
            {
                return;
            }

            var file = new FilePath(Path);
            var attachmentsFile = new FilePath(AttachmentStorePath);

            var deleteStatus = file.Delete();
            if (!deleteStatus)
            {
                Log.V(Database.Tag, String.Format("Error deleting the SQLite database file at {0}", file.GetAbsolutePath()));
            }

            //recursively delete attachments path
            var deletedAttachmentsPath = true;
            try {
				var dirInfo = new DirectoryInfo(attachmentsFile.GetPath());
				dirInfo.Delete(true);
				//Directory.Delete (attachmentsFile.GetPath (), true);
            } catch (Exception ex) {
                Log.V(Database.Tag, "Error deleting the attachments directory.", ex);
                deletedAttachmentsPath = false;
            }

            if (!deleteStatus)
            {
                throw new CouchbaseLiteException("Was not able to delete the database file", StatusCode.InternalServerError);
            }

            if (!deletedAttachmentsPath)
            {
                throw new CouchbaseLiteException("Was not able to delete the attachments files", StatusCode.InternalServerError);
            }
        }

		public FileReader (FilePath f) : base(f.GetPath ())
		{
		}

 public FileInputStream (FilePath file) : this(file.GetPath ())
 {
 }

		/// <summary>
		/// Waits until it is guaranteed that a subsequent file modification has a
		/// younger modification timestamp than the modification timestamp of the
		/// given file.
		/// </summary>
		/// <remarks>
		/// Waits until it is guaranteed that a subsequent file modification has a
		/// younger modification timestamp than the modification timestamp of the
		/// given file. This is done by touching a temporary file, reading the
		/// lastmodified attribute and, if needed, sleeping. After sleeping this loop
		/// starts again until the filesystem timer has advanced enough.
		/// </remarks>
		/// <param name="lastFile">
		/// the file on which we want to wait until the filesystem timer
		/// has advanced more than the lastmodification timestamp of this
		/// file
		/// </param>
		/// <returns>
		/// return the last measured value of the filesystem timer which is
		/// greater than then the lastmodification time of lastfile.
		/// </returns>
		/// <exception cref="System.Exception">System.Exception</exception>
		/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
		public static long FsTick(FilePath lastFile)
		{
			long sleepTime = 1;
			if (lastFile != null && !lastFile.Exists())
			{
				throw new FileNotFoundException(lastFile.GetPath());
			}
			FilePath tmp = FilePath.CreateTempFile("FileTreeIteratorWithTimeControl", null);
			try
			{
				long startTime = (lastFile == null) ? tmp.LastModified() : lastFile.LastModified(
					);
				long actTime = tmp.LastModified();
				while (actTime <= startTime)
				{
					Sharpen.Thread.Sleep(sleepTime);
					sleepTime *= 5;
					tmp.SetLastModified(Runtime.CurrentTimeMillis());
					actTime = tmp.LastModified();
				}
				return actTime;
			}
			finally
			{
				FileUtils.Delete(tmp);
			}
		}

		/// <summary>Constructs an exception indicating a local repository does not exist.</summary>
		/// <remarks>Constructs an exception indicating a local repository does not exist.</remarks>
		/// <param name="location">description of the repository not found, usually file path.
		/// 	</param>
		/// <param name="why">why the repository does not exist.</param>
		public RepositoryNotFoundException(FilePath location, Exception why) : this(location
			.GetPath(), why)
		{
		}

 ///// <summary>Read at most limit bytes from the local file into memory as a byte array.
 ///// 	</summary>
 ///// <remarks>Read at most limit bytes from the local file into memory as a byte array.
 ///// 	</remarks>
 ///// <param name="path">location of the file to read.</param>
 ///// <param name="limit">
 ///// maximum number of bytes to read, if the file is larger than
 ///// only the first limit number of bytes are returned
 ///// </param>
 ///// <returns>
 ///// complete contents of the requested local file. If the contents
 ///// exceeds the limit, then only the limit is returned.
 ///// </returns>
 ///// <exception cref="System.IO.FileNotFoundException">the file does not exist.</exception>
 ///// <exception cref="System.IO.IOException">the file exists, but its contents cannot be read.
 ///// 	</exception>
 //public static byte[] ReadSome(FilePath path, int limit)
 //{
 //    FileInputStream @in = new FileInputStream(path);
 //    try
 //    {
 //        byte[] buf = new byte[limit];
 //        int cnt = 0;
 //        for (; ; )
 //        {
 //            int n = @in.Read(buf, cnt, buf.Length - cnt);
 //            if (n <= 0)
 //            {
 //                break;
 //            }
 //            cnt += n;
 //        }
 //        if (cnt == buf.Length)
 //        {
 //            return buf;
 //        }
 //        byte[] res = new byte[cnt];
 //        System.Array.Copy(buf, 0, res, 0, cnt);
 //        return res;
 //    }
 //    finally
 //    {
 //        try
 //        {
 //            @in.Close();
 //        }
 //        catch (IOException)
 //        {
 //        }
 //    }
 //}
 //// do nothing
 ///// <summary>Read an entire local file into memory as a byte array.</summary>
 ///// <remarks>Read an entire local file into memory as a byte array.</remarks>
 ///// <param name="path">location of the file to read.</param>
 ///// <param name="max">
 ///// maximum number of bytes to read, if the file is larger than
 ///// this limit an IOException is thrown.
 ///// </param>
 ///// <returns>complete contents of the requested local file.</returns>
 ///// <exception cref="System.IO.FileNotFoundException">the file does not exist.</exception>
 ///// <exception cref="System.IO.IOException">the file exists, but its contents cannot be read.
 ///// 	</exception>
 public static byte[] ReadFully(FilePath path, int max)
 {
     return File.ReadAllBytes(path.GetPath());
 }

		public FileWriter (FilePath path) : base(Couchbase.Lite.File.OpenStream(path.GetPath (), true))
		{
		}