How do you give a C# auto-property an initial value?


I either use the constructor, or revert to the old syntax. 

&lt;strong&gt; Using the Constructor:&lt;/strong&gt;

    class Person 
    {
        public Person()
        {
            Name = &quot;Initial Name&quot;;
        }
        public string Name { get; set; }
    }
&lt;strong&gt;Using normal property syntax&lt;/strong&gt;  (with an initial value)

    private string name = &quot;Initial Name&quot;;
    public string Name 
    {
        get 
        {
            return name;
        }
        set
        {
            name = value;
        }
    }

Is there a better way?

What is the best way to give a C# auto-property an initial value?

What&#39;s the advantage of using getters and setters - that only get and set - instead of simply using public fields for those variables?

If getters and setters are ever doing more than just the simple get/set, I can figure this one out very quickly, but I&#39;m not 100% clear on how:

    public String foo;

is any worse than:

    private String foo;
    public void setFoo(String foo) { this.foo = foo; }
    public String getFoo() { return foo; }

Whereas the former takes a lot less boilerplate code.



Why use getters and setters/accessors?

By &quot;generate&quot;, I mean auto-generation of the code necessary for a particular selected (set of) variable(s).

But any more explicit explication or comment on good practice is welcome.



How can we generate getters and setters in Visual Studio?

I&#39;m currently working on a simple game in Java with several different modes. I&#39;ve extended a main Game class to put the main logic within the other classes. Despite this, the main game class is still pretty hefty.

After taking a quick look at my code the majority of it was Getters and Setters (60%) compared to the rest that is truly needed for the logic of the game.

A couple of Google searches have claimed that Getters and Setters are evil, whilst others have claimed that they are necessary for good OO practice and great programs.

So what should I do? Which should it be? Should I be changing my Getters and Setters for my private variables, or should I stick with them?

Are getters and setters poor design? Contradictory advice seen

I am using Ruby on Rails 3.2.2 and I would like to know if the following is a &quot;proper&quot;/&quot;correct&quot;/&quot;sure&quot; way to override a setter method for a my class attribute.

    attr_accessible :attribute_name
    
    def attribute_name=(value)
      ... # Some custom operation.
    
      self[:attribute_name] = value
    end

The above code seems to work as expected. However, *I would like to know if, by using the above code, in future I will have problems or, at least, what problems &quot;should I expect&quot;/&quot;could happen&quot; with Ruby on Rails*. If that isn&#39;t the right way to override a setter method, what is the right way?


----------

*Note*: If I use the code

    attr_accessible :attribute_name
    
    def attribute_name=(value)
      ... # Some custom operation.
    
      self.attribute_name = value
    end

I get the following error:

    SystemStackError (stack level too deep):
      actionpack (3.2.2) lib/action_dispatch/middleware/reloader.rb:70

What is the right way to override a setter method in Ruby on Rails?

I&#39;ve been trying to get my head around getters and setters and its not sinking in. I&#39;ve read [JavaScript Getters and Setters][1] and [Defining Getters and Setters][2] and just not getting it.

Can someone clearly state:

  1. What a getter and setter are meant to do, and 
  2. Give some VERY simple examples?


  [1]: http://ejohn.org/blog/javascript-getters-and-setters/
  [2]: https://developer.mozilla.org/En/Core_JavaScript_1.5_Guide:Creating_New_Objects:Defining_Getters_and_Setters

Getters \ setters for dummies

What convention do you use to comment getters and setters?  This is something I&#39;ve wondered for quite some time, for instance:

    /**
     * (1a) what do you put here?
     * @param salary (1b) what do you put here?
     */
    public void setSalary(float salary);
    
    /*
     * (2a) what do you put here?
     * @return (2b)
     */
    public float getSalary();

I always find I&#39;m pretty much writing the exact same thing for 1a/b and 2a/b, something like 1a) Sets the salary of the employee, 1b) the salary of the employee.  It just seems so redundant.  Now I could see for something more complex you might write more in the (a) parts, to give context, but for a majority of the getters/setters out there the wording is almost exactly the same.

I&#39;m just curious if, for the simple getters/setters its ok to only fill in either the (a) part OR the (b) part.

What do you think?


Simple Getter/Setter comments

I&#39;m from the php world. Could you explain what getters and setters are and could give you some examples?


How do getters and setters work?

I am confused as to what the point of getters and setters are in ECMAScript 6 classes. What is the purpose? Below is an example I am referring to:

    class Employee {
     
        constructor(name) {
            this._name = name;
        }
     
        doWork() {
            return `${this._name} is working`;
        }
     
        get name() {
            return this._name.toUpperCase();
        }
     
        set name(newName){
            if(newName){ 
                this._name = newName;
            }
        }
    }

