/// <summary> /// Validates the attachment. /// </summary> private DimeAttachment CheckAttachment(DimeAttachment attachment) { Debug.Assert(attachment != null); if (attachment.Type == null || attachment.Stream == null || !attachment.Stream.CanRead) { throw new Exception("DimeAttachment requires a valid type and a readable stream"); } return(attachment); }
// Lookup the referenced attachment in the attachment table by id // and copy over the additional attachment data. private void CopyFieldsFromInputAttachment(DimeAttachment attachment) { if (attachment == null) { return; } DimeAttachment fromAttachment = (DimeAttachment)inputAttachments[attachment.Id]; attachment.Type = fromAttachment.Type; attachment.TypeFormat = fromAttachment.TypeFormat; attachment.Stream = fromAttachment.Stream; }
void AddAttachmentValue(Type t, object o) { if (t.IsArray) { DimeAttachment[] atts = (DimeAttachment[])o; for (int i = 0; i < atts.Length; i++) { CheckAttachment(atts[i]); outputAttachments.Add(atts[i]); } } else { DimeAttachment a = (DimeAttachment)o; CheckAttachment(a); outputAttachments.Add(a); } }
/// <summary> /// Encapsulates the SOAP message into a DIME message. The stored attachments are added as DIME records. /// If an exception has been thrown, the soap message containing the exception is /// not encapsulated. /// </summary> private void AfterSerialize(SoapMessage message) { newStream.Position = 0; //if response only, then not on request if (dimeDir != DimeDir.Response && message.Exception == null) { DimeWriter dw = new DimeWriter(networkStream); int contentLength = (newStream.CanSeek && newStream.Length <= DefaultBufferSize) ? (int)newStream.Length : -1; DimeRecord record = null; if (outputAttachments.Count > 0) { record = dw.NewRecord(id, SoapContentType, TypeFormatEnum.AbsoluteUri, contentLength); } else { record = dw.LastRecord(id, SoapContentType, TypeFormatEnum.AbsoluteUri, contentLength); } BinaryCopy(newStream, record.BodyStream); //add attachments for (int i = 0; i < outputAttachments.Count; i++) { DimeAttachment attachment = (DimeAttachment)outputAttachments[i]; contentLength = attachment.Stream.CanSeek ? (int)attachment.Stream.Length : -1; if (i == (outputAttachments.Count - 1)) { record = dw.LastRecord(attachment.Id, attachment.Type, attachment.TypeFormat, contentLength); } else { record = dw.NewRecord(attachment.Id, attachment.Type, attachment.TypeFormat, contentLength); } BinaryCopy(attachment.Stream, record.BodyStream); } dw.Close(); } else { BinaryCopy(newStream, networkStream); } }
/// <summary> /// Retrieves the SOAP message from the DIME message. DIME attachments /// are removed from the stream and stored for future use by the AfterDeserialize /// method. /// </summary> private void BeforeDeserialize(SoapMessage message) { if (message.ContentType == DimeContentType) { contentType = message.ContentType; inputAttachments = new Hashtable(); DimeReader dr = new DimeReader(networkStream); DimeRecord record = dr.ReadRecord(); if (record.Type != SoapContentType) { throw new Exception(String.Format("Expected content type '{0}' in record containing SOAP payload.", SoapContentType)); } message.ContentType = "text/xml"; BinaryCopy(record.BodyStream, newStream); record.Close(); //get attachments while ((record = dr.ReadRecord()) != null) { //OutOfMemoryException Stream stream = new MemoryStream(record.Chunked ? DefaultBufferSize : record.ContentLength); BinaryCopy(record.BodyStream, stream); stream.Position = 0; DimeAttachment attachment = new DimeAttachment(record.Id.ToString(), record.Type, record.TypeFormat, stream); inputAttachments.Add(attachment.Id, attachment); record.Close(); } dr.Close(); } else { BinaryCopy(networkStream, newStream); } newStream.Position = 0; }
/// <summary> /// Sets the method's DimeAttachment parameters and return value to the stored values. /// </summary> private void AfterDeSerialize(SoapMessage message) { if (contentType == DimeContentType) { if (message.GetType() != typeof(SoapClientMessage)) { throw new Exception("DIME library not for server side processing"); /* * // check for unreferenced attachments in the container * IDimeAttachmentContainer container = ((SoapServerMessage)message).Server as IDimeAttachmentContainer; * if (container != null) * { * if (container.RequestAttachments == null) * throw new InvalidOperationException("The IDimeAttachmentContainer.RequestAttachments property must not be null."); * container.RequestAttachments.AddRange(inputAttachments.Values); * } * else * { * // check for referenced attachments in the parameter list * ParameterInfo[] parameters = message.MethodInfo.InParameters; * for (int i = 0; i < parameters.Length; i++) * { * Type type = parameters[i].ParameterType; * if (type == typeof(DimeAttachment)) * { * // only the id is in the SOAP body so copy over other attachment fields into * // the DimeAttachment object created during deserialization * CopyFieldsFromInputAttachment((DimeAttachment)message.GetInParameterValue(i)); * } * else if (type == typeof(DimeAttachment[])) * { * CopyFieldsFromInputAttachment((DimeAttachment[])message.GetInParameterValue(i)); * } * } * } */ } else //client side { // check for unreferenced attachments in the container IDimeAttachmentContainer container = ((SoapClientMessage)message).Client as IDimeAttachmentContainer; if (container != null) { if (container.ResponseAttachments == null) { throw new InvalidOperationException("The IDimeAttachmentContainer.ResponseAttachments property must not be null."); } container.ResponseAttachments.AddRange(inputAttachments.Values); } else { // check for referenced attachments in the out parameter list ParameterInfo[] parameters = message.MethodInfo.OutParameters; for (int i = 0; i < parameters.Length; i++) { // Note, using the as operator to test the type since out params have a unique type object outValue = message.GetOutParameterValue(i); DimeAttachment a = outValue as DimeAttachment; if (a != null) { CopyFieldsFromInputAttachment(a); } else { DimeAttachment[] aa = outValue as DimeAttachment[]; if (aa != null) { CopyFieldsFromInputAttachment(aa); } } } Type returnType = message.MethodInfo.ReturnType; if (returnType == typeof(DimeAttachment)) { CopyFieldsFromInputAttachment((DimeAttachment)message.GetReturnValue()); } else if (returnType == typeof(DimeAttachment[])) { CopyFieldsFromInputAttachment((DimeAttachment[])message.GetReturnValue()); } } } } }
public int IndexOf(DimeAttachment attachment) { return(List.IndexOf(attachment)); }
public void Remove(DimeAttachment attachment) { List.Remove(attachment); }
public void Add(DimeAttachment attachment) { List.Add(attachment); }
public int IndexOf(DimeAttachment attachment) { return List.IndexOf(attachment); }
public void CopyTo(DimeAttachment[] attachments, int index) { List.CopyTo(attachments, index); }