Develop Reference

Purpose of property with empty set get

Can someone tell me, what is the porpose of using a public property for a private class member but not implementing anything in the set and get part? I know that it could be just for examples and that later on you can implement something but I don't know if there is any meaning using it like that

I am going to assume you know there is a private field generated by the C# compiler as the field backing up this property. It is syntactic sugar. I am also going to assume you know this is an auto-implemented property. So what is the point of a property if it public with no logic in the get or set. In other words, any class can access it and set its value. So why choose this property over a public field?
Purpose of it is:
Today the get and set is empty but it may need code in the future. To avoid breaking a contract in the future, you use an empty get and set.
Most .NET databinding can be done against properties but not fields. So although it is empty, it still serves a far greater purpose.
The get and set can have access modifiers. For example, you can say set is private but get is public.
A field cannot be used in interfaces but properties can.

This is an "auto-implemented" property in C#. In effect, the property acts as a full property, i.e.:
This:
public int Number { get; set; }
Is equivalent to:
private int _number;
public int Number
{
get
{
return this._number;
}
set
{
this._number = value;
}
}
This prevents you from having to type out the full property declaration. This is useful when you don't have any additional logic in the getter and/or setter.
If you're creating simple data mapping and transfer classes, auto-implementing properties can make the class definition far more concise.

When you see
public int Count { get; set; }
as a member of a class, that is not nothing. You're just deferring to the default implementation of auto-properties. It's roughly,
private int _count;
public int get__Count()
{
return _count;
}
public void set__Count(int value)
{
_count = value;
}
You just have syntactic sugar in C# to use these methods roughly like a field, i.e.
instanceOfObject.Count = 42; // Not a field access, but behind the scenes a method call.

What is the meaning of "get"? [duplicate]

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.

What is the purpose of the "get" and "set" properties in C#

I saw some get set method to set values. Can anyone tell me the purpose of this?
public string HTTP_USER_NAME
{
get
{
return UserName;
}
set
{
UserName = value;
}
}
public string HTTP_USER_PASSWORD
{
get
{
return UserPwd;
}
set
{
UserPwd = value;
}
}
Actually why use these things. For global access, or is there some other reason for this type of thing?

They are just accessors and mutators. That's how properties are implemented in C#
In C# 3 you can use auto-implemented properties like this:
public int MyProperty { get; set; }
This code is automatically translated by the compiler to code similar to the one you posted, with this code is easier to declare properties and they are ideal if you don't want to implement custom logic inside the set or get methods, you can even use a different accessor for the set method making the property immutable
public int MyProperty { get; private set; }
In the previous sample the MyProperty will be read only outside the class where it was declared, the only way to mutate it is by exposing a method to do it or just through the constructor of the class. This is useful when you want to control and make explicit the state change of your entity
When you want to add some logic to the properties then you need to write the properties manually implementing the get and set methods just like you posted:
Example implementing custom logic
private int myProperty;
public int MyProperty
{
get
{
return this.myProperty;
}
set
{
if(this.myProperty <=5)
throw new ArgumentOutOfRangeException("bad user");
this.myProperty = value;
}
}

It seems as though you understand the functionality of getters and setters, and others answered that question. "Normal" class variables (without getters and setters) are called "fields", and "properties" (which have the getters and setters) encapsulate fields.
The purpose of properties is to control outside access to fields. If you want a variable to be read-only to outside logic, you can omit the setters, like so:
private int dataID;
public int DataID {
get { return dataID; }
}
You can also make the setter private and achieve the same read-only functionality.
If an object has a chance of being null (for whatever reason), you can guarantee an instance always exists like this:
private Object instance;
public Object Instance {
get {
if (instance == null)
instance = new Object();
return instance;
}
}
Another use for properties is defining indexers.
//in class named DataSet
private List<int> members;
public int this[int index] {
get { return members[index]; }
}
With that indexer defined, you can access an instance of DataSet like this:
int member = dataSet[3];

Check these links,.. they gives clear explanation.
http://www.dotnetperls.com/property
http://code.anjanesh.net/2008/02/property-getters-setters.html
if UserName and UserPwd are class variables, better to use like this
_userName
_userPwd

Standard way to implement properties in C#. UserName and UserPwd are private member variables (string type) of the class where these 2 methods are defined.

HTTP_USER_NAME and HTTP_USER_PASSWORD are the public properties of your class. UserName and UserPwd could be your private field. And you are allowing other people to set or get the values via these public properties. No direct accesss to private propeties. Also you can do some logic inside the get method of the property.Ex : you will have a public property called Age and in the get method of that, you may read the value of your private field called "dateOfBirth" and do some calculation ( CurrentYear-dateOfBirth) and return that as the Age.

