¿Creando enum vs nulable bool para la legibilidad? [cerrado] -- # camp codereview Relacionados El problema

Creating Enum vs Nullable bool for readability? [closed]


-7
vote

problema

Español
cerrado. Esta pregunta es off-topic . Actualmente no está aceptando respuestas.

¿Quieres mejorar esta pregunta? Actualizar la pregunta por lo que es on-topic para el intercambio de pila de revisión de código.

CERRADO hace 6 años .

Mejorar esta pregunta

¿Cuál es más verboso?

  private bool? _hasChangesToReconcile; public bool HasChanges() {     if (!_hasChangesToReconcile.HasValue)     {         if (Model != null)         {             using (var broker = _documentBrokerDelegateFactory())             {                   return broker.Value.HasSectionChanges(Model.Id);                 _hasChangesToReconcile = broker.Value.HasSectionChanges(Model.Id);             }         }         else         {             _hasChangesToReconcile = false;         }     }     return _hasChangesToReconcile.Value; }   public void Handle(PageSectionVersionsCreated message) {     if (!message.ChangesApplyTo(Model))         return;     _hasChangesToReconcile = null;     NotifyOfPropertyChange(() => ItemType); }   

o

  private State _pageStatus; private enum PageStatus {     HasChanges,     NoChanges, } private bool _hasChanges; public bool HasChanges() {     if (_pageStatus == PageStatus.HasChanges)     {         if (Model != null)         {             using (var broker = _documentBrokerDelegateFactory())             {                 _hasChanges = broker.Value.HasSectionChanges(Model.Id);             }         }     }     return _hasChanges; }   public void Handle(PageSectionVersionsCreated message) {     if (!message.ChangesApplyTo(Model))         return;     _pageStatus = PageStatus.HasChanges;     NotifyOfPropertyChange(() => ItemType);     _pageStatus = PageStatus.NoChanges; }   
Original en ingles

Which one is more verbose?

private bool? _hasChangesToReconcile; public bool HasChanges() {     if (!_hasChangesToReconcile.HasValue)     {         if (Model != null)         {             using (var broker = _documentBrokerDelegateFactory())             {                   return broker.Value.HasSectionChanges(Model.Id);                 _hasChangesToReconcile = broker.Value.HasSectionChanges(Model.Id);             }         }         else         {             _hasChangesToReconcile = false;         }     }     return _hasChangesToReconcile.Value; }   public void Handle(PageSectionVersionsCreated message) {     if (!message.ChangesApplyTo(Model))         return;     _hasChangesToReconcile = null;     NotifyOfPropertyChange(() => ItemType); } 

or

private State _pageStatus; private enum PageStatus {     HasChanges,     NoChanges, } private bool _hasChanges; public bool HasChanges() {     if (_pageStatus == PageStatus.HasChanges)     {         if (Model != null)         {             using (var broker = _documentBrokerDelegateFactory())             {                 _hasChanges = broker.Value.HasSectionChanges(Model.Id);             }         }     }     return _hasChanges; }   public void Handle(PageSectionVersionsCreated message) {     if (!message.ChangesApplyTo(Model))         return;     _pageStatus = PageStatus.HasChanges;     NotifyOfPropertyChange(() => ItemType);     _pageStatus = PageStatus.NoChanges; } 
  
         
         

Lista de respuestas

1
 
vote
vote
La mejor respuesta
 

El comportamiento de los dos fragmentos es ligeramente diferente:

  • En el 2º _pageStatus = PageStatus.NoChanges;5 en el método Handle
  • En la primera, estableció un valor no nulo en el método HasChanges

para hacerlos iguales La segunda implementación debe ser así:

  public bool HasChanges() {     if (_pageStatus == PageStatus.HasChanges)     {         _pageStatus = PageStatus.NoChanges;         if (Model != null)         {             using (var broker = _documentBrokerDelegateFactory())             {                 _hasChanges = broker.Value.HasSectionChanges(Model.Id);             }         }     }     return _hasChanges; }   public void Handle(PageSectionVersionsCreated message) {     if (!message.ChangesApplyTo(Model))         return;     _pageStatus = PageStatus.HasChanges;     NotifyOfPropertyChange(() => ItemType); }   

