why do we do this:
private string StatusText
{
set { toolStripStatusLabel1.Text = value; }
}
instead of just this?
private string StatusText
{
toolStripStatusLabel1.Text = value;
}
i do not understand the point of using set?
These are two completely different things.
This is a method:
private string StatusText()
{
toolStripStatusLabel1.Text = value;
}
which is called like this:
StatusText();
(and which will not compile, because the local variable value cannot be found). To make it work, you would need to write it like this:
private string StatusText(string value)
{
toolStripStatusLabel1.Text = value;
}
and call it like this:
StatusText("bla");
On the other hand, this is the definition of a property:
private string StatusText
{
set { toolStripStatusLabel1.Text = value; }
}
whose setter (hence the keyword set) is called like this:
StatusText = "bla";
Because there could also be a get:
get { return toolStripStatusLabel1.Text; }
Properties are syntactic sugar. When compiled you will have two methods get_[property name] and set_[property name]. If you only have the set method, only the set_[propety name] will be in the IL.
In a little more detail, since the OP has said she doesn't understand gets and sets:
The get and set keywords are used to define a "property". A property is a pair of methods - a "getter" and "setter" - that are used behind the scenes when the property is used or written to by other code. The advantage of a property over explicitly defining getter and setter methods is that you can use the property as if it were a "field" (a simple, publicly-visible member variable). The advantage of using a property instead of a field is that a property allows you to customize the behavior of assigning or using a variable. You can create "calculated fields" that are evaluated when needed based on other data in the object, or include basic validation or other business logic when reading or writing a value.
To define a property, you start by declaring it like you would a field, but then add a code block with get and set sub-blocks. You then define its read behavior in the get block, and the write behavior in the set block. You can choose to define only one accessor (making a "read-only" or "write-only" property), or you can define more limited visibility for one function or the other; for instance, you can make the getter public but the setter protected, so everyone can examine the property's value but only the class's other members and derived types can set its value.
The most common property implementation uses a "backing field", a private variable that acts as the store for the value exposed by the property. To streamline this implementation, .NET 3.0 included the concept of an "auto-property"; if you didn't define the code bodies of the getter and setter, the compiler would generate a basic implementation using a backing field.
First will not compile for value isn't valid unless you have set.
private string StatusText
{
toolStripStatusLabel1.Text = value;
}
Check out MSDN on Accessors here.
Setting and Getting fields and properties...
Example:
private string statusText;
public string StatusText
{
get { return this.statusText;}
set { this.statusText = value;
toolStripStatusLabel1.Text = this.statusText;
}
}
private String StatusText
{
get { ... }
set { ... }
}
The get/set tokens are to distinguish between the get and set accessors.
The latter wouldn't compile. The set part shows that it's the setter part of a property.
An alternative is to just write a method:
private void SetStatusText(string value)
{
toolStripStatusLabel1.Text = value;
}
To enable you to apply more complex logic, when the need will arise.
Related
I have a boolean variable, I want every change to its value to invoke a piece of code.
my current solution is the following:
bool _manualControl;
bool manualControl {
get {
return _manualControl;
}
set {
this._manualControl = value;
GlobalEventManager.ManualControlEvent?.Invoke(value);
}
}
this solution has two problems:
the value of "_manualControl" can be changed internally without invoking my piece of code, I want to prevent that.
I would prefer to avoid using two variables to get the desired behavior.
Is there any way to achieve what I want while avoiding these two specified issues?
You can set the property to be public and have a private backing field that can only be modified from within the class, which you have control of.
Or you could use an Aspect Oriented Programming framework like PostSharp, which would allow you to use an auto property and annotate it with the behaviour you desire. This would remove the need for you to have a backing field.
To me this sounds a bit like you want to solve an architectural problem, aka code smell. Why is it that you fear your field might be set outside your setter? Is it a particularly large class that a lot of people are chaning without really knowing what it is doing?
Why even have code in the setter? Like you could just redesign your code to have a method do what your setter code does and introduce that into your code flow / process.
And have a Unit Test validate your desired behavior.
If you want to:
ensure that the setter code always executes when a new value is assigned (inside and outside of the class)
avoid having two members in the class, that represent a single value
Then this can be approached by wrapping the value within a struct like one below:
struct Intercepted<T>
{
private readonly Action<T> _onChange;
private T _value;
public Intercepted(Action<T> onChange, T initialValue = default(T))
{
_onChange = onChange;
_value = initialValue;
}
public T Value
{
get
{
return _value;
}
set
{
_value = value;
_onChange?.Invoke(value);
}
}
}
In the class, ManualControl can now be represented with a single member, of type Intercepted<bool>:
public Intercepted<bool> ManualControl { get; } = new ManualControl(
onChange: newValue => {
GlobalEventManager.ManualControlEvent?.Invoke(newValue);
}
);
The value can be accessed like this:
// from within the class
if (ManualControl.Value) { ... }
// from outside
myObj.ManualControl.Value = true;
Now there is no way to change the value without triggering the setter code, both inside and outside the class.
I have a class with the two following members:
private _something;
public something
{
get
{
return _something;
}
set
{
// ... Manipulate value ...
_something = value;
}
}
I'd like to use get { } and set { } without referring to the separate member, but keep this same functionality. Is there a mechanism to do this?
It looks like you are asking whether you can use an auto-implemented property while you have a some logic in your setter method.The answer is no, you can't. You have to provide a backing field explicitly.
An auto-implemented property is also using a backing field created by the compiler.So there has to be something to store the value because a property is just a syntactic sugar for get and set methods.
My question about set and get methods..
Although I know how to use and why it is using for, I cant understand main differences between these using styles...
public string a{get;set;}
public string a
{
get{return a;}
set{a=value;}
}
The first form is Auto implemented properties in C#
In C# 3.0 and later, auto-implemented properties make
property-declaration more concise when no additional logic is required
in the property accessors.
The second form (although incorrect) in current form requires a backing field explicitly defined and you can put explicit code for setting and reading the values.
Second form can be like:
private string _a; // a backing field
public string a
{
get
{
return _a;
}
set
{
if (a != null) //some validation
_a = value;
else
_a = string.Empty;
}
}
(Currently your second form of property would cause a stackoverflow exception since it will enter in an infinite loop)
If you want to wite less code, use the first form, called auto property. Behind the scene, the compiler will create the backing field for you.
If you have some procesing in the property, use the standard way
public string A{get;set;} //Auto property
public string A
{
get{return a;}`
set{
//Do some check-Processing
if(value != null)
a=value;
}
}
The first one will generate an implicit field your values will be written to and read from. These are called "auto implemented properties". Whereas in the second, you explicitly name the fields your property will write to and read from. From MSDN:
In C# 3.0 and later, auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors. They also enable client code to create objects. When you declare a property as shown in the following example, the compiler creates a private, anonymous backing field that can only be accessed through the property's get and set accessors.
Your implementation
public string a
{
get{return a;}
set{a=value;}
}
will cause a StackoverflowException as you are calling a recursively in the get-accessor.
Change it to
private string a;
public string A{
get{ return a; }
set{ a = value; }
}
Let's take an example :
private string _chars;
public string Chars
{
get { return _chars; }
set
{
DoSomeThingSpecialWhenEdited();
_chars = value;
}
}
Can give you a choice to trigger DoSomeThingSpecialWhenEdited or not by setting _chars or Chars
Otherwise, the two are equivalent (Note that the latter is infinite loop) .
This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
In C# what does this code with “get” mean?
I'm using open source project. In this project there is function.
public virtual ICollection<Customer> AffiliatedCustomers
{
get
{
return _affiliatedCustomers ?? (_affiliatedCustomers = new List<Customer>());
}
protected set { _affiliatedCustomers = value; }
}
I don't understand what is the meaning of "get".
Can you please explain this function.
AffiliatedCustomers is a property.
The get defines the property getter, which is a method used internally to return the value by the property. It allows you to use this given an instance of the class like so:
var customers = theClass.AffiliatedCustomers; // Looks like a field, but is a property
Properties can also have a set section, as well, as this one does (protected set { _affiliatedCustomers = value; }), which gives you control over what happens when you set the value via the Property.
For details, see Properties in C#.
This is not a function. It is a property. A property is basically a fancy wrapper for some variable. For example, declaring the following property:
public string SomeProperty { get; set; }
will actually compile to something like this:
private string backing_SomeProperty;
public void set_SomeProperty(string value)
{
backing_SomeProperty = value;
}
public int get_SomeProperty()
{
return backing_SomeProperty;
}
That's an example of an automatic property. Of course, you can also define the getter and setter methods yourself like this:
public string SomeProperty
{
get
{
// some logic code here
// then return some value
}
set
{
// some logic code here
// then set some value
}
}
This is a property,
Quoted by msdn:
Properties are members that provide a flexible mechanism to read, write, or compute the values of private fields. Properties can be used as though they are public data members, but they are actually special methods called accessors. This enables data to be accessed easily while still providing the safety and flexibility of methods.
Please refer to this link for more:
http://msdn.microsoft.com/en-us/library/x9fsa0sw(v=vs.80).aspx
Properties have a getter and a setter - their purpose is obvious (to get and set the value of the property).
When you use auto properties, there is still a get and a set, but the backing variable is automatically implemented for you. In the example you have given the author of the code has chosen to have their own implementation of the get - in this case to automatically initialise the member variable the first time the property is accessed.
Just wondering in the below function
public Dictionary<string, List<TrainingItem>> TrainingItems
{
set
{
trainingItems = SanitizeTrainingItems(value);
Results_Repeater.DataSource = trainingItems;
Results_Repeater.DataBind();
}
}
How does the value of (value) get past here and what is it. I mean there is no parameters to function but yet I am still passing a value in function I just don't understand where it comes from ?
A property in C# simulates a data member when in reality it's a set of accessor methods, specifically a get accessor and a set accessor (unless the property is read-only). In most cases, a property is used to read, write or compute the value of a private field.
A common use for a property would be:
private string _firstName;
public int FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
The get and set blocks within the property definition represent the accessor method bodies that either read or write the value of _firstName. In the set accessor, value is a contextual keyword representing the parameter of the set_FirstName accessor method generated by the compiler.
Without properties, you would have to write these methods yourself, i.e., you'd have a public string getFirstName(); and a public void setFirstName(string value); and you would call each method accordingly. A C# property is just a shortcut and gives you an easy to use mechanism to invoke the correct accessor.
set accessor uses implicit parameter called value, whose type is the type of the property. In the following example, a set accessor is added to the TrainingItems property
When you assign a value to the property, the set accessor is invoked by using an argument that provides the new value.
See it here - http://msdn.microsoft.com/en-us/library/w86s7x04(v=vs.90).aspx