WriteObject() public méthode

public WriteObject ( System value ) : void
value System
Résultat void
	    public void TestWriteOnlyBody() 
		{
	        ActiveMQBytesMessage message = new ActiveMQBytesMessage();
	        message.ClearBody();
	        
			try
			{
	            message.WriteBoolean(true);
	            message.WriteByte((byte) 1);
	            message.WriteBytes(new byte[1]);
	            message.WriteBytes(new byte[3], 0, 2);
	            message.WriteChar('a');
	            message.WriteDouble(1.5);
	            message.WriteSingle((float) 1.5);
	            message.WriteInt32(1);
	            message.WriteInt64(1);
	            message.WriteObject("stringobj");
	            message.WriteInt16((short) 1);
	            message.WriteString("utfstring");
	        }
			catch(MessageNotWriteableException)
			{
	            Assert.Fail("Should be writeable");
	        }
			
	        try
			{
	            message.ReadBoolean();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadByte();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadBytes(new byte[1]);
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadBytes(new byte[2], 2);
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadChar();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadDouble();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try 
			{
	            message.ReadSingle();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadInt32();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadInt64();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadString();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try
			{
	            message.ReadInt16();
	            Assert.Fail("Should have thrown exception");
	        }
			catch(MessageNotReadableException)
			{
	        }
	        
			try 
			{
	            message.ReadString();
	            Assert.Fail("Should have thrown exception");
	        } 
			catch(MessageNotReadableException) 
			{
	        }
	    }		
	    public void TestWriteObject()
		{
	        ActiveMQBytesMessage msg = new ActiveMQBytesMessage();
			
	        try
			{
	            msg.WriteObject("fred");
	            msg.WriteObject((Boolean) true);
	            msg.WriteObject((Char) 'q');
	            msg.WriteObject((Byte) ((byte) 1));
	            msg.WriteObject((Int16) ((short) 3));
	            msg.WriteObject((Int32) 3 );
	            msg.WriteObject((Int64) 300L);
	            msg.WriteObject((Single) 3.3f );
	            msg.WriteObject((Double) 3.3 );
	            msg.WriteObject((Object) new byte[3]);
	        } 
			catch(MessageFormatException) 
			{
	            Assert.Fail("objectified primitives should be allowed");
	        }
			
	        try 
			{
	            msg.WriteObject(new Object());
	            Assert.Fail("only objectified primitives are allowed");
	        } 
			catch(MessageFormatException ) 
			{
	        }
	    }