int MyProperty { set; }
What's the idea for using only setter on property? If we set one property with some value, I guess it's very likely to read this value at some point ?
Write-only properties are rare in the Base Class Library, but XmlReaderSettings.XmlResolver is one example. Based on the security note in that topic, I believe the get accessor was omitted to prevent partially trusted code from accessing or tampering with the default resolver.
XmlResolver.Credentials and XmlTextReader.XmlResolver are probably write-only properties for the same reason.
(Strangely, XmlAttribute.InnerText is also a write-only property, but this doesn't seem to be good design.)
Following the above examples, I'd say you should use a write-only property only when a read-write property would otherwise make sense, but you don't want a get accessor for security reasons.
You could of course use a Set method instead, but a property has the advantage that it can be used in an object initializer, as is commonly done with XmlReaderSettings.
You normally don't create a property like this. As you say, it doesn't have much value.
If you really want to allow only setting a certain value without reading it, then provide a method. That's cleaner.
It doesn't make a whole lot of sense to have an auto-property with only a setter. It can make sense to have a manually implemented property with only a setter that can then set a field used internally, but not visible externally.
Having a set only property is very uncommon, and are often implemented with a set method instead of a property as a set-only property is not expected behavior for most developers.
In fact, it is a compiler error for an auto-implemented property to define a set without a get. A set-only property must be manually defined.
A method would make much more sense than a 'write only property' - even if the code did compile. There is an interesting discussion around write only proprties Here
Related
Why to access a value in an anonymous types, a compiler creates a getter method? Would not it be easier to give a direct access to read-only backing field?
Because properties of anonymous types are readonly after construction. You cannot change them once the object has been created.
They can achieve this using a get only property, but not with a public field (you can always change a field).
EDIT: I've looked around but couldn't find an obvious reason as to why they didn't go with public read-only fields. However, my best guess is: so that you can have properties.
If they had exposed public fields, and didn't have any properties, inevitably, anonymous types would be unusable by things that look for public properties, e.g. WPF binding. So having properties with private readonly backing fields probably was the safer choice.
It's not obvious why they don't simply use a read-only property, but a good reason is this:
If they just used a read-only property, you would know its name and therefore it would be easy to use reflection to change it.
Because they generate a private backing field, it's much harder to know what the name of it is (you'd have to inspect the generated IL), and therefore you are much less likely to change it using reflection. You still could, of course - but it would be such an obviously weird thing to do that you are definitely going to think once or twice before doing so.
In all the examples I see, C# auto-implemented properties are made public, even in the MSDN documentation examples. Coming from a C++ background, I've always been taught that it is a good idea to make member data private, unless there is a good reason not to.
Why is the following never used (at least I've never seen it):
private Name { get; set; }
I've looked through the MSDN documentation and read several tutorials regarding auto-implemented properties but there does not seem to be any advice on their pros and cons and when they should be avoided. Do auto-implemented properties compromise program security? Are there situations where they should be avoided? In which situations are they the ideal choice?
Thanks.
You are correct that auto-implemented properties that simply expose a backing field are not much of a gain over a public field.
As Alan Kay said:
But most people who use setters simply use them to simulate direct assignments to interior variables, and this violates the spirit and intent of real OOP.
However, there is an advantage to an auto-implemented property over a public field, and that is that it's a non-breaking change to later revise the implementation. If you have a public field, and code outside your class manipulates that public field, you can't change it to a private field in a future version of the class, or else any other code that touches that field will have to be recompiled. By contrast, once you have a public property, you can revise the implementation of that property in a future version, and client classes can continue using it with zero changes.
So it's useful to use auto-implemented properties for properties that right now would have trivial getter and setter implementations, but that may have more complex implementations in the future.
Have you asked yourself why you've always been taught that it's a good idea to make members private?
It's because (among other reasons) fields are an implementation detail. The detail of "storing data in memory", and it is an unimportant detail to any object which wishes to retrieve or set the data. Another class doesn't need to care whether he can access some memory slot somewhere - he just wants an interface for which he can pass or retrieve a value - there are the getters and setters, or properties.
Having decoupled the property from the detail of "memory based storage", we're given a large number of advantages. Primarily - we can override the behaviour of getting and setting without upsetting any code which uses the property. We can also use the property as an abstraction for retrieving data over a number of different implementations. That becomes extremely useful for testing/mocking behaviour, and providing alternative storage. If other classes depend on the implementation detail of "memory storage", you are not going to be able to change the behaviour of your class without breaking all those.
Before auto properties came along, we would typically store a field and create a getter and setter to encapsulate it for the reasons described above. An auto property automates that for us. We might write code that commonly uses fields everywhere in code, but we do so holding the idea of "I'll do this as a field for now, but that may be subject to change later if the criteria change".
Since a class knows about it's own implementation, it's usually a pointless endeavour to create private auto properties, you're not hiding the detail that's already known. Protected auto properties can be useful if you need to expose to subclasses.
As for situations where they should be avoided: When you want readonly data. (data which will not change after the object is constructed). Auto-properties lack the syntax to allow you to create an automated property that's backed by readonly data.
Auto implemented properties have a private backing member. Compiler adds them for you. Its just a shortcut for
private int _aMember;
public int AMember {
get {return _aMember;}
set {_aMember = value;}
}
You use them you have no real logic in the getter/setter (other than needing to encapsulate).
Auto-implemented properties are just a shortcut for a common pattern. Any time you would have a private member with corresponding get and set functions in C++, you can accomplish the same thing with an auto property in C#. They don't introduce any different best practices or security issues.
Auto-implemented properties with public getters and setters are shortcuts for private backing fields with trivial get and set implementations.
You should think of them as akin to private fields with public get and set methods in C++. That's a role for properties on C#.
Properties aren't "member" data. They are kind of your
const T& field() const;
T& field();
type of things, or get and set methods, i.e. they are accessors.
If you don't need member exposed, don't express them in properties.
In the case of autogenerated ones, you can simply (as of C# 2.0 afaik) write
int SomeProperty { get; private set; }
This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
Why use getters and setters?
In C#(ASP.NET) we use getter and setter methods to set properties of private variables but same thing can be done if we declare that variable as public. Because at one end we are restricting user from accessing that variable by declaring it as private and on other end we are allowing user to access those properties by using getter and setter properties. I can't understand its significance.
by using getter and setter you hide the internal implementation of your class. which means in the set method of a setter, you can run a whole algorithm to parse the input data into your internal data structure. you'll be able to later change your implementation without any impact to your users.
now if you expose your internal members as public, you can't hide them anymore, and any change you make to your class internal definition will probably break the user usage.
In C#, the preferred method is to use Properties.
The advantage of this is that it exposes a convenient way of getting (or setting) data, but without exposing implemention details of the class.
A Property, or a getter or setter, can implement additional logic, for example:
Calculating a value based on some private data (rather than just returning a value directly)
Checking and validating data provided (to prevent overflows or out of range input).
By doing this you seperate the interface to your class from the implementation, allowing you easily to change the way your code works internally from how it is publicly accessed.
Because it allows you to override those properties in inherited classes, add validation / INotifyProperty changed handlers at a later date, and preserves binary compatibility between versions
Is there any downside to letting C# create the private backing fields that are generated by using the automatic property creation (ie {get; set})?
I am aware that it is automatic and therefore you cannot customize the get/set, and would like to know if there are any other implications.
Thanks!
The biggest issue that I have come across is that it is often very limiting when looking at binding scenarios. Typically when using data binding you need to implement INotifyPropertyChanged which is not supported by the automatic properties.
If you are using BinaryFormatter, changing to (or from) automatically implemented properties is a breaking change, since field names matter to BF. Of course, one easy fix there is: don't use BF!
You also can't add attributes to the backing field using automatic properties.
No field initialisers.
No true readonly for use with immutability.
You can't add logic, obviously; no laziness, validation, side-effects or notification events.
With structs, you need to call :this() on custom constructors, which is ugly.
Otherwise though: they are great. I'm a big fan.
The biggest problem is that you can't work with the backing fields, since they are created by the compiler. This means you can't declare them const or readonly, it means you can't add logic around accessing them (lazy initialization, for example), etc. The good news is that starting with the autoproperty makes the refactor to using a backing field easy, when you have a reason.
This question already has answers here:
Closed 12 years ago.
Possible Duplicates:
Should I use public properties and private fields or public fields for data?
Property(with no extra processing) vs public field
What is the point in having a property inside a class that simply get and sets a member variable?
What practical difference would be there to just making the variable public?
I think similar questions have been answered on many occasions, but basically it gives you the option of adding error checking/etc validation to your property without changing the public interface.
There's also some good information here, the following quote probably answers your question best:
A property communicates the idea of "I will make a value available to you, or accept a value from you." It's not an implementation concept, it's an interface concept. A field, on the other hand, communicates the implementation - it says "this type represents a value in this very specific way". There's no encapsulation, it's the bare storage format. This is part of the reason fields aren't part of interfaces - they don't belong there, as they talk about how something is achieved rather than what is achieved.
Ease of maintenance... you can log assignments, add validation, etc., without breaking existing callers.
You can't databind to public variables. Only public properties.
If you ever want to change the way the method is accessed, just changing the property is much easier than going through all of your code to find it. Also, you could make the property virtual, change the underlying data type easily, or use a Settings variable so that it's saved and recalled automatically. I had a similar question myself.
Properties allow future expansion in accessors and getters (validation, eventing, etc).
You can also make a property virtual, whereas a field cannot be.
The IL for calling fields is different to that of properties, so if you change a field to a property later on, existing compiled calling code will break.
The point is that caller of your class do not know what field the property gets/sets, whether it's calculated, fetched from somewhere, or whether messing with it causes and update/change to the state of you class instance. With a simple field call none of these are an option.