Obtenir uniquement le nom de domaine à partir d'une URL?
J'essaie d'extraire uniquement le nom de domaine d'une chaîne URL. Je l'ai presque ... J'utilise l'URI
J'ai une chaîne .. ma première pensée a été d'utiliser Regex mais j'ai décidé d'utiliser la classe URI
J'ai besoin de convertir ce qui précède en google.com et google sans le www
J'ai fait ce qui suit
Uri test = new Uri(referrer);
log.Info("Domain part : " + test.Host);
Fondamentalement, cela renvoie www.google.com .... je voudrais essayer de renvoyer 2 formulaires si possible ... comme mentionné ...
google.com et google
Est-ce possible avec l'URI?
Oui, il est possible d'utiliser:
Uri.GetLeftPart( UriPartial.Authority )
@Dewfy: le défaut est que votre méthode retourne "uk" pour "www.test.co.uk" mais le domaine ici est clairement "test.co.uk".
@naivists: le défaut est que votre méthode renvoie "beta.Microsoft.com" pour "www.beta.Microsoft.com" mais le domaine ici est clairement "Microsoft.com"
J'avais besoin de la même chose, j'ai donc écrit un cours que vous pouvez copier et coller dans votre solution. Il utilise un tableau de chaînes codées en dur de tld. http://Pastebin.com/raw.php?i=VY3DCNhp
Console.WriteLine(GetDomain.GetDomainFromUrl("http://www.beta.Microsoft.com/path/page.htm"));
les sorties Microsoft.com
et
Console.WriteLine(GetDomain.GetDomainFromUrl("http://www.beta.Microsoft.co.uk/path/page.htm"));
les sorties Microsoft.co.uk
google.com n'est pas garanti d'être le même que www.google.com (enfin, pour cet exemple c'est techniquement, mais peut être autrement).
peut-être que ce dont vous avez besoin est de supprimer le domaine "de premier niveau" et la sous-base "www"? Alors juste split('.') et prenez la partie avant la dernière partie!
J'ai essayé à peu près toutes les approches, mais toutes n'ont pas atteint le résultat souhaité. Voici donc mon approche ajustée de servermanfail.
Le fichier tld est disponible sur https://publicsuffix.org/list/ J'ai pris le fichier sur https://publicsuffix.org/list/effective_tld_names.dat parse et recherchez les tld. Si de nouveaux tld sont publiés, téléchargez simplement le dernier fichier.
s'amuser.
using System;
using System.Collections.Generic;
using System.IO;
namespace SearchWebsite
{
internal class NetDomain
{
static public string GetDomainFromUrl(string Url)
{
return GetDomainFromUrl(new Uri(Url));
}
static public string GetDomainFromUrl(string Url, bool Strict)
{
return GetDomainFromUrl(new Uri(Url), Strict);
}
static public string GetDomainFromUrl(Uri Url)
{
return GetDomainFromUrl(Url, false);
}
static public string GetDomainFromUrl(Uri Url, bool Strict)
{
initializeTLD();
if (Url == null) return null;
var dotBits = Url.Host.Split('.');
if (dotBits.Length == 1) return Url.Host; //eg http://localhost/blah.php = "localhost"
if (dotBits.Length == 2) return Url.Host; //eg http://blah.co/blah.php = "localhost"
string bestMatch = "";
foreach (var tld in DOMAINS)
{
if (Url.Host.EndsWith(tld, StringComparison.InvariantCultureIgnoreCase))
{
if (tld.Length > bestMatch.Length) bestMatch = tld;
}
}
if (string.IsNullOrEmpty(bestMatch))
return Url.Host; //eg http://domain.com/blah = "domain.com"
//add the domain name onto tld
string[] bestBits = bestMatch.Split('.');
string[] inputBits = Url.Host.Split('.');
int getLastBits = bestBits.Length + 1;
bestMatch = "";
for (int c = inputBits.Length - getLastBits; c < inputBits.Length; c++)
{
if (bestMatch.Length > 0) bestMatch += ".";
bestMatch += inputBits[c];
}
return bestMatch;
}
static private void initializeTLD()
{
if (DOMAINS.Count > 0) return;
string line;
StreamReader reader = File.OpenText("effective_tld_names.dat");
while ((line = reader.ReadLine()) != null)
{
if (!string.IsNullOrEmpty(line) && !line.StartsWith("//"))
{
DOMAINS.Add(line);
}
}
reader.Close();
}
// This file was taken from https://publicsuffix.org/list/effective_tld_names.dat
static public List<String> DOMAINS = new List<String>();
}
}
Vous trouverez ci-dessous un code qui donnera uniquement l'extension SLD plus gTLD ou ccTLD (notez l'exception ci-dessous). Je me fiche du DNS.
La théorie est la suivante:
- Tout ce qui est inférieur à 3 jetons reste tel quel, par exemple "localhost", "domain.com", sinon: le dernier jeton doit être une extension gTLD ou ccTLD.
- L'avant-dernier jeton est considéré comme faisant partie de l'extension si sa longueur est <3 OR s'il est inclus dans une liste d'exceptions.
- Enfin le jeton avant celui-là est considéré comme le SLD. Tout ce qui précède est considéré comme un sous-domaine ou un qualificatif d'hôte, par exemple Www.
Quant au code, court et doux:
private static string GetDomainName(string url)
{
string domain = new Uri(url).DnsSafeHost.ToLower();
var tokens = domain.Split('.');
if (tokens.Length > 2)
{
//Add only second level exceptions to the < 3 rule here
string[] exceptions = { "info", "firm", "name", "com", "biz", "gen", "ltd", "web", "net", "pro", "org" };
var validTokens = 2 + ((tokens[tokens.Length - 2].Length < 3 || exceptions.Contains(tokens[tokens.Length - 2])) ? 1 : 0);
domain = string.Join(".", tokens, tokens.Length - validTokens, validTokens);
}
return domain;
}
L'exception évidente est que cela ne traitera pas des noms de domaine à 2 lettres. Donc, si vous avez la chance de posséder ab.com, vous devrez légèrement adapter le code. Pour nous, simples mortels, ce code couvrira à peu près tous les gTLD et ccTLD, à l'exception de quelques-uns très exotiques.
Voir le blog de Rick Strahl récemment comme référence pour certains c # et .net centric:
Je pense que vous affichez une mauvaise compréhension de ce qui constitue un "nom de domaine" - il n'y a pas de "nom de domaine pur" dans l'usage courant - c'est quelque chose que vous devrez définir si vous voulez des résultats cohérents.
Voulez-vous simplement supprimer la partie "www"? Et puis avoir une autre version qui supprime le domaine de premier niveau (par exemple, supprimer les parties ".com" ou ".co.uk", etc.)? Une autre réponse mentionne le fractionnement (".") - vous devrez utiliser quelque chose comme ceci si vous souhaitez exclure manuellement des parties spécifiques du nom d'hôte, il n'y a rien dans le framework .NET pour répondre exactement à vos besoins - vous devrez implémenter ces choses vous-même.
Je suis venu avec la solution ci-dessous (en utilisant Linq):
public string MainDomainFromHost(string Host)
{
string[] parts = Host.Split('.');
if (parts.Length <= 2)
return Host; // Host is probably already a main domain
if (parts[parts.Length - 1].All(char.IsNumber))
return Host; // Host is probably an IPV4 address
if (parts[parts.Length - 1].Length == 2 && parts[parts.Length - 2].Length == 2)
return string.Join(".", parts.TakeLast(3)); // this is the case for co.uk, co.in, etc...
return string.Join(".", parts.TakeLast(2)); // all others, take only the last 2
}
L'hôte d'Uri renvoie toujours le domaine (www.google.com), y compris une étiquette (www) et un domaine de premier niveau (com). Mais souvent, vous voudrez extraire le bit du milieu. Je fais simplement
Uri uri;
bool result = Uri.TryCreate(returnUri, UriKind.Absolute, out uri);
if (result == false)
return false;
//if you are sure it's not "localhost"
string domainParts = uri.Host.Split('.');
string topLevel = domainParts[domainParts.Length - 1]
string hostBody = domainParts[domainParts.Length - 2]
string label = domainParts[domainParts.Length - 3]
Mais vous devez vérifier domainParts.length, car souvent l'URI donné est comme "google.com".
Oui, j'ai publié la solution ici: http://Pastebin.com/raw.php?i=raxNQkCF
Si vous souhaitez supprimer l'extension, ajoutez simplement
if (url.indexof(".")>-1) {url = url.substring(0, url.indexof("."))}
Utilisez Nager.PublicSuffix
package d'installation Nager.PublicSuffix
var domainParser = new DomainParser(new WebTldRuleProvider());
var domainName = domainParser.Get("sub.test.co.uk");
//domainName.Domain = "test";
//domainName.Hostname = "sub.test.co.uk";
//domainName.RegistrableDomain = "test.co.uk";
//domainName.SubDomain = "sub";
//domainName.TLD = "co.uk";