Ajouter des annotations de données à une classe générée par le framework d'entité

J'ai la classe suivante générée par le framework d'entité:

public partial class ItemRequest
{
    public int RequestId { get; set; }
    //...

Je voudrais en faire un champ obligatoire

[Required]
public int RequestId { get;set; }

Cependant, comme il s'agit de code généré, cela sera effacé. Je ne peux pas imaginer un moyen de créer une classe partielle car la propriété est définie par la classe partielle générée. Comment puis-je définir la contrainte de manière sûre?

La classe générée ItemRequestsera toujours une partialclasse. Cela vous permet d'écrire une deuxième classe partielle qui est marquée avec les annotations de données nécessaires. Dans votre cas, la classe partielle ItemRequestressemblerait à ceci:

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;

//make sure the namespace is equal to the other partial class ItemRequest
namespace MvcApplication1.Models 
{
    [MetadataType(typeof(ItemRequestMetaData))]
    public partial class ItemRequest
    {
    }

    public class ItemRequestMetaData
    {
        [Required]
        public int RequestId {get;set;}

        //...
    }
}

Comme MUG4N a répondu, vous pouvez utiliser des classes partielles, mais il sera préférable d'utiliser des interfaces à la place. Dans ce cas, vous aurez des erreurs de compilation si le modèle EF ne correspond pas au modèle de validation. Vous pouvez donc modifier vos modèles EF sans craindre que les règles de validation ne soient obsolètes.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace YourApplication.Models
{
    public interface IEntityMetadata
    {
        [Required]
        Int32 Id { get; set; }
    }

    [MetadataType(typeof(IEntityMetadata))]
    public partial class Entity : IEntityMetadata
    {
        /* Id property has already existed in the mapped class */
    }
}

PS Si vous utilisez un type de projet différent de ASP.NET MVC (lorsque vous effectuez une validation manuelle des données) n'oubliez pas d'enregistrer vos validateurs

/* Global.asax or similar */

TypeDescriptor.AddProviderTransparent(
    new AssociatedMetadataTypeTypeDescriptionProvider(typeof(Entity), typeof(IEntityMetadata)), typeof(Entity));

J'ai trouvé une solution comme la réponse de MUG4N , mais à la place, imbriquant la MetaDataclasse dans la classe d'entité, réduisant ainsi le nombre de classes dans votre liste d'espaces de noms publics, et éliminant le besoin d'avoir un nom unique pour chaque classe de métadonnées.

using System.ComponentModel.DataAnnotations;

namespace MvcApplication1.Models 
{
    [MetadataType(typeof(MetaData))]
    public partial class ItemRequest
    {
        public class MetaData
        {
            [Required]
            public int RequestId;

            //...
        }
    }
}

C'est une sorte d'extension de la réponse @dimonser si vous régénérez votre modèle de base de données, vous devrez ré-ajouter manuellement des interfaces sur ces classes.

Si vous avez l'estomac pour cela, vous pouvez également modifier votre .tt modèles:

Voici un exemple d'interfaces générant automatiquement sur certaines classes, il s'agit d'un fragment de la méthode de .ttremplacement EntityClassOpeningde la vôtre par la suite (et évidemment var stringsToMatchavec les noms et interfaces de vos entités).

public string EntityClassOpening(EntityType entity)
{
    var stringsToMatch = new Dictionary<string,string> { { "Answer", "IJourneyAnswer" }, { "Fee", "ILegalFee" } };
    return string.Format(
        CultureInfo.InvariantCulture,
        "{0} {1}partial class {2}{3}{4}",
        Accessibility.ForType(entity),
        _code.SpaceAfter(_code.AbstractOption(entity)),
        _code.Escape(entity),
        _code.StringBefore(" : ", _typeMapper.GetTypeName(entity.BaseType)),
        stringsToMatch.Any(o => _code.Escape(entity).Contains(o.Key)) ? " : " + stringsToMatch.Single(o => _code.Escape(entity).Contains(o.Key)).Value : string.Empty);
}

Cependant, aucune personne normale ne devrait se faire cela, il a été prouvé dans la Bible que l'on va en Enfer pour cela.

Je ne sais pas comment faire ce que vous demandez, mais il existe un moyen de contourner le problème. Validation dynamique des données en remplaçant les GetValidators de votre DataAnnotationsModelValidatorProvider personnalisé. Vous pouvez y lire les règles de validation de chaque champ (à partir d'une base de données, fichier de configuration, etc.) et ajouter des validateurs selon les besoins. Il a les valeurs ajoutées que votre validation n'est plus étroitement liée au modèle et peut être modifiée sans même avoir besoin de redémarrer le site. Bien sûr, cela pourrait être exagéré pour votre cas, mais c'était idéal pour le nôtre!

Modifiez le modèle T4 en ajoutant les annotations requises, ce fichier est généralement nommé MODELNAME.tt

trouver où le T4 crée la classe et les méthodes pour savoir où les mettre.

     <#=codeStringGenerator.IgnoreJson(navigationProperty)#>


//create this method in file
public string IgnoreJson(NavigationProperty navigationProperty){
            string result = navigationProperty.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? "" : @"[JsonIgnore]
    [IgnoreDataMember]";

            return result;
        }

Vous devrez également ajouter les espaces de noms;

<#=codeStringGenerator.UsingDirectives(inHeader: false)#>
using System.ComponentModel.DataAnnotations;
using Newtonsoft.Json;
using System.Runtime.Serialization;

Reconstruisez vos classes en sauvegardant votre modèle, toutes vos méthodes doivent être annotées.