`[DataType(DataType.PhoneNumber)]` does not come with any validation logic out of the box. 

According to the [docs][1]: 

> When you apply the `DataTypeAttribute` attribute to a data field you must do the following:
>
> * Issue validation errors as appropriate.

The `[Phone]` Attribute inherits from `[DataType]` and was introduced in .NET Framework 4.5+ and is in .NET Core which does provide it's own flavor of validation logic. So you can use like this:



 [Phone()]
 public string PhoneNumber { get; set; }

However, the out-of-the-box validation for Phone numbers is [pretty permissive][2], so you might find yourself wanting to inherit from DataType and implement your own `IsValid` method or, as others have suggested here, use a [regular expression][3] & `RegexValidator` to constrain input.

**Note**: Use caution with Regex against unconstrained input per the [best practices][4] as .NET has made the [pivot away from regular expressions in their own internal validation logic for phone numbers][5]

[1]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute?view=netframework-4.7.2
[2]: https://source.dot.net/#System.ComponentModel.Annotations.Tests/System/ComponentModel/DataAnnotations/PhoneAttributeTests.cs
[3]: https://stackoverflow.com/questions/9776231/regular-expression-to-validate-us-phone-numbers
[4]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/best-practices
[5]: https://github.com/Microsoft/dotnet/blob/master/Documentation/compatibility/aspnet-472-compat-doc.md

I am trying to use a regular expression to validate a phone number and return an error when an invalid number or phone number is submitted. 
 
**MVC Code**:



 <ol class="row">
 <li class="cell" style="width: 20%;">Phone Number:</li>
 <li class="cell last" style="width: 60%;">
 @Html.TextBoxFor(model => model.PhoneNumber, new { @class = "textbox" }) 
 @Html.ValidationMessageFor(model => model.PhoneNumber)
 </li>
 </ol>



**C# Code**:



 [DataType(DataType.PhoneNumber)]
 [Display(Name = "Phone Number")]
 [Required(ErrorMessage = "Phone Number Required!")]
 [RegularExpression(@"^$?([0-9]{3})$?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$",
 ErrorMessage = "Entered phone format is not valid.")]
 public string PhoneNumber { get; set; }



However, the input box will not show a message to the user indicating that the phone number which was submitted is not valid.

Phone Number Validation MVC

### *TLDR*: `[Phone]` provides validation logic while `[DataType]` does not

The inheritance chain looks like this:

`Attribute` 
&nbsp;&nbsp;↳ `ValidationAttribute` 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;↳ `DataTypeAttribute` 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;↳ `PhoneAttribute`

So both are instances of `ValidationAttribute`, however both don't provide Validation out of the box. The DataType base class just provides the structure for assigning an `enum DataType` and leaves overriding the validation up to the caller

### `DataType` - According to the Docs:

> When you apply the `DataTypeAttribute` attribute to a data field you must do the following:
>
> * Issue validation errors as appropriate.

### `DataType` - According to the Source Code:



 [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Parameter, AllowMultiple = false)]
 public class DataTypeAttribute : ValidationAttribute
 {
 /// <summary> Override of <see cref="ValidationAttribute.IsValid(object)" /> </summary>
 /// <remarks>This override always returns <c>true</c>. Subclasses should override this to provide the correct result.</remarks>
 /// <param name="value">The value to validate</param>
 /// <returns>Unconditionally returns <c>true</c></returns>
 /// <exception cref="InvalidOperationException"> is thrown if the current attribute is ill-formed.</exception>
 public override bool IsValid(object value)
 {
 EnsureValidDataType();
 
 return true;
 }
 }

**Aside**: Since you are required to override `IsValid`, I'm not sure why .NET didn't mark the class and property as [`abstract`][10] to guarantee an implementation programmatically.


### `PhoneAttribute` - Validation Logic

So if you do want to provide validation, and you're using .NET 4.5+ or .NET Core, you can use the `[Phone]` attribute, but the mechanism for validation has changed over time as well and also you might have a different set of rules on what constitutes valid input for your business process.