What are getters and setters for in ECMAScript 6 classes?

Is there a way to have a private setter for a property in TypeScript?

	class Test
	{
		private _prop: string;
		public get prop() : string
		{
			return this._prop;
		}

		private set prop(val: string)
		{
			//can put breakpoints here
			this._prop = val;
		}
	}

Compiler complains that visibility for getter and setter don&#39;t match. I know I can just set the backing field, but but then I can&#39;t set breakpoints when the value is set.

I though about using an interface to hide the setter, but interfaces can only define a property, not whether it has a getter on setter.

Am I missing something here? There doesn&#39;t seem to be any reason to not allow private setters, the resulting JS doesn&#39;t enforce visibility anyway, and seems better that the current alternatives.

Am I missing something? If not is there a good reason for no private setters?

Private setter typescript?

Normally we use 

    @interface interface_name : parent_class &lt;delegates&gt;
    {
    ......
    }
    @end 

method in .h file and in .m file we synthesis the properties of variables declared in .h file.

But in some code, this @interface.....@end method is kept in the .m file also. What does it mean?  What is the difference between them?

Also give some words about getters and setters for the interface file that is defined in .m file...


Thanks in Advance

Difference between @interface definition in .h and .m file

I am currently working in Qt and so C++. I am having classes that has private data members and public member functions. I have public getters and setters for the data members available in the class. 

**Now my question is, if we have getters and setters for data members in our classes then what&#39;s the point in making those data members as private?** I agree having private data members in Base classes sounds logical. But besides that, having private members and so do their getters and setters doesn&#39;t seem to be of a logical one for me. 

Or instead **can we make all variables as public so that no need for getters and setters at all? Is it a good practice to have those?** I know having private members ensure data abstraction but having getters and setters actually lets access to those variables quite easily. Any pointers regarding this are welcome.

Public Data members vs Getters, Setters

Several questions about accessor methods in C++ have been asked on SO, but none was able satisfy my curiosity on the issue.

I try to avoid accessors whenever possible, because, like Stroustrup and other famous programmers, I consider a class with many of them a sign of bad OO. In C++, I can in most cases add more responsibility to a class or use the friend keyword to avoid them. Yet in some cases, you really need access to specific class members.

There are several possibilities:

**1. Don&#39;t use accessors at all**

We can just make the respective member variables public. This is a no-go in Java, but seems to be OK with the C++ community. However, I&#39;m a bit worried about cases were an explicit copy or a read-only (const) reference to an object should be returned, is that exaggerated?

**2. Use Java-style get/set methods**

I&#39;m not sure if it&#39;s from Java at all, but I mean this:

    int getAmount(); // Returns the amount
    void setAmount(int amount); // Sets the amount

**3. Use objective C-style get/set methods**

This is a bit weird, but apparently increasingly common:

    int amount(); // Returns the amount
    void amount(int amount); // Sets the amount

In order for that to work, you will have to find a different name for your member variable. Some people append an underscore, others prepend &quot;m_&quot;. I don&#39;t like either.

Which style do you use and why?

Conventions for accessor methods (getters and setters) in C++

