Questa struttura segue lo schema DDD / UoW?

-2

Sto sviluppando un'API Web, con un approccio a più livelli, utilizzando Entity Framework e l'utilizzo del primo approccio al codice.

  1. Le mie domande sono: il mio DAL e il livello Business Logic seguono il modello DI / UoW / DDD se non dove dovrei cambiare il mio codice per renderlo più standard.
  2. Che aspetto dovrebbe avere il mio livello di servizio per collegare tra l'API Web e il livello aziendale. Ho in programma di definire la gestione dei ruoli in questo livello, solo x l'utente può eseguire questa attività.
  3. La convalida è definita in core, buona lì o dovrebbe essere la sua classe per ogni elemento?

Questo è un esempio del codice, e potrebbe mancare qualcosa, ma sto cercando di enfatizzare, quanto sono vicino al DDD. Manca l'implementazione del ruolo. In questa fase, il layout dell'API Web e il layout del servizio non vengono creati ma creati al volo, ma ci si chiede se ci sono modifiche che dovrei fare per questo.

Struttura

Library Name      Reference
API               Service , Model, Common
Service           Core, Model, Common
Core              DAL, Model, Common
DAL               Model, Common
Model
Common

Modello

public abstract class Base
{
    public int ID { get; set; }
    public Boolean isValid { get; set; }
    public DateTime createdOn { get; set; }
    public int createdID { get; set; }
    public Person createdPerson { get; set; }
    public DateTime updatedOn { get; set; }
    public int updatedID { get; set; }
    public Person updatedPerson { get; set; }
}
public class Person : Base
{
    public DateTime DOB { get; set; }
    public virtual ICollection<Name> PreferredName { get; set; }
    public virtual ICollection<Prefix> PrefixID { get; set; }
    public virtual ICollection<Gender> GenderID { get; set; }
    public virtual ICollection<Ethnicity> EthnicityID { get; set; }
}

DAL

public interface IPersonRepsoitory
{
    IEnumerable<Person> GetPersons();
    Person GetPersonByID(int id);
    IEnumerable<Person> GetPersonByFirst(string first);
    IEnumerable<Person> GetPersonByLast(string last);
    IEnumerable<Person> GetPersonBirthday(DateTime d);
    IEnumerable<Person> GetPersonWithGroup(IEnumerable<Roles> r);
    void InsertPerson(Person p);
    void DeletePerson(int id);
    void UpdatePerson(Person p);
    void Save();
}

public class PersonRepository : IPersonRepsoitory, IDisposable
{

    private Context context;
    private bool disposed = false;

    public PersonRepository(Context _context)
    {
        this.context = _context;
    }

    public IEnumerable<Person> GetPersons()
    {
        return context.Person.ToList();
    }

    public Person GetPersonByID(int id)
    {
        return context.Person.Where(x => x.ID == id).FirstOrDefault();
    }

    public IEnumerable<Person> GetPersonByFirst(string first)
    {
        return context.Person.Where(x => x.PreferredName.First().firstName == first);
    }

    public IEnumerable<Person> GetPersonByLast(string last)
    {
        return context.Person.Where(x => x.PreferredName.First().lastName == last);
    }

    public IEnumerable<Person> GetPersonBirthday(DateTime d)
    {
        return context.Person.Where(x => x.DOB == d);
    }

    public IEnumerable<Person> GetPersonWithGroup(IEnumerable<Roles> r)
    {
        // need to complete association
        return null;
    }

    public void InsertPerson(Person p)
    {
        context.Person.Add(p);
    }

    public void DeletePerson(int id)
    {
        Person p = context.Person.Find(id);
        context.Person.Remove(p);
    }


    public void UpdatePerson(Person p)
    {
        context.Entry(p).State = EntityState.Modified;
    }

    public void Save()
    {
        context.SaveChanges();
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

Nucleo

public interface IPersonCore
{
    IEnumerable<Person> PersonList();
    Person UserWithID(int id);
    IEnumerable<Person> UserWithRole(IEnumerable<Roles> r);
    int AddPerson(Person p);
    int RemovePerson(int id);
    int UpdatePerson(Person p);
}

public class PersonCore : IPersonCore
{

    private IPersonRepsoitory dbPerson;
    private Person currUser;

    public PersonCore(Person _currUser)
    {
        this.dbPerson = new PersonRepository(new Context());
        this.currUser = _currUser;
    }

    public IEnumerable<Person> PersonList()
    {
        return dbPerson.GetPersons();
    }

    public Person UserWithID(int id)
    {
        return dbPerson.GetPersonByID(id);
    }

    public IEnumerable<Person> UserWithRole(IEnumerable<Roles> r)
    {
        return dbPerson.GetPersonWithGroup(r);
    }

    public int AddPerson(Person p)
    {
        if (isValid(p))
        {
            p.createdOn = DateTime.Now;
            p.updatedOn = DateTime.Now;
            p.createdPerson = currUser;
            p.updatedPerson = currUser;
            dbPerson.InsertPerson(p);
            return 1;
        }
        return 0;
    }
    public int RemovePerson(int id)
    {
        Person found = dbPerson.GetPersonByID(id);
        if (found != null)
        {
            dbPerson.DeletePerson(found.ID);
            return 1;
        }
        return 0;
    }

    public int UpdatePerson(Person p)
    {
        if (isValid(p))
        {
            Person found = dbPerson.GetPersonByID(p.ID);
            if (found != null)
            {
                found = p;
                found.updatedOn = DateTime.Now;
                found.updatedPerson = currUser;
                dbPerson.InsertPerson(found);
                return 1;
            }
        }
        return 0;
    }

    private static bool isValid(Person p)
    {
        if (p == null)
        {
            return false;
        }
        // More validation done here

        return true;
    }

}

servizio

public interface IPersonService
{
    void GetListPerson();
}

public class personService : IPersonService
{
    private IPersonCore personCore;

    public class personService()
    {
        this.personCore = new PersonCore();
    }

    public IEnumerable<Person> GetListPerson()
    {
        return personCore.PersonList();
    }
}

API web

public class PersonController : ApiController
        {
            private IPersonService personService;

            public PersonController()
            {
                this.personService = new personService();
            }

            public ListPerson[] Get()
            {
                return personService.GetListPerson();
            }

        }
    
posta Jseb 15.11.2016 - 04:07
fonte

1 risposta

2

My questions is does my DAL, and Business Logic layer are following DI/UoW/DDD pattern if not where should I change my code to make it more standard.

Riguardo a DI, non vedo alcuna prova di DI nel tuo codice. Ad ogni livello, hai costruttori come:

public personService()
{
    this.personCore = new PersonCore();
}

Per usare DI, sembrerebbe:

public personService(IPersonCore personCore)
{
    this.personCore = personCore;
}

cioè, stai iniettando la dipendenza, non avendo ogni classe creata per se stessa.

Il codice è incompleto, ma al momento non ci sono prove di alcuna "unità di lavoro" nel codice.

DDD non è un modello software. Whetehr stai modellando il tuo dominio e usarlo per guidare questo design non può essere determinato dal codice.

    
risposta data 15.11.2016 - 07:53
fonte

Leggi altre domande sui tag