Jestem programistą .Net używanym do tworzenia aplikacji internetowych na Microsoft Technologies. Próbuję nauczyć się rozumieć podejście REST do usług internetowych. Do tej pory kocham framework ServiceStack.

Czasami jednak znajduję się w sytuacji, w której piszę usługi w sposób, do którego jestem przyzwyczajony do WCF. Mam więc pytanie, które mnie wkurza.

Mam 2 prośby o dwie usługi DTO, takie jak te:

[Route("/bookinglimit", "GET")]
[Authenticate]
public class GetBookingLimit : IReturn<GetBookingLimitResponse>
{
    public int Id { get; set; }
}
public class GetBookingLimitResponse
{
    public int Id { get; set; }
    public int ShiftId { get; set; }
    public DateTime StartDate { get; set; }
    public DateTime EndDate { get; set; }
    public int Limit { get; set; }

    public ResponseStatus ResponseStatus { get; set; }
}

[Route("/bookinglimits", "GET")]
[Authenticate]
public class GetBookingLimits : IReturn<GetBookingLimitsResponse>
{      
    public DateTime Date { get; set; }
}
public class GetBookingLimitsResponse
{
    public List<GetBookingLimitResponse> BookingLimits { get; set; }
    public ResponseStatus ResponseStatus { get; set; }
}

Jak widać na tych Request DTO, mam podobne żądanie DTO prawie dla każdej usługi i wydaje się, że nie jest to DRY.

Próbowałem użyćGetBookingLimitResponse klasa na liście wewnątrzGetBookingLimitsResponse z tego powoduResponseStatus wewnątrzGetBookingLimitResponse klasa jest zdublowana w przypadku błęduGetBookingLimits usługa.

Mam również implementacje usług dla takich żądań, jak:

public class BookingLimitService : AppServiceBase
{
    public IValidator<AddBookingLimit> AddBookingLimitValidator { get; set; }

    public GetBookingLimitResponse Get(GetBookingLimit request)
    {
        BookingLimit bookingLimit = new BookingLimitRepository().Get(request.Id);
        return new GetBookingLimitResponse
        {
            Id = bookingLimit.Id,
            ShiftId = bookingLimit.ShiftId,
            Limit = bookingLimit.Limit,
            StartDate = bookingLimit.StartDate,
            EndDate = bookingLimit.EndDate,
        };
    }

    public GetBookingLimitsResponse Get(GetBookingLimits request)
    {
        List<BookingLimit> bookingLimits = new BookingLimitRepository().GetByRestaurantId(base.UserSession.RestaurantId);
        List<GetBookingLimitResponse> listResponse = new List<GetBookingLimitResponse>();

        foreach (BookingLimit bookingLimit in bookingLimits)
        {
            listResponse.Add(new GetBookingLimitResponse
                {
                    Id = bookingLimit.Id,
                    ShiftId = bookingLimit.ShiftId,
                    Limit = bookingLimit.Limit,
                    StartDate = bookingLimit.StartDate,
                    EndDate = bookingLimit.EndDate
                });
        }


        return new GetBookingLimitsResponse
        {
            BookingLimits = listResponse.Where(l => l.EndDate.ToShortDateString() == request.Date.ToShortDateString() && l.StartDate.ToShortDateString() == request.Date.ToShortDateString()).ToList()
        };
    }
}

Jak widzisz, chcę również użyć funkcji sprawdzania poprawności tutaj, więc muszę pisać klasy walidacji dla każdego żądania DTO, które mam. Mam więc wrażenie, że powinienem utrzymywać niski poziom usług, grupując podobne usługi w jedną usługę.

Ale pytanie, które pojawia się w moim umyśle, czy powinienem wysłać więcej informacji, niż potrzebuje tego klient?

Myślę, że mój sposób myślenia powinien się zmienić, ponieważ nie jestem zadowolony z obecnego kodu, który napisałem myśląc jak facet z WCF.

Czy ktoś może mi wskazać właściwy kierunek.