risposta-alla-domanda-sullo-sviluppo-web-bd.com

Qual è un esempio del principio di responsabilità unica?

Qualcuno può darmi un esempio del Principio di Responsabilità Unica? Sto cercando di capire cosa significa, in pratica, che una classe abbia una singola responsabilità, perché temo che io possa infrangere questa regola ogni giorno.

27
Sachin Kainth

Dai un'occhiata a Solid description

A meno che tu non chieda qualcosa di più specifico, sarà difficile aiutare di più.

La singola responsabilità è il concetto di una classe che fa una cosa specifica (responsabilità) e non cerca di fare più di quanto dovrebbe, che è anche nota come alta coesione.

Le classi spesso non iniziano con la bassa coesione, ma in genere dopo diverse versioni e diversi sviluppatori che si aggiungono a loro, improvvisamente noterai che è diventato un mostro o una classe di Dio come alcuni chiamano. Quindi la classe dovrebbe essere refactored.

È difficile pensare ad un buon esempio, ma quello che posso pensare di recente sarebbe una classe che abbiamo che gestisce diverse fasi di elaborazione dei pacchetti, un tipo di Chain of Responsibility. L'intenzione iniziale di questa classe era di mantenere un elenco di fasi e di orchestrare il pacchetto packetProcess () su di esse. Bene, si è concluso che tutti hanno aggiunto qualcosa a che fare con le fasi di elaborazione (poiché la classe manager era un posto facile per accedere alle fasi) a questa classe manager, in particolare la configurazione dello stage. La classe manager non aveva più una singola responsabilità, ma era anche responsabile di effettuare chiamate alle fasi per le modifiche alla configurazione: quindi la coesione era stata ridotta.

Abbiamo finito con il dover refactoring della classe manager, estrapolando tutte le configurazioni del palco e inserendole in una fabbrica, lasciando così il manager a fare ciò che intendeva fare.

4
Brady

Il modo più efficace per spezzare le applicazioni per creare DIO classi. Sono classi che tengono traccia di molte informazioni e hanno diverse responsabilità. Una modifica del codice molto probabilmente interesserà altre parti della classe e quindi indirettamente tutte le altre classi che la usano. Ciò a sua volta porta a un pasticcio di manutenzione ancora più grande dal momento che nessuno osa apportare modifiche diverse dall'aggiunta di nuove funzionalità.

L'esempio seguente è una classe TypeScript che definisce un Person, questa classe non deve includere la convalida dell'email perché non è correlata a un comportamento di una persona:

class Person {
    public name : string;
    public surname : string;
    public email : string;
    constructor(name : string, surname : string, email : string){
        this.surname = surname;
        this.name = name;
        if(this.validateEmail(email)) {
          this.email = email;
        }
        else {
            throw new Error("Invalid email!");
        }
    }
    validateEmail(email : string) {
        var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
        return re.test(email);
    }
    greet() {
        alert("Hi!");
    }
}

Possiamo migliorare la classe di cui sopra rimuovendo la responsabilità della convalida della posta elettronica dalla classe Person e creando una nuova classe Email che avrà tale responsabilità:

class Email {
    public email : string;
    constructor(email : string){
        if(this.validateEmail(email)) {
          this.email = email;
        }
        else {
            throw new Error("Invalid email!");
        }        
    }
    validateEmail(email : string) {
        var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
        return re.test(email);
    }
}

class Person {
    public name : string;
    public surname : string;
    public email : Email;
    constructor(name : string, surname : string, email : Email){
        this.email = email;
        this.name = name;
        this.surname = surname;
    }
    greet() {
        alert("Hi!");
    }
}

Fare in modo che una classe abbia una singola responsabilità rende per impostazione predefinita anche più facile vedere cosa fa e come è possibile estenderlo/migliorarlo.

32
Remo H. Jansen

Single Responsibility Principle (SRP) afferma che una classe o un metodo dovrebbero fare solo una cosa e non dovrebbe essere nulla che faccia qualcosa relativo. Una classe dovrebbe avere solo una ragione per cambiare.

Un esempio tipico potrebbe essere una classe EmailSender:

  • questo dovrebbe solo gestire l'invio di una email.
  • questo non dovrebbe essere responsabile del caricamento del contenuto dell'email dal database o persino della formattazione del contenuto dell'email da inviare.

Qui è un articolo su questo.

2
Ranganatha

Una classe dovrebbe avere solo una ragione per cambiare.

Questo principio afferma che se abbiamo 2 motivi per cambiare per una classe, dobbiamo dividere la funzionalità in due classi. Ogni classe gestirà una sola responsabilità e se in futuro dovremo apportare una modifica, la faremo nella classe che la gestisce.

Se ci sono due diversi motivi per cambiare, è ipotizzabile che due team diversi possano lavorare sullo stesso codice per due diversi motivi. Ognuno dovrà implementare la propria soluzione, che nel caso di un linguaggio compilato (come C++, C # o Java), può portare a moduli incompatibili con altri team o altre parti dell'applicazione.

Questo principio è strettamente correlato ai concetti di accoppiamento e coesione. L'accoppiamento si riferisce al modo in cui i diversi aspetti di un'applicazione sono collegati in modo inestricabile, mentre la coesione si riferisce a quanto strettamente correlato può essere il contenuto di una particolare classe o pacchetto. Tutti i contenuti di una singola classe sono strettamente accoppiati, poiché la classe stessa è una [singola unità] [1] che deve essere interamente utilizzata o non essere affatto utilizzata.

Il mio post sul blog su questo:

http://javaexplorer03.blogspot.in/2016/12/single-responsibility-principle.html

1
Rajesh Dixit