对象反系列化问题

ntchjie

gentellu发表于2008-9-9 10:26:00但直接用Form1启动程序时系列化及反系列化都正常，只是利用CAD来启动Form1进行反系列化时出现异常，我就是不太明白这方面的原因。

就是写成类库（在CAD内调用的dll），就出现异常。

我也为这个问题困扰很久。

雪山飞狐_lzh

这段时间碰巧用了BinaryFormatter序列化/反序列化，
可以实现，但注意不要在初始化例程里反序列化（奇怪的Bug）
贴上代码：）
Command类：

3. using System;
4. using System.Reflection;
5. using Autodesk.AutoCAD.Runtime;
7. namespace TlsCad.NetAutoLoad
8. {
10.     [Serializable]
11.     public class Command : IComparable
12.     {
14.         public string GlobalName;
15.         public string LocalizedName;
16.         public string Description;
18.         public string ModuleName;
19.         public string TypeName;
20.         public string MethodName;
22.         public Command() { }
24.         public Command(string globalName)
25.         {
26.             GlobalName = globalName;
27.         }
30.         #region IComparable 成员
32.         int IComparable.CompareTo(object obj)
33.         {
34.             Command cmd = obj as Command;
35.             return this.GlobalName.CompareTo(cmd.GlobalName);
36.         }
38.         #endregion
39.     }
40. }

