XmlMessageFormatter.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / Messaging / System / Messaging / XmlMessageFormatter.cs / 1305376 / XmlMessageFormatter.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Messaging { 
    using System; 
    using System.IO;
    using System.Xml; 
    using System.Collections;
    using System.Xml.Serialization;
    using System.ComponentModel;
    using System.Security.Permissions; 

    ///  
    ///  
    ///    Formatter class that serializes and deserializes objects into
    ///    and from  MessageQueue messages using Xml. 
    /// 
    public class XmlMessageFormatter : IMessageFormatter {
        private Type[] targetTypes;
        private string[] targetTypeNames; 
        Hashtable targetSerializerTable = new Hashtable();
        private bool typeNamesAdded; 
        private bool typesAdded; 

        ///  
        /// 
        ///    Creates a new Xml message formatter object.
        /// 
        public XmlMessageFormatter() { 
            this.TargetTypes = new Type[0];
            this.TargetTypeNames = new string[0]; 
        } 

        ///  
        /// 
        ///    Creates a new Xml message formatter object,
        ///    using the given properties.
        ///  
        public XmlMessageFormatter(string[] targetTypeNames) {
            this.TargetTypeNames = targetTypeNames; 
            this.TargetTypes = new Type[0]; 
        }
 
        /// 
        /// 
        ///    Creates a new Xml message formatter object,
        ///    using the given properties. 
        /// 
        public XmlMessageFormatter(Type[] targetTypes) { 
            this.TargetTypes = targetTypes; 
            this.TargetTypeNames = new string[0];
        } 

        /// 
        /// 
        ///    Specifies the set of possible types that will 
        ///    be deserialized by the formatter from the
        ///    message provided. 
         ///  
        [MessagingDescription(Res.XmlMsgTargetTypeNames)]
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")] 
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
        public string[] TargetTypeNames {
            get {
                return this.targetTypeNames; 
            }
 
            set { 
                if (value == null)
                    throw new ArgumentNullException("value"); 

                this.typeNamesAdded = false;
                this.targetTypeNames = value;
            } 
        }
 
        ///  
        /// 
        ///    Specifies the set of possible types that will 
        ///    be deserialized by the formatter from the
        ///    message provided.
         /// 
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MessagingDescription(Res.XmlMsgTargetTypes)] 
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] 
        public Type[] TargetTypes { 
            get {
                return this.targetTypes; 
            }

            set {
                if (value == null) 
                    throw new ArgumentNullException("value");
 
                this.typesAdded = false; 
                this.targetTypes = value;
            } 
        }

        /// 
        ///  
        ///    When this method is called, the formatter will attempt to determine
        ///    if the contents of the message are something the formatter can deal with. 
        ///  
        public bool CanRead(Message message) {
            if (message == null) 
                throw new ArgumentNullException("message");

            this.CreateTargetSerializerTable();
 
            Stream stream = message.BodyStream;
            XmlTextReader reader =  new XmlTextReader(stream); 
            reader.WhitespaceHandling = WhitespaceHandling.Significant; 
            reader.DtdProcessing = DtdProcessing.Prohibit;
            bool result = false; 
            foreach (XmlSerializer serializer in targetSerializerTable.Values) {
                if (serializer.CanDeserialize(reader)) {
                    result = true;
                    break; 
                }
            } 
 
            message.BodyStream.Position = 0; // reset stream in case CanRead is followed by Deserialize
            return result; 
        }

        /// 
        ///  
        ///    This method is needed to improve scalability on Receive and ReceiveAsync scenarios.  Not requiring
        ///     thread safety on read and write. 
        ///  
        public object Clone() {
            XmlMessageFormatter formatter = new XmlMessageFormatter(); 
            formatter.targetTypes = targetTypes;
            formatter.targetTypeNames = targetTypeNames;
            formatter.typesAdded = typesAdded;
            formatter.typeNamesAdded = typeNamesAdded; 
            foreach (Type targetType in targetSerializerTable.Keys)
                formatter.targetSerializerTable[targetType] = new XmlSerializer(targetType); 
 
            return formatter;
        } 


        ///
        private void CreateTargetSerializerTable() { 
            if (!this.typeNamesAdded) {
                for (int index = 0; index < this.targetTypeNames.Length; ++ index) { 
                    Type targetType = Type.GetType(this.targetTypeNames[index], true); 
                    if (targetType != null)
                       this.targetSerializerTable[targetType] = new XmlSerializer(targetType); 
                }

                this.typeNamesAdded = true;
            } 

            if (!this.typesAdded) { 
                for (int index = 0; index < this.targetTypes.Length; ++ index) 
                    this.targetSerializerTable[this.targetTypes[index]] = new XmlSerializer(this.targetTypes[index]);
 
                this.typesAdded = true;
            }

            if (this.targetSerializerTable.Count == 0) 
                throw new InvalidOperationException(Res.GetString(Res.TypeListMissing));
        } 
 
        /// 
        ///  
        ///    This method is used to read the contents from the given message
        ///     and create an object.
        /// 
        public object Read(Message message) { 
            if (message == null)
                throw new ArgumentNullException("message"); 
 
            this.CreateTargetSerializerTable();
 
            Stream stream = message.BodyStream;
            XmlTextReader reader =  new XmlTextReader(stream);
            reader.WhitespaceHandling = WhitespaceHandling.Significant;
            reader.DtdProcessing = DtdProcessing.Prohibit; 
            foreach (XmlSerializer serializer in targetSerializerTable.Values) {
                if (serializer.CanDeserialize(reader)) 
                    return serializer.Deserialize(reader); 
            }
 
            throw new InvalidOperationException(Res.GetString(Res.InvalidTypeDeserialization));
        }

        ///  
        /// 
        ///    This method is used to write the given object into the given message. 
        ///     If the formatter cannot understand the given object, an exception is thrown. 
        /// 
        public void Write(Message message, object obj) { 
            if (message == null)
                throw new ArgumentNullException("message");

            if (obj == null) 
                throw new ArgumentNullException("obj");
 
            Stream stream = new MemoryStream(); 
            Type serializedType =  obj.GetType();
            XmlSerializer serializer = null; 
            if (this.targetSerializerTable.ContainsKey(serializedType))
                serializer = (XmlSerializer)this.targetSerializerTable[serializedType];
            else {
                serializer = new XmlSerializer(serializedType); 
                this.targetSerializerTable[serializedType] = serializer;
            } 
 
            serializer.Serialize(stream, obj);
            message.BodyStream = stream; 
            //Need to reset the body type, in case the same message
            //is reused by some other formatter.
            message.BodyType = 0;
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Messaging { 
    using System; 
    using System.IO;
    using System.Xml; 
    using System.Collections;
    using System.Xml.Serialization;
    using System.ComponentModel;
    using System.Security.Permissions; 

    ///  
    ///  
    ///    Formatter class that serializes and deserializes objects into
    ///    and from  MessageQueue messages using Xml. 
    /// 
    public class XmlMessageFormatter : IMessageFormatter {
        private Type[] targetTypes;
        private string[] targetTypeNames; 
        Hashtable targetSerializerTable = new Hashtable();
        private bool typeNamesAdded; 
        private bool typesAdded; 

        ///  
        /// 
        ///    Creates a new Xml message formatter object.
        /// 
        public XmlMessageFormatter() { 
            this.TargetTypes = new Type[0];
            this.TargetTypeNames = new string[0]; 
        } 

        ///  
        /// 
        ///    Creates a new Xml message formatter object,
        ///    using the given properties.
        ///  
        public XmlMessageFormatter(string[] targetTypeNames) {
            this.TargetTypeNames = targetTypeNames; 
            this.TargetTypes = new Type[0]; 
        }
 
        /// 
        /// 
        ///    Creates a new Xml message formatter object,
        ///    using the given properties. 
        /// 
        public XmlMessageFormatter(Type[] targetTypes) { 
            this.TargetTypes = targetTypes; 
            this.TargetTypeNames = new string[0];
        } 

        /// 
        /// 
        ///    Specifies the set of possible types that will 
        ///    be deserialized by the formatter from the
        ///    message provided. 
         ///  
        [MessagingDescription(Res.XmlMsgTargetTypeNames)]
 		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")] 
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
        public string[] TargetTypeNames {
            get {
                return this.targetTypeNames; 
            }
 
            set { 
                if (value == null)
                    throw new ArgumentNullException("value"); 

                this.typeNamesAdded = false;
                this.targetTypeNames = value;
            } 
        }
 
        ///  
        /// 
        ///    Specifies the set of possible types that will 
        ///    be deserialized by the formatter from the
        ///    message provided.
         /// 
        [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), MessagingDescription(Res.XmlMsgTargetTypes)] 
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] 
        public Type[] TargetTypes { 
            get {
                return this.targetTypes; 
            }

            set {
                if (value == null) 
                    throw new ArgumentNullException("value");
 
                this.typesAdded = false; 
                this.targetTypes = value;
            } 
        }

        /// 
        ///  
        ///    When this method is called, the formatter will attempt to determine
        ///    if the contents of the message are something the formatter can deal with. 
        ///  
        public bool CanRead(Message message) {
            if (message == null) 
                throw new ArgumentNullException("message");

            this.CreateTargetSerializerTable();
 
            Stream stream = message.BodyStream;
            XmlTextReader reader =  new XmlTextReader(stream); 
            reader.WhitespaceHandling = WhitespaceHandling.Significant; 
            reader.DtdProcessing = DtdProcessing.Prohibit;
            bool result = false; 
            foreach (XmlSerializer serializer in targetSerializerTable.Values) {
                if (serializer.CanDeserialize(reader)) {
                    result = true;
                    break; 
                }
            } 
 
            message.BodyStream.Position = 0; // reset stream in case CanRead is followed by Deserialize
            return result; 
        }

        /// 
        ///  
        ///    This method is needed to improve scalability on Receive and ReceiveAsync scenarios.  Not requiring
        ///     thread safety on read and write. 
        ///  
        public object Clone() {
            XmlMessageFormatter formatter = new XmlMessageFormatter(); 
            formatter.targetTypes = targetTypes;
            formatter.targetTypeNames = targetTypeNames;
            formatter.typesAdded = typesAdded;
            formatter.typeNamesAdded = typeNamesAdded; 
            foreach (Type targetType in targetSerializerTable.Keys)
                formatter.targetSerializerTable[targetType] = new XmlSerializer(targetType); 
 
            return formatter;
        } 


        ///
        private void CreateTargetSerializerTable() { 
            if (!this.typeNamesAdded) {
                for (int index = 0; index < this.targetTypeNames.Length; ++ index) { 
                    Type targetType = Type.GetType(this.targetTypeNames[index], true); 
                    if (targetType != null)
                       this.targetSerializerTable[targetType] = new XmlSerializer(targetType); 
                }

                this.typeNamesAdded = true;
            } 

            if (!this.typesAdded) { 
                for (int index = 0; index < this.targetTypes.Length; ++ index) 
                    this.targetSerializerTable[this.targetTypes[index]] = new XmlSerializer(this.targetTypes[index]);
 
                this.typesAdded = true;
            }

            if (this.targetSerializerTable.Count == 0) 
                throw new InvalidOperationException(Res.GetString(Res.TypeListMissing));
        } 
 
        /// 
        ///  
        ///    This method is used to read the contents from the given message
        ///     and create an object.
        /// 
        public object Read(Message message) { 
            if (message == null)
                throw new ArgumentNullException("message"); 
 
            this.CreateTargetSerializerTable();
 
            Stream stream = message.BodyStream;
            XmlTextReader reader =  new XmlTextReader(stream);
            reader.WhitespaceHandling = WhitespaceHandling.Significant;
            reader.DtdProcessing = DtdProcessing.Prohibit; 
            foreach (XmlSerializer serializer in targetSerializerTable.Values) {
                if (serializer.CanDeserialize(reader)) 
                    return serializer.Deserialize(reader); 
            }
 
            throw new InvalidOperationException(Res.GetString(Res.InvalidTypeDeserialization));
        }

        ///  
        /// 
        ///    This method is used to write the given object into the given message. 
        ///     If the formatter cannot understand the given object, an exception is thrown. 
        /// 
        public void Write(Message message, object obj) { 
            if (message == null)
                throw new ArgumentNullException("message");

            if (obj == null) 
                throw new ArgumentNullException("obj");
 
            Stream stream = new MemoryStream(); 
            Type serializedType =  obj.GetType();
            XmlSerializer serializer = null; 
            if (this.targetSerializerTable.ContainsKey(serializedType))
                serializer = (XmlSerializer)this.targetSerializerTable[serializedType];
            else {
                serializer = new XmlSerializer(serializedType); 
                this.targetSerializerTable[serializedType] = serializer;
            } 
 
            serializer.Serialize(stream, obj);
            message.BodyStream = stream; 
            //Need to reset the body type, in case the same message
            //is reused by some other formatter.
            message.BodyType = 0;
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• MutexSecurity.cs
• NoPersistHandle.cs
• AstTree.cs
• WsdlServiceChannelBuilder.cs
• FontFamily.cs
• DataGridViewTopRowAccessibleObject.cs
• CodeTypeReference.cs
• ClientRoleProvider.cs
• EncryptedPackageFilter.cs
• PropVariant.cs
• WebPartMenuStyle.cs
• SerializationStore.cs
• InputBinding.cs
• ResourcePermissionBaseEntry.cs
• KnownBoxes.cs
• AnnotationResourceCollection.cs
• HttpStaticObjectsCollectionWrapper.cs
• KeyValueConfigurationCollection.cs
• CombinedGeometry.cs
• ExpandoClass.cs
• SchemaMapping.cs
• ApplicationBuildProvider.cs
• RepeatInfo.cs
• XmlUnspecifiedAttribute.cs
• HttpListenerException.cs
• VolatileEnlistmentState.cs
• TextRangeEdit.cs
• PasswordDeriveBytes.cs
• Semaphore.cs
• BuiltInExpr.cs
• WpfWebRequestHelper.cs
• CommandEventArgs.cs
• _NestedSingleAsyncResult.cs
• SystemIPGlobalProperties.cs
• dbdatarecord.cs
• MenuItemCollection.cs
• Regex.cs
• CachedTypeface.cs
• CryptoProvider.cs
• CompositeCollectionView.cs
• SyndicationDeserializer.cs
• XmlSchemaDocumentation.cs
• LeftCellWrapper.cs
• ObjectDisposedException.cs
• BoundingRectTracker.cs
• ellipse.cs
• FrameSecurityDescriptor.cs
• Size3DConverter.cs
• Rotation3DAnimationUsingKeyFrames.cs
• DataGridViewComponentPropertyGridSite.cs
• PostBackOptions.cs
• GB18030Encoding.cs
• MulticastIPAddressInformationCollection.cs
• XmlReflectionMember.cs
• RestHandler.cs
• __ConsoleStream.cs
• AudioFormatConverter.cs
• HelpInfo.cs
• HuffmanTree.cs
• keycontainerpermission.cs
• StorageAssociationTypeMapping.cs
• SchemaImporterExtensionElement.cs
• CachedFontFamily.cs
• EdmFunction.cs
• AccessText.cs
• listitem.cs
• KeyboardEventArgs.cs
• ImageListImage.cs
• ConnectionsZone.cs
• TemplateNameScope.cs
• TextDpi.cs
• SettingsPropertyCollection.cs
• DESCryptoServiceProvider.cs
• MouseActionValueSerializer.cs
• ConstructorBuilder.cs
• DataGridViewColumnHeaderCell.cs
• OutKeywords.cs
• ApplicationServiceManager.cs
• SchemaCollectionPreprocessor.cs
• AttributeTableBuilder.cs
• IUnknownConstantAttribute.cs
• HtmlTableCell.cs
• FrameSecurityDescriptor.cs
• XAMLParseException.cs
• TextStore.cs
• SQLResource.cs
• WsdlBuildProvider.cs
• OperatingSystem.cs
• WindowsGraphics.cs
• PeerCustomResolverElement.cs
• CodeDelegateCreateExpression.cs
• TextServicesManager.cs
• CommandDevice.cs
• MiniConstructorInfo.cs
• PrimitiveXmlSerializers.cs
• SafeNativeMethodsOther.cs
• XNodeSchemaApplier.cs
• ResourcePropertyMemberCodeDomSerializer.cs
• RepeaterCommandEventArgs.cs
• GridViewCommandEventArgs.cs