C # Comment puis-je vérifier si une URL existe / est valide?

Je crée un programme simple en visuel c # 2005 qui recherche un symbole boursier sur Yahoo! Finance, télécharge les données historiques, puis trace l'historique des prix pour le symbole boursier spécifié.

Je connais l'URL exacte dont j'ai besoin pour acquérir les données, et si l'utilisateur entre un symbole boursier existant (ou au moins un avec des données sur Yahoo! Finance), cela fonctionne parfaitement. Cependant, j'ai une erreur d'exécution si l'utilisateur crée un symbole boursier, car le programme tente d'extraire des données d'une page Web inexistante.

J'utilise la classe WebClient et la fonction DownloadString. J'ai parcouru toutes les autres fonctions membres de la classe WebClient, mais je n'ai rien vu que je pourrais utiliser pour tester une URL.

Comment puis-je faire ceci?

Vous pourriez émettre une demande "HEAD" plutôt qu'un "GET"?

(modifier) ​​- lol! On dirait que j'ai déjà fait ça ! changé en wiki pour éviter les accusations de collecte de représentants. Donc, pour tester une URL sans le coût du téléchargement du contenu:

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

Vous devriez try/ catchautour du DownloadStringpour vérifier les erreurs; pas d'erreur? Ça existe...

Avec C # 2.0 (VS2005):

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

et

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

Voici une autre implémentation de cette solution:

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.dotnetought.net/2009/10/14/how-to-check-remote-file-exists-using-c/

Ces solutions sont plutôt bonnes, mais elles oublient qu'il peut y avoir d'autres codes d'état que 200 OK. C'est une solution que j'ai utilisée sur des environnements de production pour la surveillance de l'état et autres.

S'il y a une redirection d'url ou une autre condition sur la page cible, le retour sera vrai en utilisant cette méthode. De plus, GetResponse () lèvera une exception et vous n'obtiendrez donc pas de StatusCode pour cela. Vous devez intercepter l'exception et rechercher une ProtocolError.

Tout code d'état 400 ou 500 renverra faux. Tous les autres retournent vrai. Ce code est facilement modifié pour répondre à vos besoins de codes d'état spécifiques.

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

Si je comprends bien votre question, vous pouvez utiliser une petite méthode comme celle-ci pour vous donner les résultats de votre test d'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;

Vous pouvez envelopper le code ci-dessus dans une méthode et l'utiliser pour effectuer la validation. J'espère que cela répond à la question que vous posiez.

Essayez ceci (assurez-vous d'utiliser System.Net):

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

Lorsque la fonction checkWebsite () est appelée, elle essaie d'obtenir le code source de l'URL qui lui est passé. S'il obtient le code source, il renvoie true. Sinon, il renvoie false.

Exemple de code:

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

Voici une autre option

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

Cette solution semble facile à suivre:

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

J'ai un moyen plus simple de déterminer la météo qu'une URL est valide.

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

J'ai toujours trouvé que les exceptions sont beaucoup plus lentes à être traitées.

Peut-être qu'une manière moins intensive permettrait d'obtenir un meilleur résultat plus rapide?

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

Ensuite, utilisez simplement:

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

Les serveurs Web répondent avec un code d'état HTTP indiquant le résultat de la demande, par exemple 200 (parfois 202) signifie succès, 404 - non trouvé, etc. (voir ici ). En supposant que la partie adresse du serveur de l'URL est correcte et que vous n'obtenez pas de délai d'expiration de socket, l'exception vous indique très probablement que le code d'état HTTP était différent de 200. Je suggérerais de vérifier la classe de l'exception et de voir si l'exception porte le code d'état HTTP.

IIRC - L'appel en question lève une WebException ou un descendant. Vérifiez le nom de la classe pour voir lequel et encapsulez l'appel dans un bloc try pour intercepter la condition.

À la suite des exemples déjà donnés, je dirais, il est préférable d'envelopper également la réponse dans une utilisation comme celle-ci

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