IS String is valid URL OR NOT

Question

I'm using .net 2010 c# windows application with this code: to check Valid Uri or not

Code:

static bool IsValidUrl(string urlString)
{
    Uri uri;
    return Uri.TryCreate(urlString, UriKind.Absolute, out uri)
        && (uri.Scheme == Uri.UriSchemeHttp
         || uri.Scheme == Uri.UriSchemeHttps
         || uri.Scheme == Uri.UriSchemeFtp
         || uri.Scheme == Uri.UriSchemeMailto
         );
}

Problem: if i validate this http://http://www.Google.com i'm getting its valid but when i trying to use IE it not showing any site.

Is there any way to find out String is valid uri or not? (with out using regular expressions and internet access)

Answer 1

It's not an invalid URI or even a URI that won't ever work: You could use it in a browser somewhere where there was a local machine called "http" (or if you had your Hosts file set to call a machine that).

The problem is that the perfectly correct URI http://http://www.Google.com, which would normlly be used in the form http://http//www.Google.com, because we normlly don't include the : after the host unless we're including the port number, won't work because it fails to find a machine called "http".

Now, even if that would work sometimes, it of course wouldn't work all the time. So it's a different problem to that of the URI http://www.thisdoesnotexistbecauseijustmdeitup.com/.

If you need to also detect that case, then there really is no way other than connecting to the Internet.

If you need to detect URIs that will work globally, rather than just on particular LANs then:

static bool IsGloballyUsableWebMailorFtpUrl(string urlString)
{
  Uri uri;
  if(!Uri.TryCreate(urlString, UriKind.Absolute, out uri))
    return false;
  if(uri.Scheme != Uri.UriSchemeHttp
     && uri.Scheme != Uri.UriSchemeHttps
     && uri.Scheme != Uri.UriSchemeFtp
     && uri.Scheme != Uri.UriSchemeMailto)
     return false;
  string host = uri.Host;
  IPAddress ip;
  if(!IPAddress.TryParse(host, out ip))//if we don't have an IP address in the host part.
    return host.Contains('.') && !host.EndsWith(".local", StringComparison.OrdinalIgnoreCase); // Does the domain have at least one period
                                                   // And not the "local" binding used on many
                                                   // Private networks
  var octets = ip.GetAddressBytes();
  if(octets.Length == 4)
    switch(octets[0])//We've an IPv4 IP address, check it's not reserved.
    {
      case 0: case 10: case 127:
        return false;
      case 128: case 191:
        return octets[1] != 0;
      case 169:
        return octets[1] != 254;
      case 172:
        return octets[1] < 16 || octets[1] > 31;
      case 192:
        return octets[1] != 168 && (octets[1] != 0 || octets[2] != 0);
      case 223:
        return octets[1] != 255 && octets[2] != 255;
      default:
        return true;
    }
  else
    {  //We've an IPv6 IP address, check it's not reserved.
      if(IPAddress.HostToNetworkOrder(1) != 1)
        octets = octets.Reverse().ToArray();
      var ipInt = new BigInteger(octets);
      //Not the neatest approach, but serves
      if(ipInt < 0)
        return true;
      if(ipInt < 2)
        return false;
      if(ipInt < 281470681743360)
        return true;
      if(ipInt < 281474976710656)
        return false;
      if(ipInt < BigInteger.Parse("524413980667603649783483181312245760"))
        return true;
      if(ipInt < BigInteger.Parse("524413980667603649783483185607213056"))
        return false;
      if(ipInt < BigInteger.Parse("42540488161975842760550356425300246528"))
        return true;
      if(ipInt < BigInteger.Parse("42540488241204005274814694018844196864"))
        return false;
      if(ipInt < BigInteger.Parse("42540489429626442988779757922003451904"))
        return true;
      if(ipInt < BigInteger.Parse("42540490697277043217009159418706657280"))
        return false;
      if(ipInt < BigInteger.Parse("42540766411282592856903984951653826560"))
        return true;
      if(ipInt < BigInteger.Parse("42540766490510755371168322545197776896"))
        return false;
      if(ipInt < BigInteger.Parse("42545680458834377588178886921629466624"))
        return true;
      if(ipInt < BigInteger.Parse("42550872755692912415807417417958686720"))
        return false;
      if(ipInt < BigInteger.Parse("334965454937798799971759379190646833152"))
        return true;
      if(ipInt < BigInteger.Parse("337623910929368631717566993311207522304"))
        return false;
      if(ipInt < BigInteger.Parse("338288524927261089654018896841347694592"))
        return true;
      if(ipInt < BigInteger.Parse("338620831926207318622244848606417780736"))
        return false;
      if(ipInt < BigInteger.Parse("338953138925153547590470800371487866880"))
        return true;
      if(ipInt < BigInteger.Parse("340282366920938463463374607431768211456"))
        return false;
      return true;
    }
}

