Vamos a um código super útil que fiz a alguns anos que converte caminhos Absolutos (c:\windows\temp) para um caminho Relativo (..\..\temp), e também converte URLs Absolutas para URL’s Relativas.

Código em C#

/// <summary>
/// Classe de Conversão de Caminho Relativo
/// em Caminho Absoluto
/// </summary>
public sealed class AbsoluteToRelativePathConverter
{
    private readonly char[] _Separadores = {
        System.IO.Path.DirectorySeparatorChar, System.IO.Path.AltDirectorySeparatorChar,
        System.IO.Path.VolumeSeparatorChar
    };

    /// <summary>
    /// Recupera um Camimho Relativo a Partir de Dois Caminhos Absolutos
    /// </summary>
    /// <param name="origem">Caminho de Origem</param>
    /// <param name="destino">Caminho de Destino</param>
    /// <returns></returns>
    public string RecuperaPathRelativa(string origem, string destino)
    {
        return ProcessaCaminhoRelativo(origem, destino, System.IO.Path.DirectorySeparatorChar);
    }

    /// <summary>
    /// Recupera uma URL Relativa a Partir de Dois Caminhos Absolutos
    /// </summary>
    /// <param name="origem">URL de Origem</param>
    /// <param name="destino">URL de Destino</param>
    /// <returns></returns>
    public string RecuperaURLRelativa(string origem, string destino)
    {
        return ProcessaCaminhoRelativo(origem, destino, System.IO.Path.AltDirectorySeparatorChar);
    }

    /// <summary>
    /// Processa o Caminho Relativo
    /// </summary>
    /// <param name="origem">Caminho de Origem</param>
    /// <param name="destino">Caminho de Destino</param>
    /// <param name="separador">Separador do Caminho</param>
    /// <returns></returns>
    private string ProcessaCaminhoRelativo(string origem, string destino, char separador)
    {
        // Valida os Parâmetros de Entrada
        if (string.IsNullOrEmpty(origem))
        {
            return destino;
        }

        if (string.IsNullOrEmpty(destino))
        {
            return destino;
        }

        // Cria Objetos
        string[] caminhoDeOrigem;
        string[] caminhoDeDestino;
        System.Text.StringBuilder caminhoRelativoFinal = new System.Text.StringBuilder();
        int diffIndex = 0;

        // Separa os Caminhos em Array
        if (origem.IndexOf("/") <= 0 ) // Caminho Físico
        {
            caminhoDeOrigem = System.IO.Path.GetFullPath(origem).Split( this._Separadores);
            caminhoDeDestino = System.IO.Path.GetFullPath(destino).Split( this._Separadores);
        }
        else // URL
        {
            caminhoDeOrigem = origem.Split('/');
            caminhoDeDestino = destino.Split('/');
        }

        // Localiza o Indice aonde os Caminhos Diferem
        for (; diffIndex < caminhoDeOrigem.Length && diffIndex < caminhoDeDestino.Length; ++diffIndex)
        {
            if (! caminhoDeOrigem[diffIndex].Equals( caminhoDeDestino[diffIndex], StringComparison.InvariantCultureIgnoreCase))
            {
                break;
            }
        }

        // Se for no Começo, Retorna o Caminho Inteiro pois não é Possível Caminho Relativo
        if (diffIndex == 0)
        {
            return System.IO.Path.GetFullPath(destino);
        }

        // Coloca "." para Indicar Diretório Atual
        caminhoRelativoFinal.Append(".");

        // Monta o ../ do Separador de Retorno do Caminho
        for (int y = diffIndex; y < caminhoDeOrigem.Length; ++y)
        {
            caminhoRelativoFinal.Append(separador);
            caminhoRelativoFinal.Append("..");
        }

        // Monta a "Diferença de Profundidade do Caminho"
        for (int y = diffIndex; y < caminhoDeDestino.Length; ++y)
        {
            caminhoRelativoFinal.Append(separador);
            caminhoRelativoFinal.Append(caminhoDeDestino[y]);
        }

        // Retorna o Caminho
        return caminhoRelativoFinal.ToString();
    }
}

Como
Existem 2 métodos, 1 para Caminho Físico (RecuperaPathRelativa) e 1 para URL (RecuperaURLRelativa).
Ambos métodos tem 2 parâmetros (Caminho/URL de Origem e Caminho/URL de Destino).

O Algorítmo Calcula o Caminho Relativo da Origem para o Destino.

Exemplo de uso em C#

AbsoluteToRelativePathConverter pathConverter = new AbsoluteToRelativePathConverter();

string pathRelativaDiretorio = pathConverter.RecuperaPathRelativa(@"c:\windows\temp", @"c:\tmp");

string pathRelativaURL = pathConverter.RecuperaURLRelativa(@"http://www.uol.com.br/Dir1/Dir2/Dir3", @"http://www.uol.com.br/Dir1A");

Posts Relacionados:

1. Copiando Arquivos no .Net com C#
2. Algoritmo para Validação de CPF
3. Abrindo Arquivos de Texto e Lendo Todo o Conteúdo
4. Calculando CRC de Strings (Texto), Array’s e Arquivos
5. Convertendo String Delimitada por Tamanho (Trancode) em Array
6. Abrindo Arquivos Texto e Lendo Linha a Linha
7. Criando um documento Pdf com iTextSharp – Parte II