Aggiungi annotazioni di dati a una classe generata dal framework di entità

Ho la seguente classe generata da Entity Framework:

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

Vorrei renderlo un campo obbligatorio

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

Tuttavia, poiché questo è codice generato, verrà cancellato. Non riesco a immaginare un modo per creare una classe parziale perché la proprietà è definita dalla classe parziale generata. Come posso definire il vincolo in modo sicuro?

La classe generata ItemRequestsarà sempre una partialclasse. Ciò consente di scrivere una seconda classe parziale contrassegnata con le annotazioni dei dati necessarie. Nel tuo caso la classe parziale ItemRequestsarebbe simile a questa:

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;}

        //...
    }
}

Come ha risposto MUG4N puoi usare classi parziali ma sarà meglio usare invece le interfacce . In questo caso si verificheranno errori di compilazione se il modello EF non corrisponde al modello di convalida. Quindi puoi modificare i tuoi modelli EF senza temere che le regole di convalida siano obsolete.

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 Se utilizzi un tipo di progetto diverso da ASP.NET MVC (quando esegui la convalida manuale dei dati) non dimenticare di registrare i tuoi validatori

/* Global.asax or similar */

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

Ho trovato una soluzione come la risposta di MUG4N , ma invece, annidando la MetaDataclasse all'interno della classe entità, riducendo così il numero di classi nel tuo elenco di spazio dei nomi pubblico ed eliminando la necessità di avere un nome univoco per ogni classe di metadati.

using System.ComponentModel.DataAnnotations;

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

            //...
        }
    }
}

Questa è una sorta di estensione alla risposta di @dimonser se rigeneri il tuo modello db dovrai aggiungere manualmente le interfacce su quelle classi.

Se hai stomaco per questo, puoi anche modificare i tuoi .ttmodelli:

Ecco un esempio di interfacce di generazione automatica su alcune classi, questo è un frammento del .ttsolo EntityClassOpeningmetodo di sostituzione nel tuo con il seguente (e ovviamente var stringsToMatchcon i nomi e le interfacce delle tue entità).

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);
}

Nessuna persona normale dovrebbe fare questo a se stessa, però, è stato dimostrato nella Bibbia che si va all'Inferno per questo.

Non sono sicuro di come fare quello che chiedi, ma c'è un modo per aggirarlo. Convalida dinamica dei dati sovrascrivendo i GetValidators del tuo DataAnnotationsModelValidatorProvider personalizzato. In esso puoi leggere le regole per la convalida di ogni campo (da un database, file di configurazione, ecc.) E aggiungere validatori secondo necessità. Ha il valore aggiunto che la tua convalida non è più strettamente collegata al modello e può essere modificata senza bisogno di riavviare il sito. Ovviamente potrebbe essere eccessivo per il tuo caso, ma era l'ideale per il nostro!

Modificare il modello T4 aggiungendo le annotazioni richieste, questo file è solitamente denominato MODELNAME.tt

trova dove il T4 sta creando la classe e i metodi per sapere dove metterli.

     <#=codeStringGenerator.IgnoreJson(navigationProperty)#>


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

            return result;
        }

Dovrai anche aggiungere gli spazi dei nomi;

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

Ricostruisci le tue classi salvando il tuo modello, tutti i tuoi metodi dovrebbero essere annotati.