private MessagePartDescriptionCollection GetWrappedParts(MessagePartDescription bodyPart) { System.Type type = bodyPart.Type; MessagePartDescriptionCollection descriptions = new MessagePartDescriptionCollection(); foreach (MemberInfo info in type.GetMembers(BindingFlags.Public | BindingFlags.Instance)) { if (((info.MemberType & (MemberTypes.Property | MemberTypes.Field)) != 0) && !info.IsDefined(typeof(SoapIgnoreAttribute), false)) { MessagePartDescription description; System.ServiceModel.Description.XmlName name = new System.ServiceModel.Description.XmlName(info.Name); description = new MessagePartDescription(name.EncodedName, string.Empty) { AdditionalAttributesProvider = description.MemberInfo = info, Index = description.SerializationPosition = descriptions.Count, Type = (info.MemberType == MemberTypes.Property) ? ((PropertyInfo)info).PropertyType : ((FieldInfo)info).FieldType }; if (bodyPart.HasProtectionLevel) { description.ProtectionLevel = bodyPart.ProtectionLevel; } descriptions.Add(description); } } return(descriptions); }
/// <summary> /// Copies the elements of the collection to an <see cref="Array"/>, starting at a particular array index. /// </summary> /// <param name="array">The one-dimensional <see cref="Array"/> that is the destination of the elements copied from collection. The array must have zero-based indexing.</param> /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param> public void CopyTo(HttpParameterDescription[] array, int arrayIndex) { if (array == null) { throw new ArgumentNullException("array"); } if (arrayIndex < 0 || ((arrayIndex + this.Count) > array.Length)) { throw new ArgumentOutOfRangeException("arrayIndex"); } if (this.IsSynchronized) { MessagePartDescriptionCollection mdpColl = this.MessagePartDescriptionCollection; if (mdpColl != null) { HttpParameterDescription[] newArray = ToArray(mdpColl); Array.Copy(newArray, 0, array, arrayIndex, newArray.Length); } else { throw new ArgumentOutOfRangeException("arrayIndex"); } } else { this.innerCollection.CopyTo(array, arrayIndex); } }
internal MessageBodyDescription(MessageBodyDescription other) { this.WrapperName = other.WrapperName; this.WrapperNamespace = other.WrapperNamespace; _parts = new MessagePartDescriptionCollection(); foreach (MessagePartDescription mpd in other.Parts) { this.Parts.Add(mpd.Clone()); } if (other.ReturnValue != null) { this.ReturnValue = other.ReturnValue.Clone(); } }
/// <summary> /// Removes all items from the collection. /// </summary> public void Clear() { if (this.IsSynchronized) { MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection; if (mpdColl != null) { mpdColl.Clear(); } } else { this.innerCollection.Clear(); } }
/// <summary> /// Returns an enumerator that iterates through the collection. /// </summary> /// <returns>An enumerator that can be used to iterate through the collection.</returns> Collections.IEnumerator Collections.IEnumerable.GetEnumerator() { if (this.IsSynchronized) { MessagePartDescriptionCollection mdpColl = this.MessagePartDescriptionCollection; if (mdpColl == null) { return(Enumerable.Empty <HttpParameterDescription>().GetEnumerator()); } HttpParameterDescription[] newArray = ToArray(mdpColl); return(newArray.GetEnumerator()); } return(this.innerCollection.GetEnumerator()); }
/// <summary> /// Gets or sets the element at the specified index. /// </summary> /// <param name="index">The zero-based index of the element to get or set.</param> /// <returns>The item at the specified index.</returns> public HttpParameterDescription this[int index] { get { if (index < 0 || (index >= this.Count)) { throw new ArgumentOutOfRangeException("index"); } if (this.IsSynchronized) { // The Count check above will have thrown if there is no MessagePartDescriptionCollection, // because Count would have been zero. MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection; Debug.Assert(mpdColl != null, "MessagePartDescriptionCollection cannot be null"); return(new HttpParameterDescription(mpdColl[index])); } return(this.innerCollection[index]); } set { if (index < 0 || (index >= this.Count)) { throw new ArgumentOutOfRangeException("index"); } if (value == null) { throw new ArgumentNullException("value"); } if (this.innerCollection != null) { this.innerCollection[index] = value; } else { // The Count check above will have thrown if there is no MessagePartDescriptionCollection, // because Count would have been zero. MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection; Debug.Assert(mpdColl != null, "MessagePartDescriptionCollection cannot be null"); mpdColl[index] = this.EnsureSynchronizedMessagePartDescription(value); } } }
/// <summary> /// Adds an item to the collection. /// </summary> /// <param name="item">The object to add to the collection.</param> public void Add(HttpParameterDescription item) { if (item == null) { throw new ArgumentNullException("item"); } if (this.IsSynchronized) { MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item); MessagePartDescriptionCollection mpdColl = this.GetOrCreateMessagePartDescriptionCollection(); mpdColl.Add(mpd); } else { this.innerCollection.Add(item); } }
/// <summary> /// Removes the item at the specified index. /// </summary> /// <param name="index">The zero-based index of the item to remove,</param> public void RemoveAt(int index) { if (index < 0 || (index >= this.Count)) { throw new ArgumentOutOfRangeException("index"); } if (this.IsSynchronized) { // The Count check above will have thrown if there is no MessagePartDescriptionCollection, // because Count would have been zero. MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection; Debug.Assert(mpdColl != null, "MessagePartDescriptionCollection cannot be null"); mpdColl.RemoveAt(index); } else { this.innerCollection.RemoveAt(index); } }
/// <summary> /// Determines the index of a specific item in the collection. /// </summary> /// <param name="item">The object to locate in the collection.</param> /// <returns>The index of item if found in the list; otherwise, -1.</returns> public int IndexOf(HttpParameterDescription item) { if (item == null) { throw new ArgumentNullException("item"); } if (this.IsSynchronized) { MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection; if (mpdColl == null) { return(-1); } MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item); return(mpdColl.IndexOf(mpd)); } return(this.innerCollection.IndexOf(item)); }
/// <summary> /// Removes the first occurrence of a specific object from the collection. /// </summary> /// <param name="item">The object to remove from the collection.</param> /// <returns><c>true</c> if <paramref name="item"/> was successfully removed from the collection; otherwise, <c>false</c>. /// This method also returns <c>false</c> if <paramref name="item"/> is not found in the original collection.</returns> public bool Remove(HttpParameterDescription item) { if (item == null) { throw new ArgumentNullException("item"); } if (this.IsSynchronized) { MessagePartDescriptionCollection mdpColl = this.MessagePartDescriptionCollection; if (mdpColl == null) { return(false); } MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item); return(mdpColl.Remove(mpd)); } return(this.innerCollection.Remove(item)); }
/// <summary> /// Retrieves the appropriate <see cref="MessagePartDescriptionCollection"/> for the current instance. /// If the synchronized <see cref="OperationDescription"/> does not have the corresponding collection, /// this method will create a default <see cref="MessageDescription"/> element so that the collection exists. /// </summary> /// <returns>The <see cref="MessagePartDescriptionCollection"/>.</returns> private MessagePartDescriptionCollection GetOrCreateMessagePartDescriptionCollection() { Debug.Assert(this.IsSynchronized, "This method cannot be called for unsynchronized collections"); MessagePartDescriptionCollection mpdColl = this.MessagePartDescriptionCollection; if (mpdColl == null) { OperationDescription od = this.operationDescription; int messageIndex = this.isOutputCollection ? 1 : 0; if (od.Messages.Count <= messageIndex) { HttpOperationDescription.CreateMessageDescriptionIfNecessary(od, messageIndex); } Debug.Assert(od.Messages.Count > messageIndex, "CreateMessageDescription should have created Message element"); mpdColl = od.Messages[messageIndex].Body.Parts; } Debug.Assert(mpdColl != null, "return value can never be null"); return(mpdColl); }
private CodeExpression[] ExportMessages(MessageDescriptionCollection messages, CodeMemberMethod method, bool return_args) { CodeExpression [] args = null; foreach (MessageDescription md in messages) { if (md.Direction == MessageDirection.Output) { if (md.Body.ReturnValue != null) { ExportDataContract(md.Body.ReturnValue); method.ReturnType = md.Body.ReturnValue.CodeTypeReference; } continue; } if (return_args) { args = new CodeExpression [md.Body.Parts.Count]; } MessagePartDescriptionCollection parts = md.Body.Parts; for (int i = 0; i < parts.Count; i++) { ExportDataContract(parts [i]); method.Parameters.Add( new CodeParameterDeclarationExpression( parts [i].CodeTypeReference, parts [i].Name)); if (return_args) { args [i] = new CodeArgumentReferenceExpression(parts [i].Name); } } } return(args); }
/// <summary> /// Determines whether the collection contains a specific value. /// </summary> /// <param name="item">The object to locate in the collection.</param> /// <returns><c>true</c> if item is found in the collection; otherwise, <c>false</c>.</returns> public bool Contains(HttpParameterDescription item) { if (item == null) { throw new ArgumentNullException("item"); } if (this.IsSynchronized) { MessagePartDescriptionCollection mdpColl = this.MessagePartDescriptionCollection; if (mdpColl == null) { return(false); } // Strategy: use the knowledge we would have wrapped the MessagePartDescription in the // past when we released this HttpParameterDescription. MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item); return(mdpColl.Contains(mpd)); } return(this.innerCollection.Contains(item)); }
/// <summary> /// Inserts an item at the specified index. /// </summary> /// <param name="index">The zero-based index at which item should be inserted.</param> /// <param name="item">The object to insert at the specified index.</param> public void Insert(int index, HttpParameterDescription item) { if (item == null) { throw new ArgumentNullException("item"); } if (index < 0 || (index > this.Count)) { throw new ArgumentOutOfRangeException("index"); } if (this.IsSynchronized) { MessagePartDescription mpd = this.EnsureSynchronizedMessagePartDescription(item); MessagePartDescriptionCollection mpdColl = this.GetOrCreateMessagePartDescriptionCollection(); Debug.Assert(mpdColl != null, "MessagePartDescriptionCollection cannot be null"); mpdColl.Insert(index, mpd); } else { this.innerCollection.Insert(index, item); } }
public MessageBodyDescription() { _parts = new MessagePartDescriptionCollection(); }
private XmlMembersMapping LoadBodyMapping(MessageDescription message, string mappingKey, out MessagePartDescriptionCollection rpcEncodedTypedMessageBodyParts) { MessagePartDescription returnPart; string wrapperName, wrapperNs; MessagePartDescriptionCollection bodyParts; rpcEncodedTypedMessageBodyParts = null; returnPart = OperationFormatter.IsValidReturnValue(message.Body.ReturnValue) ? message.Body.ReturnValue : null; bodyParts = message.Body.Parts; wrapperName = message.Body.WrapperName; wrapperNs = message.Body.WrapperNamespace; bool isWrapped = (wrapperName != null); bool hasReturnValue = returnPart != null; int paramCount = bodyParts.Count + (hasReturnValue ? 1 : 0); if (paramCount == 0 && !isWrapped) // no need to create serializer { return(null); } XmlReflectionMember[] members = new XmlReflectionMember[paramCount]; int paramIndex = 0; if (hasReturnValue) { members[paramIndex++] = XmlSerializerHelper.GetXmlReflectionMember(returnPart, IsRpc, isWrapped); } for (int i = 0; i < bodyParts.Count; i++) { members[paramIndex++] = XmlSerializerHelper.GetXmlReflectionMember(bodyParts[i], IsRpc, isWrapped); } if (!isWrapped) { wrapperNs = ContractNamespace; } return(ImportMembersMapping(wrapperName, wrapperNs, members, isWrapped, IsRpc, mappingKey)); }
/// <summary> /// Creates an array of <see cref="HttpParameterDescription"/> elements that are synchronized with their /// corresponding <see cref="MessagePartDescription"/> elements. /// </summary> /// <param name="messagePartDescriptionCollection">The existing collection from which to create the array.</param> /// <returns>The new array.</returns> private static HttpParameterDescription[] ToArray(MessagePartDescriptionCollection messagePartDescriptionCollection) { return(messagePartDescriptionCollection .Select <MessagePartDescription, HttpParameterDescription>(m => new HttpParameterDescription(m)) .ToArray()); }
internal void SetBody(SerializerStub body, MessagePartDescriptionCollection rpcEncodedTypedMessageBodyParts) { _body = body; _rpcEncodedTypedMessageBodyParts = rpcEncodedTypedMessageBodyParts; }
internal void SetBody(XmlSerializerOperationBehavior.Reflector.SerializerStub body, MessagePartDescriptionCollection rpcEncodedTypedMessageBodyParts) { this.body = body; this.rpcEncodedTypedMessageBodyParts = rpcEncodedTypedMessageBodyParts; }
private XmlMembersMapping LoadBodyMapping(MessageDescription message, string mappingKey, out MessagePartDescriptionCollection rpcEncodedTypedMessageBodyParts) { MessagePartDescription description; string name; string wrapperNamespace; MessagePartDescriptionCollection parts; if ((this.IsEncoded && message.IsTypedMessage) && (message.Body.WrapperName == null)) { MessagePartDescription wrapperPart = this.GetWrapperPart(message); description = null; rpcEncodedTypedMessageBodyParts = parts = this.GetWrappedParts(wrapperPart); name = wrapperPart.Name; wrapperNamespace = wrapperPart.Namespace; } else { rpcEncodedTypedMessageBodyParts = null; description = OperationFormatter.IsValidReturnValue(message.Body.ReturnValue) ? message.Body.ReturnValue : null; parts = message.Body.Parts; name = message.Body.WrapperName; wrapperNamespace = message.Body.WrapperNamespace; } bool isWrapped = name != null; bool flag2 = description != null; int num = parts.Count + (flag2 ? 1 : 0); if ((num == 0) && !isWrapped) { return(null); } XmlReflectionMember[] members = new XmlReflectionMember[num]; int num2 = 0; if (flag2) { members[num2++] = XmlSerializerHelper.GetXmlReflectionMember(description, this.IsRpc, this.IsEncoded, isWrapped); } for (int i = 0; i < parts.Count; i++) { members[num2++] = XmlSerializerHelper.GetXmlReflectionMember(parts[i], this.IsRpc, this.IsEncoded, isWrapped); } if (!isWrapped) { wrapperNamespace = this.ContractNamespace; } return(this.ImportMembersMapping(name, wrapperNamespace, members, isWrapped, this.IsRpc, mappingKey)); }