C # ¿Cómo puedo verificar si una URL existe / es válida?

Estoy creando un programa simple en visual c # 2005 que busca un símbolo bursátil en Yahoo! Finance, descarga los datos históricos y luego traza el historial de precios para el símbolo de cotización especificado.

Sé la URL exacta que necesito para adquirir los datos, y si el usuario ingresa un símbolo de cotización existente (o al menos uno con datos en Yahoo! Finance), funciona perfectamente bien. Sin embargo, tengo un error en tiempo de ejecución si el usuario crea un símbolo de cotización, ya que el programa intenta extraer datos de una página web que no existe.

Estoy usando la clase WebClient y la función DownloadString. Revisé todas las demás funciones miembro de la clase WebClient, pero no vi nada que pudiera usar para probar una URL.

¿Cómo puedo hacer esto?

¿Podría emitir una solicitud "HEAD" en lugar de "GET"?

(editar) - ¡lol! ¡Parece que he hecho esto antes ! cambiado a wiki para evitar acusaciones de repetición. Entonces, para probar una URL sin el costo de descargar el contenido:

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

Debería try/ catchalrededor del DownloadStringpara comprobar si hay errores; ¿No hay error? Existe...

Con C # 2.0 (VS2005):

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

y

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

Aquí hay otra implementación de esta solución:

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

Estas soluciones son bastante buenas, pero olvidan que puede haber otros códigos de estado además de 200 OK. Esta es una solución que he usado en entornos de producción para monitorear el estado y demás.

Si hay una redirección de URL o alguna otra condición en la página de destino, la devolución será verdadera usando este método. Además, GetResponse () lanzará una excepción y, por lo tanto, no obtendrá un StatusCode para ella. Debe capturar la excepción y verificar un ProtocolError.

Cualquier código de estado 400 o 500 devolverá falso. Todos los demás vuelven verdaderos. Este código se modifica fácilmente para adaptarse a sus necesidades de códigos de estado 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;
}

Si entiendo tu pregunta correctamente, puedes usar un pequeño método como este para darte los resultados de tu prueba 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;

Puede envolver el código anterior en un método y usarlo para realizar la validación. Espero que esto responda a la pregunta que estaba haciendo.

Pruebe esto (asegúrese 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;
   }
}

Cuando se llama a la función checkWebsite (), intenta obtener el código fuente de la URL que se le pasa. Si obtiene el código fuente, devuelve verdadero. Si no, devuelve falso.

Ejemplo 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 hay otra opcion

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

Tengo una forma más sencilla de determinar si una URL es válida.

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

Siempre he encontrado que las excepciones son mucho más lentas de manejar.

¿Quizás una forma menos intensiva produciría un resultado mejor y más 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;
        }
    }
}

Entonces solo usa:

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

Los servidores web responden con un código de estado HTTP que indica el resultado de la solicitud, por ejemplo, 200 (a veces 202) significa éxito, 404 - no encontrado, etc. (ver aquí ). Suponiendo que la parte de la dirección del servidor de la URL es correcta y no está obteniendo un tiempo de espera de socket, lo más probable es que la excepción le indique que el código de estado HTTP era distinto de 200. Sugeriría verificar la clase de la excepción y ver si la excepción se lleva el código de estado HTTP.

IIRC: la llamada en cuestión genera una WebException o un descendiente. Verifique el nombre de la clase para ver cuál y envuelva la llamada en un bloque try para capturar la condición.

Siguiendo los ejemplos ya dados, diría que es una buena práctica envolver también la respuesta en un 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;
        }
   }