Czy do każdej klasy Angular trzeba tworzyć aż tyle funkcji?

Jestem nowy w Angular i zastanawia mnie fakt, czy do każdej klasy trzeba tworzyć aż tyle funkcji?

Tworzę aplikacje Angular oraz używam backendu Django Rest Framework.

dla przykładu: Mam klasę obiektu Hero.

• żeby dodać obiekt klasy Hero mam funkcję:
  add(name: string): void {...} która wywołuje funkcje addHero (hero: Hero): Observable<Hero> {...}.

• żeby pobrać pojedynczy obiekt Hero:
  getHeroes(): void {...} która wywołuje funkcje getHeroes (): Observable<Hero[]> {...} i obsługuje pobrane obiekty

• żeby pobrać pojedynczy obiekt Hero:
  getHero(): void {...} która wywołuje funkcje getHero(id: number): Observable<Hero> {...}.

• żeby zapisać zmiany w obiekcie Hero:
  ** save(): void {}** która wywołuje funkcje updateHero (hero: Hero): Observable<any> {...} .

• żeby usunąć obiekt Hero:
  delete(hero: Hero): void {...} która wywołuje funkcje deleteHero (hero: Hero | number): Observable<Hero> {...}.

To daje co najmniej 10 funkcji a to zaledwie jedna klasa. Jeśli będę miał tych klas kilkanaście albo 100.
Czy muszę wówczas dla stu klas tworzyć tysiąc bardzo podobnych funkcji, żeby obsłużyć wszystkie klasy obiektów.
Czy może w praktyce pisze się to jakoś inaczej??

Lepiej mieć 10 metod w klasie które mają relatywnie mało kodu i są łatwo testowalne niż 2 które są wielkie. Moim zdaniem to nic złego.

Veox napisał(a):

Lepiej mieć 10 metod w klasie które mają relatywnie mało kodu i są łatwo testowalne niż 2 które są wielkie. Moim zdaniem to nic złego.
Zgadzam się że to nic złego.

Stworzyłem takie funkcje w pliku Service:

  getAnyObject(id: number, urExt: string): Observable<any> {
    const url = this.url + urExt + id;
    return this.http.get<any>(url).pipe(
      tap(_ => this.log('fetched Object id=' + urExt + id))
    );
  }
  getAnyObjects(urExt: string): Observable<any[]> {
    return this.http.get<any[]>(this.url + urExt)
      .pipe(
        tap(_ => this.log('fetched ' + urExt))
      );
  }
  deleteAnyObject(obj: any | number, urExt: string): Observable<any> {
    const id = typeof obj === 'number' ? obj : obj.id;
    const url = this.url + urExt + id + '/';
    return this.http.delete<any>(url, httpOptions).pipe(
      tap(_ => this.log(`deleted Object (` + urExt + `id=${id}`))
      // , catchError(this.handleError<any>('deleteObject'))
    );
  }
  addAnyObject(obj: any, urExt: string): Observable<any> {
    return this.http.post<any>(this.url + urExt, obj, httpOptions).pipe(
      tap((newObj: any) => this.log(`added newObj (` + urExt + `) w/ id=${newObj.id}`))
    );
  }
  updateAnyObject(obj: any, urExt: string): Observable<any> {
    return this.http.put(this.url + urExt + obj.id + '/', obj, httpOptions).pipe(
      tap(_ => this.log(`updated obj id=${obj.id}`))
    );
  }

Na chwilę obecną wszystko działa. Czy jest to poprawne rozwiązanie?
Czy może w późniejszych etapach mogą wystąpić jakieś komplikacje?

Rozwiązanie może i jest poprawne, ale na pewno nie jest ładne ani odporne na błędy. Wszędzie używasz any, czyli takiego typu, gdzie może wejść cokolwiek - liczba, obiekt, ciąg znaków, sam sobie wybierz. Nie znam kontekstu Twojego kodu, ale zdecydowanie lepiej byłoby porobić sobie metody, które działają na konkretnych obiektach. Dzięki temu unikniesz sytuacji, że ktoś wywoła sobie np. addAnyObject podając jako parametr coś, czego nie powinien (skąd ma to wiedzieć?) i się wszystko wykrzaczy. Ogólnie nie polecam używania any, bo się można zakopać potem we własny kod. Podefiniuj sobie interfejsy i na nich działaj.