Question

I am making a game that has several classes and each one do some kind of specific task.

I am completely new to OOP and I was wondering what I should do to make my class instances communicate between each other without recurring to static classes, methods and properties, which seems like an awful thing to do.

I am self-taught programmer, and I realize I do a lot of bad practices. So far I managed to make this work making both classes static but I wanted to know what I should do to make my code as good as possible.

Also, it would be nice if you could recommend me some resources/books/articles so I can read more about this topic (communcation between instances).

Here is some piece of code so you understand what I am talking about.

class Program
{
    static void Main(string[] args)
    {
        Class1 instance1 = new Class1();
        Class2 instance2 = new Class2();

        // infinite loop
        while (true)
        {
            instance1.UpdateMethod(someValue);
            instance2.UpdateMethod();
        }
    }
}

class Class1
{
    int Property;
    UpdateMethod(int argument)
    {
        Property += argument;
        if(Property == 3000)
        {
            // I should change the state of instance2
        }
    }
}

class Class2
{
    UpdateMethod()
    {
        if(Time.GetTime() == SomeTime)
        {
            // here I want to change the state of instance1
        }
    }
}

Answer 1

For an overview of common design patterns, I recommend

http://en.wikipedia.org/wiki/Category:Software_design_patterns

If there is a natural relationship between Class1 and Class2, it’s quite common for an instance of one to hold a reference to an instance of another. For example, if you have a Player class, and the player has a Weapon, define your class like this:

public class Player
{
    public Weapon Weapon { get; set; }
    // Other properties
}

Specifically in your case, it looks like you want to update an instance of Class1 from an instance of Class2. I would suggest that you define a property on Class2 that holds the related instance of Class1, just as in the example above.

This is called the Composite Pattern.

In software engineering, the composite pattern is a partitioning
design pattern. The composite pattern describes that a group of
objects are to be treated in the same way as a single instance of an
object. The intent of a composite is to “compose” objects into tree
structures to represent part-whole hierarchies. Implementing the
composite pattern lets clients treat individual objects and
compositions uniformly.

Another pattern frequently used to act on an object instance is the Command Pattern.

In object-oriented programming, the command pattern is a design
pattern in which an object is used to represent and encapsulate all
the information needed to call a method at a later time. This
information includes the method name, the object that owns the method
and values for the method parameters. Three terms always associated
with the command pattern are client, invoker and receiver. The client
instantiates the command object and provides the information required
to call the method at a later time. The invoker decides when the
method should be called. The receiver is an instance of the class that
contains the method’s code. Using command objects makes it easier to
construct general components that need to delegate, sequence or
execute method calls at a time of their choosing without the need to
know the owner of the method or the method parameters.