Accessing and setting the instance variable of one class from another class

Question

I currently have a class called:

public class HeatmapComponent : GH_Component

I also have another class called:

public class HeatMap

Inside the Heatmap class I have two instance variables declared as:

public int _width;
public int _height;

I would like to be able to access and set the _width and _height variables from the HeatmapComponent class. I know this is a scope issue, but, I am a bit confused as to what needs to be done.

In my HeatmapComponent class, this was what I had in mind:

this._width = width; // width is declared somewhere in this class
this._height = height; // height is same as above

I apologize beforehand if this is a stupid question. Please let me know if I am missing code snippets. I'll be happy to provide.

Answer 1

Couple of things:

readonly keyword makes anything settable only in the constructor. Example:

class XYZ
{
    private readonly int x;
    public XYZ()
    {
        x = 10; //works
    }

    public void SomeMethod()
    {
        x = 100; //does not work since it is readonly
    }
}

Then there's the various access modifiers: private is only accessible in the class itself, protected is accessible in inherited classes and public is accessible anywhere. Internal is accessible within the same assembly.

public class HeatMapComponent
{
    HeatMap _map;
    public HeatMapComponent()
    {
        _map = new HeatMap();
    }
    public void SomeMethod()
    {
        _map.Width = 10; //should work if Width is public and not readonly and if _map was initialized already, ie not null
    }
}

Answer 2

This sounds like a homework question, and the problem is you are not understanding the lesson.

Here's a way to create your HeatMap class. It contains an overload so you can either set the Width and Height in the constructor or via a Set method:

public class HeatMap {

  public HeatMap() {
    Width = 0;
    Height = 0;
  }

  public HeatMap(int width, int height) {
    Width = width;
    Height = height;
  }

  public void Set(int width, int height) {
    Width = width;
    Height = height;
  }

  public int Width { get; private set; }

  public int Height { get; private set; }

}

To use this in your HeatmapComponent class, you only need to create an instance of your HeatMap. Here are two ways of doing that:

public HeatmapComponent() {
}

public void Test1(int width, int height) {
  var hm = new HeatMap(width, height);
  Console.WriteLine("Width: {0}, Height: {1}", hm.Width, hm.Height);
}

public static void Test2(int width, int height) {
  var hm = new HeatMap();
  hm.Set(width, height);
  Console.WriteLine("Width: {0}, Height: {1}", hm.Width, hm.Height);
}

Be sure you understand what is going on, though.

Answer 3

Before I answer your question, you have one major, major issue: readonly. That means that the value of the variable cannot be changed once the object is created. By anyone. Period.

Now, you have a couple ways to do this. The first is to use properties like Snorre said. In effect, you'd get this:

public class HeatMap
{
   public int Width { get; set; }
   public int Height { get; set; }
}

public class HeatMapComponent
{
    private HeatMap myHeatMap; // Must have a reference to the object you want to change!

    public void SomeMethod()
    {
        myHeatMap.Width = 10;
    }
}

Now, the obvious downside here is that ANYONE can change the properties of HeatMap. If for some reason you really, really want to make HeatMap's width and height editable only by the HeatMapComponent, you can make HeatMapComponent an inner class, like this:

public class HeatMap
{
    private int width;
    private int height;

    public class HeatMapComponent
    {
        public HeatMap myHeatMap;

        public void SomeMethod()
        {
            myHeatMap.width = 10;
        }
    }
}

however, I would strongly advise you to rethink what you're trying to do. Public inner classes are actually quite rare, in my experience, as they can violate OOP principles easily. A different application design may suit you better.

Answer 4

You want to set the values of those two fields? They are readonly. You can do that only in the constructor.

public class HeatMap
{
    private readonly int _width;
    private readonly int _height;

    public HeatMap(int wid, int hei)
    {
        _width = wid;
        _height = hei;
    }
}

And, as it is with passing things through constructor's params, you can use/provide them only when building a new instance. That's why they are called constructor and readonly fields:

public class HeatmapComponent
{
    private int widthOfMap;
    private int heightOfMap;

    void createMapAndDoSomething() 
    {
        var hmap = new HeatMap(widthOfMap, heightOfMap);
        hmap.thing();
    }
}

If you don't want to create a new HeatMap, and if you want to be able to set the width/height from some 'external' place at any point in time, then:

• they cannot be readonly
• some public way of changing them must exist

For example:

public class HeatMap
{
    private int _width;
    private int _height;

    public void SetSize(int wid, int hei)
    {
        _width = wid;
        _height = hei;
    }
}

public class HeatmapComponent
{
    private int widthOfMap;
    private int heightOfMap;

    private HeatMap oldMap;

    void changeTheSizes() 
    {
        oldMap.SetSize(widthOfMap, heightOfMap);
    }
}

Or sometimes even better, use properties:

public class HeatMap
{
    private int _width;
    private int _height;

    public int Width { set { _width = value; } }
    public int Height { set { _height = value; } }
}

public class HeatmapComponent
{
    private int widthOfMap;
    private int heightOfMap;

    private HeatMap oldMap;

    void changeTheSizes() 
    {
        oldMap.Width = widthOfMap;
        oldMap.Height = heightOfMap;
    }
}