Changeset 2127


Ignore:
Timestamp:
Nov 25, 2010, 10:53:43 AM (11 years ago)
Author:
kopal
Message:
  • model persistence/xml serialization is now more "error" friendly and does not crash, if a model element can not be restored. But it shows a warning
Location:
trunk/CrypPlugins/WorkspaceManager/Model
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/WorkspaceManager/Model/ModelPersistance.cs

    r1903 r2127  
    4040        public static WorkspaceModel loadModel(string filename, WorkspaceManager workspaceManagerEditor)
    4141        {
    42             PersistantModel persistantModel = (PersistantModel)XMLSerialization.XMLSerialization.Deserialize(filename,true);
     42            PersistantModel persistantModel = (PersistantModel)XMLSerialization.XMLSerialization.Deserialize(filename,true,workspaceManagerEditor);
    4343            WorkspaceModel workspacemodel = persistantModel.WorkspaceModel;
    4444            workspacemodel.WorkspaceManagerEditor = workspaceManagerEditor;           
     
    5353                    foreach (PropertyInfo pInfo in arrpInfo)
    5454                    {
    55                         DontSaveAttribute[] dontSave = (DontSaveAttribute[])pInfo.GetCustomAttributes(typeof(DontSaveAttribute), false);
    56                         if (dontSave.Length == 0)
    57                         {
    58                             if (pInfo.Name.Equals(persistantSetting.Name))
     55                        try
     56                        {
     57                            DontSaveAttribute[] dontSave =
     58                                (DontSaveAttribute[]) pInfo.GetCustomAttributes(typeof (DontSaveAttribute), false);
     59                            if (dontSave.Length == 0)
    5960                            {
    60                                 if (persistantSetting.Type.Equals("System.String"))
     61                                if (pInfo.Name.Equals(persistantSetting.Name))
    6162                                {
    62                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, (String)persistantSetting.Value, null);
    63                                 }
    64                                 else if (persistantSetting.Type.Equals("System.Int16"))
    65                                 {
    66                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, System.Int16.Parse((String)persistantSetting.Value), null);
    67                                 }
    68                                 else if (persistantSetting.Type.Equals("System.Int32"))
    69                                 {
    70                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, System.Int32.Parse((String)persistantSetting.Value), null);
    71                                 }
    72                                 else if (persistantSetting.Type.Equals("System.Int64"))
    73                                 {
    74                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, System.Int64.Parse((String)persistantSetting.Value), null);
    75                                 }
    76                                 else if (persistantSetting.Type.Equals("System.Double"))
    77                                 {
    78                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, System.Double.Parse((String)persistantSetting.Value), null);
    79                                 }
    80                                 else if (persistantSetting.Type.Equals("System.Boolean"))
    81                                 {
    82                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, System.Boolean.Parse((String)persistantSetting.Value), null);
    83                                 }
    84                                 else if (pInfo.PropertyType.IsEnum)
    85                                 {
    86                                     Int32 result = 0;
    87                                     System.Int32.TryParse((String)persistantSetting.Value, out result);
    88                                     object newEnumValue = Enum.ToObject(pInfo.PropertyType, result);
    89                                     pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,newEnumValue,null);                                   
     63                                    if (persistantSetting.Type.Equals("System.String"))
     64                                    {
     65                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,
     66                                                       (String) persistantSetting.Value, null);
     67                                    }
     68                                    else if (persistantSetting.Type.Equals("System.Int16"))
     69                                    {
     70                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,
     71                                                       System.Int16.Parse((String) persistantSetting.Value), null);
     72                                    }
     73                                    else if (persistantSetting.Type.Equals("System.Int32"))
     74                                    {
     75                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,
     76                                                       System.Int32.Parse((String) persistantSetting.Value), null);
     77                                    }
     78                                    else if (persistantSetting.Type.Equals("System.Int64"))
     79                                    {
     80                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,
     81                                                       System.Int64.Parse((String) persistantSetting.Value), null);
     82                                    }
     83                                    else if (persistantSetting.Type.Equals("System.Double"))
     84                                    {
     85                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,
     86                                                       System.Double.Parse((String) persistantSetting.Value), null);
     87                                    }
     88                                    else if (persistantSetting.Type.Equals("System.Boolean"))
     89                                    {
     90                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings,
     91                                                       System.Boolean.Parse((String) persistantSetting.Value), null);
     92                                    }
     93                                    else if (pInfo.PropertyType.IsEnum)
     94                                    {
     95                                        Int32 result = 0;
     96                                        System.Int32.TryParse((String) persistantSetting.Value, out result);
     97                                        object newEnumValue = Enum.ToObject(pInfo.PropertyType, result);
     98                                        pInfo.SetValue(persistantPlugin.PluginModel.Plugin.Settings, newEnumValue, null);
     99                                    }
    90100                                }
    91101                            }
     102                        }catch(Exception ex)
     103                        {
     104                            workspaceManagerEditor.GuiLogMessage("Could not restore the setting \"" + persistantSetting.Name + "\" of plugin \"" + persistantPlugin.PluginModel.Name + "\" because of:" + ex.Message,NotificationLevel.Warning);
    92105                        }
    93106                    }
     
    98111            foreach (PluginModel pluginModel in workspacemodel.AllPluginModels)
    99112            {
    100                 pluginModel.Plugin.Initialize();
     113                try
     114                {
     115                    pluginModel.Plugin.Initialize();
     116                }
     117                catch(Exception ex)
     118                {
     119                    workspaceManagerEditor.GuiLogMessage("Error while initializing \"" + pluginModel.Name + "\". Surely plugin will not work well. Error was:" + ex.Message,NotificationLevel.Error);
     120                }
    101121                pluginModel.Plugin.OnGuiLogNotificationOccured += workspaceManagerEditor.GuiLogNotificationOccured;
    102122                pluginModel.Plugin.OnGuiLogNotificationOccured += pluginModel.GuiLogNotificationOccured;
     
    126146                ConnectorModel from = connectionModel.From;
    127147                ConnectorModel to = connectionModel.To;
    128 
    129                 if (from.IControl && to.IControl)
    130                 {
    131                     object data = null;
    132                     //Get IControl data from "to"
    133                     if (to.IsDynamic)
     148                try
     149                {
     150                    if (from.IControl && to.IControl)
    134151                    {
    135                         data = to.PluginModel.Plugin.GetType().GetMethod(to.DynamicGetterName).Invoke(to.PluginModel.Plugin, new object[] { to.PropertyName });
     152                        object data = null;
     153                        //Get IControl data from "to"
     154                        if (to.IsDynamic)
     155                        {
     156                            data =
     157                                to.PluginModel.Plugin.GetType().GetMethod(to.DynamicGetterName).Invoke(
     158                                    to.PluginModel.Plugin, new object[] {to.PropertyName});
     159                        }
     160                        else
     161                        {
     162                            data =
     163                                to.PluginModel.Plugin.GetType().GetProperty(to.PropertyName).GetValue(
     164                                    to.PluginModel.Plugin, null);
     165                        }
     166
     167                        //Set IControl data
     168                        if (from.IsDynamic)
     169                        {
     170                            MethodInfo propertyInfo = from.PluginModel.Plugin.GetType().GetMethod(from.DynamicSetterName);
     171                            propertyInfo.Invoke(from.PluginModel.Plugin, new object[] {from.PropertyName, data});
     172                        }
     173                        else
     174                        {
     175                            PropertyInfo propertyInfo = from.PluginModel.Plugin.GetType().GetProperty(from.PropertyName);
     176                            propertyInfo.SetValue(from.PluginModel.Plugin, data, null);
     177                        }
    136178                    }
    137                     else
    138                     {
    139                         data = to.PluginModel.Plugin.GetType().GetProperty(to.PropertyName).GetValue(to.PluginModel.Plugin, null);
    140                     }
    141 
    142                     //Set IControl data
    143                     if (from.IsDynamic)
    144                     {
    145                         MethodInfo propertyInfo = from.PluginModel.Plugin.GetType().GetMethod(from.DynamicSetterName);
    146                         propertyInfo.Invoke(from.PluginModel.Plugin, new object[] { from.PropertyName, data });
    147                     }
    148                     else
    149                     {
    150                         PropertyInfo propertyInfo = from.PluginModel.Plugin.GetType().GetProperty(from.PropertyName);
    151                         propertyInfo.SetValue(from.PluginModel.Plugin, data, null);
    152                     }
     179                }catch(Exception ex)
     180                {
     181                    workspaceManagerEditor.GuiLogMessage("Error while restoring IControl Connection between \"" + from.PluginModel.Name + "\" to \"" + to.PluginModel.Name + "\". Workspace surely will not work well. Error was:" + ex.Message, NotificationLevel.Error);
    153182                }
    154183            }
  • trunk/CrypPlugins/WorkspaceManager/Model/XMLSerialization.cs

    r1905 r2127  
    2424using System.Collections;
    2525using System.IO.Compression;
     26using Cryptool.PluginBase;
     27using WorkspaceManager;
    2628
    2729namespace XMLSerialization
     
    347349        /// <param name="filename"></param>
    348350        /// <param name="compress"></param>
     351        /// <param name="workspaceManager"></param>
    349352        /// <returns></returns>
    350         public static object Deserialize(String filename, bool compress=false)
     353        public static object Deserialize(String filename, bool compress=false,WorkspaceManager.WorkspaceManager workspaceManager = null)
    351354        {
    352355            FileStream sourceFile = File.OpenRead(filename);
     
    366369            try
    367370            {
    368                 return XMLSerialization.Deserialize(doc);
     371                return XMLSerialization.Deserialize(doc,workspaceManager);
    369372            }
    370373            finally
     
    381384        /// </summary>
    382385        /// <param name="doc"></param>
     386        /// <param name="workspaceManager"></param>
    383387        /// <returns></returns>
    384         public static object Deserialize(XmlDocument doc)
     388        public static object Deserialize(XmlDocument doc, WorkspaceManager.WorkspaceManager workspaceManager = null)
    385389        {
    386390            Dictionary<string, object> createdObjects = new Dictionary<string, object>();
     
    405409                    object newmember;
    406410
    407                     if (member.ChildNodes[2].Name.Equals("value"))
    408                     {
    409                         XmlNode value = member.ChildNodes[2];
    410                         if (RevertXMLSymbols(membertype.InnerText).Equals("System.String"))
    411                         {
    412 
    413                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    414                                 BindingFlags.NonPublic |
    415                                 BindingFlags.Public |
    416                                 BindingFlags.Instance).SetValue(newObject, value.InnerText);
    417                         }                       
    418                         else if (RevertXMLSymbols(membertype.InnerText).Contains("System.Int"))
    419                         {
    420                             Int32 result = 0;
    421                             System.Int32.TryParse(RevertXMLSymbols(value.InnerText), out result);
    422                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    423                                 BindingFlags.NonPublic |
    424                                 BindingFlags.Public |
    425                                 BindingFlags.Instance).SetValue(newObject, result);
    426                         }                       
    427                         else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Double"))
    428                         {
    429                             Double result = 0;
    430                             System.Double.TryParse(RevertXMLSymbols(value.InnerText), out result);
    431                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    432                                 BindingFlags.NonPublic |
    433                                 BindingFlags.Public |
    434                                 BindingFlags.Instance).SetValue(newObject, result);
    435                         }
    436                         else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Char"))
    437                         {
    438                             Char result = ' ';
    439                             System.Char.TryParse(RevertXMLSymbols(value.InnerText), out result);
    440                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    441                                 BindingFlags.NonPublic |
    442                                 BindingFlags.Public |
    443                                 BindingFlags.Instance).SetValue(newObject, result);
    444                         }
    445                         else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Boolean"))
    446                         {
    447                             Boolean result = false;
    448                             System.Boolean.TryParse(RevertXMLSymbols(value.InnerText), out result);
    449                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    450                                 BindingFlags.NonPublic |
    451                                 BindingFlags.Public |
    452                                 BindingFlags.Instance).SetValue(newObject, result);
    453                         }
    454                         else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Windows.Point"))
    455                         {
    456                             string[] values = value.InnerText.Split(new char[] { ';' });
    457 
    458                             double x = 0;
    459                             double y = 0;
    460                             double.TryParse(values[0], out x);
    461                             double.TryParse(values[1], out y);
    462 
    463                             System.Windows.Point result = new System.Windows.Point(x, y);
    464                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    465                                 BindingFlags.NonPublic |
    466                                 BindingFlags.Public |
    467                                 BindingFlags.Instance).SetValue(newObject, result);
    468                         }
    469                         else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Byte[]"))
    470                         {
    471                             byte[] bytearray = Convert.FromBase64String(value.InnerText);
    472 
    473                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    474                                 BindingFlags.NonPublic |
    475                                 BindingFlags.Public |
    476                                 BindingFlags.Instance).SetValue(newObject, bytearray);
    477                         }
    478                         else
    479                         {
    480                             newmember = System.Activator.CreateInstance(Type.GetType(RevertXMLSymbols(membertype.InnerText)));
    481 
    482                             if (newmember is Enum)
     411                    try
     412                    {
     413                        if (member.ChildNodes[2].Name.Equals("value"))
     414                        {
     415
     416                            XmlNode value = member.ChildNodes[2];
     417                            if (RevertXMLSymbols(membertype.InnerText).Equals("System.String"))
     418                            {
     419
     420                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     421                                                             BindingFlags.NonPublic |
     422                                                             BindingFlags.Public |
     423                                                             BindingFlags.Instance).SetValue(newObject, value.InnerText);
     424                            }
     425                            else if (RevertXMLSymbols(membertype.InnerText).Contains("System.Int"))
    483426                            {
    484427                                Int32 result = 0;
    485428                                System.Int32.TryParse(RevertXMLSymbols(value.InnerText), out result);
    486                                 object newEnumValue = Enum.ToObject(Type.GetType(RevertXMLSymbols(membertype.InnerText)), result);
    487 
    488                                 newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    489                                     BindingFlags.NonPublic |
    490                                     BindingFlags.Public |
    491                                     BindingFlags.Instance).SetValue(newObject, newEnumValue);
     429                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     430                                                             BindingFlags.NonPublic |
     431                                                             BindingFlags.Public |
     432                                                             BindingFlags.Instance).SetValue(newObject, result);
     433                            }
     434                            else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Double"))
     435                            {
     436                                Double result = 0;
     437                                System.Double.TryParse(RevertXMLSymbols(value.InnerText), out result);
     438                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     439                                                             BindingFlags.NonPublic |
     440                                                             BindingFlags.Public |
     441                                                             BindingFlags.Instance).SetValue(newObject, result);
     442                            }
     443                            else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Char"))
     444                            {
     445                                Char result = ' ';
     446                                System.Char.TryParse(RevertXMLSymbols(value.InnerText), out result);
     447                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     448                                                             BindingFlags.NonPublic |
     449                                                             BindingFlags.Public |
     450                                                             BindingFlags.Instance).SetValue(newObject, result);
     451                            }
     452                            else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Boolean"))
     453                            {
     454                                Boolean result = false;
     455                                System.Boolean.TryParse(RevertXMLSymbols(value.InnerText), out result);
     456                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     457                                                             BindingFlags.NonPublic |
     458                                                             BindingFlags.Public |
     459                                                             BindingFlags.Instance).SetValue(newObject, result);
     460                            }
     461                            else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Windows.Point"))
     462                            {
     463                                string[] values = value.InnerText.Split(new char[] {';'});
     464
     465                                double x = 0;
     466                                double y = 0;
     467                                double.TryParse(values[0], out x);
     468                                double.TryParse(values[1], out y);
     469
     470                                System.Windows.Point result = new System.Windows.Point(x, y);
     471                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     472                                                             BindingFlags.NonPublic |
     473                                                             BindingFlags.Public |
     474                                                             BindingFlags.Instance).SetValue(newObject, result);
     475                            }
     476                            else if (RevertXMLSymbols(membertype.InnerText).Equals("System.Byte[]"))
     477                            {
     478                                byte[] bytearray = Convert.FromBase64String(value.InnerText);
     479
     480                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     481                                                             BindingFlags.NonPublic |
     482                                                             BindingFlags.Public |
     483                                                             BindingFlags.Instance).SetValue(newObject, bytearray);
    492484                            }
    493485                            else
    494486                            {
    495                                 newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    496                                     BindingFlags.NonPublic |
    497                                     BindingFlags.Public |
    498                                     BindingFlags.Instance).SetValue(newObject, newmember);
    499                             }
    500 
    501                         }
    502                     }
    503                     else if (member.ChildNodes[2].Name.Equals("reference"))
    504                     {
    505                         XmlNode reference = member.ChildNodes[2];
    506                         links.AddLast(new object[] {
    507                                 newObject,
    508                                 RevertXMLSymbols(membername.InnerText),
    509                                 RevertXMLSymbols(reference.InnerText),
    510                                 false});
    511                     }
    512                     else if (member.ChildNodes[2].Name.Equals("list"))
    513                     {
    514                         String[] types = RevertXMLSymbols(membertype.InnerText).Split(';');
    515 
    516                         if (types.Length == 1)
    517                         {
    518                             newmember = System.Activator.CreateInstance(Type.GetType(types[0]));
    519                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    520                                     BindingFlags.NonPublic |
    521                                     BindingFlags.Public |
    522                                     BindingFlags.Instance).SetValue(newObject, newmember);
    523                         }
    524                         else if (types.Length == 2)
    525                         {   //we have 2 types, that means that we have a generic list with generic type types[1]
    526                             Type t = typeof(System.Collections.Generic.List<>);
    527                             Type[] typeArgs = { Type.GetType(types[1]) };
    528                             Type constructed = t.MakeGenericType(typeArgs);
    529                             newmember = Activator.CreateInstance(constructed);
    530                             newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
    531                                     BindingFlags.NonPublic |
    532                                     BindingFlags.Public |
    533                                     BindingFlags.Instance).SetValue(newObject, newmember);
    534                         }
    535                         else
    536                         {
    537                             throw new Exception("Expected 1 or 2 types for list; But found:" + types.Length);
    538                         }
    539 
    540                         foreach (XmlNode entry in member.ChildNodes[2].ChildNodes)
    541                         {
    542                             if (entry.ChildNodes[1].Name.Equals("reference"))
    543                             {
    544                                 XmlNode reference = entry.ChildNodes[1];
    545                                 links.AddLast(new object[] {
    546                                     newObject,
    547                                     RevertXMLSymbols(membername.InnerText),
    548                                     RevertXMLSymbols(reference.InnerText),
    549                                     true});
    550                             }
    551                             else
    552                             {
    553                                 XmlNode typ = entry.ChildNodes[1];
    554                                 XmlNode value = entry.ChildNodes[1];
    555                                 if (RevertXMLSymbols(typ.InnerText).Equals("System.String"))
    556                                 {
    557 
    558                                     ((IList)newmember).Add(RevertXMLSymbols(value.InnerText));
    559                                 }
    560                                 else if (RevertXMLSymbols(typ.InnerText).Equals("System.Int16"))
    561                                 {
    562                                     Int16 result = 0;
    563                                     System.Int16.TryParse(RevertXMLSymbols(value.InnerText), out result);
    564                                     ((IList)newmember).Add(result);
    565                                 }
    566                                 else if (RevertXMLSymbols(typ.InnerText).Equals("System.Int32"))
     487                                newmember =
     488                                    System.Activator.CreateInstance(Type.GetType(RevertXMLSymbols(membertype.InnerText)));
     489
     490                                if (newmember is Enum)
    567491                                {
    568492                                    Int32 result = 0;
    569493                                    System.Int32.TryParse(RevertXMLSymbols(value.InnerText), out result);
    570                                     ((IList)newmember).Add(result);
     494                                    object newEnumValue =
     495                                        Enum.ToObject(Type.GetType(RevertXMLSymbols(membertype.InnerText)), result);
     496
     497                                    newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     498                                                                 BindingFlags.NonPublic |
     499                                                                 BindingFlags.Public |
     500                                                                 BindingFlags.Instance).SetValue(newObject, newEnumValue);
    571501                                }
    572                                 else if (RevertXMLSymbols(typ.InnerText).Equals("System.Int64"))
     502                                else
    573503                                {
    574                                     Int64 result = 0;
    575                                     System.Int64.TryParse(RevertXMLSymbols(value.InnerText), out result);
    576                                     ((IList)newmember).Add(result);
     504                                    newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     505                                                                 BindingFlags.NonPublic |
     506                                                                 BindingFlags.Public |
     507                                                                 BindingFlags.Instance).SetValue(newObject, newmember);
    577508                                }
    578                                 else if (RevertXMLSymbols(typ.InnerText).Equals("System.Double"))
     509
     510                            }
     511                        }
     512                        else if (member.ChildNodes[2].Name.Equals("reference"))
     513                        {
     514                            XmlNode reference = member.ChildNodes[2];
     515                            links.AddLast(new object[]
     516                                              {
     517                                                  newObject,
     518                                                  RevertXMLSymbols(membername.InnerText),
     519                                                  RevertXMLSymbols(reference.InnerText),
     520                                                  false
     521                                              });
     522                        }
     523                        else if (member.ChildNodes[2].Name.Equals("list"))
     524                        {
     525                            String[] types = RevertXMLSymbols(membertype.InnerText).Split(';');
     526
     527                            if (types.Length == 1)
     528                            {
     529                                newmember = System.Activator.CreateInstance(Type.GetType(types[0]));
     530                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     531                                                             BindingFlags.NonPublic |
     532                                                             BindingFlags.Public |
     533                                                             BindingFlags.Instance).SetValue(newObject, newmember);
     534                            }
     535                            else if (types.Length == 2)
     536                            {
     537                                //we have 2 types, that means that we have a generic list with generic type types[1]
     538                                Type t = typeof (System.Collections.Generic.List<>);
     539                                Type[] typeArgs = {Type.GetType(types[1])};
     540                                Type constructed = t.MakeGenericType(typeArgs);
     541                                newmember = Activator.CreateInstance(constructed);
     542                                newObject.GetType().GetField(RevertXMLSymbols(membername.InnerText),
     543                                                             BindingFlags.NonPublic |
     544                                                             BindingFlags.Public |
     545                                                             BindingFlags.Instance).SetValue(newObject, newmember);
     546                            }
     547                            else
     548                            {
     549                                throw new Exception("Expected 1 or 2 types for list; But found:" + types.Length);
     550                            }
     551
     552                            foreach (XmlNode entry in member.ChildNodes[2].ChildNodes)
     553                            {
     554                                if (entry.ChildNodes[1].Name.Equals("reference"))
    579555                                {
    580                                     Double result = 0;
    581                                     System.Double.TryParse(RevertXMLSymbols(value.InnerText), out result);
    582                                     ((IList)newmember).Add(result);
     556                                    XmlNode reference = entry.ChildNodes[1];
     557                                    links.AddLast(new object[]
     558                                                      {
     559                                                          newObject,
     560                                                          RevertXMLSymbols(membername.InnerText),
     561                                                          RevertXMLSymbols(reference.InnerText),
     562                                                          true
     563                                                      });
    583564                                }
    584                                 else if (RevertXMLSymbols(typ.InnerText).Equals("System.Char"))
     565                                else
    585566                                {
    586                                     Char result = ' ';
    587                                     System.Char.TryParse(RevertXMLSymbols(value.InnerText), out result);
    588                                     ((IList)newmember).Add(result);
     567                                    XmlNode typ = entry.ChildNodes[1];
     568                                    XmlNode value = entry.ChildNodes[1];
     569                                    if (RevertXMLSymbols(typ.InnerText).Equals("System.String"))
     570                                    {
     571
     572                                        ((IList) newmember).Add(RevertXMLSymbols(value.InnerText));
     573                                    }
     574                                    else if (RevertXMLSymbols(typ.InnerText).Equals("System.Int16"))
     575                                    {
     576                                        Int16 result = 0;
     577                                        System.Int16.TryParse(RevertXMLSymbols(value.InnerText), out result);
     578                                        ((IList) newmember).Add(result);
     579                                    }
     580                                    else if (RevertXMLSymbols(typ.InnerText).Equals("System.Int32"))
     581                                    {
     582                                        Int32 result = 0;
     583                                        System.Int32.TryParse(RevertXMLSymbols(value.InnerText), out result);
     584                                        ((IList) newmember).Add(result);
     585                                    }
     586                                    else if (RevertXMLSymbols(typ.InnerText).Equals("System.Int64"))
     587                                    {
     588                                        Int64 result = 0;
     589                                        System.Int64.TryParse(RevertXMLSymbols(value.InnerText), out result);
     590                                        ((IList) newmember).Add(result);
     591                                    }
     592                                    else if (RevertXMLSymbols(typ.InnerText).Equals("System.Double"))
     593                                    {
     594                                        Double result = 0;
     595                                        System.Double.TryParse(RevertXMLSymbols(value.InnerText), out result);
     596                                        ((IList) newmember).Add(result);
     597                                    }
     598                                    else if (RevertXMLSymbols(typ.InnerText).Equals("System.Char"))
     599                                    {
     600                                        Char result = ' ';
     601                                        System.Char.TryParse(RevertXMLSymbols(value.InnerText), out result);
     602                                        ((IList) newmember).Add(result);
     603                                    }
    589604                                }
    590605                            }
     606                        }
     607                    }
     608                    catch(Exception ex)
     609                    {
     610                        if(workspaceManager != null)
     611                        {
     612                            workspaceManager.GuiLogMessage("Cold not deserialize model element \"" + membername.InnerText + "\" of type \"" + membertype.InnerText + "\" because of:" + ex.Message,NotificationLevel.Warning);
     613                        }else
     614                        {
     615                            Console.WriteLine("Cold not deserialize model element \"" + membername.InnerText + "\" of type \"" + membertype.InnerText + "\" because of:" + ex.Message);
    591616                        }
    592617                    }
     
    604629                createdObjects.TryGetValue(reference, out obj2);
    605630
    606                 if (isList)
    607                 {
    608                     ((IList)obj.GetType().GetField(membername).GetValue(obj)).Add(obj2);
    609                 }
    610                 else
    611                 {
    612                     if (obj != null && obj2 != null)
    613                     {
    614                         FieldInfo fieldInfo = obj.GetType().GetField(membername,
    615                             BindingFlags.NonPublic |
    616                             BindingFlags.Public |
    617                             BindingFlags.Instance);
    618 
    619                         fieldInfo.SetValue(obj, obj2);
     631                try
     632                {
     633                    if (isList)
     634                    {
     635                        ((IList) obj.GetType().GetField(membername).GetValue(obj)).Add(obj2);
     636                    }
     637                    else
     638                    {
     639                        if (obj != null && obj2 != null)
     640                        {
     641                            FieldInfo fieldInfo = obj.GetType().GetField(membername,
     642                                                                         BindingFlags.NonPublic |
     643                                                                         BindingFlags.Public |
     644                                                                         BindingFlags.Instance);
     645
     646                            fieldInfo.SetValue(obj, obj2);
     647                        }
     648                    }
     649                }
     650                catch(Exception ex)
     651                {
     652                    if (workspaceManager != null)
     653                    {
     654                        workspaceManager.GuiLogMessage("Cold not restore reference beteen model element \"" + membername + "\" and its reference with id \"" + reference + "\" because of:" + ex.Message, NotificationLevel.Warning);
     655                    }
     656                    else
     657                    {
     658                        Console.WriteLine("Cold not restore reference beteen model element \"" + membername + "\" and its reference with id \"" + reference + "\" because of:" + ex.Message);
    620659                    }
    621660                }
Note: See TracChangeset for help on using the changeset viewer.