using System; using System.Reflection; using Autodesk.AutoCAD.Runtime; namespace TlsCad.NetAutoLoad {     [Serializable]     public class Command : IComparable     {         public string GlobalName;         public string LocalizedName;         public string Description;         public string ModuleName;         public string TypeName;         public string MethodName;         public Command() { }         public Command(string globalName)         {             GlobalName = globalName;         }         #region IComparable 成员         int IComparable.CompareTo(object obj)         {             Command cmd = obj as Command;             return this.GlobalName.CompareTo(cmd.GlobalName);         }         #endregion     } }

CommandCollection类

2. using System;
3. using System.IO;
4. using System.Resources;
5. using System.Reflection;
6. using System.Collections;
7. using System.Collections.Generic;
8. using System.Runtime.Serialization;
9. using System.Runtime.Serialization.Formatters.Binary;
10. using Autodesk.AutoCAD.Runtime;
11. namespace TlsCad.NetAutoLoad
12. {
13.     public enum AssemblyLoad
14.     {
15.         LoadOnStartup = 2,
16.         LoadByCmd = 12,
17.         LoadDisabled = 20
18.     }
19.     [Serializable]
20.     public class CommandCollection : ISerializable
21.     {
22.         private AssemblyLoad _loadctrls;
23.         private string _description;
24.         private List<Command> _cmds = new List<Command>();
25.         //private List<string> _groups = new List<string>();
26.         public CommandCollection() { }
27.         public CommandCollection(SerializationInfo info, StreamingContext ctxt)
28.         {
29.             _loadctrls = (AssemblyLoad)info.GetValue("Assembly_LoadCtrls", typeof(AssemblyLoad));
30.             _description = (string)info.GetValue("Assembly_Description", typeof(string));
31.             //_groups = (List<string>)info.GetValue("Assembly_Groups", typeof(List<string>));
32.             _cmds = (List<Command>)info.GetValue("Assembly_Commands", typeof(List<Command>));
33.         }
34.         #region ISerializable 成员
35.         void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
36.         {
37.             info.AddValue("Assembly_LoadCtrls", _loadctrls);
38.             info.AddValue("Assembly_Description", _description);
39.             //info.AddValue("Assembly_Groups", _groups);
40.             info.AddValue("Assembly_Commands", _cmds);
41.         }
42.         #endregion
43.         public AssemblyLoad LoadCtrls
44.         {
45.             get { return _loadctrls; }
46.             set { _loadctrls = value; }
47.         }
48.         public string Description
49.         {
50.             get { return _description; }
51.             set { _description = value; }
52.         }
53.         public void CopyFrom(CommandCollection ai)
54.         {
55.             _loadctrls = ai._loadctrls;
56.             _description = ai._description;
57.             _cmds = ai._cmds;
58.         }
59.         public void Add(Command cmd)
60.         {
61.             _cmds.Add(cmd);
62.         }
63.         public void Remove(Command cmd)
64.         {
65.             _cmds.Remove(cmd);
66.         }
67.         public void Sort()
68.         {
69.             _cmds.Sort();
70.         }
71.         public int Count
72.         {
73.             get { return _cmds.Count; }
74.         }
76.         public void WriteTo(string path)
77.         {
78.             using (Stream stream = File.Open(path, FileMode.Create))
79.             {
80.                 BinaryFormatter bformatter = new BinaryFormatter();
81.                 bformatter.Serialize(stream, this);
82.             }
83.         }
84.         public void ReadFrom(string path)
85.         {
86.             using (Stream stream = File.Open(path, FileMode.Open))
87.             {
88.                 BinaryFormatter bformatter = new BinaryFormatter();
89.                 CommandCollection cmds = (CommandCollection)bformatter.Deserialize(stream);
90.                 CopyFrom(cmds);
91.             }
92.         }
93.         public void LoadFromAssembly(string path)
94.         {
95.             //_groups.Clear();
96.             _cmds.Clear();
97.             Assembly assem = Assembly.LoadFrom(path);
98.             foreach (System.Reflection.Module m in assem.GetModules(true))
99.             {
100.                 Type[] types = m.GetTypes();
101.                 foreach (Type t in types)
102.                 {
103.                     ResourceManager rm =
104.                         new ResourceManager(t.FullName, assem);
105.                     rm.IgnoreCase = true;
106.                     MethodInfo[] methods = t.GetMethods();
107.                     foreach (MethodInfo mi in methods)
108.                     {
109.                         object[] attbs =
110.                             mi.GetCustomAttributes(
111.                                 typeof(CommandMethodAttribute),
112.                                 true
113.                             );
114.                         foreach (object attb in attbs)
115.                         {
116.                             CommandMethodAttribute cma = attb as CommandMethodAttribute;
117.                             if (cma != null)
118.                             {
119.                                 //if (cma.GroupName != null && !_groups.Contains(cma.GroupName))
120.                                 //{
121.                                 //    _groups.Add(cma.GroupName);
122.                                 //}
123.                                 
124.                                 Command cmd = new Command(cma.GlobalName);
125.                                 cmd.ModuleName = m.Name;
126.                                 cmd.TypeName = t.FullName;
127.                                 cmd.MethodName = mi.Name;
128.                                 cmd.LocalizedName = cmd.GlobalName;
129.                                 string lnid = cma.LocalizedNameId;
130.                                 if (lnid != null)
131.                                 {
132.                                     try
133.                                     {
134.                                         cmd.LocalizedName = rm.GetString(lnid);
135.                                     }
136.                                     catch
137.                                     { }
138.                                 }
139.                                 _cmds.Add(cmd);
140.                             }
142.                         }
143.                     }
144.                 }
145.             }
146.         }
148.         //public void Run(Assem assem, Command cmd)
149.         //{
150.         //    Assembly assembly = Assembly.LoadFrom(assem.Location);
151.         //    Module m = assembly.GetModule(cmd.ModuleName);
152.         //    Type t = m.GetType(cmd.TypeName);
153.         //    MethodInfo mi = t.GetMethod(cmd.MethodName);
154.         //    object obj = assembly.CreateInstance(t.FullName);
155.         //    mi.Invoke(obj, new object[0]);
156.         //    obj = null;
157.         //}
158.         public IEnumerator GetEnumerator()
159.         {
160.             return _cmds.GetEnumerator();
161.         }
162.     }
163. }

using System; using System.IO; using System.Resources; using System.Reflection; using System.Collections; using System.Collections.Generic; using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Binary; using Autodesk.AutoCAD.Runtime; namespace TlsCad.NetAutoLoad {     public enum AssemblyLoad     {         LoadOnStartup = 2,         LoadByCmd = 12,         LoadDisabled = 20     }     [Serializable]     public class CommandCollection : ISerializable     {         private AssemblyLoad _loadctrls;         private string _description;         private List<Command> _cmds = new List<Command>();         //private List<string> _groups = new List<string>();         public CommandCollection() { }         public CommandCollection(SerializationInfo info, StreamingContext ctxt)         {             _loadctrls = (AssemblyLoad)info.GetValue("Assembly_LoadCtrls", typeof(AssemblyLoad));             _description = (string)info.GetValue("Assembly_Description", typeof(string));             //_groups = (List<string>)info.GetValue("Assembly_Groups", typeof(List<string>));             _cmds = (List<Command>)info.GetValue("Assembly_Commands", typeof(List<Command>));         }         #region ISerializable 成员         void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)         {             info.AddValue("Assembly_LoadCtrls", _loadctrls);             info.AddValue("Assembly_Description", _description);             //info.AddValue("Assembly_Groups", _groups);             info.AddValue("Assembly_Commands", _cmds);         }         #endregion         public AssemblyLoad LoadCtrls         {             get { return _loadctrls; }             set { _loadctrls = value; }         }         public string Description         {             get { return _description; }             set { _description = value; }         }         public void CopyFrom(CommandCollection ai)         {             _loadctrls = ai._loadctrls;             _description = ai._description;             _cmds = ai._cmds;         }         public void Add(Command cmd)         {             _cmds.Add(cmd);         }         public void Remove(Command cmd)         {             _cmds.Remove(cmd);         }         public void Sort()         {             _cmds.Sort();         }         public int Count         {             get { return _cmds.Count; }         }         public void WriteTo(string path)         {             using (Stream stream = File.Open(path, FileMode.Create))             {                 BinaryFormatter bformatter = new BinaryFormatter();                 bformatter.Serialize(stream, this);             }         }         public void ReadFrom(string path)         {             using (Stream stream = File.Open(path, FileMode.Open))             {                 BinaryFormatter bformatter = new BinaryFormatter();                 CommandCollection cmds = (CommandCollection)bformatter.Deserialize(stream);                 CopyFrom(cmds);             }         }         public void LoadFromAssembly(string path)         {             //_groups.Clear();             _cmds.Clear();             Assembly assem = Assembly.LoadFrom(path);             foreach (System.Reflection.Module m in assem.GetModules(true))             {                 Type[] types = m.GetTypes();                 foreach (Type t in types)                 {                     ResourceManager rm =                         new ResourceManager(t.FullName, assem);                     rm.IgnoreCase = true;                     MethodInfo[] methods = t.GetMethods();                     foreach (MethodInfo mi in methods)                     {                         object[] attbs =                             mi.GetCustomAttributes(                                 typeof(CommandMethodAttribute),                                 true                             );                         foreach (object attb in attbs)                         {                             CommandMethodAttribute cma = attb as CommandMethodAttribute;                             if (cma != null)                             {                                 //if (cma.GroupName != null && !_groups.Contains(cma.GroupName))                                 //{                                 //    _groups.Add(cma.GroupName);                                 //}                                                                  Command cmd = new Command(cma.GlobalName);                                 cmd.ModuleName = m.Name;                                 cmd.TypeName = t.FullName;                                 cmd.MethodName = mi.Name;                                 cmd.LocalizedName = cmd.GlobalName;                                 string lnid = cma.LocalizedNameId;                                 if (lnid != null)                                 {                                     try                                     {                                         cmd.LocalizedName = rm.GetString(lnid);                                     }                                     catch                                     { }                                 }                                 _cmds.Add(cmd);                             }                         }                     }                 }             }         }         //public void Run(Assem assem, Command cmd)         //{         //    Assembly assembly = Assembly.LoadFrom(assem.Location);         //    Module m = assembly.GetModule(cmd.ModuleName);         //    Type t = m.GetType(cmd.TypeName);         //    MethodInfo mi = t.GetMethod(cmd.MethodName);         //    object obj = assembly.CreateInstance(t.FullName);         //    mi.Invoke(obj, new object[0]);         //    obj = null;         //}         public IEnumerator GetEnumerator()         {             return _cmds.GetEnumerator();         }     } }

sieben

如版主所说"但注意不要在初始化例程里反序列化",即使相应的类里面没有AutoCAD的类也不行(如没有Point3d等类也不行)

另外即使不是在初始化的时候,若反序列化的类里面有AutoCAD的类也不行(如Point3d等,在构造函数里面有用到或公用属性)

会出现楼主这样的问题.(还没看楼主的代码)

不过这是我两年前AutoCAD2006的记忆了,现在版主说行应该那就是行了(还没看代码也没测试).

另外有个记忆不管是反射还是反系列化,在处理Point3d这些类时应该用全名,即"Autodesk.AutoCAD.Geometry.Point3d",而不要只写"Point3d"

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

不好意思!两年前的事情有点记得不大清楚了!
可能我只涉及了反射方面的问题
反系列化可能试过,但只失败而没成功过,因为我现在找不到成功反序列化的代码

另外在使用发射方面的技术时,若涉及Point3d等类型的数据我是自己做特殊处理

雪山飞狐_lzh

sieben发表于2009-8-31 21:53:00另外即使不是在初始化的时候,若反序列化的类里面有AutoCAD的类也不行(如Point3d等,在构造函数里面有用到或公用属性)

记得有看到2009版本的序列化Cad对象的代码，Kean的

应该是2009版本后才支持吧

雪山飞狐_lzh

代码更改了一遍，发现了一些问题
似乎有自定义类型和系统类型混用的时候反序列化仍然不成功
不过，加入下面的类，在初始化时也可以反序列化了

    public class UBinder : SerializationBinder
    {
        public override Type BindToType(string assemblyName, string typeName)
        {
            return Type.GetType(typeName);
        }
    }

反序列化时
        public void ReadFrom(string path)
        {
            using (Stream stream = File.Open(path, FileMode.Open))
            {
                BinaryFormatter bformatter = new BinaryFormatter();
                bformatter.Binder = new UBinder();
                Assem cmds = (Assem)bformatter.Deserialize(stream);
                CopyFrom(cmds);
            }
        }
看来不是Bug的问题：）

ywlm

把.dll拖到 "C:\WINDOWS\assembly\"里面就可以反序列化