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?

I am creating all of the elements in my android project dynamically. I am trying to get the width and height of a button so that I can rotate that button around. I am just trying to learn how to work with the android language. However, it returns 0. 

I did some research and I saw that it needs to be done somewhere other than in the `onCreate()` method. If someone can give me an example of how to do it, that would be great. 

Here is my current code:

    package com.animation;

    import android.app.Activity;
    import android.os.Bundle;
    import android.view.animation.Animation;
    import android.view.animation.LinearInterpolator;
    import android.view.animation.RotateAnimation;
    import android.widget.Button;
    import android.widget.LinearLayout;

    public class AnimateScreen extends Activity {
 

    //Called when the activity is first created.
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        LinearLayout ll = new LinearLayout(this);
        
        LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
        layoutParams.setMargins(30, 20, 30, 0);

        Button bt = new Button(this);
        bt.setText(String.valueOf(bt.getWidth()));
       
        RotateAnimation ra = new RotateAnimation(0,360,bt.getWidth() / 2,bt.getHeight() / 2);
        ra.setDuration(3000L);
        ra.setRepeatMode(Animation.RESTART);
        ra.setRepeatCount(Animation.INFINITE);
        ra.setInterpolator(new LinearInterpolator());

        bt.startAnimation(ra);
        
        ll.addView(bt,layoutParams);
        
        setContentView(ll);
    }

Any help is appreciated.

View&#39;s getWidth() and getHeight() returns 0

Let&#39;s say I specify an outputText component like this:

    &lt;h:outputText value=&quot;#{ManagedBean.someProperty}&quot;/&gt;

If I print a log message when the getter for `someProperty` is called and load the page, it is trivial to notice that the getter is being called more than once per request (twice or three times is what happened in my case):

    DEBUG 2010-01-18 23:31:40,104 (ManagedBean.java:13) - Getting some property
    DEBUG 2010-01-18 23:31:40,104 (ManagedBean.java:13) - Getting some property

If the value of `someProperty` is expensive to calculate, this can potentially be a problem.

I googled a bit and figured this is a known issue. One workaround was to include a check and see if it had already been calculated:

    private String someProperty;

    public String getSomeProperty() {
        if (this.someProperty == null) {
            this.someProperty = this.calculatePropertyValue();
        }
        return this.someProperty;
    }

The main problem with this is that you get loads of boilerplate code, not to mention private variables that you might not need.

What are the alternatives to this approach? Is there a  way to achieve this without so much unnecessary code? Is there a way to stop JSF from behaving in this way?

Thanks for your input!

Why JSF calls getters multiple times

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 have a strange habit it seems... according to my co-worker at least. We&#39;ve been working on a small project together. The way I wrote the classes is (simplified example):

    [Serializable()]
    public class Foo
    {
        public Foo()
        { }

        private Bar _bar;

        public Bar Bar
        {
            get
            {
                if (_bar == null)
                    _bar = new Bar();

                return _bar;
            }
            set { _bar = value; }
        }
    }

So, basically, I only initialize any field when a getter is called and the field is still null. I figured this would reduce overload by not initializing any properties that aren&#39;t used anywhere.

ETA: The reason I did this is that my class has several properties that return an instance of another class, which in turn also have properties with yet more classes, and so on. Calling the constructor for the top class would subsequently call all constructors for all these classes, when they are not _always_ all needed.

Are there any objections against this practice, other than personal preference?

UPDATE: I have considered the many differing opinions in regards to this question and I will stand by my accepted answer. However, I have now come to a much better understanding of the concept and I&#39;m able to decide when to use it and when not.

Cons:

- Thread safety issues
- Not obeying a &quot;setter&quot; request when the value passed is null
- Micro-optimizations
- Exception handling should take place in a constructor
- Need to check for null in class&#39; code

Pros:

- Micro-optimizations
- Properties never return null
- Delay or avoid loading &quot;heavy&quot; objects

Most of the cons are not applicable to my current library, however I would have to test to see if the &quot;micro-optimizations&quot; are actually optimizing anything at all.

LAST UPDATE:

Okay, I changed my answer. My original question was whether or not this is a good habit. And I&#39;m now convinced that it&#39;s not. Maybe I will still use it in some parts of my current code, but not unconditionally and definitely not all the time. So I&#39;m going to lose my habit and think about it before using it. Thanks everyone!

Good or bad practice? Initializing objects in getter

I do sometimes see abbreviations in properties for the getter. E.g. those two types:

    public int Number { get; } = 0

    public int Number =&gt; 0;

Can someone please tell me if there are any differences between those two. How do they behave? Are both of them read-only?

Difference in C# between different getter styles

I need to get the value of a field with a specific annotation, So with reflection I am able to get this Field Object. The problem is that this field will be always private though I know in advance it will always have a getter method. I know that I can use setAccesible(true) and get its value (when there is no PermissionManager), though I prefer to invoke its getter method.

I know that I could look for the method by looking for &quot;get+fieldName&quot; (though I know for example for boolean fields are sometimes named as &quot;is+fieldName&quot;).

I wonder if there is a better way to invoke this getter (many frameworks use getters/setters to access the attributes so maybe they do in another way).

Thanks

Best way of invoking getter by reflection

What does `get` mean in this ES6 class?  How do I reference this function?  How should I use it?

    class Polygon {
      constructor(height, width) {
        this.height = height;
        this.width = width;
      }
      
      get area() {
        return this.calcArea()
      }
    
      calcArea() {
        return this.height * this.width;
      }
    }

What is the &quot;get&quot; keyword before a function in a class?

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?

