Fold/unfold gameobject from code

You can also find a child of the object you want to expand, and ping it using

 EditorGUIUtility.PingObject(go) 

This will expand everything for you.

You can now write a combo of both to select certain objects. I combined both 'answers' above (the setexpandedrecursive with the above collapse.

Here's my script, non-usable universally (you'll have to modify it heavily to use it) that expands and contracts different groups, then selects the first object of a particular object group called "OObjects".

My object hierarchy looks like this:

Scene > Map Lights OObjects CCameras OWaypoints CWaypoints

This script 1) Writes all objects to lists 2) Uses the reflection code above to expand and contract a whole list of objects 3) Uses the keystroke code above to select the proper object.

You have to keep in mind that the first example with the keystrokes doesn't work unless the list is already expanded, as it doesn't use the Unity API but just the standard C# api. (SelectObject I mean)

It's nothing short of a miracle that something like this works. Here's my hierarchy after the object is selected:

And here's the code:

 #if (UNITY_EDITOR)
 using UnityEngine;
 using UnityEditor;
 using System.Collections;
 using System.Reflection;
 using System.Collections.Generic;
 
 [ExecuteInEditMode]
 public class S_Scene_Editor : MonoBehaviour {
 
     private GameObject OObjectGameObject;
 
     public bool AutoExpandOObjects;
     public bool AutoExpandCCameras;
     public bool AutoExpandOWaypoints;
     public bool AutoExpandCWaypoints;
 
     private bool SceneJustStarted = true;
     public List<GameObject> Scene_Editor_ObjectList = new List<GameObject>();
     public List<GameObject> Scene_Editor_OObjectList = new List<GameObject>();
 
     public void Update () {
         if (SceneJustStarted == true) {
             
             Debug.Log ("Scene just loaded, run this once:");
 
                 foreach (GameObject gameObject in GameObject.FindObjectsOfType(typeof(GameObject))) {
                     Scene_Editor_ObjectList.Add (gameObject);
                 }
                 foreach (GameObject gameObject in Scene_Editor_ObjectList) { 
                     string tempString = gameObject.name.Substring (0, 2);
                     if (tempString == "O_" && gameObject.name != "O_Graphics") { //do not add the O_Graphics object
                         Scene_Editor_OObjectList.Add (gameObject);
                     }
                 }
 
             if (AutoExpandOObjects) {
 
                 if (Scene_Editor_OObjectList.Count != 0) { 
 
                     OObjectGameObject = GameObject.Find ("OObjects");
 
                     SetExpandedRecursive (OObjectGameObject, true);
 
                     for (int x = 0; x < Scene_Editor_OObjectList.Count; x++) { 
                         SetExpandedRecursive (Scene_Editor_OObjectList [x], false);
                     }
                     SelectFirstOObjectInWindow ();
                 }
             }
 
             if (AutoExpandCCameras) {
                 foreach (GameObject gameObject in Scene_Editor_ObjectList) { 
                     if (gameObject.name == "CCameras") { 
                         SetExpandedRecursive (gameObject,true);
                     }
                 }
             }
 
             if (AutoExpandOWaypoints) {
                 foreach (GameObject gameObject in Scene_Editor_ObjectList) { 
                     if (gameObject.name == "OWaypoints") { 
                         SetExpandedRecursive (gameObject,true);
                     }
                 }
             }
 
             if (AutoExpandCWaypoints) {
                 foreach (GameObject gameObject in Scene_Editor_ObjectList) { 
                     if (gameObject.name == "CWaypoints") { 
                         SetExpandedRecursive (gameObject,true);
                     }
                 }
             }
     
             SceneJustStarted = false;
         }
     }
 
     public void SelectFirstOObjectInWindow() {
         var hierarchy = GetFocusedWindow("Hierarchy");
         SelectObject(OObjectGameObject);
         var key = new Event { keyCode = KeyCode.DownArrow, type = EventType.keyDown };
         hierarchy.SendEvent(key);
     }
         
     public void ExpandObjectInWindow(GameObject go, bool collapse)
     {
         if (go.transform.childCount == 0) return;
         var hierarchy = GetFocusedWindow("Hierarchy");
         SelectObject(go);
         var key = new Event { keyCode = collapse ? KeyCode.RightArrow : KeyCode.LeftArrow, type = EventType.keyDown };
         hierarchy.SendEvent(key);
     }
 
     public void SelectObject(Object obj)
     {
         Selection.activeObject = obj;
     }
 
     public EditorWindow GetFocusedWindow(string window)
     {
         FocusOnWindow(window);
         return EditorWindow.focusedWindow;
     }
 
     public void FocusOnWindow(string window)
     {
         EditorApplication.ExecuteMenuItem("Window/" + window);
     }
         
     private void SetExpandedRecursive(GameObject go, bool expand) {
         var type = typeof(EditorWindow).Assembly.GetType ("UnityEditor.SceneHierarchyWindow");
         //        var methodInfo = type.GetMethod ("ExpandTreeViewItem");
         MethodInfo methodInfo = type.GetMethod("SetExpandedRecursive");
 
         Debug.Log (methodInfo + "\n" + methodInfo.Attributes);
 
         EditorApplication.ExecuteMenuItem ("Window/Hierarchy");
         var window = EditorWindow.focusedWindow;
 
         //
         methodInfo.Invoke (window, new object[] { go.GetInstanceID (), expand });
     }
 
 }
 #endif