Sangría para funciones de c #

Question

Solo estoy buscando mejorar mi sangría en mi código actual. Me encantaría escuchar comentarios y mejoras.

public class DataAccess
{

    public List<ComplaintModel> GetComplaint(string _OrderNumber)
    {
        throw new NotImplementedException();
    }

    public void InsertComplaint(
        DateTime _Date,
        string _OrderNumber,
        string _CustomerName,
        string _CustomerContactName,
        string _Telephone,
        string _Email,
        string _CustomerReference,
        string _Product,
        string _PackSize,
        string _BatchNumber,
        DateTime _BestBeforeDate,
        string _QuantityInvolved,
        string _Details, 
        string _Comments)
    {
        using(MySqlConnection conn = new MySqlConnection(ConnectionString.ConnString))
        {
            List<ComplaintModel> complaint = new List<ComplaintModel>();

            complaint.Add(new ComplaintModel { Date = _Date,
                OrderNumber = _OrderNumber,
                CustomerName = _CustomerName,
                CustomerContactName = _CustomerContactName,
                Telephone = _Telephone,
                Email = _Email,
                CustomerReference = _CustomerReference,
                Product = _Product,
                PackSize = _PackSize,
                BatchNumber = _BatchNumber,
                BestBeforeDate = _BestBeforeDate,
                QuantityInvolved = _QuantityInvolved,
                Details = _Details,
                Comments = _Comments});

            conn.Execute(@"INSERT INTO customer_complaints 
                        (date_taken, order_number, customer_name, customer_contact, telephone, email, customer_reference, product, pack_size, batch_lot_number,
                        best_before_date, quantity_involved, details, comments) 
                        VALUES (@Date, @OrderNumber, @CustomerName, @CustomerContactName, @Telephone, @Email, @CustomerReference, @Product, @PackSize, @BatchNumber,
                        @BestBeforeDate, @QuantityInvolved, @Details, @Comments)", complaint);
        }
    }
}

Answer 1

Hay dos lugares donde usaría var:

var conn = new MySqlConnection(ConnectionString.ConnString)
var complaint = new List<ComplaintModel>();

Ya no tiene que poner llaves alrededor de un bloque de uso, lo que le ahorra un nivel de sangría:

using var conn = new MySqlConnection(ConnectionString.ConnString);

No coloque el primer parámetro al final de la línea y el resto en una nueva línea. Coloque también el primer parámetro en una nueva línea:

complaint.Add(new ComplaintModel {
    Date = _Date,
    ...

Si inicia la cadena de consulta en una nueva línea, puede retroceder un nivel de sangría:

conn.Execute(
    @"INSERT INTO customer_complaints
    ...

Answer 2

Dennis_E tiene buenos consejos, pero hay dos cosas que haría de manera diferente.

1. La declaración de inserción de SQL se ve bien tal como está. El código se lee bien, pero declararía una constante privada en la clase para almacenar la declaración.

2. También coloque las llaves para el inicializador de objetos en sus propias líneas:

   complaint.Add(new ComplaintModel     
   {
       Date = _Date,
       OrderNumber = _OrderNumber,
       CustomerName = _CustomerName,
       CustomerContactName = _CustomerContactName,
       Telephone = _Telephone,
       Email = _Email,
       CustomerReference = _CustomerReference,
       Product = _Product,
       PackSize = _PackSize,
       BatchNumber = _BatchNumber,
       BestBeforeDate = _BestBeforeDate,
       QuantityInvolved = _QuantityInvolved,
       Details = _Details,
       Comments = _Comments
   });
   

Algunas observaciones adicionales no relacionadas con la sangría:

• Cambie el nombre de sus parámetros a camelCase en lugar de PascalCase con guiones bajos iniciales. La convención de nomenclatura idiomática en C # sería en quantityInvolvedlugar de _QuantityInvolved.

  Puede parecer insignificante, pero alcanzar la tecla de mayúsculas y / o la tecla de subrayado ralentiza la velocidad de escritura. Es "muerte por mil recortes de papel". Una pequeña disminución en la velocidad por sí sola no importa. Multiplique eso por cientos de veces al día que hace esto mientras escribe el código y se suma.

Answer 3

Tienes un método con catorce parámetros, esto es demasiado. Los nombres de estos parámetros tampoco siguen el que se usa habitualmente en C #: camelCased, y sin prefijo de subrayado.

¿Por qué no construir un ComplaintModely pasarlo a InsertComplaint()?

---

DataAccesses en mi humilde opinión un nombre demasiado genérico. Tendrá la tentación de llenar esto con docenas de métodos, centralizando toda la lógica de su base de datos allí, y se volverá inmanejable. Considere tener un "Servicio de quejas", por ejemplo, en el que solo tenga los métodos relacionados con las quejas, o incluso vaya al CQRS completo .

---

No abrevie los nombres sin sentido. Puedo vivir con conn(aunque preferiría mySqlConnection), pero no ConnStringtiene sentido. Entiendo que hizo esto para evitar problemas con la clase nombrada ConnectionString, pero luego debería cambiar el nombre de esa clase.

---

Darle nombres propios a las cosas: List<ComplaintModel> complaintestá mal porque es literalmente una lista de quejas, y por eso debería llamarse complaints.

---

No soy fanático de SQL en línea cuando se vuelve largo. Soy un fanático de incrustar scripts .SQL y luego leerlos usando un QueryRetriever . La ventaja es que dichos scripts .SQL también se codifican por colores en Visual Studio (aunque me gustaría que hubiera una forma de tener diferentes extensiones según el tipo de consulta, por ejemplo, SQL Server frente a MySql frente a Oracle, etc.).