human: Hello, may I have your assistance in troubleshooting this C# code in the Visual Studio 2022 IDE:
```
internal void Point(Vector3 worldPos) {
     var viz = GameGui.WorldToScreen(worldPos, out Vector2 screenPos);

     DrawList.PathLineTo(screenPos);
     if (viz) {
          cullObj = false;
     }
}
```
The `WorldToScreen` method returns a `bool` as `true` if the converted coordinates are on screen. The method's declaration is:
```
public bool WorldToScreen(Vector3 worldPos, out Vector2 screenPos)
```
The error I'm receiving is highlighting `GameGui.WorldToScreen` on line two of the provided code and reads `"An object reference is required for the non-static field, method, or property"`
 
I can provide more detail if requested but with all this considered, what are some possible solutions to this compilation error, or alternatively, and preferably, could you direct me to some resources that I can use in order to learn the answer for myself?

Thank you in advance for your time and assistance.

assistant: The most likely cause of this error is that the GameGui object has not been initialized. You need to make sure that the GameGui object has been initialized and assigned a value before calling the WorldToScreen method. Additionally, you may need to add the 'static' keyword to the WorldToScreen method declaration, as this will make the method accessible without requiring an instance of GameGui.

You can find more information on the topics of object initialization and static methods in the official Microsoft documentation

human: When should I declare a method "static", and when shouldn't I?

assistant: In C#, you should declare a method as static if it does not depend on an instance of the class and can be called directly on the class itself.

Here are some guidelines to help you decide whether a method should be declared as static:

1. If the method does not access any non-static members (fields or properties) of the class, you can declare it as static. This means that the method can be called without creating an instance of the class.

2. If the method accesses non-static members of the class, you should declare it as an instance method. This means that the method can only be called on an instance of the class, and it will operate on that instance's data.

3. If the method needs to be overridden in a derived class, you should not declare it as static, because static methods cannot be overridden.

4. If the method needs to access the reference or call other instance methods on the same object, you should declare it as an instance method.

5. If the method needs to be called from a static method or constructor, you should declare it as static.

Here's an example to illustrate the difference between static and instance methods:

```csharp
public class MyClass
{
    private int myInt;
    
    public static void StaticMethod()
    {
        Console.WriteLine("This is a static method.");
    }
    
    public void InstanceMethod()
    {
        Console.WriteLine("This is an instance method. My int is: " + myInt);
    }
}
```

In the example above, StaticMethod() is a static method because it does not access any instance members of the MyClass class. InstanceMethod(), on the other hand, is an instance method because it accesses the myInt field of the class, which is not static.

To call a static method, you can simply call it on the class itself, like this:

```csharp
MyClass.StaticMethod();
```

To call an instance method, you need to create an instance of the class first, like this:

```csharp
MyClass myObject = new MyClass();
myObject.InstanceMethod();
```

I hope this helps! Let me know if you have any more questions.