Cómo agregar métodos a una clase en C #

En este tutorial avanzaremos con la clase Customer que creamos en el último episodio. Ahora queremos seguir aprendiendo los fundamentos orientados a objetos en C #, y para hacerlo vamos a comenzar a buscar Métodos. Nuestra clase de Cliente necesitará algunos métodos como Validate (), Retrieve () y Save () para que sea más útil. Las propiedades solo contienen datos, pero si queremos que la clase pueda funcionar, necesitamos agregar estos métodos. También revisaremos el concepto de constructores en C # y la programación orientada a objetos.

---

Agregar un método

El primer método que podemos crear es un método Validate (). En C # puede usar la sintaxis de funciones para crear un método. Utilizaremos la palabra clave pública, para que se pueda acceder desde otras partes de la aplicación. Este método devolverá verdadero o falso. Esto es lo que llamamos un booleano. Por lo tanto, debemos escribir este método como tal. Entonces, justo después de la palabra clave pública, debemos usar la palabra clave bool. Después de la palabra clave bool viene el nombre del método que elegimos, y lo llamaremos Validate (). En el cuerpo del método hay algo de lógica para validar los valores de propiedad Apellido y Dirección de correo electrónico. Este código se destaca a continuación en nuestra clase de cliente de crm .
Customer.cs

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

using System;   namespace CRMBIZ {     public class Customer     {         public static int InstanceCount { get; set; }         private string _lastName;         public string LastName         {             get             {                 return _lastName;             }             set             {                 _lastName = value;             }         }           public string FirstName { get; set; }           public string EmailAddress { get; set; }           public int CustomerId { get; private set; }           public string FullName         {             get             {                 string fullName = LastName;                 if (!string.IsNullOrWhiteSpace(FirstName))                 {                     if (!string.IsNullOrWhiteSpace(fullName))                     {                         fullName += ", ";                     }                     fullName += FirstName;                 }                 return fullName;             }         }           public bool Validate()         {             var isValid = true;               if (string.IsNullOrWhiteSpace(LastName)) isValid = false;             if (string.IsNullOrWhiteSpace(EmailAddress)) isValid = false;               return isValid;         }     } }

---

Probando un nuevo método

Ya tenemos una clase de prueba configurada para nuestra clase de Cliente llamada CustomerTest. Revisemos esa clase de prueba y agreguemos un nuevo método de prueba para confirmar que nuestro método Validate () funciona. Por brevedad, solo mostraremos el método de prueba, no todo el archivo de clase de prueba. Al crear pruebas de código automatizadas, tiene sentido tener una prueba de valores válidos y una prueba de valores no válidos. Esta primera prueba a continuación prueba valores válidos para el método. Los comentarios dan una idea de cómo seguir el proceso de las pruebas. En otras palabras, configure algunos datos, realice una acción utilizando el código que está tratando de probar y luego confirme los resultados.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

