What are getters and setters used for in C#? How do I use them with an array?

1) I'm still quite new to programming and have read a bit about getters and setters. But I really don't understand why they are used.. Could anyone explain it, or point me to an article? (The ones I read were not really understandable for me...)

2) In my cur开发者_C百科rent project I have a class where I declare and initialize an array of structs. I now need to access the array from another class, but it gives me the error: An object reference is required to access non-static member 'BaseCharacter.Attributes'.

I figures this could mean I need to use getters and setters? But how does this work for arrays?

Thanks in advance!

Simon.

EDIT: 2nd question got solved, which brings me to something else. When I want to use some class in another one, I'm making a new instance of the class, right? And this means I get the original values? But that's not what I want.

The second class is used to generate the UI, and needs the values I'm keeping in the first class.

At some point I will implement save files (XML or even on a server in later stage). Can I then just get the values from those files?

---

For the getters and setters (the things that use them are called Properties) it's just a convenient and nice-looking way to make people think they're using a variable, but to do some computation whenever the variable is updated or accessed. For instance:

BankAccount.Interest

looks better than

BankAccount.GetInterest()

Even though you can calculate the interest at the time it is requested in both cases.

They are also used to make a variable be able to be accessed from outside the class, but changeable only from within the class with this technique:

public double Interest {
    get;
    private set;
}

For an example of a setter being used, if you've ever used Windows Forms and updated a control's Height or Width property, you're using a setter. While it looks like you're using a normal instance variable like c.Height = 400, you're really letting c update it's position by redrawing at a new place. So setters notify you exactly when a variable is changed, so your class can update other things base on the new value.

Yet another application of Properties is that you can check the value people try to set the property to. For instance, if you want to maintain an interest rate for each bank account but you don't want to allow negative numbers or numbers over 50, you just use a setter:

private int _interestRate = someDefault;
public int InterestRate {
    get { return _interestRate; }
    set {
        if (value < 0 || value > 50)
            throw new SomeException(); // or just don't update _interestRate
        _interestRate = value;
    }
}

This way people can't set public values to invalid values.

---

For your second question, you can do one of two things depending on what you're trying to do.

One: You can make that member static. That means that just one of them exists for the entire class instead of one per instance of the class. Then you can access it by ClassName.MemberName.

You can do that this way:

// inside the BaseCharacter class definition:
public static SomeStruct[] Attributes = new SomeStruct[size];

// then to use it somewhere else in your code, do something with
BaseCharacter.Attributes[index]

Two: You have to make an instance of the class and access the array through that. This means that each object will have its own seperate array.

You'd do that like this:

BaseCharacter bc = new BaseCharacter();
// use bc.Attributes

The second one is probably what you'll want to do, since you probably will want to modify each character's attributes seperately from all the other characters.

---

Actually the error you mention is not related to the getters and setters concept, it's because after creating your class you need to create an object before using its members; think of the class as a template for a document and the object as the document

you are most likely doing something like this:

var someVar = BaseCharacter.Attributes;

When you should be doing something like this:

var someVar = new BaseCharacter(); var someOtherVar = someVar.Attributes;

And about why the getters and setters, Seth Carnegie's Answer covers it nicely.

---

If you are new to Object Oriented Programming, you may be missing an important concept, that is about encapsulation.

Fields (attributes) of a class should be accessed only from within the class (or it's inherited classes). That is, if we have a class person, only with a name, you can do

public class Person
{
    public string Name;
}

So anywhere in your program, you will be able to access it by doing:

Person person = new Person();
person.Name = "Andre";

This works, but it's not encapsulated. In some languages like C++ or Java, it was done like this:

public class Person
{
    private string _name;

    public string setName(string newName)
    {
        this._name = newName;
    }
    public string getName()
    {
        return this._name;
    }

    }

Person person = new Person();
person.setName("Andre");

This makes our _name attribute encapsulated, it can only be retrieved by it's get and set methods (that is, by the interface of the class).

C# makes this easier, allowing getters and setters:

public class Person
{
    private string name;
    public string Name
    {
        get { return this.name; }
        set { this.name = value; }
    }
}

Person person = new Person();
person.Name = "Andre";

This is very much like the second example (Java/C++ way), but you treat Name as property, instead of methods, and leaving our name property encapsulated

---

1) They might seem optional but they allow you more control over code:

You're able to intercept new values and avoid them being set (e.g. to exclude pointless values). Also you're able to fire custom events in case a property is changed or updated (just like the WinForms controls do).

private string name;
public string Name
{
    get
    {
        // running additional code, e.g. here I avoid returning 'null' for a name not set
        if(name == null)
            return "(Unknown)";
        return name;
    }
    set
    {
        // checking incoming values, e.g. here I avoid setting an empty name
        name = value != null && value.Length > 0 ? name : null;
        // running more/additional code, e.g. here I raise an event
        if(OnNameChange)
            OnNameChange();
    }
}

2) Without knowing the code it's hard to tell you the exact reason, but if you'd like to access some member variable or property you have to either create an object of that class or make the variable static (e.g. shared between all instances of the object):

class MyClass
{
    public static int someNumber = 55;
    public int thisNumber;
}

// ...

int someothervar = MyClass.someNumber; // access the static member variable
MyClass mc = new MyClass(); // create an object of the class
int yetanothervar = mc.thisNumber; // access the member variable