Sigo esta regla, pero algunos de mis colegas no están de acuerdo con ella y argumentan que si una clase es más pequeña, se puede dejar en el mismo archivo con otras clases.
Otro argumento que escucho todo el tiempo es "Incluso Microsoft no hace esto, entonces ¿por qué deberíamos hacerlo?"
¿Cuál es el consenso general sobre esto? ¿Hay casos en los que esto debe evitarse?
Respuestas:
Una clase por archivo también le da una mejor idea de lo que está cambiando cada registro sin mirar las diferencias del archivo.
fuente
Odio cuando la gente piensa en absoluto y dice que nunca debes hacer esto o aquello con algo subjetivo y quisquilloso como este, como si todos tuviéramos que conformarnos con la estúpida idea de lo correcto y lo incorrecto de alguien. En pocas palabras: tener más de una clase por archivo está totalmente bien si tiene sentido. Por tiene sentido me refiero a cosas como:
Un muy buen ejemplo de por qué podría querer varias clases por archivo:
Supongamos que tengo unas pocas docenas de clases de excepción personalizadas, cada una tiene un revestimiento de 4, podría tener un archivo separado para cada una o podría agrupar las excepciones y tener un archivo por grupo. Para mí, lo que parece el enfoque más racional / pragmático es agruparlos y solo tener algunos archivos, porque es más eficiente en cuanto a tiempo / codificación (no tengo que hacer clic derecho -> Agregar clase, renombrar, 50 veces) , mantiene la solución menos abarrotada y con un mejor rendimiento.
fuente
fuente
A veces agrupo más de una clase dentro de un archivo si están estrechamente acoplados y al menos uno de ellos es muy pequeño.
La 'mejor práctica' general es tener un archivo por clase.
fuente
Más allá de argumentos hipotéticos y enfocándose en Windows .NET con Visual Studio IDE y proyectos de software en crecimiento, tiene sentido en este contexto tener una clase por archivo.
En general, para referencia visual, nada supera una clase por archivo. De Verdad.
No sé si Microsoft hace o no lo mismo, sin embargo, crearon la
partial
palabra clave para dividir una clase en varios archivos (esto es aún más grave). A menudo se usa para dividir el código de diseñador generado automáticamente de su código personalizado en la misma clase (pero a veces se usa para permitir que diferentes desarrolladores trabajen en la clase al mismo tiempo a través de diferentes archivos). Por lo tanto, Microsoft ve los beneficios de múltiples archivos y todos tienen en mente múltiples ideas de organización de archivos con seguridad con .NET.Para las clases anidadas no tiene más remedio que usar un archivo, o al menos las primeras partes de las clases en ellas. Un archivo es necesario y está bien en este caso:
De lo contrario, ¿por qué mantendría múltiples clases en un archivo? El argumento "porque son pequeños" o asociados entre sí sí no retiene mucha agua porque eventualmente sus clases se asociarán con otras clases. En última instancia, no se puede inferir fácilmente la organización en el archivo de los objetos en función de su uso, especialmente a medida que el software continúa creciendo.
Además, si usa carpetas para espacios de nombres , nunca tendrá un choque de nombre de archivo de clase. También es conveniente ubicar una clase por nombre de archivo en el sistema de archivos cuando no está dentro de un entorno de desarrollo como Visual Studio (por ejemplo, si desea editar rápidamente una clase con el Bloc de notas o algo rápido / ligero ).
Tantas buenas razones ...
fuente
partial
palabra clave que mencioné.partial
msdn.microsoft.com/en-us/library/wa80x488(VS.80).aspx Lo busqué por curiosidad.En la gran mayoría de los casos, sigo la regla de una clase por archivo. La única excepción que hago regularmente es la definición de una enumeración que está estrechamente vinculada a una clase específica. En ese caso, frecuentemente incluiré la definición de la enumeración en el archivo de esa clase.
fuente
Yo también creo que debería haber un tipo incluido en un solo archivo.
Hay una excepción a esta regla que debe mencionarse: tener dos clases que difieren solo por un argumento genérico como:
y
fuente
1.cs for
Foo <T> `y Foo2.cs for
Foo <T, T1>`.Foo<T>
yFoo<U>
dentro del mismo espacio de nombres. Pero si los espacios de nombres difieren, generalmente están en carpetas diferentes. Por lo tanto, paraFoo<T>
yFoo<U>
debería ser Foo1.cs and for
Foo <U, T> `Foo`2.cs. Pero todavía una clase por archivo.Realmente, esto se reduce a preferencias personales. Todos dirán "una clase por archivo", pero todos tenemos nuestras razones para evitar eso en ciertas circunstancias. Solía tener un gran proyecto que tenía alrededor de 300 enumeraciones diferentes. De ninguna manera voy a tener 300 archivos separados, uno para cada clase, cuando algunas de las enumeraciones solo eran de tres estados.
Además, para las personas que no pueden encontrar ciertas clases si no están todas en archivos con el nombre de lo que son, ¿hay alguna razón por la que no utilices Buscar buscando en toda la solución? Usar Find me ahorra un tiempo valioso al desplazarme por el Explorador de soluciones.
fuente
No importa cuán liviano sea el contenido, creo que una clase / interfaz / etc. por archivo es esencial.
Si estoy trabajando en una gran solución en Visual Studio, quiero poder ver los archivos y no tener que profundizar para verlos. Incluso con herramientas de navegación como ReSharper, quiero un mapeo 1: 1.
Si encuentra muchos archivos fuente con poco o ningún contenido (tal vez extendiendo una clase pero sin agregarle nada), entonces tal vez debería repensar su diseño.
fuente
Encuentro que agrupar una clase con su clase estándar de fábrica en el mismo archivo es muy útil.
fuente
Normalmente tendría una clase por archivo, pero normalmente tendría que usar su discreción para ver si el archivo podría contener clases relacionadas, por ejemplo, agrupar sus excepciones que usted y otros desarrolladores pueden reutilizar. En este caso, el usuario solo necesita incluir un archivo en lugar de varios archivos.
Entonces el punto es: ¡se debe usar la discreción !
fuente
En soluciones más grandes, creo que es muy valioso tener una clase por archivo y que el archivo tenga el mismo nombre que la clase. Hace que sea mucho más fácil localizar el código en el que necesita trabajar.
fuente
La herramienta StyleCop para C # tiene reglas estándar que no requieren más de una clase de nivel superior en un espacio de nombres (más cualquier número de interfaces, delegados y enumeraciones en ese espacio de nombres).
En los casos de dos o más clases en las que la segunda y las clases posteriores solo son utilizadas por la primera, esas podrían y deberían ser clases internas, visibles solo para la clase consumidora.
fuente
namespace
bloque, ¿verdad?En algún momento una clase por archivo, pero ...
Cuando varias clases están estrictamente relacionadas, más de una clase en el mismo archivo fuente es, en mi humilde opinión, MEJOR que dedicar un archivo fuente corto a cada clase. La fuente es más legible y compacta (y usando #region, la misma fuente puede estar más estructurada que antes).
Considere también que a veces es NECESARIO distribuir la misma clase en diferentes archivos (usando parcial ), ya que tener un archivo fuente de más de 20000 líneas no es útil incluso con la RAM que tengo disponible (pero esta es otra pregunta).
fuente
En ocasiones, dejaré una clase pequeña con una clase más grande, pero solo si están muy estrechamente relacionados como un objeto y es una clase de colección o una fábrica.
Sin embargo, hay un problema con esto. Finalmente, la clase pequeña crece hasta el punto en el que debería estar en su propio archivo, si la mueve al nuevo archivo pierde el acceso fácil a su historial de revisiones.
es decir.
fuente
very tightly related
clase y lo dejaría siempre que solo ocupe una pequeña cantidad de espacio en la pantalla y ninguna otra clase lo use con el mismo propósito.¿Es realmente un problema? :) Las
clases realmente pequeñas, al igual que las enumeraciones, se pueden juntar con otras. Hay una regla a seguir: reunir solo clases que tengan algo en común.
Como una digresión, en uno de mis proyectos tengo un archivo que tiene 150 clases dentro. El archivo tiene 10000 líneas de código. Pero se genera automáticamente, por lo que es totalmente aceptable :)
fuente
Una razón para poner varias clases relacionadas en un archivo es para que el bastardo pobre que usa su API no tenga que pasar medio día escribiendo el boilerplate de la declaración de importación y el bastardo pobre que tiene que mantener el código no tiene que gastar la mitad un día desplazándose a través de repeticiones de declaración de importación. Mi regla general es que varias clases pertenecen al mismo archivo si casi siempre usa un gran subconjunto de ellas al mismo tiempo en lugar de solo una a la vez.
fuente
Hago esto, pero solo cuando las clases están relacionadas de una manera padre-hijo y las clases hijo SOLO son utilizadas por el padre.
fuente
Por lo general, me quedo con una clase por archivo. Pero haré excepciones para grupos de construcciones similares que se utilizan en todo el proyecto. Por ejemplo:
EventArgs
subclases, ya que generalmente son solo 5-10 líneas de código cada una, pero generalmente son utilizadas por varias clases diferentes. Alternativamente, podría poner lasEventArgs
clases en el mismo archivo que la clase que declara los eventos.enum
s utilizados en todo el proyecto. (Si hay unaenum
que solo usa una clase, generalmente llegaréprivate
a esa clase).fuente
Otra votación para una clase por archivo con el nombre del archivo igual a la clase. Para mí, ayuda con la mantenibilidad a largo plazo. Puedo mirar fácilmente a través del repositorio y ver qué clases son parte de una solución sin tener que abrir el proyecto ni ninguno de los archivos.
fuente
Lo sigo el 99% del tiempo. Es bueno seguir los estándares, pero también creo que la flexibilidad tiene su lugar. A veces parece una tonta pérdida de tiempo separar las cosas. En esos momentos, me supero y solo escribo mi código.
fuente
Las respuestas hasta ahora parecen girar en torno a las excepciones de las personas a la regla, así que aquí está la mía: mantengo las clases y sus clases de 'amigos' de metadatos juntas cuando uso el paquete DataAnnotations en .NET3.5 SP1. De lo contrario, siempre están en archivos separados. Ya sabes, la mayor parte del tiempo. Excepto cuando no lo son.
fuente
Solo hago esto raramente. Por ejemplo, si hay una enumeración o estructura que está estrechamente relacionada con la clase pero que es demasiado trivial para separarse por sí sola.
O una clase separada para contener algunos métodos de extensión para esa clase principal.
fuente
One case could be:
cuando sus clases forman conjuntamente una clasemodule / unit
que sirve a algunas clases principales comohelper classes
, por lo demás, no .Eche un vistazo al código fuente del proyecto ASP.NET MVC 2.0 . Sigue estrictamente esta regla
fuente
Me gusta la idea de crear clases más pequeñas y asegurarme de que la clase solo haga lo que se supone que debe hacer. Si tiene varias clases que contribuyen a resolver un solo problema, entonces no hay nada de malo en juntarlas en el mismo archivo.
¡No seguiría las prácticas de EM ya que no son las MEJORES PRÁCTICAS!
fuente
Otro punto que no he visto mencionar a nadie más es que cuando desarrollas usando la regla de una clase por archivo, puedes ver fácilmente qué está usando esa clase específica.
Por ejemplo: puede tener dos clases donde una clase usa Linq y la otra no.
Si estas clases estuvieran en el mismo archivo, no podría saber sin mirar a través del código qué clase usa qué. Cuando se trata de una clase por archivo, todo lo que tiene que hacer es mirar la parte superior del archivo para ver exactamente qué se está utilizando en esa clase. Ayuda si alguna vez está migrando a una nueva biblioteca, etc.
fuente
Otra razón para una clase por archivo que no se ha mencionado en las respuestas publicadas hasta ahora es que una clase por archivo facilita la comprensión del impacto de un RP durante una revisión de código. También reduce los conflictos de fusión.
Cuando alguien publica un RP para recibir comentarios, puedo mirar la lista de archivos modificados e inmediatamente ver cualquier superposición con lo que podría estar trabajando. Dependiendo de la superposición, es posible que desee ver su código más profundamente o darle un visto bueno porque estoy bastante seguro de que no afectará mis propios cambios.
Cuando dos personas trabajan en un archivo de varias clases y ambas agregan una dependencia, existe una buena posibilidad de que se produzca un conflicto de fusión en el
using
bloque en la parte superior. La separación de las clases en archivos separa las dependencias para que pueda ver qué está usando cada clase y no obtener conflictos como este.Hay excepciones a esta regla (interfaz + implementación, enumeraciones, ...) pero es un mejor punto de partida que lo contrario, lo que generalmente permite a los desarrolladores junior agrupar todo tipo de clases no relacionadas en el mismo archivo.
fuente
La ida y vuelta ha sido muy interesante y aparentemente poco concluyente, aunque mi impresión general es que un mapeo 1-1 entre clases y archivos es la opinión mayoritaria, aunque con algunas excepciones persona por persona.
Tengo curiosidad por saber si alguna de sus respuestas varía según si: (1) está desarrollando una aplicación de formularios Windows Forms, una aplicación web, una biblioteca o lo que sea; o (2) usando Visual Studio o no. Al usar VS, parecería que la regla de una clase por archivo también implicaría una clase por proyecto de VS ya que el consenso en otros hilos parece ser que las soluciones / proyectos de VS deben reflejarse en el nombre y la estructura del directorio / archivo. De hecho, mi impresión es que el consenso es tener el nombre del proyecto = nombre del conjunto = nombre del espacio de nombres (anidado), todo lo cual se reflejaría en la estructura y el nombre del directorio / archivo. Si esas son las pautas (o reglas) correctas, todos estos mecanismos de organización aparentemente ortogonales se mantendrían sincronizados.
fuente
Sí, en aras de la legibilidad, ¡deberíamos tener un archivo por clase! Acabo de saltar a un proyecto. Veo muchas clases en un archivo. solo hace que sea muy difícil para un chico nuevo entenderlo. ¿No deberíamos pensar en la mantenibilidad? cuando desarrollamos un software? muchas veces el desarrollo continuará por otros desarrolladores. Tenemos espacios de nombres para organizar nuestras cosas, ¡no necesitamos archivos para hacerlo !.
fuente
Un elemento de código por archivo, sí.
Todo lo demás es una mala práctica y, francamente, una señal de victimización por RAD.
Tan pronto como uno comienza el desarrollo de software adecuado (IoC, patrones de diseño, DDD, TDD, etc.) y abandona el "omg vamos a hacer esto, no tengo idea de cómo, pero me pagan", uno verá que esta regla realmente, realmente, importa.
fuente