/// <summary> /// Deserialize a user type instance from a POF stream by reading its /// state using the specified <see cref="IPofReader"/> object. /// </summary> /// <remarks> /// An implementation of <b>IPofSerializer</b> is required to follow /// the following steps in sequence for reading in an object of a /// user type: /// <list type="number"> /// <item> /// <description> /// If the object is evolvable, the implementation must get the /// version by calling <see cref="IPofWriter.VersionId"/>. /// </description> /// </item> /// <item> /// <description> /// The implementation may read any combination of the /// properties of the user type by using "read" methods of the /// <b>IPofReader</b>, but it must do so in the order of the property /// indexes. /// </description> /// </item> /// <item> /// <description> /// After all desired properties of the user type have been read, /// the implementation must terminate the reading of the user type by /// calling <see cref="IPofReader.ReadRemainder"/>. /// </description> /// </item> /// </list> /// </remarks> /// <param name="reader"> /// The <b>IPofReader</b> with which to read the object's state. /// </param> /// <returns> /// The deserialized user type instance. /// </returns> /// <exception cref="IOException"> /// If an I/O error occurs. /// </exception> public object Deserialize(IPofReader reader) { PortableException e = new PortableException(); reader.RegisterIdentity(e); e.ReadExternal(reader); reader.ReadRemainder(); return(e); }
public void PortableExceptionConstructorTest() { IConnection conn = initiator.EnsureConnection(); Channel cacheServiceChannel = (Channel)conn.OpenChannel(CacheServiceProtocol.Instance, "CacheServiceProxy", null, null); EnsureCacheRequest ensureCacheRequest = (EnsureCacheRequest)cacheServiceChannel.MessageFactory.CreateMessage(EnsureCacheRequest.TYPE_ID); ensureCacheRequest.CacheName = "nonexisting"; Assert.AreEqual(EnsureCacheRequest.TYPE_ID, ensureCacheRequest.TypeId); IStatus ensureCacheStatus = cacheServiceChannel.Send(ensureCacheRequest); Assert.IsInstanceOf(typeof(EnsureCacheRequest), ensureCacheRequest); Assert.AreEqual(EnsureCacheRequest.TYPE_ID, ensureCacheRequest.TypeId); try { ensureCacheStatus.WaitForResponse(-1); } catch (PortableException pe) { Assert.IsNotNull(pe); Assert.IsTrue(pe.Name.StartsWith("Portable(")); Assert.IsNull(pe.InnerException); Assert.IsTrue(pe.Message.ToLower().IndexOf("no scheme") >= 0); string[] fullStackTrace = pe.FullStackTrace; string stackTrace = pe.StackTrace; Assert.IsTrue(fullStackTrace.Length > 0); foreach (string s in fullStackTrace) { Assert.IsTrue(stackTrace.IndexOf(s) > 0); } Assert.IsTrue(stackTrace.IndexOf("process boundary") > 0); Assert.IsTrue( pe.ToString().Equals(pe.Name + ": " + pe.Message)); using (Stream stream = new MemoryStream()) { DataWriter writer = new DataWriter(stream); IPofContext ctx = (IPofContext)cacheServiceChannel.Serializer; ctx.Serialize(writer, pe); stream.Position = 0; DataReader reader = new DataReader(stream); PortableException result = (PortableException)ctx.Deserialize(reader); Assert.AreEqual(pe.Name, result.Name); Assert.AreEqual(pe.Message, result.Message); } } }
public void PortableExceptionSerializationTest() { IConnection conn = initiator.EnsureConnection(); Channel cacheServiceChannel = (Channel)conn.OpenChannel(CacheServiceProtocol.Instance, "CacheServiceProxy", null, null); EnsureCacheRequest ensureCacheRequest = (EnsureCacheRequest)cacheServiceChannel.MessageFactory.CreateMessage(EnsureCacheRequest.TYPE_ID); ensureCacheRequest.CacheName = "nonexisting"; IStatus ensureCacheStatus = cacheServiceChannel.Send(ensureCacheRequest); try { ensureCacheStatus.WaitForResponse(-1); } catch (PortableException pe) { IFormatter formatter = new BinaryFormatter(); byte[] buffer = new byte[1024 * 16]; Stream stream = new MemoryStream(buffer); formatter.Serialize(stream, pe); stream.Close(); stream = new MemoryStream(buffer); PortableException desPE = (PortableException)formatter.Deserialize(stream); Assert.IsNotNull(desPE); stream.Close(); // these values should be initialized before serialization Assert.AreEqual(pe.Name, desPE.Name); Assert.AreEqual(pe.Message, desPE.Message); Assert.AreEqual(pe.InnerException, desPE.InnerException); Assert.IsNull(pe.InnerException); Assert.AreEqual(pe.FullStackTrace, desPE.FullStackTrace); } }
/// <summary> /// Write the exception to the specified stream. /// </summary> /// <param name="writer"> /// The <b>IPofWriter</b> to write to. /// </param> /// <param name="e"> /// The <b>Exception</b> to write. /// </param> public static void WriteException(IPofWriter writer, Exception e) { string name; string[] arrTrace; if (e is PortableException) { PortableException pe = (PortableException)e; name = pe.Name; arrTrace = pe.FullStackTrace; } else { name = e.GetType().FullName; arrTrace = new string[] { e.StackTrace }; } writer.WriteString(0, name); writer.WriteString(1, e.Message); writer.WriteCollection(2, new ArrayList(arrTrace), typeof(string)); writer.WriteObject(3, e.InnerException); }