.NET Framework initially used the following regular expression:



 const string pattern = @"^(\+\s?)?((?<!\+.*)$\+?\d+([\s\-\.]?\d+)?$|\d+)([\s\-\.]?($\d+([\s\-\.]?\d+)?$|\d+))*(\s?(x|ext\.?)\s?\d+)?$";

But this was deprecated in .NET Framework 4.7.2 per [this change description][11], likely due to injection/security concerns layed out in the [Regular Expression Best Practices][12] from unconstrained input. 

If you want to continue using regex validation, you'd have to set the following in the `configuration` > `appsettings` section of your `.config` file:



 <add key="dataAnnotations:dataTypeAttribute:disableRegEx" value="false"/>
 
The Test project includes a sample of what inputs should pass/fail according to [PhoneAttributeTests.cs][16] and here's a [Regexr page][17] if you want to test out matching input against the (deprecated) regular expression validation engine.



-----


Here's some links for source code and documentation for different flavors of .NET:



<pre><code> | .NET Core | .NET Core 2.1 | .NET 4.7.2 | .NET |
------------------|-------------------|----------------|-----------------|----------------|
DataTypeAttribute | <a href="https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs">github.com/dotnet</a> | <a href="https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs">source.dot.net</a> | <a href="https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/DataTypeAttribute.cs">referencesource</a> | <a href="https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute">docs.microsoft</a> |
PhoneAttribute | <a href="https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/PhoneAttribute.cs">github.com/dotnet</a> | <a href="https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/PhoneAttribute.cs">source.dot.net</a> | <a href="https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/PhoneAttribute.cs">referencesource</a> | <a href="https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.PhoneAttribute">docs.microsoft</a> |
</code></pre>

**Note**: The current docs for `[Phone]` mistakenly remarks that the validation uses Regular Expressions, which has not been true since 4.7.2+ or anywhere in .NET core, so I've [submitted this PR to update][15]

[1]: https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs
[2]: https://source.dot.net/#System.ComponentModel.Annotations/System/ComponentModel/DataAnnotations/PhoneAttribute.cs
[3]: https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/DataTypeAttribute.cs
[4]: https://referencesource.microsoft.com/#System.ComponentModel.DataAnnotations/DataAnnotations/PhoneAttribute.cs
[5]: https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/DataTypeAttribute.cs
[6]: https://github.com/dotnet/corefx/blob/v2.1.5/src/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/PhoneAttribute.cs
[7]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute "System.ComponentModel.DataAnnotations.DataTypeAttribute"
[8]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.PhoneAttribute "System.ComponentModel.DataAnnotations.PhoneAttribute"

[10]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract
[11]: https://github.com/Microsoft/dotnet/blob/master/Documentation/compatibility/aspnet-472-compat-doc.md
[12]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/best-practices
[15]: https://github.com/dotnet/dotnet-api-docs/pull/686
[16]: https://source.dot.net/#System.ComponentModel.Annotations.Tests/System/ComponentModel/DataAnnotations/PhoneAttributeTests.cs
[17]: https://regexr.com/429je

What's the difference between using [`DataType` Attribute][1] and passing in a value of [`DataType.Phone`][3] and the [`Phone` Attribute][2] which inherits from `DataType` and automatically sets `DataType.Phone`?


Is there any difference between these two classes?



<pre><code>class Person {
 [DataType(DataType.PhoneNumber)]
 public string PhoneNumber {get;set;}
}
</code></pre>



<pre><code>class Person {
 [Phone]
 public string PhoneNumber {get;set;}
}
</code></pre>

[1]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute "System.ComponentModel.DataAnnotations.DataTypeAttribute"
[2]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.PhoneAttribute "System.ComponentModel.DataAnnotations.PhoneAttribute"
[3]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataType "System.ComponentModel.DataAnnotations.DataType"