and - get set c#
Buscando un ejemplo corto y simple de getters/setters en C# (12)
Tengo problemas para entender el concepto de getters y setters en el lenguaje C # . En lenguajes como Objective-C, parecen una parte integral del sistema, pero no tanto en C # ( hasta donde puedo decir ). He leído libros y artículos, así que mi pregunta es, para aquellos de ustedes que entienden getters & setters en C #, qué ejemplo usarían personalmente si estuvieran enseñando el concepto a un principiante completo ( esto incluiría tan pocas líneas de código como sea posible )?
Bueno, aquí está el uso común de setter getter en el caso de uso real,
public class OrderItem
{
public int Id {get;set;}
public int quantity {get;set;}
public int Price {get;set;}
public int TotalAmount {get {return this.quantity *this.Price;}set;}
}
C # presenta propiedades que hacen la mayor parte del trabajo pesado para usted ...
es decir
public string Name { get; set; }
es un atajo de C # para escribir ...
private string _name;
public string getName { return _name; }
public void setName(string value) { _name = value; }
Básicamente getters y setters son solo medios de ayudar a la encapsulación. Cuando haces una clase tienes varias variables de clase que quizás quieras exponer a otras clases para que puedan echar un vistazo a algunos de los datos que almacenas. Si bien las variables pueden parecer públicas, puede parecer una alternativa aceptable; a la larga, se arrepentirá de permitir que otras clases manipulen directamente las variables de miembros de su clase. Si los obliga a hacerlo a través de un setter, puede agregar lógica para garantizar que nunca se produzcan valores extraños, y siempre puede cambiar esa lógica en el futuro sin afectar las cosas que ya manipulan esta clase.
es decir
private string _name;
public string getName { return _name; }
public void setName(string value)
{
//Don''t want things setting my Name to null
if (value == null)
{
throw new InvalidInputException();
}
_name = value;
}
Creo que un poco de código ayudará a ilustrar qué setters y getters son:
public class Foo
{
private string bar;
public string GetBar()
{
return bar;
}
public void SetBar(string value)
{
bar = value;
}
}
En este ejemplo, tenemos un miembro privado de la clase que se llama barra. Los métodos GetBar y SetBar hacen exactamente lo que tienen el nombre: uno recupera el miembro de la barra y el otro establece su valor.
En c # 1.1 + tienes propiedades. La funcionalidad básica también es la misma:
public class Foo
{
private string bar;
public string Bar
{
get { return bar; }
set { bar = value; }
}
}
La barra de miembros privados no es accesible fuera de la clase. Sin embargo, el "Bar" público es, y tiene dos descriptores de acceso: get, que justo como el ejemplo anterior "GetBar ()" devuelve el miembro privado, y también un conjunto, que corresponde al método SetBar (valor de cadena) en el mencionado ejemplo.
Comenzando con C # 3.0 y superior, el compilador se optimizó hasta el punto en que dichas propiedades no necesitan tener como fuente al miembro privado. El compilador genera automáticamente un miembro privado de ese tipo y lo utiliza como fuente de una propiedad.
public class Foo
{
public string Bar { get; set; }
}
lo que el código muestra es una propiedad automática que tiene un miembro privado generado por el compilador. No ves al miembro privado, pero está allí. Esto también introdujo un par de otros problemas, principalmente con el control de acceso. En C # 1.1 y 2.0, puede omitir la parte de obtención o configuración de una propiedad:
public class Foo
{
private string bar;
public string Bar
{
get{ return bar; }
}
}
Te da la oportunidad de restringir cómo otros objetos interactúan con la propiedad "Barra" de la clase Foo. Comenzando con C # 3.0 y superior: si elige usar propiedades automáticas, debe especificar el acceso a la propiedad de la siguiente manera:
public class Foo
{
public string Bar { get; private set; }
}
Lo que eso significa es que solo la clase puede establecer Bar en algún valor, sin embargo cualquiera puede leer el valor en Bar.
Ejemplo simple
public class Simple
{
public int Propery { get; set; }
}
En C #, las Properties representan tus Getters y Setters.
Aquí hay un ejemplo:
public class PropertyExample
{
private int myIntField = 0;
public int MyInt
{
// This is your getter.
// it uses the accessibility of the property (public)
get
{
return myIntField;
}
// this is your setter
// Note: you can specifiy different accessibility
// for your getter and setter.
protected set
{
// You can put logic into your getters and setters
// since they actually map to functions behind the scenes
DoSomeValidation(value)
{
// The input of the setter is always called "value"
// and is of the same type as your property definition
myIntField = value;
}
}
}
}
Tendría acceso a esta propiedad como un campo. Por ejemplo:
PropertyExample example = new PropertyExample();
example.MyInt = 4; // sets myIntField to 4
Console.WriteLine( example.MyInt ); // prints 4
Algunas otras cosas a tener en cuenta: 1) No tiene que especificar tanto un getter como un setter, puede omitir cualquiera de los dos.
2) Las propiedades son solo "azúcar sintáctico" para su getter y setter tradicional. El compilador realmente construirá las funciones get_ y set_ detrás de las escenas (en el IL compilado) y asignará todas las referencias a su propiedad a esas funciones.
Este es un ejemplo básico de un objeto "Artículo" con getters y setters:
public class Article
{
public String title;
public String link;
public String description;
public string getTitle()
{
return title;
}
public void setTitle(string value)
{
title = value;
}
public string getLink()
{
return link;
}
public void setLink(string value)
{
link = value;
}
public string getDescription()
{
return description;
}
public void setDescription(string value)
{
description = value;
}
}
Esto sería un get / set en C # usando la menor cantidad de código posible. Obtiene propiedades implementadas automáticamente en C # 3.0+ .
public class Contact
{
public string Name { get; set; }
}
Getters y Setters en C # son algo que simplifica el código.
private string name = "spots";
public string Name
{
get { return name; }
set { name = value; }
}
Y llamándolo (supongamos que tenemos una persona obj con una propiedad de nombre):
Console.WriteLine(Person.Name); //prints "spots"
Person.Name = "stops";
Console.Writeline(Person.Name); //prints "stops"
Esto simplifica tu código. En Java, es posible que tenga que tener dos métodos, uno para Obtener () y otro para Establecer () la propiedad, en C # todo se hace en un solo lugar. Normalmente hago esto al comienzo de mis clases:
public string foobar {get; set;}
Esto crea un getter y setter para mi propiedad foobar. Llamarlo es de la misma manera que se muestra antes. Algo a tener en cuenta es que no tiene que incluir tanto get como set. Si no desea que se modifique la propiedad, ¡no incluya el conjunto!
Internamente, getters y setters son solo métodos. Cuando C # compila, genera métodos para sus getters y setters como este, por ejemplo:
public int get_MyProperty() { ... }
public void set_MyProperty(int value) { ... }
C # le permite declarar estos métodos usando una sintaxis de mano corta. La siguiente línea se compilará en los métodos anteriores cuando construya su aplicación.
public int MyProperty { get; set; }
o
private int myProperty;
public int MyProperty
{
get { return myProperty; }
set { myProperty = value; } // value is an implicit parameter containing the value being assigned to the property.
}
La mayoría de los lenguajes lo hacen de esta manera, y también puedes hacerlo en C #.
public void setRAM(int RAM)
{
this.RAM = RAM;
}
public int getRAM()
{
return this.RAM;
}
Pero C # también le da una solución más elegante a esto:
public class Computer
{
int ram;
public int RAM
{
get
{
return ram;
}
set
{
ram = value; // value is a reserved word and it is a variable that holds the input that is given to ram ( like in the example below )
}
}
}
Y luego acceder a él con.
Computer comp = new Computer();
comp.RAM = 1024;
int var = comp.RAM;
Para las versiones más nuevas de C #, es aún mejor:
public class Computer
{
public int RAM { get; set; }
}
y después :
Computer comp = new Computer();
comp.RAM = 1024;
int var = comp.RAM;
Mi explicación sería siguiente. (No es tan corto, pero es bastante simple).
Imagina una clase con una variable:
class Something
{
int weight;
// and other methods, of course, not shown here
}
Bueno, hay un pequeño problema con esta clase: nadie puede ver el weight . Podríamos hacer público el weight , pero luego todos podrían cambiar el weight en cualquier momento (que quizás no sea lo que queremos). Entonces, bueno, podemos hacer una función:
class Something
{
int weight;
public int GetWeight() { return weight; }
// and other methods
}
Esto ya es mejor, pero ahora todos en lugar de something.Weight simple. El something.Weight tiene que escribir something.GetWeight() Get something.GetWeight() , que es, bueno, feo.
Con las propiedades, podemos hacer lo mismo, pero el código permanece limpio:
class Something
{
public int weight { get; private set; }
// and other methods
}
int w = something.weight // works!
something.weight = x; // doesn''t even compile
Bien, entonces con las propiedades tenemos un control más preciso sobre el acceso variable.
Otro problema: está bien, queremos que el código externo sea capaz de establecer el weight , pero nos gustaría controlar su valor, y no permitir que los pesos sean inferiores a 100. Además, hay alguna otra density variable interna, que depende de weight , por lo que querría volver a calcular la density tan pronto como cambie el weight .
Esto se logra tradicionalmente de la siguiente manera:
class Something
{
int weight;
public int SetWeight(int w)
{
if (w > 100)
throw new ArgumentException("weight too small");
weight = w;
RecalculateDensity();
}
// and other methods
}
something.SetWeight(anotherSomething.GetWeight() + 1);
Pero, de nuevo, no queremos exponer a nuestros clientes que establecer el peso es una operación complicada, semánticamente nada más que asignar un nuevo peso. Entonces el código con un setter se ve de la misma manera, pero más agradable:
class Something
{
private int _w;
public int Weight
{
get { return _w; }
set
{
if (value > 100)
throw new ArgumentException("weight too small");
_w = value;
RecalculateDensity();
}
}
// and other methods
}
something.Weight = otherSomething.Weight + 1; // much cleaner, right?
Entonces, sin duda, las propiedades son "solo" un azúcar sintáctico. Pero hace que el código del cliente sea mejor. Curiosamente, la necesidad de cosas parecidas a las propiedades surge muy a menudo, puede comprobar con qué frecuencia encuentra las funciones como GetXXX () y SetXXX () en los otros idiomas.
Por lo que entiendo, los getters y setters deben mejorar la encapsulación. No hay nada complejo sobre ellos en C #.
Usted define una propiedad de objeto on como este:
int m_colorValue = 0;
public int Color
{
set { m_colorValue = value; }
get { return m_colorValue; }
}
Este es el uso más simple. Básicamente establece una variable interna o recupera su valor. Usas una propiedad como esta:
someObject.Color = 222; // sets a color 222
int color = someObject.Color // gets the color of the object
Eventualmente podría hacer algún procesamiento sobre el valor en los setters o getters como este:
public int Color
{
set { m_colorValue = value + 5; }
get { return m_colorValue - 30; }
}
Si omite establecer u obtener, su propiedad será de lectura o escritura solamente. Así es como entiendo las cosas.