Propiedades y métodos de C #

 

Los métodos en C # y también en otros lenguajes de programación se utilizan para definir el comportamiento. Se usan para escribir una lógica enfocada que se usa para completar una tarea específica y se pueden invocar o llamar para ejecutar el código escrito dentro de ellos. Los métodos dentro de las clases tienen modificadores de acceso, siendo el predeterminado privado . Esto significa que el método solo está disponible para usar dentro de la misma clase. Para que el método esté disponible para todo un proyecto, puede utilizar la palabra clave interna . Si usara la palabra clave pública , esto hace que el método esté disponible en cualquier lugar. Aprendamos un poco más sobre métodos, campos, eventos y propiedades en C # ahora.

---

Tipos de devoluciones

Todos los métodos tienen un tipo de retorno. ¿Qué significa esto? Cuando llamas a un método, puede devolver un valor o no. Si no es así, todavía tiene un tipo de retorno y lo llamamos un tipo de retorno vacío . Si un método se escribe como vacío, simplemente significa que el método no devuelve un valor al código de llamada. A continuación, se muestra un ejemplo de un método con un tipo de retorno de vacío.

1 2 3 4

static void WriteResult(string description, int result) {     Console.WriteLine(description + ": " + result); }

Cuando se invoca el código anterior, no devuelve un valor y, por lo tanto, tiene un tipo de vacío . Tenga en cuenta que no hay declaración de devolución. Sin embargo, el código que se enumera a continuación utiliza una declaración de devolución. Cuando se ejecuta el método ComputeStatistics (), devuelve un objeto.

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

public StockStatistics ComputeStatistics() {     StockStatistics stats = new StockStatistics();       float sum = 0;     foreach (float stock in stocks)     {         stats.HighestStock = Math.Max(stock, stats.HighestStock);         stats.LowestStock = Math.Min(stock, stats.LowestStock);         sum += stock;     }       stats.AverageStock = sum / stocks.Count;     return stats; }

---

Los métodos pueden tomar parámetros

Los métodos pueden tener uno o más parámetros en su firma o definición de método. Sin embargo, no confunda parámetros y argumentos. Nos referimos a los datos que se pasan a un método como un parámetro en su código de definición y como un argumento cuando se llama al método. Parámetros en el área de C # escritos. Esto significa que especificamos el tipo de datos de los parámetros que se pasarán al método. Considere este código aquí.
static void WriteResult (descripción de cadena, resultado flotante)

1 2 3

{     Console.WriteLine($"{description}: {result:F2}", description, result); }

El código anterior toma dos parámetros. El primero tiene un tipo de cadena y usa el nombre de descripción. Entonces, dentro del método, la descripción contendrá un tipo de datos de cadena. También tiene un parámetro de tipo float con un nombre de resultado. De nuevo, dentro de la función cada vez que vea un resultado, sabrá que contendrá un tipo de datos flotante.

---

Firmas del método C #

La firma de un método consiste en un nombre de método y el tipo y tipo de cada uno de sus parámetros. Este es un identificador único para el compilador de C #. La firma del método no incluye un tipo de retorno. Cualquier carácter legal se puede utilizar en el nombre de un método. Los nombres de los métodos suelen comenzar con una letra mayúscula. Los nombres elegidos deben ser verbos o verbos seguidos de adjetivos o sustantivos. Esto ayuda a identificar que un método realiza una acción.

---

Los métodos pueden sobrecargarse

Los métodos tienen la capacidad de sobrecargarse. Qué significa eso? Significa que un método puede tener exactamente el mismo nombre que otro método, y el compilador de C # estará de acuerdo con eso. Sin embargo, la regla es que cada método con el mismo nombre debe diferir en el tipo o número de parámetros que acepta el método. Un ejemplo de un método sobrecargado que forma parte del lenguaje C # es el método WriteLine () de uso común. En Visual Studio , incluso podemos ver que intellisense nos da un mensaje de que Console.WriteLine () tiene 18 sobrecargas.

Es la firma lo que hace que estos métodos sean únicos, aunque tengan el mismo nombre. Entonces, en realidad, está llamando a un método diferente en función de si está pasando, digamos, un valor flotante, int o de cadena.

1 2 3 4 5

public static void WriteLine(float value);   public static void WriteLine(int value);   public static void WriteLine(string value);

