C # Como posso verificar se um URL existe / é válido?

Estou criando um programa simples em visual c # 2005 que procura um símbolo de ação no Yahoo! Finanças, baixa os dados históricos e, a seguir, plota o histórico de preços para o símbolo de ação especificado.

Sei a URL exata de que preciso para adquirir os dados e, se o usuário inserir um símbolo de ação existente (ou pelo menos um com dados no Yahoo! Finance), ele funcionará perfeitamente. No entanto, eu tenho um erro de tempo de execução se o usuário inventar um símbolo de ação, enquanto o programa tenta extrair dados de uma página da web inexistente.

Estou usando a classe WebClient e a função DownloadString. Examinei todas as outras funções de membro da classe WebClient, mas não vi nada que pudesse usar para testar um URL.

Como posso fazer isso?

Você poderia emitir uma solicitação "HEAD" em vez de "GET"?

(editar) - lol! Parece que já fiz isso antes !; alterado para wiki para evitar acusações de rep-grupamento. Portanto, para testar um URL sem o custo de baixar o conteúdo:

// using MyClient from linked post
using(var client = new MyClient()) {
    client.HeadOnly = true;
    // fine, no content downloaded
    string s1 = client.DownloadString("http://google.com");
    // throws 404
    string s2 = client.DownloadString("http://google.com/silly");
}

Você faria try/ catchao redor do DownloadStringpara verificar se há erros; nenhum erro? Isso existe...

Com C # 2.0 (VS2005):

private bool headOnly;
public bool HeadOnly {
    get {return headOnly;}
    set {headOnly = value;}
}

e

using(WebClient client = new MyClient())
{
    // code as before
}

Aqui está outra implementação desta solução:

using System.Net;

///
/// Checks the file exists or not.
///
/// The URL of the remote file.
/// True : If the file exits, False if file not exists
private bool RemoteFileExists(string url)
{
    try
    {
        //Creating the HttpWebRequest
        HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
        //Setting the Request method HEAD, you can also use GET too.
        request.Method = "HEAD";
        //Getting the Web Response.
        HttpWebResponse response = request.GetResponse() as HttpWebResponse;
        //Returns TRUE if the Status code == 200
        response.Close();
        return (response.StatusCode == HttpStatusCode.OK);
    }
    catch
    {
        //Any exception will returns false.
        return false;
    }
}

De: http://www.dotnetthoughts.net/2009/10/14/how-to-check-remote-file-exists-using-c/

Essas soluções são muito boas, mas eles se esquecem de que pode haver outros códigos de status além de 200 OK. Esta é uma solução que usei em ambientes de produção para monitoramento de status e tal.

Se houver um redirecionamento de url ou alguma outra condição na página de destino, o retorno será verdadeiro usando este método. Além disso, GetResponse () lançará uma exceção e, portanto, você não obterá um StatusCode para ela. Você precisa interceptar a exceção e verificar se há um ProtocolError.

Qualquer código de status 400 ou 500 retornará falso. Todos os outros retornam verdadeiros. Este código é facilmente modificado para atender às suas necessidades de códigos de status específicos.

/// <summary>
/// This method will check a url to see that it does not return server or protocol errors
/// </summary>
/// <param name="url">The path to check</param>
/// <returns></returns>
public bool UrlIsValid(string url)
{
    try
    {
        HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
        request.Timeout = 5000; //set the timeout to 5 seconds to keep the user from waiting too long for the page to load
        request.Method = "HEAD"; //Get only the header information -- no need to download any content

        using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
        {
            int statusCode = (int)response.StatusCode;
            if (statusCode >= 100 && statusCode < 400) //Good requests
            {
                return true;
            }
            else if (statusCode >= 500 && statusCode <= 510) //Server Errors
            {
                //log.Warn(String.Format("The remote server has thrown an internal error. Url is not valid: {0}", url));
                Debug.WriteLine(String.Format("The remote server has thrown an internal error. Url is not valid: {0}", url));
                return false;
            }
        }
    }
    catch (WebException ex)
    {
        if (ex.Status == WebExceptionStatus.ProtocolError) //400 errors
        {
            return false;
        }
        else
        {
            log.Warn(String.Format("Unhandled status [{0}] returned for url: {1}", ex.Status, url), ex);
        }
    }
    catch (Exception ex)
    {
        log.Error(String.Format("Could not test url {0}.", url), ex);
    }
    return false;
}

