Convalida codice primo approccio e classi commerciali

1

Ho una soluzione divisa in due progetti: una libreria di classi contenente tutte le mie classi di modelli (chiamiamola Business ) e un progetto MVC ASP.Net.

Le mie classi Business sono pensate per essere generiche e funzionano per più tipi di progetti. Per questo motivo, non contengono alcuna annotazione dati / associazioni in altre classi, solo variabili membro / proprietà / costruttori .

Utilizzando l'approccio code-first, come dovrei progettare i miei modelli ASP.Net per lavorare con i miei modelli Business .

Il mio insegnamento iniziale stava impostando le mie classi Business come classi parziali e quindi sovrascrivo le mie proprietà aggiungendo le necessarie annotazioni di dati / associazioni . Non posso farlo perché abbiamo a che fare con due progetti separati.

Stavo anche pensando che potrei usare ereditarietà . I miei modelli ASP.Net potrebbero ereditare dalle classi Business e potrei aggiungere le mie annotazioni sui dati / associazioni . Questo sembra un po 'complicato e illogico, dato che dovrei definire tutti i miei costruttori in questa nuova sottoclasse.

C'è un modo intelligente per farlo in modo pulito?

EDIT:

Le mie classi Business hanno convalide generando eccezioni nei setter della proprietà. Il mio primo progetto è stato quello di creare la mia annotazione dati personalizzata che catturerà le eccezioni generate dai miei setter:

public class SetterBasedValidation : ValidationAttribute
    {
        string m_errorMessage = null;
        public SetterBasedValidation(string errorMessage)
        {
            m_errorMessage = errorMessage;
        }

        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            try
            {
                Type type = validationContext.ObjectType;
                PropertyInfo property = type.GetProperty(validationContext.MemberName);
                property.SetValue(validationContext.ObjectInstance, value);
            }
            catch (Exception)
            {
                return new ValidationResult(m_errorMessage);
            }

            return ValidationResult.Success;
        }
    }

Avrei quindi bisogno di un modo per usare la mia annotazione dati personalizzata nella mia classe di modello ASP.Net. Questo mi darebbe il risultato che voglio:

  • Mantieni le mie classi aziendali generiche
  • Utilizza le convalide dei miei setter
  • Utilizza annotazioni di dati

EDIT 2:

Ecco una panoramica di base su come si presenta la mia soluzione. Le mie lezioni di business (modelli di dominio) contengono codice simile a questo:

 public class User
    {

        private string m_name = null;

        public string Name
        {
            get { return m_name; }
            set
            {
                string name = value.Trim();

                if (name.Length > 20 || name.Length < 1)
                {
                    throw new ArgumentException("Name length invalid.");
                }
                m_name = name;
            }
        }
    }

    
posta Cubia 28.09.2015 - 15:07
fonte

1 risposta

2

Il tuo sito web dovrebbe avere un set separato di ViewModels che avvolge i modelli di dominio e qualsiasi altra data / logica richiesta dalla pagina.

Poiché questi modelli di visualizzazione appartengono al sito web piuttosto che al dominio, è possibile aderire a qualsiasi convalida o logica aggiuntiva richiesta solo dal sito Web / Vista per il particolare processo che si sta implementando.

Penso che l'esempio migliore sia che hai qualche processo "Iscriviti", il modello di dominio per il quale include una tonnellata di dati sulla persona che si sta registrando. I tuoi team di progettazione presentano due design.

  • Progettazione 1: un modulo di una singola pagina di grandi dimensioni con tutti i campi su

  • Progettazione 2: un approccio "procedura guidata" con più moduli separati

Sebbene entrambi i design utilizzino la stessa logica underling per la registrazione. ognuno avrà modelli di visualizzazione molto diversi.

aggiornamento ---

Le annotazioni dei dati di Entity Framework consentono a EF di mappare correttamente l'oggetto su una tabella di database. Ci sono alcune convenzioni che ti permetteranno di fare a meno di non usare alcune di queste proprietà che vengono chiamate come previsto.

Tuttavia, sei corretto nel fatto che se vuoi separare i tuoi oggetti di dominio dalla logica di persistenza devi implementare un Oggetto Entità che rispecchia le proprietà sul tuo oggetto di dominio e al quale puoi aggiungere le annotazioni di dati.

Puoi racchiudere tutto questo in un oggetto repository che può recuperare gli oggetti Entity dal DB, convertirli negli oggetti Dominio e restituirli al codice chiamante. Tuttavia, se fai tutte queste cose, scoprirai di aver perso i vantaggi di risparmio di tempo di EF e potresti aver usato SqlClient solo

Nel mondo ideale la struttura della soluzione potrebbe essere simile a questa:

DomainModels - class lib
    User.cs

EntityModels - class lib
    UserEntity.cs - with data annotations

RepositoryEF - class lib ref domain and entity
    UserRepository.cs - eg. public User GetUser(string id)

Website - ref the other three
    UserController.cs - calls repository to get a domain object
    UserViewModel.cs - populated from domain object by controller
    UserView.cshtml - uses viewmodel as its model and displays data to user
    
risposta data 28.09.2015 - 16:14
fonte

Leggi altre domande sui tag