Tu enumo de dos estados podría ser otro booleano, por ejemplo. bool _resetHasChanges .


Encuentro que tener dos variables relacionadas es más detallado que tener una variable 99887776665554433101065544331010, especialmente cuando la segunda variable de enumeración está siguiendo si la primera variable tiene un valor asignado.

 

The behaviour of the two fragments is slightly different:

  • In the 2nd you _pageStatus = PageStatus.NoChanges; in the Handle method
  • In the first you set a non-null value in the HasChanges method

To make them equal the 2nd implementation should be like this:

public bool HasChanges() {     if (_pageStatus == PageStatus.HasChanges)     {         _pageStatus = PageStatus.NoChanges;         if (Model != null)         {             using (var broker = _documentBrokerDelegateFactory())             {                 _hasChanges = broker.Value.HasSectionChanges(Model.Id);             }         }     }     return _hasChanges; }   public void Handle(PageSectionVersionsCreated message) {     if (!message.ChangesApplyTo(Model))         return;     _pageStatus = PageStatus.HasChanges;     NotifyOfPropertyChange(() => ItemType); } 

Your two-state enum could be another boolean, e.g. bool _resetHasChanges.


I find that having two related variables is more verbose than having a single bool? variable, especially when the 2nd enum variable is just tracking whether the first variable has an assigned value.

 
 
   
   
2
 
vote

Este código aquí se puede simplificar

  JSON.parse1  

para que regrese dentro de la instrucción IF que es más clara a lo que está sucediendo y realiza menos operaciones

  JSON.parse2  

Si hubo un bucle aquí donde había más de un cambio para reconciliar, podría verlo de otra manera, pero como es, este código es más limpio y más al punto.


Lo mismo con este bit de código desde el segundo conjunto de código

  JSON.parse3  

Usted debe simplemente devolver JSON.parse4 como este

  JSON.parse5  

algo más que noté:

Ambos conjuntos de código usan un condicional negativo dentro de la instrucción IF del método de la manija

  JSON.parse6  

Esto debe ser reescrito para expresar esto en términos de un positivo. Debería lucir así:

  JSON.parse7  

Ya que no está devolviendo nada de todos modos, este es el enfoque más lógico, y se ve mucho más limpio.


, así que supongo que podría decir que son los dos verbose

 

this code here can be simplified

if (!_hasChangesToReconcile.HasValue) {     if (Model != null)     {         using (var broker = _documentBrokerDelegateFactory())         {             _hasChangesToReconcile = broker.Value.HasSectionChanges(Model.Id);         }     }     else     {         _hasChangesToReconcile = false;     } } return _hasChangesToReconcile.Value; 

so that you return inside the if statement which is clearer to what is going on and performs less operations

if (!_hasChangesToReconcile.HasValue) {     if (Model != null)     {         using (var broker = _documentBrokerDelegateFactory())         {             return broker.Value.HasSectionChanges(Model.Id);         }     }     else     {         return false;     } } 

if there was a loop here where there was more than one Change to reconcile I could see doing it the other way, but as is, this code is cleaner and more to the point.


Same thing with this bit of code from the second set of code

if (_pageStatus == PageStatus.HasChanges) {     if (Model != null)     {         using (var broker = _documentBrokerDelegateFactory())         {             _hasChanges = broker.Value.HasSectionChanges(Model.Id);         }     } } return _hasChanges; 

you should just return broker.Value.HasSectionChanges(Model.Id) like this

if (_pageStatus == PageStatus.HasChanges) {     if (Model != null)     {         using (var broker = _documentBrokerDelegateFactory())         {             return broker.Value.HasSectionChanges(Model.Id);         }     }     else     {         return false;     } } 

Something else that I noticed:

both sets of code use a negative conditional inside the if statement of the Handle Method

