Мне сложно понять концепцию getters и seters на языке С#. В таких языках, как Objective-C, они кажутся неотъемлемой частью системы, но не так много в С# (насколько я могу судить). Я уже читал книги и статьи, поэтому мой вопрос касается тех из вас, кто понимает геттеры и сеттеры в С#, какой пример вы бы использовали лично, если бы вы преподавали концепцию совершенно новичку (это будет включать в себя несколько строк кода насколько возможно)?
Ищете короткий и простой пример геттеров/сеттеров в С#
Ответ 1
Я думаю, что немного кода поможет проиллюстрировать, что сеттеры и геттеры:
public class Foo
{
private string bar;
public string GetBar()
{
return bar;
}
public void SetBar(string value)
{
bar = value;
}
}
В этом примере у нас есть частный член класса, который называется bar. Методы GetBar и SetBar выполняют то, что они назвали, - один извлекает член бара, а другой устанавливает его значение.
В С# 1.1 + у вас есть свойства. Базовая функциональность также одинаков:
public class Foo
{
private string bar;
public string Bar
{
get { return bar; }
set { bar = value; }
}
}
Частная панель элементов недоступна вне класса. Однако публичная "Бар" есть, и у нее есть два accessors - get, которые так же, как пример выше "GetBar()" возвращает частный член, а также набор, который соответствует методу SetBar (строковое значение) в предыдущем пример.
Начиная с С# 3.0 и выше, компилятор стал оптимизирован до такой степени, что для таких свойств не обязательно иметь частный член в качестве источника. Компилятор автоматически генерирует частный член этого типа и использует его как источник свойства.
public class Foo
{
public string Bar { get; set; }
}
то, что показывает код, является автоматическим свойством, у которого есть частный член, сгенерированный компилятором. Вы не видите частного участника, но он есть. Это также ввело пару других проблем - в основном с контролем доступа. В С# 1.1 и 2.0 вы можете опустить get или set часть свойства:
public class Foo
{
private string bar;
public string Bar
{
get{ return bar; }
}
}
Предоставление вам возможности ограничить взаимодействие других объектов с свойством "Бар" класса Foo. Начиная с С# 3.0 и выше - если вы решили использовать автоматические свойства, вам нужно будет указать доступ к свойству следующим образом:
public class Foo
{
public string Bar { get; private set; }
}
Это означает, что только сам класс может установить Bar на какое-то значение, однако любой может прочитать значение в Bar.
Ответ 2
В С#, Свойства представляют ваши Getters и Setters.
Вот пример:
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;
}
}
}
}
Вы получите доступ к этому свойству, как к полю. Например:
PropertyExample example = new PropertyExample();
example.MyInt = 4; // sets myIntField to 4
Console.WriteLine( example.MyInt ); // prints 4
Несколько замечаний: 1) Вам не нужно указывать как получателя, так и сеттера, вы можете опустить один из них.
2) Свойства - это просто "синтаксический сахар" для вашего традиционного геттера и сеттера. Компилятор фактически построит функции get_ и set_ за кулисами (в скомпилированном IL) и сопоставляет все ссылки на ваше свойство на эти функции.
Ответ 3
Большинство языков делают это так, и вы тоже можете делать это на С#.
public void setRAM(int RAM)
{
this.RAM = RAM;
}
public int getRAM()
{
return this.RAM;
}
Но С# также дает более элегантное решение для этого:
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 )
}
}
}
И позже получите доступ к нему.
Computer comp = new Computer();
comp.RAM = 1024;
int var = comp.RAM;
Для более новых версий С# это даже лучше:
public class Computer
{
public int RAM { get; set; }
}
и позже:
Computer comp = new Computer();
comp.RAM = 1024;
int var = comp.RAM;
Ответ 4
С# вводит свойства, которые делают большую часть тяжелого подъема для вас...
т
public string Name { get; set; }
- это ярлык С# для записи...
private string _name;
public string getName { return _name; }
public void setName(string value) { _name = value; }
В основном, получатели и сеттеры - это просто средства для инкапсуляции. Когда вы создаете класс, у вас есть несколько переменных класса, которые, возможно, вы хотите открыть другим классам, чтобы они могли увидеть некоторые из данных, которые вы храните. Хотя простое создание переменных, с которых начинается публикация, может показаться приемлемой альтернативой, в конечном итоге вы пожалеете о том, что другие классы напрямую манипулируют вашими переменными-членами классов. Если вы заставите их делать это через сеттер, вы можете добавить логику, чтобы избежать каких-либо странных значений, и вы всегда можете изменить эту логику в будущем, не влияя на вещи, уже манипулирующие этим классом.
т
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;
}
Ответ 5
Мое объяснение будет следующим. (Это не так коротко, но это довольно просто.)
Представьте себе класс с переменной:
class Something
{
int weight;
// and other methods, of course, not shown here
}
Ну, есть небольшая проблема с этим классом: никто не может видеть weight. Мы могли бы сделать weight общедоступным, но тогда каждый сможет изменить weight в любой момент (что, возможно, не то, что мы хотим). Итак, хорошо, мы можем сделать функцию:
class Something
{
int weight;
public int GetWeight() { return weight; }
// and other methods
}
Это уже лучше, но теперь каждому вместо простого something.Weight нужно набрать something.GetWeight(), что, ну, уродливо.
Со свойствами мы можем сделать то же самое, но код остается чистым:
class Something
{
public int weight { get; private set; }
// and other methods
}
int w = something.weight // works!
something.weight = x; // doesn't even compile
Приятно, поэтому со свойствами мы имеем более тонкое управление доступом к переменной.
Еще одна проблема: хорошо, мы хотим, чтобы внешний код мог установить weight, но мы хотели бы контролировать его значение и не допускать веса ниже 100. Кроме того, существует некоторая другая внутренняя переменная density, который зависит от weight, поэтому мы хотели бы пересчитать density, как только изменится weight.
Это традиционно достигается следующим образом:
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);
Но опять же, мы не хотим показывать нашим клиентам, что настройка веса - сложная операция, это семантически ничего, кроме присвоения нового веса. Таким образом, код с сеттером выглядит так же, но приятнее:
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?
Таким образом, без сомнения, свойства являются "просто" синтаксическим сахаром. Но это делает клиентский код лучше. Интересно, что потребность в подобных свойствах возникает очень часто, вы можете проверить, как часто вы находите такие функции, как GetXXX() и SetXXX() на других языках.
Ответ 6
Простой пример
public class Simple
{
public int Propery { get; set; }
}
Ответ 7
Насколько я понимаю, геттеры и сеттеры должны улучшить инкапсуляцию. В С# нет ничего сложного.
Вы определяете свойство объекта on следующим образом:
int m_colorValue = 0;
public int Color
{
set { m_colorValue = value; }
get { return m_colorValue; }
}
Это самое простое использование. Он в основном устанавливает внутреннюю переменную или получает ее значение. Вы используете свойство, подобное этому:
someObject.Color = 222; // sets a color 222
int color = someObject.Color // gets the color of the object
В конечном итоге вы можете обработать значение в сеттерах или геттерах следующим образом:
public int Color
{
set { m_colorValue = value + 5; }
get { return m_colorValue - 30; }
}
Если вы пропустите set или get, ваше свойство будет считано или записано. Вот как я понимаю материал.
Ответ 8
Ну вот общее использование геттера в реальном использовании,
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;}
}
Ответ 9
Это будет get/set в С#, используя минимальный возможный код. Вы получаете автоматически реализованные свойства в С# 3.0+.
public class Contact
{
public string Name { get; set; }
}
Ответ 10
Внутренне, геттеры и сеттеры - это просто методы. Когда С# компилируется, он генерирует методы для ваших геттеров и сеттеров, например:
public int get_MyProperty() { ... }
public void set_MyProperty(int value) { ... }
С# позволяет объявлять эти методы с использованием короткого синтаксиса. Строка ниже будет скомпилирована в методы выше, когда вы создаете приложение.
public int MyProperty { get; set; }
или
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.
}
Ответ 11
Getters and Setters в С# - это то, что упрощает код.
private string name = "spots";
public string Name
{
get { return name; }
set { name = value; }
}
И называя его (предположим, что у нас есть объект obj с свойством name):
Console.WriteLine(Person.Name); //prints "spots"
Person.Name = "stops";
Console.Writeline(Person.Name); //prints "stops"
Это упрощает ваш код. Где в Java вам может потребоваться два метода: один для Get() и один для Set() свойства, в С# все это делается в одном месте. Обычно я делаю это в начале моих занятий:
public string foobar {get; set;}
Это создает getter и setter для моего свойства foobar. Вызвать это так же, как показано выше. Следует отметить, что вам не нужно включать оба метода get и set. Если вы не хотите, чтобы свойство было изменено, не включайте set!
Ответ 12
Это базовый пример объекта "Статья" с геттерами и сеттерами:
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;
}
}