Combines two path strings. : Path « File Stream « C# / C Sharp

1. C# / C Sharp
2. File Stream
3. Path

Combines two path strings.

    

#region License and Copyright
/* -------------------------------------------------------------------------
 * Dotnet Commons IO
 *
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License 
 * for more details. 
 *
 * You should have received a copy of the GNU Lesser General Public License 
 * along with this library; if not, write to the 
 * 
 * Free Software Foundation, Inc., 
 * 59 Temple Place, 
 * Suite 330, 
 * Boston, 
 * MA 02111-1307 
 * USA 
 * 
 * -------------------------------------------------------------------------
 */
#endregion

using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Web;

namespace Dotnet.Commons.IO
{
  /// <summary>
  ///  Path handling utility methods that are not available in System.IO.Path
  /// </summary>
    /// <remarks>Authors: Gonzalo Paniagua Javier (gonzalo@ximian.com)</remarks>
  public sealed class PathUtils
  {
    static string appbase;
    static char [] separators;


    private PathUtils()
    {    
    }

        
    /// <summary>
    /// Static Constructor
    /// </summary>    
    static PathUtils ()
    {      
      Assembly entry = Assembly.GetEntryAssembly ();
      appbase = Path.GetDirectoryName (entry.Location);
      
      if (Path.DirectorySeparatorChar != Path.AltDirectorySeparatorChar)
        separators = new char [] {Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar};
      else
        separators = new char [] {Path.DirectorySeparatorChar};
    }


    /// <summary>
        /// Combines two path strings.
    /// </summary>
    /// <param name="basepath"></param>
    /// <param name="relative"></param>
    /// <returns></returns>    
    public static string Combine (string basepath, string relative)
    {
      if (relative == null || relative.Length == 0)
        throw new ArgumentException ("empty or null", "relative");

      char first = relative [0];
      if (first == '/' || first == '\\' || Path.IsPathRooted (relative))
        throw new ArgumentException ("'relative' is rooted", "relative");

      if (first == '~' && relative.Length > 1 && Array.IndexOf (separators, relative [1]) != -1)
        return Path.Combine (appbase, relative.Substring (2));

      if (basepath == null)
        basepath = appbase;

      return MakeAbsolute (Path.Combine (basepath, relative));
    }
    /// <summary>
    /// 
    /// </summary>    
    /// <param name="abspath"></param>
    /// <returns></returns>
    /// <remarks>Authors: Gonzalo Paniagua Javier (gonzalo@ximian.com)</remarks>
    public static string MakeAbsolute (string abspath)
    {
      
      string [] parts = abspath.Split (separators);
      ArrayList valid = new ArrayList ();

      int len = parts.Length;
      bool hasDots = false;

      for (int i = 0; i < len; i++) 
      {
        if (parts [i] == ".") 
        {
          hasDots = true;
          continue;
        }

        if (parts [i] == "..") 
        {
          hasDots = true;
          if (valid.Count > 0)
            valid.RemoveAt (valid.Count - 1);
          continue;
        }

        valid.Add (parts [i]);
      }

      if (!hasDots)
        return abspath;

      parts = (String []) valid.ToArray (typeof (string));
      string result = String.Join (new String (Path.DirectorySeparatorChar, 1), parts);
      if (!Path.IsPathRooted (result))
        return Path.DirectorySeparatorChar + result;

      return result;
    }


  }
}

   
    
    
    
  

Related examples in the same category