&gt; **Possible Duplicate:** \
&gt; [Why use getters and setters?](https://stackoverflow.com/questions/1568091/why-use-getters-and-setters)

&lt;!-- End of automatically inserted text --&gt;

I have read books on Java, saying that it is good to create setters and getters for variables such as `x` and `y`.  For example:

    public int getX(){
        return x;
    }

    public void setX(int x){
        this.x = x;
    }

But what is the difference from that and

    ...(shape.x)...   // Basically getX()

and

    shape.x = 90;    // Basically setX()

If setters and getters are better, what practical problems would arise?






What is the point of getters and setters?

I need to write a custom setter method for a field (we&#39;ll call it `foo`) in my subclass of `NSManagedObject`. `foo` is defined in the data model and Xcode has autogenerated `@property` and `@dynamic` fields in the .h and .m files respectively.

If I write my setter like this:

    - (void)setFoo: (NSObject *)inFoo {
        [super setFoo: inFoo];
        [self updateStuff];
    }

then I get a compiler warning on the call to `super`.

Alternatively, if I do this:

    - (void)setFoo: (NSObject *)inFoo {
        [super setValue: inFoo forKey: inFoo];
        [self updateStuff];
    }

then I end up in an infinite loop.

So what&#39;s the correct approach to write a custom setter for a subclass of NSManagedObject?

Custom setter methods in Core-Data

I am having trouble understanding the concept of getters and setters *in the C# language*. In languages like Objective-C, they seem an integral part of the system, but not so much in C# (*as far as I can tell*). I have read books and articles already, so my question is, to those of you who understand getters &amp; setters in C#, what example would you personally use if you were teaching the concept to a complete beginner (*this would include as few lines of code as possible*)? 

Looking for a short &amp; simple example of getters/setters in C#

I&#39;m trying to create an abstract class that defines a property with a getter. I want to leave it up to derived classes to decide if they want to implement a setter for the property or not. Is this possible?

What I have so far:

    public abstract class AbstractClass {
        public abstract string Value { get; }
        public void DoSomething() {
            Console.WriteLine(Value);
        }
    }

    public class ConcreteClass1 : AbstractClass {
        public override string Value { get; set; }
    }

    public class ConcreteClass2 : AbstractClass {
        private string _value;
        public override string Value {
            get { return _value; }
        }
        public string Value {
            set { _value = value; }
        }
    }

    public class ConcreteClass3 : AbstractClass {
        private string _value;
        public override string Value {
            get { return _value; }
        }
        public void set_Value(string value) {
            _value = value;
        }
    }

In `ConcreteClass1`, I get an error on the `set`. It can&#39;t override `set_Value` because no overridable set accessor exists in AbstractClass.

In `ConcreteClass2`, I get an error on both `Value`&#39;s because a member with the same name is already declared.

`ConcreteClass3` doesn&#39;t give an error, but even though Value&#39;s set accessor would be compiled into set_Value, it doesn&#39;t work the other way around. Defining a `set_Value` does not mean that `Value` gets a set accessor. So I can&#39;t assign a value to a ConcreteClass3.Value property. I *can* use ConcreteClass3.set_Value(&quot;value&quot;), but that&#39;s not what I&#39;m trying to achieve here.

Is it possible to have the abstract class demand a public getter, while allowing an optional setter to be defined in a derived class?

_In case you&#39;r wondering, this is just a theoretical question. I don&#39;t have a real situation where something like this is needed. But I can imagine an abstract class that doesn&#39;t care how a property gets set, but that does need to be able to get the property._

Abstract property with public getter, define private setter in concrete class possible?

so far I have seen two approaches of setting a variable&#39;s value in Java. Sometimes a constructor with arguments is used, others setter methods are used to set the value of each variable. 

I know that a constructor initialises an instance variable inside a class once a class is instantiated using the &quot;new&quot; Keyword. 

But when do we use constructors and when do we use setters?


Setter methods or constructors

Allen Holub wrote the following,
&gt;You can&#39;t have a program without some coupling. Nonetheless, you can minimize coupling considerably by slavishly following OO (object-oriented) precepts (the most important is that the implementation of an object should be completely hidden from the objects that use it). For example, an object&#39;s instance variables (member fields that aren&#39;t constants), should always be private. Period. No exceptions. Ever. I mean it. (You can occasionally use protected methods effectively, but protected instance variables are an abomination.)

Which sounds reasonable, but he then goes on to say,
&gt;You should &lt;b&gt;never use get/set functions&lt;/b&gt; for the same reason—they&#39;re just overly complicated ways to make a field public (though access functions that return full-blown objects rather than a basic-type value are reasonable in situations where the returned object&#39;s class is a key abstraction in the design).

Which, frankly, just sounds insane to me.

I understand the principle of information hiding, but without accessors and mutators you couldn&#39;t use Java beans at all. I don&#39;t know how you would follow a MVC design without accessors in the model, since the model *can not* be responsible for rendering the view.

However, I am a younger programmer and I learn more about Object Oriented Design everyday. Perhaps someone with more experience can weigh in on this issue.

Allen Holub&#39;s articles for reference
-----------------------------------

 - [Why Extends Is Evil][1]
 - [Why Getter And Setter Methods Are Evil][2]


----------

Related Questions:
========

&gt;* [Java: Are Getters and Setters evil?][3]
* [Is it really that wrong not using setters and getters?][4]
* [Are get and set functions popular with C++ programmers?][5]
* [Should you use accessor properties from within the class, or just from outside of the class?][6]


  [1]: http://www.javaworld.com/javaworld/jw-08-2003/jw-0801-toolbox.html?page=1
  [2]: http://www.javaworld.com/javaworld/jw-09-2003/jw-0905-toolbox.html
  [3]: https://stackoverflow.com/questions/565095/java-are-getters-and-setters-evil
  [4]: https://stackoverflow.com/questions/808348/is-it-really-that-wrong-not-using-setters-and-getters
  [5]: https://stackoverflow.com/questions/737409/are-get-and-set-functions-popular-with-c-programmers
  [6]: https://stackoverflow.com/questions/476021/should-you-use-accessor-properties-from-within-the-class-or-just-from-outside-of

All Setter Solutions on Gang of Coders

Total of 19 Setter Solutions