@Html.ValidationFor() an @Html.EditorFor(x => x.Name, typeof(string).FullName)
<p>Thanks in advance for your help. </p>

<p>I have a rickety old MVC client as part of my VS Solution, we'll call it ApiClient (a backend client). The Root Model, we'll call it User, has all the Validation requirements and messages. But, have a look at the code in the related View...</p>

<p><strong>View</strong></p>

<pre><code>@using Cms.Utils
@using Utils.Strings
@using Utils.Web
@using Utils.DateTimes
@using System.Web.Mvc
@using Models
@model Cms.Models.Users.AddModel

@SectionBreadcrumb.Add(Html, "Manage Users", "Add")
&lt;script src="~/Scripts/jquery.validate.min.js"&gt;&lt;/script&gt;
&lt;script src="~/Scripts/jquery.validate.unobtrusive.min.js"&gt;&lt;/script&gt;

&lt;div class="col-xs-12"&gt;
    &lt;div class="row"&gt;
        &lt;h2&gt;
            Add Person
        &lt;/h2&gt;
    &lt;/div&gt;
    &lt;form method="POST"&gt;
            &lt;div class="row"&gt;
                @*@Html.LabelFor(x =&gt; x.User.Username, new { @class = "control-label col-md-2" })*@
                &lt;div&gt;
                    @Html.EditorFor(x =&gt; x.User.Username, typeof(string).FullName, new { @class = "form-control" })
                &lt;/div&gt;
                &lt;div class="row"&gt;
                    @Html.ValidationMessageFor(x =&gt; x.User.Username, "", new { @class = "text-danger" })
                &lt;/div&gt;
            &lt;/div&gt;
</code></pre>

<p><strong>View's Model</strong></p>

<pre><code>namespace Cms.Models.Users
{
    public class AddModel
    {
        public User User { get; set; }
        public List&lt;Role&gt; Roles { get; set; }
    }
}
</code></pre>

<p><em>Here I must mention that User is a model in a Submodule (another project) in the solution. It also inherits from CoreUser (also in the same Submodule)</em></p>

<p><strong>User Model</strong></p>

<pre><code>namespace Models
{
    public class User : CoreUser
    {
        public bool IsFollowing { get; set; }
        public bool IsFollowingMe { get; set; }
    }
}
</code></pre>

<p><strong>CoreUser Model</strong></p>

