Ho la seguente struttura di progetto che vorrei implementare. Vorrei sapere se ci sono delle insidie nella strutturazione del mio codice in questo modo. Utilizzerà WebAPI di Microsoft, un progetto MVC 4 e Plain Old C # Objects (POCO). La spiegazione segue.
Per prima cosa ci sarà un progetto di libreria di classi che contiene solo interfacce e oggetti come questi:
public interface IBookService {
IEnumerable<Book> GetBooks();
}
public class Book {
public int Id { get; set; }
public string Name { get; set; }
}
Questa interfaccia e classe saranno condivise dagli altri progetti. Il primo è il progetto di implementazione che contiene:
public class BookService : IBookService {
// implementation that pulls books from somewhere
}
Il terzo progetto sarà un progetto WebAPI che espone IBookService come uri, come link . AGGIORNAMENTO: questo sito WebAPI si troverà su un computer diverso rispetto al sito MVC.
Ora è qui che sono preoccupato per la mia scelta di implementazione. Il quarto e ultimo progetto è un'applicazione MVC 4. Farà riferimento solo alle interfacce e alla web api (tramite HttpContent e amici). Vorrei implementare anche l'interfaccia IBookService in questo progetto. Tranne che in questa implementazione chiamerebbe la WebAPI in questo modo.
public class MvcBookService : IBookService {
public IEnumerable<Book> GetBooks() {
var client = new HttpClient();
client.BaseAddress = new Uri("http://mySite"); // would be pulled from config
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = client.GetAsync("books").Result; // blocking call
if (response.IsSuccessStatusCode) {
// blocking call
return response.Content.ReadAsAsync<IEnumerable<Book>>().Result;
} else {
// handle response code
return null;
}
}
}
Ho intenzione di applicare questa struttura di progetto per tutte le interazioni WebAPI all'interno dell'azienda.
Non vedo alcun problema di manutenzione con questo layout di progetto. Tuttavia molti occhi aiutano sempre.