C # Wie kann ich überprüfen, ob eine URL vorhanden / gültig ist?

Ich mache ein einfaches Programm in Visual C # 2005, das ein Aktiensymbol auf Yahoo! Finanzen, lädt die historischen Daten herunter und zeichnet dann den Preisverlauf für das angegebene Tickersymbol.

Ich kenne die genaue URL, die ich zum Erfassen der Daten benötige, und wenn der Benutzer ein vorhandenes Tickersymbol (oder mindestens eines mit Daten auf Yahoo! Finance) eingibt, funktioniert dies einwandfrei. Ich habe jedoch einen Laufzeitfehler, wenn der Benutzer ein Tickersymbol erstellt, da das Programm versucht, Daten von einer nicht vorhandenen Webseite abzurufen.

Ich verwende die WebClient-Klasse und die DownloadString-Funktion. Ich habe alle anderen Mitgliedsfunktionen der WebClient-Klasse durchgesehen, aber nichts gefunden, mit dem ich eine URL testen könnte.

Wie kann ich das machen?

Sie könnten eher eine "HEAD" -Anforderung als eine "GET" -Anforderung ausgeben ?

(bearbeiten) - lol! Sieht so aus, als hätte ich das schon mal gemacht ! wurde in das Wiki geändert, um Vorwürfe der Wiederholung zu vermeiden. So testen Sie eine URL ohne die Kosten für das Herunterladen des Inhalts:

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

Sie würden try/ catchum die DownloadStringauf Fehler prüfen; kein Fehler? Es existiert...

Mit C # 2.0 (VS2005):

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

und

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

Hier ist eine weitere Implementierung dieser Lösung:

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

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

Diese Lösungen sind ziemlich gut, aber sie vergessen, dass es möglicherweise andere Statuscodes als 200 OK gibt. Dies ist eine Lösung, die ich in Produktionsumgebungen zur Statusüberwachung und dergleichen verwendet habe.

Wenn auf der Zielseite eine URL-Umleitung oder eine andere Bedingung vorliegt, ist die Rückgabe mit dieser Methode wahr. Außerdem löst GetResponse () eine Ausnahme aus und daher erhalten Sie keinen StatusCode dafür. Sie müssen die Ausnahme abfangen und nach einem ProtocolError suchen.

Jeder 400- oder 500-Statuscode gibt false zurück. Alle anderen kehren wahr zurück. Dieser Code kann leicht an Ihre Anforderungen für bestimmte Statuscodes angepasst werden.

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

Wenn ich Ihre Frage richtig verstehe, können Sie eine kleine Methode wie diese verwenden, um die Ergebnisse Ihres URL-Tests zu erhalten:

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;

Sie können den obigen Code in eine Methode einbinden und damit eine Validierung durchführen. Ich hoffe, dies beantwortet die Frage, die Sie gestellt haben.

Versuchen Sie Folgendes (stellen Sie sicher, dass Sie System.Net verwenden):

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

Wenn die Funktion checkWebsite () aufgerufen wird, wird versucht, den Quellcode der übergebenen URL abzurufen. Wenn der Quellcode abgerufen wird, wird true zurückgegeben. Wenn nicht, wird false zurückgegeben.

Codebeispiel:

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

Hier ist eine weitere 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;
}

Diese Lösung scheint leicht zu folgen:

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

Ich habe eine einfachere Möglichkeit, das Wetter zu bestimmen, für das eine URL gültig ist.

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

Ich habe immer festgestellt, dass Ausnahmen viel langsamer behandelt werden.

Vielleicht würde ein weniger intensiver Weg zu einem besseren, schnelleren Ergebnis führen?

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

Dann benutze einfach:

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

Webserver antworten mit einem HTTP-Statuscode, der das Ergebnis der Anforderung angibt, z. B. 200 (manchmal 202) bedeutet Erfolg, 404 - nicht gefunden usw. (siehe hier ). Angenommen, der Teil der Serveradresse in der URL ist korrekt und Sie erhalten kein Socket-Timeout. Die Ausnahme teilt Ihnen höchstwahrscheinlich mit, dass der HTTP-Statuscode nicht 200 war. Ich würde empfehlen, die Klasse der Ausnahme zu überprüfen und festzustellen, ob die Ausnahme vorliegt den HTTP-Statuscode.

IIRC - Der betreffende Aufruf löst eine WebException oder einen Nachkommen aus. Überprüfen Sie den Klassennamen, um festzustellen, welcher, und schließen Sie den Aufruf in einen try-Block ein, um die Bedingung abzufangen.

In Anlehnung an die bereits gegebenen Beispiele würde ich sagen, dass es empfehlenswert ist, die Antwort auch in eine Verwendung wie diese zu verpacken

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