c# - Share variable between multiple classes

Question

If i have 3 classes, lets say: Mainclass, ChildClass, OtherChild.

MainClass()
{
     ChildClass cc = new ChildClass();
     OtherChild oc = new OtherChild();

     //Set the name property of childclass
     string childName = "some name";
}

ChildClass()
{
    public string name {get; set;}
}

OtherChild()
{
     //Here i want to get the name property from ChildClass()
     //Doing this will make a new instance of ChildClass,  which will not have the name property set.
     ChildClass cc = new ChildClass(); 

}

What is the solution for this ?

Answer 1

Basically, in order to access information from class to class, you must "pass" that information in some way between instances.

Here is a quick annotated example using your basic setup. I have included a few examples of different ways you could go about sending information between objects:

public MainClass()
{
    // just using auto-properties here. Will need initialized before use.
    public ChildClass cc { get; set; }
    public OtherChild oc { get; set; }

     // Constructor. Gets called when initializing as "new MainClass()"
     public MainClass() 
     {                
        // initialize our properties

        // option 1 - initialize, then set
        cc = new ChildClass();
        cc.childName = "some name"; //Set the name property of childclass

        //option 2 - initialize and set via constructor
        cc = new ChildClass("some name");

        // option 3 - initialize and set with initializer (more here: http://msdn.microsoft.com/en-us/library/vstudio/bb397680.aspx)
        cc = new ChildClass() { name = "some name" };

        oc = new OtherChild(cc);
     }
}

public ChildClass()
{
    public string name { get; set; }

    // Default constructor. this.name will = null after this is run
    public ChildClass() 
    {                
    }

    // Other constructor. this.name = passed in "name" after this is run
    public ChildClass(string name) 
    {
        //"this.name" specifies that you are referring to the name that belongs to this class
        this.name = name;
    }

}

public OtherChild()
{
    public ChildClass cc { get; set; } 

    public OtherChild() 
    {        
       cc = new ChildClass(); // initialize object in the default constructor
    }

    public OtherChild(ChildClass childClass) 
    {        
       cc = childClass; // set to the reference of the passed in childClass
    }
}

Of course, those all use .NET's auto-properties. For simple implementations, they work fine. If, however, you needed to (or just wanted to) split a member out, here is an example using the full property syntax.

public MainClass()
{
    // private backing field is only accessible within this class
    private ChildClass _cc = new ChildClass();

    // public property is accessible from other classes
    public ChildClass cc 
    { 
        get 
        {
            return _cc;
        }
        set
        {
            _cc = value;
        }
    }
}

If you notice, this initializes the private _cc at the beginning, in the member declaration. This ensures that the cc property does not need to be explicitly initialized before use. Again, this is more an example than a rigid standard. It's important to know all of the ways .NET uses properties and private members, so you may choose and use the best one for your particular situation.

---

Also, as a side note, you'll notice that I included either private or public in front of each private member, property, and constructor. While not technically necessary, it is generally good practice to explicitly specify your level of accessibility for each class member (this promotes encapsulation). The Wikipedia article on encapsulation has a pretty decent introductory explanation and examples.

For the future, I'd also suggest taking a look at a set of .NET naming conventions for things such as property names, backing fields, method names, etc:

• .net Naming Conventions and Programming Standards - Best Practices (quick reference)
• The MSDN's Framework Design Guidelines (more extensive)

While you may be fine reading your own code, following these different naming conventions ensures that others will be more able to read and understand it as well.