Agreguemos un nuevo método contenedor a nuestra aplicación llamado CustomWriteLine (). Lo que este método hará por nosotros es aceptar una descripción de los resultados del programa, así como el valor del resultado en sí. Dentro del método CustomWriteLine () hay una llamada a Console.WriteLine que usa la interpolación de cadenas para generar los datos. Esto nos permite personalizar el formato de los datos que generamos.

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     class Program     {         static void Main(string[] args)         {             StockPortfolio portfolio = new StockPortfolio();               portfolio.Name = "'Warren Buffet Portfolio'";               portfolio.AddStock(55.81f);             portfolio.AddStock(74.52f);             portfolio.AddStock(92.88f);               StockStatistics stats = portfolio.ComputeStatistics();             Console.WriteLine("Current Name: " + portfolio.Name + "\n");             CustomWriteLine("Average Stock Price", stats.AverageStock);             CustomWriteLine("Highest Stock Price", stats.HighestStock);             CustomWriteLine("Lowest Stock Price", stats.LowestStock);         }           static void CustomWriteLine(string description, float result)         {             Console.WriteLine($"{description}: {result:C} \n", description, result);         }     } }

Ahora, cuando se ejecuta el programa, podemos ver que el resultado es exactamente lo que estamos buscando. ¡Agradable!

---

Propiedades y campos

Campos: los campos se utilizan para almacenar datos, o estado, dentro de una clase. Son básicamente variables, pero viven dentro de una clase. En nuestra pequeña aplicación, actualmente tenemos un campo de Nombre en la clase StockPortfolio y se define usando la cadena pública Name; . Como es público, cualquiera puede cambiar el nombre del StockPortfolio. Una forma un poco más avanzada de manejar esto es hacer que el campo sea privado . Esto oculta o encapsula los datos para que ningún código fuera de la clase tenga acceso directo a ese campo. Por qué querrías hacer esto? Bueno, al adoptar este enfoque, puede proteger y validar cualquier dato que se inserte en un objeto. Esa es una buena cosa. A continuación, se muestra un ejemplo de código que utiliza un campo privado.

1 2 3 4 5 6 7 8

public class Dog {     private readonly string _name;     public Dog(string <span class="hiddenGrammarError" pre="">name)     {         _name</span> = name;     } }

El código anterior usa un campo privado de tipo cadena. Por convención, a menudo verá un campo privado con el subrayado inicial para dar una indicación visual de que se trata de un campo privado. Entonces, este campo está dentro de una clase llamada Perro, y en el constructor de Perro, un desarrollador necesita pasar un nombre para crear un objeto Perro. Luego, el constructor guarda el nombre en el campo privado y lo hace disponible para que lo use el resto del objeto. Este campo también es un campo de solo lectura. Esto significa que solo el código de esta clase puede asignar un nombre a través del constructor. Intentar establecer el nombre en un nuevo valor en cualquier otro método que no sea el constructor generaría una excepción por parte del compilador de C #.

Propiedades: una propiedad en C # es casi como un campo, pero tiene captadores y definidores que son una forma genial de administrar lo que sucede al leer o escribir datos en esa propiedad. Estos descriptores de acceso se utilizan a menudo para la validación para garantizar que los datos estén seguros y limpios. Veamos esto en algún código.

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

public class Dog {     private string _name;     public string Name     {         get { return _name; }         set         {             if (!String.IsNullOrEmpty(value))             {                 _name = value;             }         }     } }

Este código todavía tiene el campo privado llamado _name. Lo que es diferente es que ahora tenemos una propiedad llamada Nombre. En C #, los nombres de las propiedades y los métodos deben comenzar con una letra mayúscula. Observe los descriptores de acceso get y set en esta propiedad. En el descriptor de acceso get hay una declaración de retorno simple que devuelve el valor en _name. El valor devuelto debe ser una picadura ya que la propiedad se define como una cadena. Además del descriptor de acceso get, hay un descriptor de acceso establecido. El descriptor de acceso set es posiblemente más importante que el descriptor de acceso get. Esto se debe a que aquí es donde se puede colocar la lógica de validación para garantizar que se almacenen los datos correctos en _name. No queremos que nadie intente establecer _name en nulo o en una cadena vacía. Este tipo de código se usa a menudo para validar un valor entrante antes de asignar ese valor al objeto.

Si lo desea, también puede utilizar una propiedad implementada automáticamente en C #. Este tipo de propiedad no tiene lógica asociada. Solo usa las palabras clave get y set sin código adicional. El compilador de C # crea automáticamente un campo para almacenar el valor de esta propiedad. Automáticamente leerá ese campo durante una operación de obtención y escribirá en ese campo durante una operación de configuración. Esto es útil si no necesita ninguna lógica especial, pero aún desea el beneficio de un getter y setter.

