Проверка данных в Epplus -Email address [duplicate]
Чтобы предотвратить копирование самой папки, т. е. создание
c:\temp\targetdirectory\sourcedirectory
указывает файлы ( обычно с помощью подстановочного знака ) вместо папки в качестве источника:
Copy-item c:\temp\sourcedirectory\*.txt -destination c:\temp\targetdirectory -recurse
29
задан Zack Peterson 25 August 2009 в 22:58
поделиться
10 ответов
Не утруждайте себя собственной проверкой. .NET 4.0 значительно улучшил проверку с помощью класса MailAddress . Просто используйте MailAddress address = new MailAddress(input), и если он выбрасывает, это недействительно. Если есть какая-либо возможная интерпретация вашего ввода в качестве спецификации адреса электронной почты, совместимой с RFC 2822, она будет анализировать ее как таковую. Режимы выше, даже в первой статье MSDN, ошибочны, потому что они не учитывают отображаемое имя, цитированную локальную часть, значение литерального домена для домена, исправляют спецификации точки-атома для локальной части, возможность того, что адрес электронной почты может быть в угловых скобках, нескольких значениях кавычек для отображаемого имени, экранированных символов, unicode в отображаемом имени, комментариях и максимальной допустимой длине адресной почты. Я потратил три недели на повторную запись парсера почтовых адресов в .NET 4.0 для System.Net.Mail и доверяю мне, это было намного сложнее, чем просто придумать какое-то регулярное выражение, так как есть много крайних случаев. Класс MailAddress в .NET 4.0 beta 2 будет иметь эту улучшенную функциональность.
Еще одна вещь, которую вы можете проверить, - это формат почтового адреса. Вы никогда не сможете подтвердить, что адрес электронной почты действительно действителен для получения электронной почты, не отправляя электронное письмо на этот адрес и не проверяя, принимает ли сервер его на доставку. Это невозможно, и хотя есть SMTP-команды, которые вы можете дать почтовому серверу, чтобы попытаться его проверить, во много раз они будут отключены или будут возвращать неверные результаты, поскольку это обычный способ для спамеров найти адреса электронной почты.
57
ответ дан Dan Herbert 26 August 2018 в 00:46
поделиться
-
1Спасибо, что ответили. Я рад слышать, что это привлекло внимание Microsoft! Но, просто для уточнения, вы говорите, что наилучшая практика есть , чтобы поймать исключение, как это было сделано в вышеприведенной функции? – Zack Peterson 27 August 2009 в 15:43
-
2Я хотел бы добавить, что, как правило, неправильная практика заключается в том, чтобы поймать исключение как способ проверки данных. В основном причина заключается в производительности, особенно при выполнении такой проверки на больших наборах данных, но, как правило, она считается плохой практикой. Для таких простых адресов, как адреса электронной почты, я бы предпочел использовать RegEx. – jpierson 11 March 2011 в 23:22
-
3Однако это, по-видимому, позволяет просто «part1 @ part2». не требуя домена верхнего уровня ".com" или еще что-то. – Jeff Handley 1 April 2011 в 07:08
-
4Я долгое время писал это, но он не должен позволять part2 просто быть случайным словом, он может быть либо точечным атомом, либо литералом домена, а литералы домена могут быть просто «part2». но должны быть заключены в "[& quot; и "]" чтобы быть действительным. Точечный атом должен иметь "." в нем и предшествует и сопровождается одним законным символом точки-атома. Спецификация здесь: tools.ietf.org/html/rfc2822#page-17 Кроме того, возможно, что он интерпретирует литерал домена без скобок как литерал домена и добавит скобки для вас. Не помните наверняка, но звучит как-то, что я сделал бы. – Jeff Tucker 11 April 2011 в 23:53
-
5Я также могу ввести myname@mail*.com, и он принимает его, поэтому это не работает :( – MojoDK 7 May 2013 в 14:45
В этом случае я протестировал одобренный «ответ» и, похоже, не соответствует спецификациям того, что на самом деле является действительным адресом электронной почты. После многих головных болей я нашел это регулярное выражение, которое делает гораздо лучшую работу, чем Microsoft.
"(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]" +
")+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:" +
"\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(" +
"?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ " +
"\t]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\0" +
"31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\" +
"](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+" +
"(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:" +
"(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z" +
"|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)" +
"?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\" +
"r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[" +
" \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)" +
"?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]" +
")*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[" +
" \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*" +
")(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]" +
")+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)" +
"*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+" +
"|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r" +
"\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:" +
"\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t" +
"]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031" +
"]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](" +
"?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?" +
":(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?" +
":\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?" +
":(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?" +
"[ \t]))*""(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\"".\[\] " +
"\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|" +
"\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>" +
"@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""" +
"(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]" +
")*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\" +
""".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?" +
":[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[" +
"\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\"".\[\] \000-" +
"\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(" +
"?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;" +
":\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([" +
"^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\""" +
".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\" +
"]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\" +
"[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\" +
"r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] " +
"\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]" +
"|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\"".\[\] \0" +
"00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\" +
".|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@," +
";:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|""(?" +
":[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*" +
"(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\""." +
"\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[" +
"^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\]" +
"]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(" +
"?:(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\" +
""".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(" +
"?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[" +
"\[""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t" +
"])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t" +
"])+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?" +
":\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|" +
"\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:" +
"[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\"".\[\" +
"]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)" +
"?[ \t])*(?:@(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""" +
"()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)" +
"?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>" +
"@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[" +
" \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@," +
";:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]" +
")*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\" +
""".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?" +
"(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[""()<>@,;:\\""." +
"\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:" +
"\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[" +
"""()<>@,;:\\"".\[\]]))|""(?:[^\""\r\\]|\\.|(?:(?:\r\n)?[ \t]))*""(?:(?:\r\n)?[ \t])" +
"*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])" +
"+|\Z|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\" +
".(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z" +
"|(?=[\[""()<>@,;:\\"".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(" +
"?:\r\n)?[ \t])*))*)?;\s*)"
Я уже отформатировал его как строку vb с помощью простого приложения. Слишком плохое переполнение стека больше интересует «репозиторий кодирования», чем полный ответ на проблему.
1
ответ дан codemonkeyliketab 26 August 2018 в 00:46
поделиться
-
1Мне жаль бедного разработчика, который должен устранить этот бегемот. – Justin Pavatte 10 May 2016 в 20:45
Public Shared Function ValidEmailAddress(ByVal emailAddress As String, ByRef errorMessage As String) As Boolean
If emailAddress.Length = 0 Then
errorMessage = "E-mail address is required."
Return False
End If
If emailAddress.IndexOf("@") > -1 Then
If (emailAddress.IndexOf(".", emailAddress.IndexOf("@")) > emailAddress.IndexOf("@")) AndAlso emailAddress.Split(".").Length > 0 AndAlso emailAddress.Split(".")(1) <> "" Then
errorMessage = ""
Return True
End If
End If
errorMessage = "E-mail address must be valid e-mail address format."
Return False
End Function
-1
ответ дан drneel 26 August 2018 в 00:46
поделиться
-
1Существует гораздо больше для проверки подлинности электронной почты ... – Paul Ishak 28 December 2016 в 05:25
'-----------------------------------------------------------------------
'Creater : Rachitha Madusanka
'http://www.megazoon.com
'jewandara@gmail.com
'jewandara@hotmail.com
'Web Designer and Software Developer
'@ http://www.zionx.net16.net
'-----------------------------------------------------------------------
Function ValidEmail(ByVal strCheck As String) As Boolean
Try
Dim bCK As Boolean
Dim strDomainType As String
Const sInvalidChars As String = "!#$%^&*()=+{}[]|\;:'/?>,< "
Dim i As Integer
'Check to see if there is a double quote
bCK = Not InStr(1, strCheck, Chr(34)) > 0
If Not bCK Then GoTo ExitFunction
'Check to see if there are consecutive dots
bCK = Not InStr(1, strCheck, "..") > 0
If Not bCK Then GoTo ExitFunction
' Check for invalid characters.
If Len(strCheck) > Len(sInvalidChars) Then
For i = 1 To Len(sInvalidChars)
If InStr(strCheck, Mid(sInvalidChars, i, 1)) > 0 Then
bCK = False
GoTo ExitFunction
End If
Next
Else
For i = 1 To Len(strCheck)
If InStr(sInvalidChars, Mid(strCheck, i, 1)) > 0 Then
bCK = False
GoTo ExitFunction
End If
Next
End If
If InStr(1, strCheck, "@") > 1 Then 'Check for an @ symbol
bCK = Len(Left(strCheck, InStr(1, strCheck, "@") - 1)) > 0
Else
bCK = False
End If
If Not bCK Then GoTo ExitFunction
strCheck = Right(strCheck, Len(strCheck) - InStr(1, strCheck, "@"))
bCK = Not InStr(1, strCheck, "@") > 0 'Check to see if there are too many @'s
If Not bCK Then GoTo ExitFunction
strDomainType = Right(strCheck, Len(strCheck) - InStr(1, strCheck, "."))
bCK = Len(strDomainType) > 0 And InStr(1, strCheck, ".") < Len(strCheck)
If Not bCK Then GoTo ExitFunction
strCheck = Left(strCheck, Len(strCheck) - Len(strDomainType) - 1)
Do Until InStr(1, strCheck, ".") <= 1
If Len(strCheck) >= InStr(1, strCheck, ".") Then
strCheck = Left(strCheck, Len(strCheck) - (InStr(1, strCheck, ".") - 1))
Else
bCK = False
GoTo ExitFunction
End If
Loop
If strCheck = "." Or Len(strCheck) = 0 Then bCK = False
ExitFunction:
ValidEmail = bCK
Catch ex As ArgumentException
Return False
End Try
Return ValidEmail
End Function
3
ответ дан Lance Roberts 26 August 2018 в 00:46
поделиться
Вы должны использовать Регулярные выражения для проверки адресов электронной почты.
1
ответ дан Lucky 26 August 2018 в 00:46
поделиться
-
1
-
2Интернет и этот сайт шокированы ошибками неправильных при решении этого вопроса с помощью регулярного выражения. Если вы не являетесь мастером регулярных выражений и мастером электронной почты, даже не думайте об этом. (Я, и я это сделал, и решил не делать этого.) – tripleee 13 September 2011 в 07:39
EMails, такие как «адрес @ localhost» и «user@192.168.1.2», фактически являются действительными адресами, и вы можете протестировать их, запустив собственный почтовый сервер (обычно это делается путем изменения файла хоста). Однако для полного решения:
''' <summary>
''' METHODS FOR SENDING AND VALIDATING EMAIL
''' </summary>
''' <remarks></remarks>
Public Class email
''' <summary>
''' check if email format is valid
''' </summary>
''' <param name="emailAddress">[required] Email address.</param>
''' <param name="disallowLocalDomain">[optional] Allow headers like "@localhost"?</param>
''' <param name="allowAlerts">[optional] Enable error messages?</param>
''' <returns>Returns true if email is valid and false otherwise.</returns>
''' <remarks></remarks>
Public Shared Function isValid(ByVal emailAddress As String,
Optional ByVal disallowLocalDomain As Boolean = True,
Optional ByVal allowAlerts As Boolean = True
) As Boolean
Try
Dim mailParts() As String = emailAddress.Split("@")
If mailParts.Length <> 2 Then
If allowAlerts Then
MsgBox("Valid email addresses are formatted [sample@domain.tld]. " &
"Your address is missing a header [i.e. ""@domain.tld""].",
MsgBoxStyle.Exclamation, "No Header Specified")
End If
Return False
End If
If mailParts(mailParts.GetLowerBound(0)) = "" Then
If allowAlerts Then
MsgBox("Valid email addresses are formatted [sample@domain.tld]. " &
"The username portion of the e-mail address you provided (before the @ symbol) is empty.",
MsgBoxStyle.Exclamation, "Invalid Email User")
End If
Return False
End If
Dim headerParts() As String = mailParts(mailParts.GetUpperBound(0)).Split(".")
If disallowLocalDomain AndAlso headerParts.Length < 2 Then
If allowAlerts Then
MsgBox("Valid email addresses are formatted [sample@domain.tld]. " &
"Although addresses formatted like [sample@domain] are valid, " &
"only addresses with headers like ""sample.org"", ""sample.com"", and etc. " &
"[i.e. @domain.org] are accepted.",
MsgBoxStyle.Exclamation, "Invalid Header")
End If
Return False
ElseIf headerParts(headerParts.GetLowerBound(0)) = "" Or
headerParts(headerParts.GetUpperBound(0)) = "" Then
If allowAlerts Then
MsgBox("Valid email addresses are formatted [sample@domain.tld]. " &
"Your header """ & mailParts(mailParts.GetUpperBound(0)) & """ is invalid.",
MsgBoxStyle.Exclamation, "Invalid Header")
End If
Return False
End If
Dim address As MailAddress = New MailAddress(emailAddress)
Catch ex As Exception
If allowAlerts Then
MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Invalid Email Address")
End If
Return False
End Try
Return True
End Function
End Class 'email'
0
ответ дан RJBaytos 26 August 2018 в 00:46
поделиться
Вы можете использовать Regex для этого.
Там написано много статей об этом; это произошло, когда я искал google для 'regex для проверки адреса электронной почты': Найти или проверить адрес электронной почты .
0
ответ дан Roman Boiko 26 August 2018 в 00:46
поделиться
-
1Согласитесь с путешественником. Теперь у меня возникнут две проблемы. – Zack Peterson 25 August 2009 в 22:38
-
2Они лучше, чем регулярное выражение в статье MSDN, но все еще не работают во многих случаях. – Jeff Tucker 25 August 2009 в 23:25
вам сначала нужно ограничить пользователя, введя неправильные символы, вы можете сделать это, используя текстовое поле KeyPress event
Private Sub txtemailid_KeyPress(ByVal sender As System.Object,
ByVal e As System.Windows.FormsKeyPressEventArgs) Handles txtemailid.KeyPress
Dim ac As String = "@"
If e.KeyChar <> ChrW(Keys.Back) Then
If Asc(e.KeyChar) < 97 Or Asc(e.KeyChar) > 122 Then
If Asc(e.KeyChar) <> 46 And Asc(e.KeyChar) <> 95 Then
If Asc(e.KeyChar) < 48 Or Asc(e.KeyChar) > 57 Then
If ac.IndexOf(e.KeyChar) = -1 Then
e.Handled = True
Else
If txtemailid.Text.Contains("@") And e.KeyChar = "@" Then
e.Handled = True
End If
End If
End If
End If
End If
End If
End Sub
, указанный выше код позволит пользователю вводить az (small), от 0 до 9 (цифры), @,., _
и после использования проверки события управления текстовым полем для проверки идентификатора электронной почты с использованием регулярного выражения
Private Sub txtemailid_Validating(ByVal sender As System.Object,
ByVal e As System.ComponentModel.CancelEventArgs)
Handles txtemailid.Validating
Dim pattern As String = "^[a-z][a-z|0-9|]*([_][a-z|0-9]+)*([.][a-z|0-9]+([_][a-z|0-9]+)*)?@[a-z][a-z|0-9|]*\.([a-z][a-z|0-9]*(\.[a-z][a-z|0-9]*)?)$"
Dim match As System.Text.RegularExpressions.Match = Regex.Match(txtemailid.Text.Trim(), pattern, RegexOptions.IgnoreCase)
If (match.Success) Then
MessageBox.Show("Success", "Checking")
Else
MessageBox.Show("Please enter a valid email id", "Checking")
txtemailid.Clear()
End If
End Sub
2
ответ дан Spontifixus 26 August 2018 в 00:46
поделиться
Public Function ValidateEmail(ByVal strCheck As String) As Boolean
Try
Dim vEmailAddress As New System.Net.Mail.MailAddress(strCheck)
Catch ex As Exception
Return False
End Try
Return True
End Function
2
ответ дан texwil 26 August 2018 в 00:46
поделиться
-
1ответ должен сопровождаться некоторым объяснением, а не фрагментом кода для лучшего понимания – user2720864 20 November 2014 в 12:03
-
2
Статья MSDN: Практическое руководство. Проверка того, что строки находятся в допустимом формате электронной почты
Этот метод example вызывает метод Regex.IsMatch (String, String), чтобы убедиться, что строка соответствует шаблону регулярного выражения.
Function IsValidEmailFormat(ByVal s As String) As Boolean
Return Regex.IsMatch(s, "^([0-9a-zA-Z]([-\.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$")
End Function
5
ответ дан Zack Peterson 26 August 2018 в 00:46
поделиться
-
1Это кажется окончательным. Но я все же предпочел бы найти такую функцию, встроенную и безвозвратную, где-нибудь в System.Net.Mail. :( – Zack Peterson 25 August 2009 в 22:57
-
2Это не учитывает множество разных случаев с адресами электронной почты, наиболее значимым из которых является цитированная локальная часть. Существует множество других не-алфавитно-цифровых символов, которые также действительны, что это регулярное выражение не позволяет. Я знаю, что это статья MSDN, но это неправильно. Я повторно написал парсинг адресов для .NET 4.0 в System.Net.Mail.MailAddress, чтобы быть намного более надежным и учитывать эти вещи. См. Мой ответ ниже для более подробной информации. – Jeff Tucker 25 August 2009 в 23:24
-
3
-
4Регулярное выражение отклонит действительные адреса, которые используют домены верхнего уровня с более чем 9 символами, – Paul B. 29 February 2016 в 10:59
Другие вопросы по тегам: