it-swarm.com.de

Wie kann ich überprüfen, ob eine URL existiert/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 die Preisentwicklung für das angegebene Tickersymbol auf.

Ich kenne die genaue URL, die ich zur Erfassung der Daten benötige, und wenn der Benutzer ein vorhandenes Tickersymbol (oder mindestens eines mit Daten in Yahoo! Finance) eingibt, funktioniert es 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 Memberfunktionen der WebClient-Klasse durchgesehen, konnte jedoch keine URLs testen.

Wie kann ich das machen?

103
Daniel Waltrip

Sie könnten eine "HEAD" Anfrage statt eines "GET" ausgeben?

(bearbeiten) - lol! Sieht aus, als hätte ich das schon mal gemacht !; in 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/catch um die DownloadString herum suchen, um nach Fehlern zu suchen; 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
}
101
Marc Gravell

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.dotnetthoughts.net/2009/10/14/wie-nach-check-remote-file-exists-using-c/

123
BigJoe714

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

Wenn auf der Zielseite eine URL-Weiterleitung oder eine andere Bedingung vorliegt, wird die Rückgabe mit dieser Methode erfüllt. Außerdem gibt GetResponse () eine Ausnahme aus, und Sie erhalten daher keinen Statuscode. Sie müssen die Ausnahme abfangen und nach einem ProtocolError suchen.

Jeder 400- oder 500-Statuscode gibt "false" zurück. Alle anderen kehren zurück. Dieser Code kann leicht an Ihre Statusanforderungen 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;
}
31
jsmith

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

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 einschließen und zur Validierung verwenden. Ich hoffe, das beantwortet die Frage, die Sie gestellt haben.

8

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, versucht sie, den Quellcode der URL, die an sie übergeben wird, abzurufen. Wenn der Quellcode abgerufen wird, wird true zurückgegeben. Wenn nicht, gibt er falsch zurück.

Code-Beispiel:

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

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;
}
2
Zain Ali

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 ;
}
2
abobjects.com

ich habe eine einfachere Methode, um festzustellen, ob eine URL gültig ist.

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

Webserver antworten mit einem HTTP-Statuscode, der das Ergebnis der Anforderung angibt, z. 200 (manchmal 202) bedeutet Erfolg, 404 - nicht gefunden usw. (siehe hier ). Angenommen, der Teil der URL der Serveradresse ist korrekt und Sie erhalten kein Socket-Timeout. Die Ausnahme wird höchstwahrscheinlich Ihnen mitteilt, dass der HTTP-Statuscode nicht 200 lautet der HTTP-Statuscode.

IIRC - Der fragliche Aufruf löst eine WebException oder einen Nachkommen aus. Überprüfen Sie den Klassennamen, um zu sehen, welcher Name, und binden Sie den Aufruf in einen try-Block ein, um die Bedingung abzufangen.

0
David Taylor

Nach den bereits genannten Beispielen würde ich sagen, dass es die beste Praxis ist, die Antwort auch in einer solchen Verwendung zu verwenden

    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;
        }
   }
0
user3154431
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");`
}
0
Praveen Dasare

Ich habe immer festgestellt, dass Ausnahmen viel langsamer gehandhabt werden müssen.

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"));
0
Rusty Nail