1 2 3 4 5 6 7 8 9

public class Dog {     private string _name;     public string Name     {         get;         set;     } }

Podemos agregar este tipo de enfoque a nuestra clase StockPortfolio como tal.

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     public class StockPortfolio     {         public StockPortfolio()         {             stocks = new List<float>();         }           public StockStatistics ComputeStatistics()         {             StockStatistics stats = new StockStatistics();                 float sum = 0;             foreach (float stock in stocks)             {                 stats.HighestStock = Math.Max(stock, stats.HighestStock);                 stats.LowestStock = Math.Min(stock, stats.LowestStock);                 sum += stock;             }               stats.AverageStock = sum / stocks.Count;             return stats;         }           public void AddStock(float stock)         {             stocks.Add(stock);         }           public string Name         {             get             {                 return _name;             }             set             {                 if (!String.IsNullOrEmpty(value))                 {                     _name = value;                 }             }         }           private string _name;           private List<float> stocks;     } }

Entonces, el propósito de las propiedades sobre los campos es que pueda escribir lógica dentro de un descriptor de acceso get o set. El descriptor de acceso get puede realizar algunas operaciones en los datos o simplemente recuperar algún valor de campo y devolverlo. El descriptor de acceso establecido puede realizar la validación y proteger el estado interno de un objeto para asegurarse de que alguien no le esté dando un valor que usted no desea. Las propiedades mantienen el estado de nuestros diversos objetos en un programa.

---

Eventos de C #

Los eventos son una característica realmente interesante del lenguaje de programación C #. Los eventos se pueden usar para interactuar con partes de la aplicación que hacen cosas en momentos que quizás no conozcamos de antemano. Si está familiarizado con los eventos en JavaScript, el concepto es similar. Imagina un botón en la interfaz de usuario de una aplicación. Queremos que se nos informe cada vez que un usuario hace clic en ese botón para que podamos realizar una acción en el software. No se sabe cuándo el usuario puede hacer clic en el botón, pero necesitamos que se nos notifique si sucede. Otro escenario podría ser escuchar un gancho web de algún tiempo. Queremos que se nos notifique si alguna vez se realiza una solicitud POST a un determinado punto final para que podamos tomar una acción. Estos tipos de escenarios son buenos para eventos. Los eventos permiten que los objetos realicen un anuncio en cualquier parte de la aplicación que esté escuchando. El anuncio es el evento y el objeto desde el cual se hace el anuncio es el editor de ese evento. En el otro extremo está el suscriptor del evento. Esta es la parte de la aplicación que está interesada en escuchar los anuncios de cualquier evento y luego realizar una acción. Puede haber muchos suscriptores a un evento. Imagine que un usuario hace clic en un botón y, como resultado, se registra una acción en una base de datos, se envía un correo electrónico a un administrador, se guarda un archivo en el sistema de archivos y se muestra una alerta en la pantalla. Por lo tanto, puede tener varias piezas de código independientes que se ponen en acción en función del anuncio de un evento. ¿Cómo funciona esto en C #? ¡Vía delegados! Esta es la parte de la aplicación que está interesada en escuchar los anuncios de cualquier evento y luego realizar una acción. Puede haber muchos suscriptores a un evento. Imagine que un usuario hace clic en un botón y, como resultado, se registra una acción en una base de datos, se envía un correo electrónico a un administrador, se guarda un archivo en el sistema de archivos y se muestra una alerta en la pantalla. Por lo tanto, puede tener varias piezas de código independientes que se ponen en acción en función del anuncio de un evento. ¿Cómo funciona esto en C #? ¡Vía delegados! Esta es la parte de la aplicación que está interesada en escuchar los anuncios de cualquier evento y luego realizar una acción. Puede haber muchos suscriptores a un evento. Imagine que un usuario hace clic en un botón y, como resultado, se registra una acción en una base de datos, se envía un correo electrónico a un administrador, se guarda un archivo en el sistema de archivos y se muestra una alerta en la pantalla. Por lo tanto, puede tener varias piezas de código independientes que se ponen en acción en función del anuncio de un evento. ¿Cómo funciona esto en C #? ¡Vía delegados! y se muestra una alerta en la pantalla. Por lo tanto, puede tener varias piezas de código independientes que se ponen en acción en función del anuncio de un evento. ¿Cómo funciona esto en C #? ¡Vía delegados! y se muestra una alerta en la pantalla. Por lo tanto, puede tener varias piezas de código independientes que se ponen en acción en función del anuncio de un evento. ¿Cómo funciona esto en C #? ¡Vía delegados!

