Save changes (delta) made to prefab in editor as serialized data and apply it later in runtime.

I was trying to do the same thing by reading the prefab as yaml (Asset serialization changed to text) then cheking for changed attributes base on other template prefab. Btw is far from working ... I can post more if you are interested.

But i guess the ease way is doing a search in the prefab transform tree using:

 void Do (Transform t) 
 {
     var components = t.GetComponents<Component>(); // Gets all components
     Debug.Log (t.name + " (" + components.Length + ")");

     // Use some reflection to get all attributes foreach component
 }

 void ForAllChilds(Transform t) {
     Do(t);
     for (int i = 0; i < t.childCount; i++) {
         ForAllChilds(t.GetChild(i));
     }
 }

Then using some reflection magic to compare and save the results.

BIG EDIT i just got some thing work ! If i have this moths ago it would have saved me a lot of time...

The way this works you need to put two Objects in your scene one the m_Left is the template and the m_Rigth is the changed then run Execute from the context menu and it will give a function that changes the m_Left object into the m_Rigth. For now the generated code can be optimized a lot, and only attributes changes are allowed, like color, text and so on.

For more support add extra functions on m_SaveAs to support Vector3 and Vector2 for instance.

     using UnityEngine;

 using System.Text;
 using System.Linq;
 using System.Reflection;
 using System.Collections;
 using System.Collections.Generic;

 public class SimplerDiff : MonoBehaviour {

     public Transform m_Left;
     public Transform m_Right;

     static List<string> m_IgnoreComponents = new List<string> () {"Transform", "RectTransform", "CanvasRenderer"};
     static List<string> m_IgnorePropsNames = new List<string> () {"name", "onCullStateChanged"};

     static Dictionary<System.Type, System.Func<object, string>> m_SaveAs;

     StringBuilder code;

     static SimplerDiff()
     {
         m_SaveAs = new Dictionary<System.Type, System.Func<object, string>>();
         m_SaveAs.Add(typeof(string), (x) => "\""+x.ToString()+"\"");
         m_SaveAs.Add(typeof(int), (x) => x.ToString());
         m_SaveAs.Add(typeof(float), (x) => x.ToString() + "f");

         m_SaveAs.Add(typeof(Color),
             (x) => {
                 var c = (Color)x;
                 return string.Format("new Color({0}f, {1}f, {2}f, {3}f)", c.r, c.g, c.b, c.a);
             }
         );

         m_SaveAs.Add(typeof(Color32),
             (x) => {
                 var c = (Color32)x;
                 return string.Format("new Color32({0}, {1}, {2}, {3})", c.r, c.g, c.b, c.a);
             }
         );
     }

     [ContextMenu("Execute")]
     void Execute ()
     {
         code = new StringBuilder();
         code.AppendLine("void ChangeTo_" + m_Right.name + "(GameObject go) {");
         ForAllChilds(m_Left, Do);
         code.AppendLine("}");

         Debug.Log(code.ToString());
     }

     void Do (Transform left)
     {
         bool edit1 = false;
         var path = GetGameObjectPath(left, m_Left);
         var right = GameObject.Find(m_Right.name + path).transform;
         foreach(var lmono in left.GetComponents<Component>())
         {
             var type = lmono.GetType();

             if (m_IgnoreComponents.FindIndex(x => type.Name.Equals(x)) != -1) continue;

             var rmono = right.GetComponent(type);

             if (rmono == null)
                 continue;

             var props = type.GetProperties(BindingFlags.Instance|BindingFlags.Public)
                 .Where(x => x.CanRead && x.CanWrite).ToArray();

             bool edit2 = false;
             foreach (var prop in props)
             {
                 if (m_IgnorePropsNames.FindIndex(x => prop.Name.Equals(x)) != -1) continue;
                 
                 var lval = prop.GetValue(lmono, null);
                 var rval = prop.GetValue(rmono, null);

                 if (!lval.Equals(rval))
                 {
                     System.Func<object, string> cast;
                     if (m_SaveAs.TryGetValue(prop.PropertyType, out cast))
                     {
                         if (!edit1)
                         {
                             code.AppendLine("\t{");
                             if (string.IsNullOrEmpty(path))
                             {
                                 code.AppendLine("\t\tvar child = go.transform;");
                             }
                             else
                             {
                                 // ignore the frist / in the path
                                 code.AppendLine(string.Format("\t\tvar child = go.transform.Find(\"{0}\");", path.Substring(1)));
                             }
                             edit1 = true;
                         }
                         
                         if (!edit2)
                         {
                             code.AppendLine("\t\t{");
                             code.AppendLine(string.Format("\t\t\tvar c = child.GetComponent<{0}>();", type.Name));
                             edit2 = true;
                         }
                         
                         code.AppendLine(
                             string.Format("\t\t\tc.{0} = {1};", prop.Name, cast(rval))
                         );
                     }
                 }
             }

             if (edit2)
             {
                 code.AppendLine("\t\t}");
             }
         }

         if (edit1)
         {
             code.AppendLine("\t}");
         }
     }

     void ForAllChilds(Transform transform, System.Action<Transform> map) {
         map(transform);
         for (int i = 0; i < transform.childCount; i++) {
             ForAllChilds(transform.GetChild(i), map);
         }
     }

     private string GetGameObjectPath(Transform transform, Transform top)
     {
         string path = "";

         while (top != transform && transform.parent != null)
         {
             path = "/" + transform.name + path;
             transform = transform.parent;
         }

         return path;
     }
 }