Properties are just accessors over fields. They allow to do certain operations (if needed), and provide controlled access to fields.
If you want to know when to use Properties, and when to use Only fields, Check the link Properties vs Fields – Why Does it Matter? (Jonathan Aneja)

From Properties (C# Programming Guide)
A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field. Properties can be used as if they are public data members, but they are actually special methods called accessors. This enables data to be accessed easily and still helps promote the safety and flexibility of methods.
In this example, the TimePeriod class stores a time period. Internally the class stores the time in seconds, but a property named Hours enables a client to specify a time in hours. The accessors for the Hours property perform the conversion between hours and seconds.
Example
class TimePeriod
{
private double seconds;
public double Hours
{
get { return seconds / 3600; }
set { seconds = value * 3600; }
}
}
class Program
{
static void Main()
{
TimePeriod t = new TimePeriod();
// Assigning the Hours property causes the 'set' accessor to be called.
t.Hours = 24;
// Evaluating the Hours property causes the 'get' accessor to be called.
System.Console.WriteLine("Time in hours: " + t.Hours);
}
}
// Output: Time in hours: 24
Properties Overview
Properties enable a class to expose a public way of getting and setting values, while hiding implementation or verification code.
A get property accessor is used to return the property value, and a set accessor is used to assign a new value. These accessors can have different access levels. For more information, see Restricting Accessor Accessibility (C# Programming Guide).
The value keyword is used to define the value being assigned by the set accessor.
Properties that do not implement a set accessor are read only.
For simple properties that require no custom accessor code, consider the option of using auto-implemented properties. For more information, see Auto-Implemented Properties (C# Programming Guide).

ASP.NET use of "value' in a function

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

How to define properties

I noticed that some developers use this syntax for properties :
private int someVar;
public int SomeVar
{
get { return someVar; }
set { someVar= value; }
}
while some developers use this:
public int SomeVar
{
get;
set;
}
i am guessing both will be same performance wise. For readibility, reusability and for other factors that you might know, which one is better and considered the way to use inside the community.

If you aren't going to be doing any validation or anything else when a property is accessed or changed, use the auto property (your second example). If you need to validate your setter, or call a method when someone gets or sets the value, or something of that nature, use your first example. An auto property just prevents you from having both a property and a backing field if you don't need both.

The later version is more readable. And avoids the missuses of "someVar" or "SomeVar"

They are really the same when it comes down to it. For auto-implemented properties the compiler creates the field for you. If you do not need a field because it is a standard getter or setter most people us auto-implemented properties. If you need logic in your properties than you need a field.

It depends...
If all you are doing is setting and reading back the value of a field then the second method is preferred as it is considered more readable. This mechanism was introduced in C# 3.0.
If your getter needs to do some validating on the value or your setter needs to fire a PropertyChanged event so that the UI can update then the first method is required.

As everyone else has said, the latter is called auto property that generates a field automatically at compile time. One extra thing to note is that the exact equivalent of what you have is
public int SomeVar
{
get;
private set;
}

Method 1
private int someVar;
public int SomeVar
{
get { return someVar; }
set { someVar= value; }
}
This method is generally, not preferred because some languages (such as VB.NET) are case insensitive. Therefore someVar, SomeVar, SOMEVAR and somevar as well as all possible combinations of upper and lower case you can think of mean the same to the compiler and this is likely to generate errors.
Method 2
public int SomeVar{get; set;}
This method, called automatic property implementation, creates a private variable in the shadows for storage and retrieval of the data passed to the property.
In VB.NET, the name of the variable created for each auto-implemented property is the same as the property prefixed with an underscore (_). So a property with name SomeProperty will have a corresponding private variable called _SomeProperty.
This can be demonstrated in your VB.NET code by creating any auto-implemented property and then creating a variable with the same name as the auto-implemented property prefixed with an underscore.
In C#, however, if you have an auto-implemented property, a variable decorated with the CompilerGenerated attribute is used for the property. Thus, you can have the auto-implemented property and a variable with the same name as the property but in a different casing (as in Method 1).
Conclusion
It is generally preferred to use auto-implemented properties whenever possible. Where the need arises that you perform some validation before assigning the property to it's corresponding variable, it is recommended to use name the variable to which the property's value is stored with an underscore prefix as below.
private int _SomeVar;
public int SomeVar
{
get { return _SomeVar;}
set { _SomeVar = value > 0 ? value : 0; }
}

The basic and the best way to define a property is like this
private int _student_rollnumber;
private string _student_name;
public int Student_RollNumber
{
get { return _student_rollnumber; }
set { _student_rollnumber = value; }
}
public string Student_Name
{
get { return _student_name; }
set { _student_name = value; }
}