C# RelativePath类代码示例

 public static void WriteAllText(this FileAbstractLayer fal, RelativePath file, string content)
 {
     using (var writer = CreateText(fal, file))
     {
         writer.Write(content);
     }
 }

 public PathChangeKind GetPathChangeKind(RelativePath path) {
   PathChangeKind result;
   if (!_map.TryGetValue(path, out result)) {
     result = PathChangeKind.None;
   }
   return result;
 }

 private static void FixLink(XAttribute link, RelativePath filePath, HashSet<string> linkToFiles)
 {
     string linkFile;
     string anchor = null;
     if (PathUtility.IsRelativePath(link.Value))
     {
         var index = link.Value.IndexOf('#');
         if (index == -1)
         {
             linkFile = link.Value;
         }
         else if (index == 0)
         {
             return;
         }
         else
         {
             linkFile = link.Value.Remove(index);
             anchor = link.Value.Substring(index);
         }
         var path = filePath + (RelativePath)linkFile;
         var file = (string)path.GetPathFromWorkingFolder();
         link.Value = file + anchor;
         linkToFiles.Add(HttpUtility.UrlDecode(file));
     }
 }

 public static string ReadAllText(this FileAbstractLayer fal, RelativePath file)
 {
     using (var sr = OpenReadText(fal, file))
     {
         return sr.ReadToEnd();
     }
 }

 public static string GetProperty(this FileAbstractLayer fal, RelativePath file, string propertyName)
 {
     var dict = fal.GetProperties(file);
     string result;
     dict.TryGetValue(propertyName, out result);
     return result;
 }

 public override void Copy(PathMapping sourceFilePath, RelativePath destFilePath)
 {
     var key = destFilePath.GetPathFromWorkingFolder();
     _mapping[key] = new PathMapping(key, sourceFilePath.PhysicalPath)
     {
         Properties = sourceFilePath.Properties,
     };
 }

 public IEnumerable<string> GetSection(string sectionName, Func<IEnumerable<string>, IEnumerable<string>> postProcessing)
 {
     var filename = new RelativePath(sectionName);
       return _configurationFileProvider.ReadFile(filename, (fullPathName, lines) => {
     _volatileToken.AddFile(fullPathName);
     return postProcessing(lines);
       });
 }

 public FileName(DirectoryName parent, RelativePath relativePath) {
   if (parent == null)
     throw new ArgumentNullException("parent");
   if (relativePath.IsEmpty)
     throw new ArgumentException("Relative path is empty", "relativePath");
   _parent = parent;
   _relativePath = relativePath;
 }

		public PhpSourceFile(FullPath root, FullPath fullPath)
		{
			root.EnsureNonEmpty("root");
			fullPath.EnsureNonEmpty("fullPath");

			this.fullPath = fullPath;
			this.relativePath = RelativePath.Empty;
			this.root = root;
		}

 public bool Exists(RelativePath file)
 {
     if (file == null)
     {
         throw new ArgumentNullException(nameof(file));
     }
     EnsureNotDisposed();
     return Reader.FindFile(file) != null;
 }

 public PathMapping? FindFile(RelativePath file)
 {
     var pp = Path.Combine(_expandedInputFolder, file.RemoveWorkingFolder());
     if (!File.Exists(pp))
     {
         return null;
     }
     return new PathMapping(file, Path.Combine(InputFolder, file.RemoveWorkingFolder())) { Properties = Properties };
 }

        public void RelativePath_Unit_Append1_PathContainsAnotherSeparator()
        {
            String[] nodes = new String[] { "sites" };
            Char separator = RelativePath.ForwardSlash;
            RelativePath target = new RelativePath(nodes, separator);
            String path = "Chad\\Greer";

            target.Append(path);
        }

    public bool MatchFileName(RelativePath relativePath, IPathComparer comparer) {
      var path = relativePath.Value;
      CheckPath(path);

      if (PrePassWontMatch(MatchKind.File, path, comparer))
        return false;

      var result = BaseOperator.Match(MatchKind.File, comparer, Operators, 0, path, 0);
      return IsMatch(path, result);
    }

 public FileStream OpenRead(RelativePath file)
 {
     if (file == null)
     {
         throw new ArgumentNullException(nameof(file));
     }
     EnsureNotDisposed();
     var pp = FindPhysicalPath(file);
     return File.OpenRead(Environment.ExpandEnvironmentVariables(pp.PhysicalPath));
 }

        public IEnumerable<string> ReadFile(RelativePath relativePath, Func<FullPath, IEnumerable<string>, IEnumerable<string>> postProcessing)
        {
            foreach (var directoryName in PossibleDirectoryNames()) {
            var path = directoryName.Combine(relativePath);
            if (_fileSystem.FileExists(path))
              return postProcessing(path, _fileSystem.ReadAllLines(path));
              }

              throw new FileLoadException(
            string.Format("Could not load configuration file \"{0}\" from the following locations:{1}", relativePath,
                      PossibleDirectoryNames().Aggregate("", (x, y) => x + "\n" + y)));
        }