Sto sviluppando un'API Web, con un approccio a più livelli, utilizzando Entity Framework e l'utilizzo del primo approccio al codice.
- 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.
- 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à.
- 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();
}
}