Edit: It's worth considering whether you should do this check at all, if it's for an application that will eventually connect to the URI in question, you're just going to annoy users by refusing to connect to machines on their lan.

Answer 2

The best way to know whether a given string represents a valid url, without actually testing it and by bearing in mind the comments above (something which might fit within the given schema, but is not what you consider right), is performing a custom analysis. Also, you should replace your bool function with a string (or an Uri) one able to correct certain situations (like the example you propose). Sample code:

private void Form1_Load(object sender, EventArgs e)
{
    string rightUrl = returnValidUrl("http://http://www.Google.com");
    if (rightUrl != "")
    {
        //It is OK
    }
}

static string returnValidUrl(string urlString)
{
    string outUrl = "";
    Uri curUri = IsValidUrl(urlString);
    if (curUri != null)
    {
        string headingBit = "http://";
        if (curUri.Scheme == Uri.UriSchemeHttps) headingBit = "https://";
        if (curUri.Scheme == Uri.UriSchemeFtp) headingBit = "ftp://";
        if (curUri.Scheme == Uri.UriSchemeMailto) headingBit = "mailto:";

        outUrl = headingBit + urlString.ToLower().Substring(urlString.ToLower().LastIndexOf(headingBit) + headingBit.Length);
    }

    return outUrl;
}

static Uri IsValidUrl(string urlString)
{
    Uri uri = null;
    bool isValid = Uri.TryCreate(urlString, UriKind.Absolute, out uri)
        && (uri.Scheme == Uri.UriSchemeHttp
         || uri.Scheme == Uri.UriSchemeHttps
         || uri.Scheme == Uri.UriSchemeFtp
         || uri.Scheme == Uri.UriSchemeMailto
         );

    if (!isValid) uri = null;

    return uri;
}

What can be called with:

string rightUrl = returnValidUrl("http://http://www.Google.com");
if (rightUrl != "")
{
    //It is OK
}

You would have to extend this method to recognise as valid/correct all the situations you need.

UPDATE

As suggested via comments and, in order to deliver the exact functionality the OP is looking for (a sample of it; as far as the proposed solution is just an example of the type of casuistic approach, which this problem requires), here you have a corrected bool function considering the posted example wrong:

static bool IsValidUrl2(string urlString)
{
    Uri uri;
    return Uri.TryCreate(urlString, UriKind.Absolute, out uri)
        && ((uri.Scheme == Uri.UriSchemeHttp && numberOfBits(urlString.ToLower(), "http://") == 1)
         || (uri.Scheme == Uri.UriSchemeHttps && numberOfBits(urlString.ToLower(), "https://") == 1)
         || (uri.Scheme == Uri.UriSchemeFtp && numberOfBits(urlString.ToLower(), "ftp://") == 1)
         || (uri.Scheme == Uri.UriSchemeMailto && numberOfBits(urlString.ToLower(), "mailto:") == 1)
         );
}

static int numberOfBits(string inputString, string bitToCheck)
{
    return inputString.ToLower().Split(new string[] { bitToCheck.ToLower() }, StringSplitOptions.None).Length - 1;
}

CLARIFICATION

The only way to be completely sure that a given url is valid or not is actually testing it; but the OP said no connections what I understood as pure string analysis: exactly what this answer is about. In any case, as explained via comments, the intention of this post is just showing the way through: .NET + custom algorithm (by understanding that aiming overall-applicability by relying on string analysis is pretty difficult); my proposal accounts for the specific problem explained by the OP (duplicated "heading parts") and by relying on his conditions. It cannot be understood as a generally-applicable, blindly-usable approach at all; but as a general framework with a sample functionality (a mere proof of concept).

CLARIFICATION 2

As shown in the conversation with Jon Hanna in the comments below, there is a third alternative I wasn't aware of: analysing the to-be IP address (i.e., numbers already put together, but IP address availability not checked yet and thus definitive IP address generation not started); by looking at it, it would also be possible to determine the likelihood of a given string to be a valid URL address (under the expected conditions). In any case, this cannot be considered as a 100% reliable process either, as far as the IP address being analysed is not the definitive one. In any case, Jon Hanna is in a much better position than myself to talk about the limitations of this alternative.

Answer 3

You could write a custom function to check if http:// or initial part is repeated alongwith this code you have written.