What is the need of the GetInstanceID() check in the following code?

Questions & Answers
1

I’m confused about the need for checking the instance ID when the member it’s checking is static and should be the same object anyways. If someone could walk me through it, I’d appreciate it.

using UnityEngine;
using System.Collections;

public class GameManager : MonoBehaviour 
{
	//C# property to retrieve currently active instance of object, if any.
    public static GameManager Instance
    {
        get
        {
            if (instance == null)
            {
				//Create game manager object if required.
                instance = new GameObject("GameManager").AddComponent<GameManager>();
            }

            return instance;
        }
    }

   //This recursive definition is a bit confusing to me.
    private static GameManager instance = null;

    //Called before Start() on object creation.
    void Awake()
    {
        //Not understanding the need to check for a different instance of
        //GameManager since it's static anyways.
        if ((instance) && (instance.GetInstanceID () != GetInstanceID ()))
        {
            DestroyImmediate (gameObject);	//Delete duplicate
        }
        else
        {
            instance = this;	//Make this object the only instance.
            DontDestroyOnLoad (gameObject);	//Set as do not destory.
        }
    }
}
2

It checks first if instance is null or not. If it is not null, then it checks if the id of the object is the same as this object making the check. This is meant to destroy the duplicate item.

Think you have the first one coming with id = 100, so the instance points towards the object with id = 100. This object has a DontDestroyOnLoad so it is persistent between scenes.

Now you reload the scene and a second object is created since your scene is meant to create that object but this time it has id = 150, so the second check won’t do and the duplicate item is removed.

This is a bit unusual, you are more likely to see:

if(instance != this){ }

which is the same and less confusing. It takes care of nullity and difference in value at once.