Validation de l'adresse IP
Je suis refactoring mon code et je voulais utiliser le IPAddress.TryParse
méthode pour valider si une chaîne est valide adresse IPv4 au lieu d'utiliser des expressions régulières:
public static bool IsIPv4(string value)
{
IPAddress address;
if (IPAddress.TryParse(value, out address))
{
if (address.AddressFamily == AddressFamily.InterNetwork)
{
return true;
}
}
return false;
}
Mon unité de test est maintenant à défaut parce que ces valeurs d'entrée de retour true
et obtenir analysée à la suite de IPAddress
objets:
value = "0.0.0.0" -> address = {0.0.0.0}
value = "255.255.255" -> address = {255.255.0.255}
value = "65536" -> address = {0.1.0.0}
Cela fait-il sens? Je vois que 0.0.0.0
est techniquement valide l'adresse IPv4, même si elle n'a pas de sens pour l'utilisateur de saisir que. Concernant les deux autres? Pourquoi sont-ils convertis dans la façon dont ils sont et dois-je les traiter comme valide, même si il pourrait ne pas être transparent pour l'utilisateur, qui peut-être juste oublié de saisir les périodes (65536
au lieu de 6.5.5.36
).
Toute aide est le plus apprécié.
http://65536
.OriginalL'auteur Martin Buberl | 2011-02-23
Vous devez vous connecter pour publier un commentaire.
Il ressemble à la documentation pour
IPAddress.Parse
rationaliser ce problème en soulignant que l'entrée dans moins de pièces est pratique pour entrer en classe A et B les adresses. Si vous voulez forcer un quatre-partie de l'adresse, vous pourriez vouloir vérifier qu'il y a trois périodes dans l'adresse avant de nourrirIPAddress.TryParse
, je suppose.Un peu de code pour votre référence:
OriginalL'auteur
Le travail de IPAddress.TryParse() n'est pas de vérifier si la chaîne est une adresse IP valide, mais si oui ou non le contenu de la chaîne peut être analysé (c'est à dire; converti) à une adresse IP valide.
Toutes les options dans vos cas de test peut en effet être analysée afin de représenter et de la propriété intellectuelle. Ce que c'est que votre cas de test sont valides. Le problème est que les données de vos cas de test ne sont pas valides, ou vous n'êtes pas à l'aide de l'outil approprié(s) dans votre cas de test pour obtenir le résultat escompté.
Si vous êtes à tester la validité de l'IPv4, avec exactement 4 quads (chacun étant un nombre entier compris entre 0 et 255), et que vous voulez éviter les regex votre pourrait diviser ensuite d'analyser et de valider.
Au lieu de "quad", l'article de Wikipedia pour IPv4 utilise le terme "octet."
OriginalL'auteur
Si vous voulez être très strict sur votre entrée, vous pouvez comparer le
ToString()
version de l'analyseIPAddress
, et de refuser l'entrée si elles sont différentes.Le tous-adresse zéro, et autres telles choses, devront être traités comme des cas particuliers.
ToString()
peut donner un résultat différent de la représentation originale. Par exemple, un octet qui commence avec un ou plusieurs0
s'est traité comme un nombre octal. Pour illustrer, par un exemple levée à partir de la IPv4 l'article sur Wikipédia,ToString()
convertit0300.0000.0002.0353
à son équivalent décimal192.0.2.235
. Ainsi, certains peuvent trouver que l'utilisation deToString()
offre certains avantages par rapport à la simple vérification de quatre octets.OriginalL'auteur
Je suggère:
C'est exactement ce qu'il demandait, comon lire la question au moins
Non, il n'est pas... du tout.
OriginalL'auteur
D'autres réponses, soit autoriser le protocole IPv6 ou permettre l'entrée comme "1.-0.1.1".
OriginalL'auteur
Le nombre de parties (chaque partie est séparée par un point) dans ipString détermine la manière dont l'adresse IP est construit. Une partie de l'adresse est stockée directement dans le réseau de l'adresse. Une deuxième partie de l'adresse, pratique pour la spécification d'une classe d'Une adresse, met de la partie de tête dans le premier octet et la fin de la partie la plus à droite de trois octets de l'adresse réseau. Les trois partie de l'adresse, pratique pour la spécification d'une adresse de classe B, pose la première partie du premier octet, la deuxième partie du deuxième octet, et la partie finale dans la plus à droite des deux octets de l'adresse réseau. Par exemple:
Nombre de pièces et l'exemple ipString
Une adresse IPv4 pour IPAddress
1 -- "65536"
0.0.255.255
2 -- "20.2"
20.0.0.2
2 -- "20.65535"
20.0.255.255
3 -- "128.1.2"
128.1.0.2
Vous pouvez consulter la documentation MSDN
http://msdn.microsoft.com/en-us/library/system.net.ipaddress.parse.aspx
Votre meilleur pari sera IPAddress.ToString() ou des expressions régulières.
IPAddress.TryParse
est plus élégant, mais en réalité, il semble de plus en plus à confusion 😉Il y a une faute de frappe dans la documentation MSDN.
65536
analyse de0.1.0.0
.65535
à0.0.255.255
OriginalL'auteur
Oui, ceux sont des adresses valides. Voir http://en.wikipedia.org/wiki/IPv4#Address_representations pour plus d'informations.
value = "255.255.255" -> address = {255.255.0.255}
Précisément pourquoi le 3ème octet à zéro au lieu d'être le premier ou le dernier?OriginalL'auteur
Bien que cette question a été répondu comme il y a deux ans, je pense qu'il est pertinent de produire jusqu'à ce que je pensais quand je cherchais la même chose aujourd'hui, et après avoir trouvé cette page décidé que j'étais trop paresseux pour aller à travers toutes la validation progmatically.
Si l'information est d'être accepté par un
Form
et unTextBox
, il serait dans votre meilleur intérêt à utiliser uneMaskedTextBox
à la place. Vous pouvez forcer l'utilisateur à mettre à l'information dans le format d'Adresse IP au lieu d'avoir à faire la conjecture de vous-même.Le masque à être utilisés pour cette validation est
990.990.990.990
qui ditOptionalNumber, OptionalNumber, MandatoryNumber
parce que1.1.1.1
,10.10.10.10
, et123.123.123.123
sont tous Adresse IP valide formats. Les masques sont du même format que Microsoft utilise dans l'Accès.IPAddress.TryParse
est se comporter de la même manière.Mais ne pas le masque que vous avocat accepter
321.321.321.321
? Ce serait problématique car aucun octet de l'adresse IPv4 peut dépasser la valeur décimale 255.OriginalL'auteur
Il est logique, comme 65536 est égal à 0x00010000, ou 0.1.0.0. Je devine TryParse aussi d'accepter des nombres hexadécimaux. En tout cas, je ne pense pas que vous voulez accepter une telle valeur à partir d'un utilisateur normal, mais je suppose que cela dépend de l'utilisateur final.
OriginalL'auteur
Le code ci-dessous est à l'aide de regex, suggéré par Roshe
OriginalL'auteur