**EDIT Oct 2016**: Please note this question was asked in 2012. Every month or so someone adds a new answer or comment that refutes an answer, but doesn&#39;t really make sense to do so as the question is probably out of date (remember, it was for **Gnome Javascript** to write gnome-shell extensions, not browser stuff, which is quite specific).

Following [my previous question](https://stackoverflow.com/questions/10580158/making-subclass-with-prototype-and-proto) on how to do subclassing in Javascript, I&#39;m making a subclass of a superclass like so:

    function inherits(Child,Parent) {
        var Tmp = function {};
        Tmp.prototype = Parent.prototype;
        Child.prototype = new Tmp();
        Child.prototype.constructor = Child;
    }
    /* Define subclass */
    function Subclass() {
        Superclass.apply(this,arguments);
        /* other initialisation */
    }
    /* Set up inheritance */
    inherits(Subclass,Superclass);
    /* Add other methods */
    Subclass.prototype.method1 = function ... // and so on.

My question is, **how do I define a setter/getter on the prototype with this syntax?**

I used to do:

    Subclass.prototype = {
        __proto__: Superclass.prototype,
        /* other methods here ... */
    
        get myProperty() {
            // code.
        }
    }

But obviously the following won&#39;t work:

    Subclass.prototype.get myProperty() { /* code */ }

I&#39;m using GJS (GNOME Javascript), and the engine is meant to be the more-or-less same as the Mozilla Spidermonkey one. My code is not intended for a browser so as long as it&#39;s supported by GJS (I guess that means Spidermonkey?), I don&#39;t mind if it&#39;s not cross-compatible.

How to define setter/getter on prototype

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?

Long story short: I&#39;m in a situation where I&#39;d like a PHP-style getter, but in JavaScript.

My JavaScript is running in Firefox only, so Mozilla specific JS is OK by me.

The only way I can find to make a JS getter requires specifying its name, but I&#39;d like to define a getter for *all* possible names.  I&#39;m not sure if this is possible, but I&#39;d very much like to know.

JavaScript getter for all properties

    public static function __get($value)
does not work, and even if it did, it so happens that I already need the magic __get getter for instance properties in the same class.

This probably is a yes or no question, so, it is possible?

Magic __get getter for static properties in PHP

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?

What is the best practice for a C++ getter method which is supposed to return a non trivial type, but a member which is of type class, or struct.

  1. Return by value, such as: `MyType MyClass::getMyType() { return mMyType; }` 
  2. Return by const reference:  `const MyType&amp; MyClass::getMyType() { return mMyType; }` 
  3. Return by address: `MyType* MyClass::getMyType() { return &amp;mMyType; }` 

where

    class MyType { /* ... */ };

    class MyClass
    {
      private:
         MyType mMyType;
    }

I specifically worry about the following usages of this method. Can you please elaborate in details how this might affect copying the object, and the danger of dangling references and wild gone pointers if `function()` wants to save it for further usage.

    MyType* savedPointer;

    SomeType function(MyType* pointer) { savedPointer = pointer; };

a. valid for 1. and 2.

    {
      MyType t = myClass.getMyType();
      function(&amp;t);
    }

    // is savedPointer still valid here?
    
b. valid for 1. and 2.

    {
      const MyType&amp; t = myClass.getMyType();
      function(&amp;t);
    }

    // is savedPointer still valid here?

c. valid for 1. and 2.

    {
      MyType&amp; t = myClass.getMyType();
      function(&amp;t);
    }

    // is savedPointer still valid here?
    

d. valid for 3.

    {
      MyType* t = myClass.getMyType();
      function(t);
    }

    // is savedPointer still valid here?
    

where `myClass` is an object of type `MyClass`.

What should a C++ getter return

I have a mocked object that is passed as a constructor argument to another object.

How can I test that a mocked object&#39;s property has been called? This is code I am using currently:

    INewContactAttributes newContact = MockRepository.GenerateMock&lt;INewContactAttributes&gt;();
    newContact.Stub(x =&gt; x.Forenames).Return(&quot;One Two Three&quot;);
    someobject.ConsumeContact(newContact);
    newContact.AssertWasCalled(x =&gt; { var dummy = x.Forenames; });

This works except when within the &quot;someobject&quot; the getter on Forenames property is used multiple times. That&#39;s when I get &quot;Rhino.Mocks.Exceptions.ExpectationViolationException: INewContactAttributes.get_Forenames(); Expected #1, Actual #2..&quot;

Simply using 

    newContact.AssertWasCalled(x =&gt; { var dummy = x.Forenames; }, options =&gt; options.Repeat.Any());

does not work and gives the error below:

&quot;The expectation was removed from the waiting expectations list, did you call Repeat.Any() ? This is not supported in AssertWasCalled().&quot;

So how do I cater for the multiple calls?


Rhino Mocks AssertWasCalled (multiple times) on property getter using AAA

I love project [Lombok](https://projectlombok.org/) but in these days I&#39;m reading and trying some of the new features of java 14.

Inside the new capability, there is the [record](https://openjdk.java.net/jeps/359) keyword that allows creating a class with already built-in the following functionality: constructor, private final fields, accessors, equals/hashCode, getters, toString methods.

Now my question is: is better to rely on the feature of Lombok or should we start using the record functionality:

Is better to use this:

```java
record Person (String name, String surname) {}
```

or that:

```java
@AllArgsConstructor
@ToString
@EqualsAndHashCode
public class Person {
  @Getter private int name;
  @Getter private int surname;
}
```

What are the pros and cons of the both approach?


Lombok getter/setter vs Java 14 record

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 Getter Solutions on Gang of Coders

Total of 27 Getter Solutions