getfullpath - Biblioteca de manipulación de ruta.NET

relative path c#

Question

¿Alguien sabe de alguna buena biblioteca que resuma el problema de la manipulación de rutas de una manera agradable? Me gustaría poder combinar y analizar rutas con separadores arbitrarios (''/'' o '':'' por ejemplo) sin reinventar la rueda.

Es una pena que System.IO.Path no sea más reutilizable.

Gracias

Answer 1

¡Estás describiendo expresiones regulares! Úselo como el fundamento de lo que necesita hacer.

Answer 2

System.IO.Path.Combine funcionará de maravilla para muchos tipos diferentes de rutas:

http://msdn.microsoft.com/en-us/library/system.io.path.combine.aspx

System.IO.Path.Combine utiliza los separadores estándar de la plataforma actual para combinar rutas. Eso significa que en Windows usa "/" y en unix / linux (mono) usa "/". ¿Puedes dar algunas muestras de qué caminos estás tratando de combinar y en qué plataforma?

Answer 3

Compruebe la biblioteca de Patrick para manejar el texto de enlace de operaciones de ruta

Este es el proyecto Codeplex

Answer 4

No puedo decir qué entorno podría estar utilizando en base a sus separadores, pero nunca antes había visto una biblioteca como esta.

Así que usar reflector y System.IO.Path como base no es difícil reinventar la rueda.

• Crea una instancia de esta clase
• Proporcione sus caracteres separadores en el CTor
• Opcionalmente cambie InvalidPathChars si es necesario.

Este es más o menos el código que utiliza el marco, por lo que debe ser igual de rápido o solo una diferencia insignificante. Puede o no ser más rápido que RegEx, sin embargo, vale la pena probarlo.

class ArbitraryPath
{
    private readonly char _directorySeparatorChar;
    private readonly char _altDirectorySeparatorChar;
    private readonly char _volumeSeparatorChar;

    public ArbitraryPath(char directorySeparatorChar, char altDirectorySeparatorChar, char volumeSeparatorChar)
    {
        _directorySeparatorChar = directorySeparatorChar;
        _altDirectorySeparatorChar = altDirectorySeparatorChar;
        _volumeSeparatorChar = volumeSeparatorChar;
    }

    public string Combine(string path1, string path2)
    {
        if ((path1 == null) || (path2 == null))
        {
            throw new ArgumentNullException((path1 == null) ? "path1" : "path2");
        }
        CheckInvalidPathChars(path1);
        CheckInvalidPathChars(path2);
        if (path2.Length == 0)
        {
            return path1;
        }
        if (path1.Length == 0)
        {
            return path2;
        }
        if (IsPathRooted(path2))
        {
            return path2;
        }

        char ch = path1[path1.Length - 1];
        if (ch != _directorySeparatorChar && ch != _altDirectorySeparatorChar && ch != _volumeSeparatorChar)
        {
            return (path1 + _directorySeparatorChar + path2);
        }
        return (path1 + path2);
    }

    public bool IsPathRooted(string path)
    {
        if (path != null)
        {
            CheckInvalidPathChars(path);
            int length = path.Length;
            if (length >= 1 && (path[0] == _directorySeparatorChar || path[0] == _altDirectorySeparatorChar) || length >= 2 && path[1] == _volumeSeparatorChar)
            {
                return true;
            }
        }
        return false;
    }

    internal static void CheckInvalidPathChars(string path)
    {
        for (int i = 0; i < path.Length; i++)
        {
            int num2 = path[i];
            if (num2 == 0x22 || num2 == 60 || num2 == 0x3e || num2 == 0x7c || num2 < 0x20)
            {
                throw new ArgumentException("Argument_InvalidPathChars");
            }
        }
    } 

}

Answer 5

Me temo que tendrás que implementar una clase de ruta tú mismo , como yo lo hice. Ofrece las siguientes ventajas:

• puede beneficiarse de la seguridad tipo
• puede anular el operador /, lo que facilita la concatenación
• puede agregar funciones de miembro de conveniencia como GetParentPath () y GetLeafPart ()