C # Come posso verificare se un URL esiste / è valido?

Sto realizzando un semplice programma in visual c # 2005 che cerca un simbolo di borsa su Yahoo! Finance, scarica i dati storici e quindi traccia la cronologia dei prezzi per il simbolo ticker specificato.

Conosco l'URL esatto di cui ho bisogno per acquisire i dati e se l'utente inserisce un simbolo ticker esistente (o almeno uno con dati su Yahoo! Finance) funziona perfettamente. Tuttavia, ho un errore di runtime se l'utente compone un simbolo ticker, poiché il programma tenta di estrarre dati da una pagina Web inesistente.

Sto usando la classe WebClient e sto usando la funzione DownloadString. Ho esaminato tutte le altre funzioni membro della classe WebClient, ma non ho visto nulla che potessi usare per testare un URL.

Come posso fare questo?

Potresti inviare una richiesta "HEAD" piuttosto che "GET"?

(modifica) - lol! Sembra che l'abbia già fatto prima ! cambiato in wiki per evitare accuse di guadagno di reputazione. Quindi, per testare un URL senza il costo del download del contenuto:

// 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");
}

Si farebbe try/ catchintorno al DownloadStringper controllare gli errori; nessun errore? Esiste...

Con 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
}

Ecco un'altra implementazione di questa soluzione:

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;
    }
}

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

Queste soluzioni sono abbastanza buone, ma stanno dimenticando che potrebbero esserci altri codici di stato oltre a 200 OK. Questa è una soluzione che ho utilizzato negli ambienti di produzione per il monitoraggio dello stato e simili.

Se c'è un reindirizzamento URL o qualche altra condizione sulla pagina di destinazione, il ritorno sarà vero utilizzando questo metodo. Inoltre, GetResponse () genererà un'eccezione e quindi non otterrai uno StatusCode per questo. È necessario intercettare l'eccezione e verificare la presenza di un ProtocolError.

Qualsiasi codice di stato 400 o 500 restituirà false. Tutti gli altri tornano veri. Questo codice può essere facilmente modificato in base alle proprie esigenze per codici di stato specifici.

/// <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 capisco correttamente la tua domanda, potresti utilizzare un piccolo metodo come questo per darti i risultati del tuo test 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;

È possibile racchiudere il codice precedente in un metodo e utilizzarlo per eseguire la convalida. Spero che questo risponda alla domanda che stavi facendo.

Prova questo (assicurati di utilizzare System.Net):

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

Quando la funzione checkWebsite () viene chiamata, cerca di ottenere il codice sorgente dell'URL passato al suo interno. Se ottiene il codice sorgente, restituisce true. In caso contrario, restituisce false.

Esempio di codice:

//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");

Ecco un'altra opzione

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

Questa soluzione sembra facile da seguire:

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");`
}

ho un modo più semplice per determinare se un URL è valido.

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

Ho sempre riscontrato che le eccezioni sono molto più lente da gestire.

Forse un modo meno intenso produrrebbe un risultato migliore e più veloce?

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;
        }
    }
}

Quindi usa:

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

I server Web rispondono con un codice di stato HTTP che indica il risultato della richiesta, ad esempio 200 (a volte 202) significa successo, 404 - non trovato ecc. (Vedere qui ). Supponendo che la parte dell'indirizzo del server dell'URL sia corretta e non stai ricevendo un timeout del socket, l'eccezione molto probabilmente ti dice che il codice di stato HTTP era diverso da 200. Suggerirei di controllare la classe dell'eccezione e vedere se l'eccezione porta il codice di stato HTTP.

IIRC: la chiamata in questione genera un'eccezione WebException o un discendente. Controllare il nome della classe per vedere quale e racchiudere la chiamata in un blocco try per intercettare la condizione.

Seguendo gli esempi già forniti, direi che è buona norma racchiudere anche la risposta in un utilizzo come questo

    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;
        }
   }