Nome classe molto lungo

Question

Provo a nominare una classe (anche membri, proprietà e così via) il più precisa possibile. Ma a volte non sono sicuro se questo è così intelligente se il nome della classe diventa enorme (50 caratteri e più). La gestione è così scomoda e il codice diventa difficile da leggere.

La domanda si è verificata raramente e quindi non ho molta esperienza con il lavoro con nomi così lunghi, ma di tanto in tanto (ora) si verifica. Come le altre persone gestiscono questo? Hai un limite massimo approssimativo e poi fai abbreviazioni o vale la pena di gestire nomi così lunghi?

Aggiornamento

Come richiesto qui un esempio di tale nome di classe lungo.

ProjectContractChargingPeriodProjectAccountReferenceVM 

Il primo progetto rappresenta il dominio, può essere omesso, perché lo spazio dei nomi già implica che gestisce i progetti. Il problema è che se faccio questo con questo nome di classe, allora devo farlo con tutte le classi di questo spazio dei nomi e che non mi piace in modo definitivo perché molti nomi (brevi) di questo spazio dei nomi perderanno il loro espressività. [Progetto] ContractChargingPeriod descrive l'oggetto, questa classe è utilizzata per e ProjectAccountReference significa che la classe è un riferimento a ProjectAccount. Con ProjectAccount è lo stesso problema di ProjectContract. Solo l'uso di Account non è significativo in quanto nell'app esistono anche altre classi di account. Il Riferimento è un po 'debole perché in realtà è un po' più di un semplice riferimento, ma questo è lo scopo generale. La VM è un'abbreviazione che utilizzo sempre e corrisponde a ViewModel. Penso che questo sia legale perché chiunque lavori con WPF sa cosa significa VM.

Devo dire che la classe è utilizzata per avvolgere una classe da un ORM che è stato creato con uno strumento più vecchio che ho creato molto tempo fa. Le classi lì rappresentano quasi 1: 1 l'ERM e sono consapevole che ciò non è ottimale, ma cambiarlo sarebbe un grande sforzo.

Answer 1

(io uso Java/C++, e hanno usato altri linguaggi OO, ma non C#, quello che dico qui più o meno vale per tutte le lingue che ho usato)

Io uso i nomi delle classi descrittivi. Comunque non credo di averlo fatto a 50 caratteri :-) In genere i nomi di classi lunghe non sono pubblici e di solito sono nascosti dietro un'interfaccia e una fabbrica. L'interfaccia ha un nome molto più corto rispetto alle classi.

Una cosa che potresti fare è, supponendo che tu abbia un numero di classi di lungo nome strettamente correlate, metterle in un pacchetto. Un modo per individuare questo è se le classi hanno tutte le stesse parole di prefisso. Se ci sono un certo numero di classi che iniziano tutte con lo stesso nome, forse, il nome dovrebbe essere un pacchetto.

Answer 2

Avete un limite superiore approssimativa e poi fare abbreviazioni o è vale la pena di gestire tali lunghi nomi?

Nessuno dei due. Nessuna abbreviazione, tranne quelle estremamente ben note come URL o HTTP. E forse per variabili locali con uno scopo molto piccolo. Altrimenti, pensa più a come ottenere nomi che siano sia descrittivi che non molto lunghi (direi che oltre 30 caratteri sono troppo lunghi).

In genere, i nomi lunghi contengono informazioni ridondanti o irrilevanti che possono essere tralasciate. Ad esempio, non inserire informazioni che sono già fornite dal contesto (ovvero informazioni nei nomi dei membri già presenti nel nome della classe). Ed evitare parole di riempimento non specifiche come "dati", "informazioni", "gestore", "gestore", "helper", "calcolo", "processore" - descrivono praticamente tutto il codice e quindi non contengono informazioni reali (e alcune di esse riflettono concetti procedurali e sono quasi un odore di codice per questo solo).

Answer 3

Un nome di classe lungo può essere un suggerimento che la tua classe ha a molte responsabilità (avviso ho detto "può").

Vedere SRP per ulteriori dettagli (mi dispiace, sono di fretta ^^).

Answer 4

50 caratteri sta spingendo la grande fine dei nomi di classe, ma non è inconcepibile. Per quanto riguarda Java, il limite massimo per il nome completo della classe (pacchetto incluso) è 2 bytes.