[TestMethod] public void ValidateValid() {     // Set up the data     var customer = new Customer();     customer.LastName = "Smith";     customer.EmailAddress = "Hsmith@greenenergy.com";       var expected = true;       // Take an action     var actual = customer.Validate();       // Assert the results     Assert.AreEqual(expected, actual); }

En el código de prueba anterior, primero creamos un nuevo Cliente y luego completamos la propiedad Apellido y la propiedad Dirección de correo electrónico. Es necesario completar esas dos propiedades en nuestro método original Validate (). Entonces, dado que ese es el caso, esperamos que esto vuelva a ser cierto en este escenario. Declaramos esto con la var esperado = verdadero; sintaxis. Luego, llamamos al método Validate () fuera del objeto del cliente y almacenamos el valor de retorno en la actualvariable. Por último, utilizamos el método Assert.AreEqual () para confirmar eso expectedy actual, de hecho, son iguales. Y de hecho, lo son porque nuestra prueba pasa cuando la ejecutamos.

---

Prueba de datos no válidos

El código anterior prueba datos válidos. ¿Qué pasa con los datos inválidos? Considere que faltan los datos de Apellido, ¿entonces qué? El siguiente código nos muestra cómo podemos hacer eso. Note que esta vez, cuando estamos configurando los datos, no completamos el campo Apellido. Esto está mal, por lo que esperamos que el método Validate () devuelva falso en este escenario. Por lo tanto, la expectedvariable se establece en falso. Cuando Validate () llamó, debería devolver false y almacenarlo en actual. Ahora, expectedes falso , y actualdebería ser falso , por lo que Assert.AreEqual () debería ser verdadero.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

[TestMethod] public void ValidateMissingLastName() {     // Set up the data     var customer = new Customer();     customer.EmailAddress = "Hsmith@greenenergy.com";       var expected = false;       // Take an action     var actual = customer.Validate();       // Assert the results     Assert.AreEqual(expected, actual); }

Consejo profesional: para ejecutar solo una prueba en lugar de todo el conjunto, puede hacer clic con el botón derecho en el nombre del método de prueba que se ejecutará y luego elegir "Ejecutar pruebas seleccionadas".

Podemos agregar un método de prueba más para datos no válidos. Esta vez, comprobaremos si falta una dirección de correo electrónico. Aquí está el método de prueba para lo que llamamos ValidateMissingEmailAddress ().

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

[TestMethod] public void ValidateMissingEmailAddress() {     // Set up the data     var customer = new Customer();     customer.LastName = "Smith";       var expected = false;       // Take an action     var actual = customer.Validate();       // Assert the results     Assert.AreEqual(expected, actual); }

Por si acaso, ejecutaremos todas las pruebas ahora. Parece que todas las pruebas están pasando, ¡eso es genial!

---

Agregar un constructor

Nuestra clase de cliente necesita un constructor para que podamos abordar eso ahora. Un constructor es una pieza especial de código que se ejecuta cada vez que se crea una instancia de una clase. En otras palabras, cada vez que se crea un objeto a partir de una clase, se ejecuta el constructor de la clase. Se nombra con el mismo nombre de la propia Clase. Los constructores deben colocarse en la parte superior de la clase sobre cualquier propiedad y método. Una forma de crear un constructor es mediante un fragmento de código de Visual Studio. Al escribir ctor, luego tabular y tabular nuevamente, verá que el constructor se crea automáticamente.

Si un constructor no tiene parámetros, se lo denomina constructor predeterminado. Todas las propiedades de nuestra clase Cliente ya tienen valores sensibles predeterminados, por lo que no necesitamos inicializar nada en el constructor. Es posible agregar constructores adicionales con parámetros si es necesario. Aquí está lo gracioso. Si no necesita ejecutar ningún código en el constructor, entonces técnicamente no lo necesita. C # lo ejecutará automáticamente en segundo plano. Agreguemos otro constructor que inicializará algunos datos. Aquí está nuestra clase de Cliente con los dos nuevos constructores que acabamos de crear.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

using System;   namespace CRMBIZ {     public class Customer     {         public Customer()         {           }           public Customer(int customerId)         {             this.CustomerId = customerId;         }           public static int InstanceCount { get; set; }         private string _lastName;         public string LastName         {             get             {                 return _lastName;             }             set             {                 _lastName = value;             }         }           public string FirstName { get; set; }           public string EmailAddress { get; set; }           public int CustomerId { get; private set; }           public string FullName         {             get             {                 string fullName = LastName;                 if (!string.IsNullOrWhiteSpace(FirstName))                 {                     if (!string.IsNullOrWhiteSpace(fullName))                     {                         fullName += ", ";                     }                     fullName += FirstName;                 }                 return fullName;             }         }           public bool Validate()         {             var isValid = true;               if (string.IsNullOrWhiteSpace(LastName)) isValid = false;             if (string.IsNullOrWhiteSpace(EmailAddress)) isValid = false;               return isValid;         }           public bool Save()         {             return true;         }     } }

Observe que el uso de la thispalabra clave en el segundo constructor. Lo que eso significa es que hace referencia a la instancia actual de la clase. Imagine que crea un nuevo cliente y lo asigna a una variable como c1. Cuando se llama al constructor durante esa inicialización para c1, la thispalabra clave se refiere a c1.

Si alguien aparece y crea una instancia diferente de un Cliente y coloca ese cliente en c2, digamos, entonces la palabra clave this apunta a esa nueva instancia.

---

Cómo agregar métodos a una clase en el resumen de C #

En este tutorial, observamos cómo agregar métodos a nuestra clase de Cliente. Aprendimos un poco sobre las firmas de métodos, las sobrecargas de métodos y sobre cómo se usan los constructores.

La firma de un método es su nombre y conjunto de parámetros. No incluye el tipo de devolución. El compilador de C # usa la firma del método para hacer coincidir el código de llamada con el método correcto. Cuando hay más de un método con el mismo nombre, lo llamamos sobrecarga.

---

La sobrecarga es cuando dos o más métodos tienen el mismo nombre, pero diferentes parámetros. Puede haber un número diferente de parámetros, diferentes tipos de parámetros o una combinación de diferentes números de parámetros y tipos de parámetros. El código anterior muestra un método que toma un parámetro entero y el otro que no toma parámetros.

---

Un constructor es un fragmento de código en la clase que se ejecuta cada vez que se crea una instancia de la clase en un objeto. La convención es configurar el constructor como un método público de la clase usando el mismo nombre exacto que la clase misma. Un constructor predeterminado es uno que no toma parámetros. No es necesario incluir específicamente un constructor a menos que necesite inicializar algunos valores o pasar algunos parámetros a la clase.