Se entendi sua pergunta corretamente, você poderia usar um pequeno método como este para fornecer os resultados do seu teste de URL:

WebRequest webRequest = WebRequest.Create(url);  
WebResponse webResponse;
try 
{
  webResponse = webRequest.GetResponse();
}
catch //If exception thrown then couldn't get response from address
{
  return 0;
} 
return 1;

Você pode envolver o código acima em um método e usá-lo para realizar a validação. Espero que isso responda à pergunta que você estava fazendo.

Tente isto (certifique-se de usar System.Net):

public bool checkWebsite(string URL) {
   try {
      WebClient wc = new WebClient();
      string HTMLSource = wc.DownloadString(URL);
      return true;
   }
   catch (Exception) {
      return false;
   }
}

Quando a função checkWebsite () é chamada, ela tenta obter o código-fonte do URL passado para ela. Se obtiver o código-fonte, ele retorna verdadeiro. Caso contrário, ele retorna falso.

Exemplo de código:

//The checkWebsite command will return true:
bool websiteExists = this.checkWebsite("https://www.google.com");

//The checkWebsite command will return false:
bool websiteExists = this.checkWebsite("https://www.thisisnotarealwebsite.com/fakepage.html");

Aqui está outra opção

public static bool UrlIsValid(string url)
{
    bool br = false;
    try {
        IPHostEntry ipHost = Dns.Resolve(url);
        br = true;
    }
    catch (SocketException se) {
        br = false;
    }
    return br;
}

Esta solução parece fácil de seguir:

public static bool isValidURL(string url) {
    WebRequest webRequest = WebRequest.Create(url);
    WebResponse webResponse;
    try
    {
        webResponse = webRequest.GetResponse();
    }
    catch //If exception thrown then couldn't get response from address
    {
        return false ;
    }
    return true ;
}

WebRequest request = WebRequest.Create("http://www.google.com");
try
{
     request.GetResponse();
}
catch //If exception thrown then couldn't get response from address
{
     MessageBox.Show("The URL is incorrect");`
}

Eu tenho uma maneira mais simples de determinar se um url é válido.

if (Uri.IsWellFormedUriString(uriString, UriKind.RelativeOrAbsolute))
{
   //...
}

Sempre descobri que as exceções são muito mais lentas para serem tratadas.

Talvez uma forma menos intensiva produzisse um resultado melhor e mais rápido?

public bool IsValidUri(Uri uri)
{

    using (HttpClient Client = new HttpClient())
    {

    HttpResponseMessage result = Client.GetAsync(uri).Result;
    HttpStatusCode StatusCode = result.StatusCode;

    switch (StatusCode)
    {

        case HttpStatusCode.Accepted:
            return true;
        case HttpStatusCode.OK:
            return true;
         default:
            return false;
        }
    }
}

Depois é só usar:

IsValidUri(new Uri("http://www.google.com/censorship_algorithm"));

Os servidores da Web respondem com um código de status HTTP indicando o resultado da solicitação, por exemplo, 200 (às vezes 202) significa sucesso, 404 - não encontrado etc (veja aqui ). Supondo que a parte do endereço do servidor da URL esteja correta e você não esteja obtendo um tempo limite de soquete, a exceção provavelmente está informando que o código de status HTTP era diferente de 200. Eu sugeriria verificar a classe da exceção e ver se ela carrega o código de status HTTP.

IIRC - A chamada em questão lança uma WebException ou um descendente. Verifique o nome da classe para ver qual deles e envolva a chamada em um bloco try para interceptar a condição.

Seguindo com os exemplos já fornecidos, eu diria que é uma prática recomendada também envolver a resposta em um uso como este

    public bool IsValidUrl(string url)
    {
         try
         {
             var request = WebRequest.Create(url);
             request.Timeout = 5000;
             request.Method = "HEAD";

             using (var response = (HttpWebResponse)request.GetResponse())
             {
                response.Close();
                return response.StatusCode == HttpStatusCode.OK;
            }
        }
        catch (Exception exception)
        { 
            return false;
        }
   }