Erstellen und auflösen von relativen Pfaden?

Meine app öffnen Sie die Datei in dem Unterverzeichnis von Verzeichnis wo es ausgeführt wird, Unterverzeichnis sample " und enthält die Dateien:

  • example.raf (Beispiel Erweiterung, nicht signifikant)
  • background.gif

example.raf enthält den relativen Pfad zu background.gif (in diesem Fall nur der Dateiname Ursache, dass sich die Dateien im selben Verzeichnis wie die raf) und die Eröffnung der RAF-Ursachen-Anwendung zum Lesen und anzeigen von background.gif.

Wenn ich OpenFileDialog zu laden, RAF-Datei alles in Ordnung ist, Bild lädt richtig. Ich weiß, dass Datei-öffnen-dialog ändert sich auf irgendeine Weise das aktuelle Arbeitsverzeichnis, aber ich war nicht in der Lage, neu zu erstellen diese ohne Datei-öffnen-dialog

Leider in dem Fall, wenn ich rufe raf Lesen - Methode direkt aus dem code, ohne die Versorgung Pfad zu Datei-form OpenFileDialog wie diese

LoadRAF("sample\\example.raf");

in diesem Fall bekam ich problem, die app zu laden Bild aus ExecutablePath und nicht vom Unterverzeichnis enthält RAF Datei und Bild. Natürlich ist es normales Verhalten, aber in diesem Fall ist es highkly unerwünschte. Es ist die erforderlich sind, um sowohl relative als auch absolute Art der Pfade in meiner app, was soll ich also tun, um dieses Problem zu lösen, wie ändern ExecutablePath oder was anderes was ich tun kann, um diese Arbeit zu machen, zumindest, wie im Fall der OpenFileDialog?

InformationsquelleAutor | 2008-10-02
  1. 3

    Nächsten code aus meinem Projekt ZipSolution (http://zipsolution.codeplex.com/)
    zeigt, wie zu beheben, und erstellen Sie relative Pfade in .net

    using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ZipSolution
{
    internal static class RelativePathDiscovery
    {
        ///<summary>
        ///Produces relative path when possible to go from baseLocation to targetLocation
        ///</summary>
        ///<param name="baseLocation">The root folder</param>
        ///<param name="targetLocation">The target folder</param>
        ///<returns>The relative path relative to baseLocation</returns>
        ///<exception cref="ArgumentNullException">base or target locations are null or empty</exception>
        public static string ProduceRelativePath(string baseLocation, string targetLocation)
        {
            if (string.IsNullOrEmpty(baseLocation))
            {
                throw new ArgumentNullException("baseLocation");
            }

            if (string.IsNullOrEmpty(targetLocation))
            {
                throw new ArgumentNullException("targetLocation");
            }

            if (!Path.IsPathRooted(baseLocation))
            {
                return baseLocation;
            }

            if (!Path.IsPathRooted(targetLocation))
            {
                return targetLocation;
            }

            if (string.Compare(Path.GetPathRoot(baseLocation), Path.GetPathRoot(targetLocation), true) != 0)
            {
                return targetLocation;
            }

            if (string.Compare(baseLocation, targetLocation, true) == 0)
            {
                return ".";
            }

            string resultPath = ".";

            if (!targetLocation.EndsWith(@"\"))
            {
                targetLocation = targetLocation + @"\";
            }

            if (baseLocation.EndsWith(@"\"))
            {
                baseLocation = baseLocation.Substring(0, baseLocation.Length - 1);
            }

            while (!targetLocation.StartsWith(baseLocation + @"\", StringComparison.OrdinalIgnoreCase))
            {
                resultPath = resultPath + @"\..";
                baseLocation = Path.GetDirectoryName(baseLocation);

                if (baseLocation.EndsWith(@"\"))
                {
                    baseLocation = baseLocation.Substring(0, baseLocation.Length - 1);
                }
            }

            resultPath = resultPath + targetLocation.Substring(baseLocation.Length);

            //preprocess .\ case
            return resultPath.Substring(2, resultPath.Length - 3);
        }

        ///<summary>
        ///Resolves the relative pathes
        ///</summary>
        ///<param name="relativePath">Relative path</param>
        ///<param name="basePath">base path for discovering</param>
        ///<returns>Resolved path</returns>
        public static string ResolveRelativePath(string relativePath, string basePath)
        {
            if (string.IsNullOrEmpty(basePath))
            {
                throw new ArgumentNullException("basePath");
            }

            if (string.IsNullOrEmpty(relativePath))
            {
                throw new ArgumentNullException("relativePath");
            }

            var result = basePath;

            if (Path.IsPathRooted(relativePath))
            {
                return relativePath;
            }

            if (relativePath.EndsWith(@"\"))
            {
                relativePath = relativePath.Substring(0, relativePath.Length - 1);
            }

            if (relativePath == ".")
            {
                return basePath;
            }

            if (relativePath.StartsWith(@".\"))
            {
                relativePath = relativePath.Substring(2);
            }

            relativePath = relativePath.Replace(@"\.\", @"\");
            if (!relativePath.EndsWith(@"\"))
            {
                relativePath = relativePath + @"\";
            }

            while (!string.IsNullOrEmpty(relativePath))
            {
                int lengthOfOperation = relativePath.IndexOf(@"\") + 1;
                var operation = relativePath.Substring(0, lengthOfOperation - 1);
                relativePath = relativePath.Remove(0, lengthOfOperation);

                if (operation == @"..")
                {
                    result = Path.GetDirectoryName(result);
                }
                else
                {
                    result = Path.Combine(result, operation);
                }
            }

            return result;
        }
    }
}
    • Wenn Sie möchten, verwenden Datei-E / a für (was nicht gut ist), können Sie auch vollständige Pfad zur Datei aus der relativen in der folgenden Weise: new FileInfo(Path.Kombinieren(baseLocation, targetLocation)).FullName
    InformationsquelleAutor Siarhei Kuchuk
  2. 1

    OpenFileDialog ist spuckt einen absoluten Pfad hinter den kulissen.

    Wenn Sie wissen, wo die raf-Datei, die Sie tun können, so etwas wie:

    string parentPath = Directory.GetParent(rafFilePath);
string imagePath = Path.Combine(parentPath, imageFileNameFromRaf);

    BildPfad enthält nun den absoluten Pfad zu deinem Bild, abgeleitet von den Namen des Bildes enthalten in der raf-Datei, sowie das Verzeichnis der raf-Datei war in.

    • dies ist keine Lösung für mich. Ich weiß, dass das falsch ist in einigen Aspekten, aber ich will lieber ändern Sie das aktuelle Verzeichnis, es wwould besser für mich in diesem Fall, eine andere Sache sind absolute Pfade, was ist mit Ihnen ?
    InformationsquelleAutor Bob King
  3. 0

    Können Sie versuchen, ändern Sie das aktuelle Verzeichnis zu dem Verzeichnis mit der ausführbaren Datei mit Umgebung.CurrentDirectory vor dem Lesen aus der relativen Pfade. Oder stattdessen, wenn Sie einen relativen Pfad (Path.IsPathRooted) kombiniert werden kann (Weg.Kombinieren Sie) Ihrem root-Verzeichnis mit dem relativen Pfad ein absoluter.

    InformationsquelleAutor munissor
Schreibe einen Kommentar