In natura, le librerie Spring sono famose per i nomi di classi lunghe. Ad esempio, la classe AbstractTransactionalDataSourceSpringContextTests arriva a 49 caratteri. Ciò fornisce test dell'unità con l'iniezione di fagioli a molla (SpringContextTests); iniezione di fonti di dati (DataSource); i test sono a conoscenza delle transazioni (Transactional); la classe in questione è astratta (Abstract).

Provare a spremerlo in meno di 49 caratteri sarebbe una sfida. Queste informazioni potrebbero invece essere fornite nella documentazione, ma per le classi che utilizzano/estendono questa classe che non sarebbe immediatamente evidente. Questo potrebbe ridurre la comprensione per gli sviluppatori che leggono i test delle unità, quindi c'è sicuramente un compromesso qui a cui dovrai pensare.

Answer 5

Come altre persone gestiscono questo? Hai un limite massimo approssimativo e poi fai abbreviazioni o vale la pena di gestire nomi così lunghi?

Una classe dovrebbe rappresentare un tipo di cosa: è un sostantivo (non un verbo, e certamente non un intero una frase).

Mi piace descrivere le mie cose usando una o due parole, forse tre: un solo nome o un nome composto (come in tedesco), o forse un aggettivo e un sostantivo.

Per esempio, ecco un elenco di alcune delle mie classi in un unico progetto:

Ancestors.cs 
Block.cs 
BlockCollection.cs 
BlockDocument.cs 
BlockInline.cs 
BlockInlineText.cs 
BlockListBullet.cs 
BlockListItem.cs 
BlockP.cs 
BlockSequence.cs 
BlockTable.cs 
BlockText.cs 
BlockTextParent.cs 
Border.cs 
BorderEdges.cs 
Box.cs 
Canvass.cs 
CaretLocation.cs 
CaretLocationAndNode.cs 
CaretLocationAndPoint.cs 
CaretLocationData 
CaretLocationPair.cs 
CaretLocationPairAndPoint.cs 
CaretsInBlock.cs 
DebugDumpDom.cs 
DebugOutput.cs 
Display.cs 
Displayed.cs 
DocumentHandle.cs 
DomDocument.cs 
DomDocumentFragment.cs 
DomElementBody 
DomElementHandle.cs 
DomElementTag.cs 
DomEvent.cs 
DomList.cs 
DomNode.cs 
DomNodeChild.cs 
DomRange.cs 
DomRangeBase.cs 
DomTextBody.cs 
DomTextHandle.cs 
Edge.cs 
Editing.cs 
EditingState.cs 
Editor.cs 
EditorAction 
EditorActions 
EditorMutations.cs 
EditorTransaction 
EventListeners.cs 
ExtractedRangeInDomDocument.cs 
ExtraDebugInformation.cs 
FormControl.cs 
... etc ... 

Come potete vedere, la maggior parte dei nomi di classe sono solo due parole (un sostantivo composto).

Uso anche spazi dei nomi per separare le classi in diverse categorie e diversi progetti (il che aiuta a mantenere i nomi delle classi più brevi: perché alcune o la maggior parte delle informazioni gerarchiche si trovano nel nome dello spazio dei nomi, non nel nome della classe).

Se sono fortunato, i nomi di classe sono unici o quasi unici dopo le prime lettere: quindi se scrivo le prime lettere, posso selezionare la classe specifica usando Intellisense. Per questo motivo, non ho bisogno di usare le abbreviazioni.

Answer 6

Per quanto riguarda l'esempio di ProjectContractChargingPeriodProjectAccountReferenceVM, è possibile refactoring in qualcosa di simile:

namespace Project 
{ 
    public class ContractChargingPeriod implements IAccountReference 
    { 
    ... 
    } 

    public interface IAccountReference 
    { 
    ... 
    } 
} 

Il ContractChargingPeriod a che fare con tutta la logica di business relative a contrarre i periodi di carica. Il fatto che implementa IAccountReference indica anche che l'oggetto fa riferimento a un account, ma senza specificarlo nel nome della classe.

È possibile creare viewmodels semplici che riflettono il contenuto di questi tipi, ma i modelli di visualizzazione stessi non devono contenere alcuna logica di business. I viewmodels possono utilizzare la stessa struttura dell'esempio precedente, ma devono essere definiti in uno spazio dei nomi separato.

Answer 7

Ogni volta che ti senti male per i tuoi nomi lunghi, prova a guardare questo corso per più di 5 secondi.

• InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState

E la sua sorella maggiore:: Gli dò

• HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor

Non sento male a questo proposito, i nomi dovrebbero essere autoesplicativo , quindi finché il nome della tua classe è più breve del codice che contiene, penso che siamo tutti bravi.