Read the Readme.md near the bottom

readme.md

Read first

If you really wanted to enforce your LocalSerializer class to be used in a specific way without allowing other classes to use it directly, you can try employing double-dispatch. It's not a frequently used pattern and has some code-bloating side effects if you aren't careful.

To see the magic, start at DataManager.OnEnable()

Note, in the example below:

• There is no way to use your serializer without a DataManager. This will help guide the user of the API as well as restrict them. Furthermore, I made sure not to make an interface for the DataManager. Serializers should use THE DataManager, not just any subclass.

• DataManager is sealed : This prevents the user from subclassing to get around your API rules. This is overkill

• LocalSerializers and DataManagers are fairly coupled. Changes in one will need to be propagated to the others.

ConcreteClasses.cs

public class LocalSerializer: ILocalSerializer
{
  public void LoadSomeStuff(DataManager dataManager)
  {
    /* Pretend this loads resources*/
    List<Resources> resources = Resources.Load("thestuff.ini");
    manager.LoadResources(resources);
  }
}

DataManager.cs

// Sealed, so that users can't subclass it.
public sealed class DataManager : Monobehaviour
{
  // !!! Start here. This is where the magic begins to happen.
  void OnEnable()
  {
    var serializer = (ILocalSerializer)FindObjectOfType(typeof(ILocalSerializer));
    serializer.LoadResources(this);
  }
  
  public void LoadResources(IEnumerable<Resources> resources)
  {
    /* do somehting with the resources */
  }
}

Interfaces.cs

public interface ILocalSerializer
{
  void LoadResources(DataManager dataManager);
}

For Posterity: is a response to a reddit post: http://www.reddit.com/r/Unity3D/comments/1oak7h/isolating_a_class_from_the_rest_of_the_codebase/