C# - Apresentando os recursos da classe Uri - II

 Neste artigo vou apresentar os recursos da classe Uri do namespace System da linguagem C#.

Vamos continuar a primeira parte deste artigo apresentando mais recursos da classe Uri.

Recursos Usados neste artigo :

Combinando URIs relativas e absolutas

As URI relativas são usadas com frequência, mas devem ser combinadas com uma URI absoluta para serem úteis.

Podemos realizar essas combinações com outro par de construtores. Ao instanciar um objeto Uri, podemos fornecer uma URI absoluta como o primeiro argumento e uma URI relativa no segundo argumento, usando uma segunda Uri ou uma string.

A Uri resultante manterá o caminho relativo da URI com o esquema e autoridade da URI absoluta.

using System;
using static System.Console;
namespace CShp_Uri
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri uriAbsoluta = new Uri("http://www.macoratti.net");
            Uri uriRelativa = new Uri("c_uri1.htm", UriKind.Relative);
            Uri combinacao = new Uri(uriAbsoluta, uriRelativa);
            WriteLine(combinacao);
            ReadLine();
        }
    }
}

Um recurso interessante desse construtor com dois parâmetros, é que a barra inclinada entre a autoridade e o caminho é incluida de forma correta.

No exemplo acima o resultado mostra que a barra foi adicionada corretamente : http://www.macoratti.net/c_uri1.htm

E se tivéssemos incluido as barras tanto na URI absoluta como na relativa ?  Qual seria o resultado ?

Veja no exemplo abaixo que o resultado seria o mesmo:

using System;
using static System.Console;
namespace CShp_Uri
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri uriAbsoluta = new Uri("http://www.macoratti.net/");
            Uri uriRelativa = new Uri("/c_uri1.htm", UriKind.Relative);
            Uri combinacao = new Uri(uriAbsoluta, uriRelativa);
            WriteLine(combinacao);
            ReadLine();
        }
    }
}

Agora veja o exemplo abaixo onde temos uma URI absoluta que inclui um caminho (path) : http://www.macoratti.net/origem.aspx (Esta página pode ser uma página que contém um link relativo.)

Quando combinamos a URI absoluta com a URI relativa note que o resultado exclui o caminho(path) da URI absoluta (origem.aspx) :

using System;
using static System.Console;
namespace CShp_Uri
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri uriAbsoluta = new Uri("http://www.macoratti.net/origem.aspx");
            Uri uriRelativa = new Uri("/destino.htm", UriKind.Relative);
            Uri combinacao = new Uri(uriAbsoluta, uriRelativa);
            WriteLine(combinacao);
            ReadLine();
        }
    }
}

Extraindo informação da Uri

Os construtores Uri são muito úteis e podemos usar propriedades para extrair partes de uma URI.

Vamos criar uma Uri completa com todas as partes, e a seguir, vamos extrair cada parte individualmente e em grupos.

Para isso vamos definir o código abaixo e a seguir exibir o resultado exibido no console:

using System;
using static System.Console;
namespace CShp_Uri
{
    class Program
    {
        static void Main(string[] args)
        {
            Uri uri = new Uri("http://macoratti:password@authority.com:5555/path/pagina.aspx?valor1=10&valor2=20#fragment");
            WriteLine(uri.Scheme);
            WriteLine(uri.Authority);
            WriteLine(uri.UserInfo);
            WriteLine(uri.Port);
            WriteLine(uri.AbsolutePath);
            WriteLine(uri.Query);
            WriteLine(uri.Fragment);
            WriteLine(uri.Host);
            WriteLine(uri.HostNameType);
            WriteLine(uri.PathAndQuery);
            WriteLine(uri.LocalPath);
            ReadLine();
        }
    }
}

Agora vamos debulhar cada linha do código usado:

 WriteLine(uri.Scheme);

A propriedade Scheme fornece o esquema da URI. Se você estiver atuando sobre uma URI pode usar o esquema para saber como carregá-lo.

 WriteLine(uri.Authority);

A propriedade Authority retorna a autoridade da URI como uma string e inclui o número da porta mas não incluir informação do usuário.

 WriteLine(uri.UserInfo);

A propriedade UserInfo retorna os detalhes do usuário. Não existe uma propriedade para obter o nome do usuário ou a senha individualmente. Mas podemos usar o método Split para separar essas informações.

 WriteLine(uri.Port);

A propriedade Port retorna a porta usada como um inteiro.

 WriteLine(uri.AbsolutePath);

A propriedade AbsolutePath retorna o caminho da URI como uma string simples, iniciando com a barra inicial do caminho até o começo da consulta.

 WriteLine(uri.Query);

A propriedade Query retorna a consulta incluindo o sinal de interrogação inicial.(?)

  WriteLine(uri.Fragment);

A propriedade Fragment retorna o fragmento onde o separador de caractere agora é um hash(#) que é incluído no resultado.

 WriteLine(uri.Host);

A propriedade Host retorna a parte do host da URI que não mencionamos ainda.

O host é geralmente o nome de  um servidor, um nome DNS ou um endereço IP, e faz parte da autoridade mas não inclui o número da porta ou informação do usuário.

Ao recuperar o nome do host, muitas vezes é importante saber qual o tipo do host. Por exemplo, você pode querer tratar um endereço IP de forma diferente de um nome DNS.

Em vez de analisar a string e aplicar regras para determinar o tipo de host, você pode obter essa informação usando a propriedade HostNameType.

Isso retorna um valor da enumeração UriHostNameType cujos valores possíveis são:

- Unknown - O tipo de nome do host não está presente na Uri;
- Basic - O tipo de nome do host está presente, mas não pode ser determinado;
- Dns - O nome do host é um host DNS, como "macoratti.net";
- IPv4 - O host é um endereço IP, como "192.168.0.1";
- IPv6 - O host é um endereço IP versão 6, como "2001: 0DB8: AC10: FE01 ::";

Assim usando :

  WriteLine(uri.HostNameType);

Iremos obter o resultado : Dns

  WriteLine(uri.PathAndQuery);

A propriedade PathAndQuery retorna a informação do caminho e da consulta como uma string.(Não existe uma propriedade Path).

  WriteLine(uri.LocalPath);

A propriedade LocalPath obtém o caminho local. Ela é útil quando você tem uma URI que representa uma caminho de um arquivo.

A URI fornece um formato padrão neste caso que é independente do sistema operacional.

A propriedade LocalPath converte a URI para o caminho que pode ser usado no seu sistema de arquivos local. No Exemplo:

            Uri uri2 = new Uri("file://c:/windows/system32/vfprint.dll");
            WriteLine(uri2.LocalPath);
            ReadLine();
 

Teremos como resultado o caminho local  :  c:\windows\system32\vfprint.dll

Na próxima parte do artigo veremos outros recursos da classe Uri.

"Vede quão grande amor nos tem concedido o Pai, que fôssemos chamados filhos de Deus. Por isso o mundo não nos conhece; porque não o conhece a ele."
 1 João 3:1

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Referências:

José Carlos Macoratti