<pre><code>namespace Sqor.Models
{
    public class CoreUser : IEntity, IAttributeContainer
    {
        public int Id { get; set; }
        [StringLength(256), RegularExpression(@"[^\s@]+@[^\s@]+\.[^\s@]+", ErrorMessage = "Invalid Email Address")]
        public string Email { get; set; }
        public string Phone { get; set; }
        public bool IsPhoneVerified { get; set; }
        [StringLength(20, ErrorMessage = "Usernames cannot exceed 20 characters."), RegularExpression("^[a-zA-Z](_[a-zA-Z0-9]|[a-zA-Z0-9])+$", ErrorMessage = "Letters, numbers, and underscores only. Start with a letter. No spaces. Max length of 20 characters.")]
        public string Username { get; set; }
        [MaxLength(200, ErrorMessage = "Snippet cannot exceed 200 characters.")]
        public string Snippet { get; set; }
        [MaxLength]
        public string Bio { get; set; }
        public bool IsTeam { get; set; }
        public bool IsAmbassador { get; set; }
        public DateTime Created { get; set; }
        public string TimeZone { get; set; }
        public int? ContractTypeId { get; set; }
        public bool IsMvp { get; set; }
        public string FacebookPageId { get; set; }
        public string TwitterHandle { get; set; }
        public string WikipediaUrl { get; set; }
        public int NumberOfPosts { get; set; }
        public string College { get; set; }
        public bool? AdFree { get; set; }
        public bool MarketingEmails { get; set; }

        [StringLength(45, ErrorMessage = "First names cannot exceed 45 characters.")]
        [Obsolete("Use FirstName property instead.")]
        public string Firstname { get; set; }
        [StringLength(45, ErrorMessage = "Last names cannot exceed 45 characters.")]
        [Obsolete("Use LastName property instead.")]
        public string Lastname { get; set; }

        /// &lt;summary&gt;
        /// Use this property moving forward.
        /// &lt;/summary&gt;
        /// 
        [StringLength(45, ErrorMessage = "First names cannot exceed 45 characters.")]
        public string FirstName
        {
#pragma warning disable 618
            get { return this.Firstname; }
            set { this.Firstname = value; }
#pragma warning restore 618
        }
        /// &lt;summary&gt;
        /// Use this property moving forward.
        /// &lt;/summary&gt;
        /// 
        [StringLength(45, ErrorMessage = "Last names cannot exceed 45 characters.")]
        public string LastName
        {
#pragma warning disable 618
            get { return this.Lastname; }
            set { this.Lastname = value; }
#pragma warning restore 618
        }

        [RegularExpression(@"^([0]\d|[1][0-2])\/([0-2]\d|[3][0-1])\/([2][01]|[1][6-9])\d{2}(\s([0-1]\d|[2][0-3])(\:[0-5]\d){1,2})?$", ErrorMessage = "Please use a valid date. MM/DD/YYYY")]
        public DateTime? BirthDate { get; set; }
        [StringLength(45, ErrorMessage = "Locations cannot exceed 45 characters.")]
        public string Location { get; set; }
        [StringLength(45, ErrorMessage = "Gender cannot exceed 45 characters.")]
        public string Gender { get; set; }
        public string Avatar { get; set; }
        public string ProfileHeader { get; set; }
        public bool IsPlayer { get; set; }
        public bool IsUser { get; set; }

        public List&lt;PlayerLeague&gt; Leagues { get; set; }

        public List&lt;AthleteContract&gt; Contracts { get; set; }

        public List&lt;Organization&gt; Organizations { get; set; }

        public int? AccountManagerId { get; set; }

        [JsonIgnore]
        public string FullName
        {
            get { return FirstName + " " + LastName; }
        }

        EntityType IEntity.Type
        {
            get { return EntityType.User; }
        }

        string IEntity.Name
        {
            get { return FullName; }
        }

        string IEntity.Team
        {
            get { return null; }
        }

        string IEntity.League
        {
            get { return null; }
        }

        int IEntity.LeaguePrecedence
        {
            get { return 0; }
        }

        string IEntity.JerseyNumber
        {
            get { return null; }
        }

        string IEntity.Position
        {
            get { return null; }
        }


        [JsonIgnore]
        public Dictionary&lt;string, object&gt; Attributes
        {
            get { return AttributeTokens != null ? AttributeTokens.ToDictionary(x =&gt; x.Key, x =&gt; x.Value == null ? null : x.Value.ToObject&lt;object&gt;()) : new Dictionary&lt;string, object&gt;(); }
            set { AttributeTokens = value.ToDictionary(x =&gt; x.Key, x =&gt; x.Value == null ? null : JToken.FromObject(x.Value)); }
        }

        [JsonExtensionData]
        public Dictionary&lt;string, JToken&gt; AttributeTokens { get; set; }

        [JsonIgnore]
        public IEnumerable&lt;AttributeValue&gt; AttributeValues
        {
            get { return Attributes.Select(x =&gt; new AttributeValue { Name = x.Key, Value = x.Value }); }
            set { Attributes = value.ToDictionary(x =&gt; x.Name, x =&gt; x.Value); }
        }

        public override string ToString()
        {
            return FullName + " (" + Id + ")";
        }
    }
}
</code></pre>

<p>My problem is that in my View above each of the below...
@Html.EditorFor(x.User.Username) has an overload, typeof(string).FullName.
<em>@Html.EditorFor(x.User.Username, typeof(string).FullName, new { placeholder = "blah" })</em></p>

<p>Essentially changing the name of my editor, therefore each client side @Html.ValidationMessageFor(x.User.Username) code does not activate. </p>

<p>Also, if I remove typeof(string).FullName from the @Html.EditorFor instances, my Client Side validation starts working, however when saving, it then passes null values to the related controller, so a User with all blank information gets created.</p>

<ol>
<li>Why has the previous developer used this typeof(string).FullName thing and what exactly is it?</li>
<li>How can I rid myself of this typeof(string).FullName and it work with my model (ie. not send null values when submitted to the controller.) so that client side validation works?</li>
<li>Can I make client side validation work with the typeof(string).FullName thing in tact?</li>
</ol>

<p>Thank you so much for any and all help!!</p>

<p>Solution Explorer <a href="https://i.stack.imgur.com/V9KQu.png" rel="nofollow">Solution Explorer Screenclip</a>
@42shadow42 <a href="https://i.stack.imgur.com/N8TxN.png" rel="nofollow">Views/Shared/EditorTemplates</a></p>

<p><strong>UPDATE - UsersController.cs</strong></p>

<pre><code>[Route("person/add"), HttpPost]
public new async Task&lt;ActionResult&gt; Add(string email,  string username, string firstName, string lastName, string snippet, string bio, bool isAmbassador = false, bool isTeam = false, Gender gender = Gender.None, string location = null, DateTime? birthdate = null, 
    string twitterHandle = null, string facebookPageId = null, string wikipediaUrl = null, bool marketingEmails = false, string[] roles = null)
</code></pre>