mcs/class/System.Messaging/System.Messaging/Message.cs

   1 //
   2 // System.Messaging
   3 //
   4 // Authors:
   5 //        Peter Van Isacker (sclytrack@planetinternet.be)
   6 //        Rafael Teixeira   (rafaelteixeirabr@hotmail.com)
   7 //
   8 // (C) 2003 Peter Van Isacker
   9 //
  10
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using System;
  33 using System.IO;
  34 using System.ComponentModel;
  35
  36 using Mono.Messaging;
  37
  38 namespace System.Messaging
  39 {
  40         [DesignerAttribute ("System.Messaging.Design.MessageDesigner, " + Consts.AssemblySystem_Design)]
  41         public class Message: Component
  42         {
  43                 private readonly IMessage delegateMessage;
  44                 private IMessageFormatter formatter;
  45                 //private int bodyType = 0;
  46                 private object body;
  47
  48                 #region Constructor
  49
  50                 public Message() : this (CreateMessage (), null, null)
  51                 {
  52                 }
  53
  54                 public Message (object body) : this (CreateMessage (), body, null)
  55                 {
  56                 }
  57
  58                 public Message (object body, IMessageFormatter formatter)
  59                         : this (CreateMessage (), body, formatter)
  60                 {
  61                 }
  62
  63                 internal Message (IMessage delegateMessage, object body,
  64                         IMessageFormatter formatter)
  65                 {
  66                         this.delegateMessage = delegateMessage;
  67                         this.body = body;
  68                         this.formatter = formatter;
  69                 }
  70
  71                 #endregion //Constructor
  72
  73                 [MonoTODO]
  74                 public static readonly TimeSpan InfiniteTimeout;
  75
  76                 #region Properties
  77
  78                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
  79                 [ReadOnly (true)]
  80                 [MessagingDescription ("MsgAcknowledgeType")]
  81                 public AcknowledgeTypes AcknowledgeType {
  82                         get {
  83                                 return (AcknowledgeTypes) delegateMessage.AcknowledgeType;
  84                         }
  85                         set {
  86                                 delegateMessage.AcknowledgeType = (Mono.Messaging.AcknowledgeTypes) value;
  87                         }
  88                 }
  89
  90                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
  91                 [ReadOnly (true)]
  92                 [MessagingDescription ("MsgAcknowledgement")]
  93                 public Acknowledgment Acknowledgment {
  94                         get {
  95                                 return (Acknowledgment) (int) delegateMessage.Acknowledgment;
  96                         }
  97                 }
  98
  99                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 100                 [ReadOnly (true)]
 101                 [MessagingDescription ("MsgAdministrationQueue")]
 102                 public MessageQueue AdministrationQueue {
 103                         get {
 104                                 if (delegateMessage.AdministrationQueue == null)
 105                                         return null;
 106
 107                                 return new MessageQueue
 108                                         (delegateMessage.AdministrationQueue);
 109                         }
 110                         set {
 111                                 delegateMessage.AdministrationQueue
 112                                         = value.DelegateQueue;
 113                         }
 114                 }
 115
 116                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 117                 [ReadOnly (true)]
 118                 [MessagingDescription ("MsgAppSpecific")]
 119                 public int AppSpecific {
 120                         get { return delegateMessage.AppSpecific; }
 121                         set { delegateMessage.AppSpecific = value; }
 122                 }
 123
 124                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 125                 [MessagingDescription ("MsgArrivedTime")]
 126                 public DateTime ArrivedTime {
 127                         get { return delegateMessage.ArrivedTime; }
 128                 }
 129
 130                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 131                 [ReadOnly (true)]
 132                 [MessagingDescription ("MsgAttachSenderId")]
 133                 public bool AttachSenderId {
 134                         get { return delegateMessage.AttachSenderId; }
 135                         set { delegateMessage.AttachSenderId = value; }
 136                 }
 137
 138                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 139                 [MessagingDescription ("MsgAuthenticated")]
 140                 public bool Authenticated {
 141                         get { return delegateMessage.Authenticated; }
 142                 }
 143
 144                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 145                 [ReadOnly (true)]
 146                 [MessagingDescription ("MsgAuthenticationProviderName")]
 147                 public string AuthenticationProviderName {
 148                         get { return delegateMessage.AuthenticationProviderName; }
 149                         set { delegateMessage.AuthenticationProviderName = value; }
 150                 }
 151
 152                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 153                 [ReadOnly (true)]
 154                 [MessagingDescription ("MsgAuthenticationProviderType")]
 155                 public CryptographicProviderType AuthenticationProviderType {
 156                         get {
 157                                 return (CryptographicProviderType)
 158                                         delegateMessage.AuthenticationProviderType;
 159                         }
 160                         set {
 161                                 delegateMessage.AuthenticationProviderType =
 162                                         (Mono.Messaging.CryptographicProviderType) value;
 163                         }
 164                 }
 165
 166                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 167                 [Browsable (false)]
 168                 public object Body {
 169                         get {
 170                                 if (body == null && delegateMessage.BodyStream == null)
 171                                         return null;
 172                                 else if (body == null)
 173                                         body = formatter.Read (this);
 174
 175                                 return body;
 176                         }
 177                         set { body = value; }
 178                 }
 179
 180                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 181                 [ReadOnly (true)]
 182                 [Editor ("System.ComponentModel.Design.BinaryEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 183                 [MessagingDescription ("MsgBodyStream")]
 184                 public Stream BodyStream {
 185                         get { return delegateMessage.BodyStream; }
 186                         set { delegateMessage.BodyStream = value; }
 187                 }
 188
 189                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 190                 [MessagingDescription ("MsgBodyType")]
 191                 [ReadOnly (true)]
 192                 public int BodyType {
 193                         get { return delegateMessage.BodyType; }
 194                         set { delegateMessage.BodyType = value; }
 195                 }
 196
 197                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 198                 [ReadOnly (true)]
 199                 [MessagingDescription ("MsgConnectorType")]
 200                 public Guid ConnectorType {
 201                         get { return delegateMessage.ConnectorType; }
 202                         set { delegateMessage.ConnectorType = value; }
 203                 }
 204
 205                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 206                 [ReadOnly (true)]
 207                 [MessagingDescription ("MsgCorrelationId")]
 208                 public string CorrelationId {
 209                         get { return delegateMessage.CorrelationId; }
 210                         set { delegateMessage.CorrelationId = value; }
 211                 }
 212
 213                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 214                 [MessagingDescription("MsgDestinationQueue")]
 215                 public MessageQueue DestinationQueue {
 216                         get {
 217                                 return new MessageQueue(delegateMessage.DestinationQueue);
 218                         }
 219                 }
 220
 221                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 222                 [ReadOnly(true)]
 223                 [MessagingDescription("MsgDestinationSymmetricKey")]
 224                 public byte[] DestinationSymmetricKey {
 225                         get { return delegateMessage.DestinationSymmetricKey; }
 226                         set { delegateMessage.DestinationSymmetricKey = value; }
 227                 }
 228
 229                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 230                 [ReadOnly(true)]
 231                 [MessagingDescription("MsgDigitalSignature")]
 232                 public byte[] DigitalSignature {
 233                         get { return delegateMessage.DigitalSignature; }
 234                         set { delegateMessage.DigitalSignature = value; }
 235                 }
 236
 237                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 238                 [ReadOnly(true)]
 239                 [MessagingDescription("MsgEncryptionAlgorithm")]
 240                 public EncryptionAlgorithm EncryptionAlgorithm {
 241                         get {
 242                                 return (EncryptionAlgorithm) delegateMessage.EncryptionAlgorithm;
 243                         }
 244                         set {
 245                                 delegateMessage.EncryptionAlgorithm =
 246                                         (Mono.Messaging.EncryptionAlgorithm) value;
 247                         }
 248                 }
 249
 250                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 251                 [ReadOnly(true)]
 252                 [MessagingDescription("MsgExtension")]
 253                 public byte[] Extension {
 254                         get { return delegateMessage.Extension; }
 255                         set { delegateMessage.Extension = value; }
 256                 }
 257
 258                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 259                 [Browsable(false)]
 260                 public IMessageFormatter Formatter {
 261                         get { return formatter; }
 262                         set { formatter = value; }
 263                 }
 264
 265                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 266                 [ReadOnly(true)]
 267                 [MessagingDescription("MsgHashAlgorithm")]
 268                 public HashAlgorithm HashAlgorithm {
 269                         get {
 270                                 return (HashAlgorithm) delegateMessage.HashAlgorithm;
 271                         }
 272                         set {
 273                                 delegateMessage.HashAlgorithm =
 274                                         (Mono.Messaging.HashAlgorithm) value;
 275                         }
 276                 }
 277
 278                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 279                 [ReadOnly(true)]
 280                 [MessagingDescription("MsgId")]
 281                 public string Id {
 282                         get { return delegateMessage.Id; }
 283                 }
 284
 285                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 286                 [MessagingDescription("MsgIsFirstInTransaction")]
 287                 public bool IsFirstInTransaction {
 288                         get { return delegateMessage.IsFirstInTransaction; }
 289                 }
 290
 291                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 292                 [MessagingDescription("MsgIsLastInTransaction")]
 293                 public bool IsLastInTransaction {
 294                         get { return delegateMessage.IsLastInTransaction; }
 295                 }
 296
 297                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 298                 [ReadOnly(true)]
 299                 [MessagingDescription("MsgLabel")]
 300                 public string Label {
 301                         get { return delegateMessage.Label; }
 302                         set { delegateMessage.Label = value; }
 303                 }
 304
 305                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 306                 [MessagingDescription("MsgMessageType")]
 307                 public MessageType MessageType {
 308                         get {
 309                                 return (MessageType) delegateMessage.MessageType;
 310                         }
 311                 }
 312
 313                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 314                 [ReadOnly(true)]
 315                 [MessagingDescription("MsgPriority")]
 316                 public MessagePriority Priority {
 317                         get {
 318                                 return (MessagePriority) delegateMessage.Priority;
 319                         }
 320                         set {
 321                                 delegateMessage.Priority = (Mono.Messaging.MessagePriority) value;
 322                         }
 323                 }
 324
 325                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 326                 [ReadOnly(true)]
 327                 [MessagingDescription("MsgRecoverable")]
 328                 public bool Recoverable {
 329                         get { return delegateMessage.Recoverable; }
 330                         set { delegateMessage.Recoverable = value; }
 331                 }
 332
 333                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 334                 [ReadOnly(true)]
 335                 [MessagingDescription("MsgResponseQueue")]
 336                 public MessageQueue ResponseQueue {
 337                         get {
 338                                 if (delegateMessage.ResponseQueue == null)
 339                                         return null;
 340
 341                                 return new MessageQueue
 342                                         (delegateMessage.ResponseQueue);
 343                         }
 344                         set {
 345                                 delegateMessage.ResponseQueue
 346                                         = value.DelegateQueue;
 347                         }
 348                 }
 349
 350                 [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
 351                 [ReadOnly(true)]
 352                 [MessagingDescription("MsgSenderCertificate")]
 353                 public byte[] SenderCertificate {
 354                         get { return delegateMessage.SenderCertificate; }
 355                         set { delegateMessage.SenderCertificate = value; }
 356                 }
 357
 358                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 359                 [MessagingDescription ("MsgSenderId")]
 360                 public byte[] SenderId {
 361                         get { return delegateMessage.SenderId; }
 362                 }
 363
 364                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 365                 [ReadOnly (true)]
 366                 [MessagingDescription ("MsgSenderVersion")]
 367                 public long SenderVersion {
 368                         get { return delegateMessage.SenderVersion; }
 369                 }
 370
 371                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 372                 [ReadOnly (true)]
 373                 [MessagingDescription ("MsgSentTime")]
 374                 public DateTime SentTime {
 375                         get { return delegateMessage.SentTime; }
 376                 }
 377
 378                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 379                 [MessagingDescription ("MsgSourceMachine")]
 380                 public string SourceMachine {
 381                         get { return delegateMessage.SourceMachine; }
 382                 }
 383
 384                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 385                 [ReadOnly (true)]
 386                 [MessagingDescription ("MsgTimeToBeReceived")]
 387                 [TypeConverter (typeof(TimeoutConverter))]
 388                 public TimeSpan TimeToBeReceived {
 389                         get { return delegateMessage.TimeToBeReceived; }
 390                         set { delegateMessage.TimeToBeReceived = value; }
 391                 }
 392
 393                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 394                 [ReadOnly (true)]
 395                 [MessagingDescription ("MsgTimeToReachQueue")]
 396                 [TypeConverter (typeof(TimeoutConverter))]
 397                 public TimeSpan TimeToReachQueue {
 398                         get { return delegateMessage.TimeToReachQueue; }
 399                         set { delegateMessage.TimeToReachQueue = value; }
 400                 }
 401
 402                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 403                 [MessagingDescription ("MsgTransactionId")]
 404                 public string TransactionId {
 405                         get { return delegateMessage.TransactionId; }
 406                 }
 407
 408                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 409                 [ReadOnly (true)]
 410                 [MessagingDescription ("MsgTransactionStatusQueue")]
 411                 public MessageQueue TransactionStatusQueue {
 412                         get {
 413                                 return new MessageQueue(delegateMessage.TransactionStatusQueue);
 414                         }
 415                         set {
 416                                 delegateMessage.TransactionStatusQueue = value.DelegateQueue;
 417                         }
 418                 }
 419
 420                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 421                 [ReadOnly (true)]
 422                 [MessagingDescription ("MsgUseAuthentication")]
 423                 public bool UseAuthentication {
 424                         get { return delegateMessage.UseAuthentication; }
 425                         set { delegateMessage.UseAuthentication = value; }
 426                 }
 427
 428                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 429                 [ReadOnly (true)]
 430                 [MessagingDescription ("MsgUseDeadLetterQueue")]
 431                 public bool UseDeadLetterQueue {
 432                         get { return delegateMessage.UseDeadLetterQueue; }
 433                         set { delegateMessage.UseDeadLetterQueue = value; }
 434                 }
 435
 436                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 437                 [ReadOnly (true)]
 438                 [MessagingDescription ("MsgUseEncryption")]
 439                 public bool UseEncryption {
 440                         get { return delegateMessage.UseEncryption; }
 441                         set { delegateMessage.UseEncryption = value; }
 442                 }
 443
 444                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 445                 [ReadOnly (true)]
 446                 [MessagingDescription ("MsgUseJournalQueue")]
 447                 public bool UseJournalQueue {
 448                         get { return delegateMessage.UseJournalQueue; }
 449                         set { delegateMessage.UseJournalQueue = value;}
 450                 }
 451
 452                 [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
 453                 [ReadOnly (true)]
 454                 [MessagingDescription ("MsgUseTracing")]
 455                 public bool UseTracing {
 456                         get { return delegateMessage.UseTracing; }
 457                         set { delegateMessage.UseTracing = value; }
 458                 }
 459
 460                 internal IMessage DelegateMessage {
 461                         get { return delegateMessage; }
 462                 }
 463
 464                 #endregion //Properties
 465
 466                 internal static IMessage CreateMessage ()
 467                 {
 468                         return MessagingProviderLocator.GetProvider ()
 469                                 .CreateMessage ();
 470                 }
 471         }
 472 }