---

Delegados en C #

Los delegados es donde las cosas divertidas comienzan a suceder en C #. Una forma fácil de pensar en Delegados es si está familiarizado con el funcionamiento de JavaScript. En JavaScript, puede asignar una función a una variable. Luego, puede llamar al nombre de la variable como una función. Puede hacer el mismo tipo de cosas en C # utilizando Delegados. La propia variable contiene código ejecutable en el programa. Para demandar a un Delegado en C #, primero cree un Tipo de Delegado. La creación de un tipo de delegado no es tan diferente de cómo usamos la palabra clave class o la palabra clave struct para crear un tipo. Al crear un Delegado, usará, lo adivinó, la delegatepalabra clave durante la definición del tipo.

Vamos a agregar un delegado a nuestro programa, por lo que podemos comenzar agregando un archivo de clase al proyecto y simplemente nombrarlo como delegado. Este delegado representa cada vez que cambia el nombre de una cartera en el programa.
PortfolioNameChangedDelegate.cs

1 2 3 4 5 6 7 8 9 10

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     public delegate void PortfolioNameChangedDelegate(string oldName, string newName); }

A continuación, podemos agregar un campo público en la clase StockPortfolio que haga referencia a nuestro nuevo delegado como tal.

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

using System; using System.Collections.Generic;   namespace Stocks {     public class StockPortfolio     {         public StockPortfolio()         {             _name = "'New Portfolio'";             stocks = new List<float>();         }           public StockStatistics ComputeStatistics()         {             StockStatistics stats = new StockStatistics();               float sum = 0;             foreach (float stock in stocks)             {                 stats.HighestStock = Math.Max(stock, stats.HighestStock);                 stats.LowestStock = Math.Min(stock, stats.LowestStock);                 sum += stock;             }               stats.AverageStock = sum / stocks.Count;             return stats;         }           public void AddStock(float stock)         {             stocks.Add(stock);         }           public string Name         {             get { return _name; }             set             {                 if (!String.IsNullOrEmpty(value))                 {                     // add code here next                 }             }         }           public PortfolioNameChangedDelegate PortfolioNameChanged;           private string _name;         private List<float> stocks;     } }

Esto significa que ahora podemos hacer uso de ese delegado en nuestra clase. Entonces, en nuestro caso, lo que queremos hacer es hacer un anuncio cada vez que cambia el nombre de un StockPortfolio. Eso significa que podemos sumergirnos en la propiedad Name, específicamente en el setter. Cada vez que se establece la variable _name, podemos hacer un anuncio. Aquí es un comienzo.

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

using System; using System.Collections.Generic;   namespace Stocks {     public class StockPortfolio     {         public StockPortfolio()         {             _name = "'Starting Portfolio Name'";             stocks = new List<float>();         }           public StockStatistics ComputeStatistics()         {             StockStatistics stats = new StockStatistics();               float sum = 0;             foreach (float stock in stocks)             {                 stats.HighestStock = Math.Max(stock, stats.HighestStock);                 stats.LowestStock = Math.Min(stock, stats.LowestStock);                 sum += stock;             }               stats.AverageStock = sum / stocks.Count;             return stats;         }           public void AddStock(float stock)         {             stocks.Add(stock);         }           public string Name         {             get { return _name; }             set             {                 if (!String.IsNullOrEmpty(value))                 {                     if (_name != value)                     {                         // make announcement                         PortfolioNameChanged(_name, value);                           // set the new value                         _name = value;                     }                 }             }         }           public PortfolioNameChangedDelegate PortfolioNameChanged;           private string _name;         private List<float> stocks;     } }

Ahora, en la clase principal Program.cs podemos asignar nuestro delegado al miembro público PortfolioNameChanged que acabamos de agregar a la clase StockPortfolio. Esta línea de código se vería así.

1	portfolio.PortfolioNameChanged = new PortfolioNameChangedDelegate();

En este punto, se establece portfolio.Name, luego el delegado hace un anuncio. En ese momento, nos gustaría que un suscriptor tomara una acción en respuesta a ese anuncio. ¿Cómo se hace esto? Necesitamos crear un nuevo método que se pueda pasar a PortfolioNameChangedDelegate (). Piense en ello así: WhenThisHappens (TakeThisAction); Entonces, con eso en mente, actualizaremos el código a esto.

1	portfolio.PortfolioNameChanged = new PortfolioNameChangedDelegate(OnPortfolioNameChanged);

El método OnPortfolioNameChanged () aún no existe, por lo que podemos crearlo.

1 2 3 4

static void OnPortfolioNameChanged(string oldName, string newName) {     Console.WriteLine($"Portfolio name changed from {oldName} to {newName}! \n"); }

Ahora podemos ejecutar el programa y ver qué pasa. Parece que está funcionando. Cuando el nombre cambia en el portafolio, se escribe un mensaje en la consola que lo explica.

---

Delegados de multidifusión

Eso estuvo muy bien, pero ahora queremos subir de nivel. El nombre cambia, se hizo un anuncio y sucedió algo. Es un tipo de cosas uno a uno en este momento. Sin embargo, recuerde que dijimos que puede hacer que suceda una cosa y luego que sucedan varias cosas en respuesta a eso. ¿Qué pasa si cuando invocamos PortfolioNameChanged () queremos activar dos, tres o incluso diez métodos diferentes? ¡Usted puede hacer eso! Veamos eso en acción.

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     class Program     {         static void Main(string[] args)         {             StockPortfolio portfolio = new StockPortfolio();               portfolio.PortfolioNameChanged += new PortfolioNameChangedDelegate(OnPortfolioNameChanged);             portfolio.PortfolioNameChanged += new PortfolioNameChangedDelegate(OnPortfolioNameChangedSecondAction);               portfolio.Name = "'New Portfolio Name'";               portfolio.AddStock(55.81f);             portfolio.AddStock(74.52f);             portfolio.AddStock(92.88f);               StockStatistics stats = portfolio.ComputeStatistics();             Console.WriteLine("The Current Name Is: " + portfolio.Name + "\n");             CustomWriteLine("The Average Stock Price Is: ", stats.AverageStock);             CustomWriteLine("The Highest Stock Price Is: ", stats.HighestStock);             CustomWriteLine("The Lowest Stock Price Is: ", stats.LowestStock);         }           static void OnPortfolioNameChanged(string oldName, string newName)         {             Console.WriteLine($"Portfolio name changed from {oldName} to {newName}! \n");         }           static void OnPortfolioNameChangedSecondAction(string oldName, string newName)         {             Console.WriteLine("OnPortfolioNameChanged ran, now OnPortfolioNameChangedSecondAction ran \n");         }           static void CustomWriteLine(string description, float result)         {             Console.WriteLine($"{description}: {result:C} \n", description, result);         }     } }

Ahora, cuando se ejecuta el programa, ocurren dos acciones si cambia el nombre de la cartera. Primero, el método OnPortfolioNameChanged () se activa y escribe en la pantalla “¡El nombre de la cartera cambió de 'Nombre de la cartera inicial' a 'Nombre de la cartera nueva'!”. Luego, OnPortfolioNameChangedSecondAction () se activa y escribe en la pantalla "OnPortfolioNameChanged se ejecutó, ahora OnPortfolioNameChangedSecondAction se ejecutó".

¡Excelente! Ahora podemos ver cómo hacer que sucedan muchas cosas en respuesta a un evento.

---

De delegados a eventos

Por lo general, tiene más sentido hacer uso de la eventpalabra clave cuando se sigue el estilo de programación pub-sub. La razón de esto es que exponer delegados sin procesar es un poco más propenso a errores. El uso de un evento agrega un poco más de protección para que, fuera de la clase StockPortfolio, lo único que puedan hacer otros fragmentos de código sea agregar un suscriptor a este evento o eliminar un suscriptor a este evento. Si solo usáramos delegados, sería posible hacer una asignación que anularía todas las demás suscripciones y probablemente no queremos eso. Entonces, todo lo que tenemos que hacer es agregar la palabra clave de evento así.

1	public event PortfolioNameChangedDelegate PortfolioNameChanged;

---

Convenciones de eventos

Queremos hacer un cambio más en la forma en que configuramos nuestros eventos en la aplicación. En lugar de pasar dos cadenas PortfolioNameChangedDelegate (), deberíamos seguir una convención popular de incluir el remitente de un evento como parámetro. Si la clase StockPortfolio anuncia que el nombre ha cambiado, debería enviarse a sí misma como primer parámetro. El segundo parámetro también será un objeto que contenga los argumentos del evento. Para hacer esto, primero crearemos una nueva clase así.
PortfolioNameChangedEventArgs.cs

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     public class PortfolioNameChangedEventArgs : EventArgs     {         public string oldName { get; set; }         public string newName { get; set; }     } }

Una vez que se crea esa clase arriba, necesitamos actualizar PortfolioNameChangedDelegate () para aceptar los objetos sender y args en lugar de dos cadenas como era antes.

1 2 3 4 5 6 7 8 9 10

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     public delegate void PortfolioNameChangedDelegate(object sender, PortfolioNameChangedEventArgs args); }

Ahora, StockPortfolio.cs deberá actualizarse para reflejar este cambio como tal.

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

using System; using System.Collections.Generic;   namespace Stocks {     public class StockPortfolio     {         public StockPortfolio()         {             _name = "'Starting Name'";             stocks = new List<float>();         }           public StockStatistics ComputeStatistics()         {             StockStatistics stats = new StockStatistics();               float sum = 0;             foreach (float stock in stocks)             {                 stats.HighestStock = Math.Max(stock, stats.HighestStock);                 stats.LowestStock = Math.Min(stock, stats.LowestStock);                 sum += stock;             }               stats.AverageStock = sum / stocks.Count;             return stats;         }           public void AddStock(float stock)         {             stocks.Add(stock);         }           public string Name         {             get { return _name; }             set             {                 if (!String.IsNullOrEmpty(value))                 {                     if (_name != value)                     {                         PortfolioNameChangedEventArgs args = new PortfolioNameChangedEventArgs();                         args.oldName = _name;                         args.newName = value;                         PortfolioNameChanged(this, args);                     }                     _name = value;                 }             }         }           public event PortfolioNameChangedDelegate PortfolioNameChanged;           private string _name;         private List<float> stocks;     } }

Lo último que tenemos que hacer es actualizar el archivo Program.cs para reflejar que ahora estamos usando esos dos objetos como parámetros en lugar de dos cadenas como antes.

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

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;   namespace Stocks {     class Program     {         static void Main(string[] args)         {             StockPortfolio portfolio = new StockPortfolio();               portfolio.PortfolioNameChanged += OnPortfolioNameChanged;               portfolio.Name = "'Warren Buffet Portfolio'";             portfolio.Name = "'Bootleg Capital'";               portfolio.AddStock(55.81f);             portfolio.AddStock(74.52f);             portfolio.AddStock(92.88f);               StockStatistics stats = portfolio.ComputeStatistics();             Console.WriteLine("The Current Name Is: " + portfolio.Name + "\n");             CustomWriteLine("The Average Stock Price Is: ", stats.AverageStock);             CustomWriteLine("The Highest Stock Price Is: ", stats.HighestStock);             CustomWriteLine("The Lowest Stock Price Is: ", stats.LowestStock);         }           static void OnPortfolioNameChanged(object sender, PortfolioNameChangedEventArgs args)         {             Console.WriteLine($"Portfolio name changed from {args.oldName} to {args.newName}! \n");         }           static void CustomWriteLine(string description, float result)         {             Console.WriteLine($"{description}: {result:C} \n", description, result);         }     } }

Ejecutar el programa ahora nos da una salida interesante. Cuando se inicia el programa, el nombre se inicializa a 'Nombre de inicio'. Luego, cuando asignamos un nuevo nombre, vemos que se activa nuestro evento y el mensaje "¡El nombre de la cartera cambió de 'Nombre inicial' a 'Cartera de Warren Buffet'!" aparece. Cambiamos el nombre de nuevo, y el evento vuelve a dispararse dándonos un nuevo mensaje de "¡El nombre de la cartera cambió de 'Warren Buffet Portfolio' a 'Bootleg Capital'!".

---

Resumen de propiedades y métodos de C #

En este tutorial de propiedades de clases y métodos de C # , aprendimos mucho sobre los diferentes miembros que pueden ser parte de una clase. Vimos que las propiedades y los campos se utilizan para almacenar estados o datos dentro de un objeto. Por supuesto, los métodos se utilizan para realizar acciones y pueden sobrecargarse. En otras palabras, dos métodos pueden parecer exactamente el mismo método, pero son diferentes según el número y el tipo de parámetros que aceptan. Esto se conoce como la firma del método, que identifica de forma única un método para el compilador de C #. Aunque los nombres de los métodos a veces pueden parecer duplicados, cada método es único en .NET según la firma del método.