public void Handle(PageSectionVersionsCreated message) {   if (!message.ChangesApplyTo(Model))       return;   _pageStatus = PageStatus.HasChanges;   NotifyOfPropertyChange(() => ItemType);     _pageStatus = PageStatus.NoChanges; } 

this should be rewritten to express this in terms of a positive. it should look like this:

public void Handle(PageSectionVersionsCreated message) {     if (message.ChangesApplyTo(Model))     {         _pageStatus = PageStatus.HasChanges;         NotifyOfPropertyChange(() => ItemType);         _pageStatus = PageStatus.NoChanges;     } } 

since you aren't returning anything anyways, this is the more logical approach, and it looks way cleaner.


So I guess that you could say that they are both Verbose

 
 
1
 
vote

En el primer bloque de código, tiene código que es inalcanzable

  JSON.parse8  

JSON.parse9 nunca se establece en JSON.stringify0

Si necesita ese conjunto, debe hacerlo antes de la devolución.

 

in the first code block you have code that is unreachable

using (var broker = _documentBrokerDelegateFactory()) {     return broker.Value.HasSectionChanges(Model.Id);     _hasChangesToReconcile = broker.Value.HasSectionChanges(Model.Id); } 

hasChangesToReconcile is never set to broker.Value.HasSectionChanges(Model.Id)

if you need that set, you should do it before the return.

 
 

Relacionados problema

6  PRIGO DE PODER TICTACTOO EN C #  ( Command prompt tictactoe in c ) 
Escribí un juego básico de comando TIC TAC TOE juego. Quiero saber qué se puede mejorar en términos de modelado y qué errores he hecho (si corresponde). vo...

3  Generador de imágenes de Mandelbrot con iteración paralela  ( Mandelbrot image generator with parallel iteration ) 
Actualmente estoy tratando de optimizar esta clase que tengo para la generación fractal. La ecuación está destinada a ser conectable; He usado z => z*z + c ...

3  Genéricos anulables - implementando secuencialSearchst en C #  ( Nullable generics implementing sequentialsearchst in c ) 
Para fines de aprendizaje, estoy implementando cierto código de SEDEDWICK & AMP; Los algoritmos de Wayne, cuarta edición . Debido a las características del...

35  Demasiados bucles en la aplicación de dibujo  ( Too many loops in drawing app ) 
Tengo un método que tiene muchos bucles: #ifndef __RUNES_STRUCTURES_H #define __RUNES_STRUCTURES_H /* Runes structures. */ struct Game { char board[2...

1  TPL HILO FUGA Y FUGA DE MEMORIA  ( Tpl thread leak and memory leak ) 
Estoy tratando de rastrear lo que supongo que debo ser una pérdida de memoria / hilo en uno de mis programas. Mi programa usa una función para cargar un arc...

6  ¿Está mi delegado definió la forma correcta y necesita transformarse en una mariposa bonita?  ( Is my delegate defined the right way and does it need to transform to a pretty e ) 
He leído tantos Historias de tiempo de cama e inserciones de cómo < fuertes> delegados trabajo y por qué eventos deben ser reemplazados por los delegado...

7  Versión LINQ del algoritmo de recocido simulado  ( Linq version of the simulated annealing algorithm ) 
Decidí intentarlo e implementar (una versión de) la recocido simulado algoritmo usando solo linq , solo para ver si pudiera. Me encantaría si alguien pudi...

3  Mientras que el bucle usa variables adicionales, ¿se puede limpiar esto?  ( While loop uses extra variables can this be cleaned up ) 
Una pieza de mi programa permite que se utilice el bucle y la incremento de una entidad seleccionada en un bucle de tiempo en otro lugar. Aquí hay una muestra...

0  Creación de múltiples objetos del extracto de SQL Server  ( Creating multiple objects from sql server extract ) 
He creado una solución prototipo simplificada como una especie de prueba de concepto antes de comenzar un programa más grande. Aquí están los datos de prueb...

7  Colecciones vacías en caché  ( Cached empty collections ) 
A menudo necesito devolver las colecciones vacías. Uno de esos días, escribí lo siguiente para devolver una instancia en caché: public static class Array<...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos