private static IEnumerable<IEdmOperation> GetMatchedOperations(this IEnumerable<IEdmOperation> operations,
            string operationIdentifier, IEdmType bindingType)
        {
            Contract.Assert(operations != null);
            Contract.Assert(operationIdentifier != null);
            Contract.Assert(bindingType != null);

            string[] nameParts = operationIdentifier.Split('.');
            Contract.Assert(nameParts.Length != 0);

            if (nameParts.Length == 1)
            {
                // Name
                string name = nameParts[0];
                operations = operations.Where(f => f.Name == name);
            }
            else
            {
                // Namespace.Name
                string name = nameParts[nameParts.Length - 1];
                string nspace = String.Join(".", nameParts.Take(nameParts.Length - 1));
                operations = operations.Where(f => f.Name == name && f.Namespace == nspace);
            }

            return operations.Where(procedure => procedure.CanBindTo(bindingType));
        }

 /// <summary>
 /// Sets the single instance of <see cref="ClientTypeAnnotation"/> on the given instance of <paramref name="edmType"/>.
 /// </summary>
 /// <param name="model">The model the <paramref name="edmType"/> belongs to.</param>
 /// <param name="edmType">IEdmType instance to set the annotation on.</param>
 /// <param name="annotation">The annotation to set</param>
 internal static void SetClientTypeAnnotation(this IEdmModel model, IEdmType edmType, ClientTypeAnnotation annotation)
 {
     Debug.Assert(model != null, "model != null");
     Debug.Assert(edmType != null, "edmType != null");
     Debug.Assert(annotation != null, "annotation != null");
     model.SetAnnotationValue<ClientTypeAnnotation>(edmType, annotation);
 }

        /// <summary>
        /// Gets the single instance of <see cref="ClientTypeAnnotation"/> from the given instance of <paramref name="edmType"/>.
        /// </summary>
        /// <param name="model">The model the <paramref name="edmType"/> belongs to.</param>
        /// <param name="edmType">IEdmType instance to get the annotation.</param>
        /// <returns>Returns the single instance of <see cref="ClientTypeAnnotation"/> from the given instance of <paramref name="edmType"/>.</returns>
        internal static ClientTypeAnnotation GetClientTypeAnnotation(this IEdmModel model, IEdmType edmType)
        {
            Debug.Assert(model != null, "model != null");
            Debug.Assert(edmType != null, "edmType != null");

            return model.GetAnnotationValue<ClientTypeAnnotation>(edmType);
        }

 private static IEdmTypeReference GetPropertyType(IEdmType type, string propertyName)
 {
     IEdmStructuredType type2 = type as IEdmStructuredType;
     IEdmProperty property = (type2 == null) ? null : type2.FindProperty(propertyName);
     if (property != null)
     {
         IEdmTypeReference typeReference = property.Type;
         if (typeReference.IsNonEntityODataCollectionTypeKind())
         {
             throw new ODataException(Microsoft.Data.OData.Strings.EpmSourceTree_CollectionPropertyCannotBeMapped(propertyName, type.ODataFullName()));
         }
         if (typeReference.IsStream())
         {
             throw new ODataException(Microsoft.Data.OData.Strings.EpmSourceTree_StreamPropertyCannotBeMapped(propertyName, type.ODataFullName()));
         }
         if (typeReference.IsSpatial())
         {
             throw new ODataException(Microsoft.Data.OData.Strings.EpmSourceTree_SpatialTypeCannotBeMapped(propertyName, type.ODataFullName()));
         }
         return property.Type;
     }
     if ((type != null) && !type.IsOpenType())
     {
         throw new ODataException(Microsoft.Data.OData.Strings.EpmSourceTree_MissingPropertyOnType(propertyName, type.ODataFullName()));
     }
     return null;
 }

 internal static IEdmTypeReference ResolveAndValidateNonPrimitiveTargetType(EdmTypeKind expectedTypeKind, IEdmTypeReference expectedTypeReference, EdmTypeKind payloadTypeKind, IEdmType payloadType, string payloadTypeName, IEdmModel model, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, out SerializationTypeNameAnnotation serializationTypeNameAnnotation)
 {
     bool flag = (messageReaderSettings.ReaderBehavior.TypeResolver != null) && (payloadType != null);
     if (!flag)
     {
         ValidateTypeSupported(expectedTypeReference, version);
         if (model.IsUserModel() && ((expectedTypeReference == null) || !messageReaderSettings.DisableStrictMetadataValidation))
         {
             VerifyPayloadTypeDefined(payloadTypeName, payloadType);
         }
     }
     else
     {
         ValidateTypeSupported((payloadType == null) ? null : payloadType.ToTypeReference(true), version);
     }
     if ((payloadTypeKind != EdmTypeKind.None) && (!messageReaderSettings.DisableStrictMetadataValidation || (expectedTypeReference == null)))
     {
         ValidationUtils.ValidateTypeKind(payloadTypeKind, expectedTypeKind, payloadTypeName);
     }
     serializationTypeNameAnnotation = null;
     if (!model.IsUserModel())
     {
         return null;
     }
     if ((expectedTypeReference == null) || flag)
     {
         return ResolveAndValidateTargetTypeWithNoExpectedType(expectedTypeKind, payloadType, payloadTypeName, out serializationTypeNameAnnotation);
     }
     if (messageReaderSettings.DisableStrictMetadataValidation)
     {
         return ResolveAndValidateTargetTypeStrictValidationDisabled(expectedTypeKind, expectedTypeReference, payloadType, payloadTypeName, out serializationTypeNameAnnotation);
     }
     return ResolveAndValidateTargetTypeStrictValidationEnabled(expectedTypeKind, expectedTypeReference, payloadType, payloadTypeName, out serializationTypeNameAnnotation);
 }

 public override IEnumerable<IEdmOperation> ResolveBoundOperations(
     IEdmModel model,
     string identifier,
     IEdmType bindingType)
 {
     return unqualified.ResolveBoundOperations(model, identifier, bindingType);
 }

 /// <summary>
 /// Throws if the type is not related to the type of the given set.
 /// </summary>
 /// <param name="type">Type to check.</param>
 /// <param name="secondType">Second type, which should be related to the first type.</param>
 /// <param name="segmentName">The segment that is checking this.</param>
 internal static void ThrowIfTypesUnrelated(IEdmType type, IEdmType secondType, string segmentName)
 {
     if (!UriEdmHelpers.IsRelatedTo(type.AsElementType(), secondType))
     {
         throw new ODataException(Strings.PathParser_TypeMustBeRelatedToSet(type, secondType, segmentName));
     }
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="EdmTypeReference"/> class.
        /// </summary>
        /// <param name="definition">Type that describes this value.</param>
        /// <param name="isNullable">Denotes whether the type can be nullable.</param>
        protected EdmTypeReference(IEdmType definition, bool isNullable)
        {
            EdmUtil.CheckArgumentNull(definition, "definition");

            this.definition = definition;
            this.isNullable = isNullable;
        }

 public static AndConstraint<IEdmType> ShouldBeEquivalentTo(this IEdmType type, IEdmType expectedType)
 {
     type.IsEquivalentTo(expectedType).Should().BeTrue();
     ////typeReference.Should().BeSameAs(expectedTypeReference.Definition);
     ////typeReference.IsNullable.Should().Be(expectedTypeReference.IsNullable);
     return new AndConstraint<IEdmType>(type);
 }

        public TypeSchema UpdateSchema(object value, IEdmType edmType, bool collection = false)
        {
            TypeSchema schema = null;
            if (edmType != null)
            {
                try
                {
                    schema = ODataAvroSchemaGen.GetSchemaFromModel(edmType);
                }
                catch (ApplicationException) { }
            }

            if (schema == null)
            {
                if (value == null)
                {
                    return null;
                }

                schema = ODataAvroSchemaGen.GetSchema(value);
            }

            TypeSchema single = AvroSerializer.CreateGeneric(schema.ToString()).WriterSchema;

            if (collection)
            {
                schema = ODataAvroSchemaGen.GetArraySchema(schema);
                single = ((ArraySchema)AvroSerializer.CreateGeneric(schema.ToString()).WriterSchema).ItemSchema;
            }

            var writer = AvroContainer.CreateGenericWriter(schema.ToString(), stream, true, Codec.Null);
            this.seqWriter = new SequentialWriter<object>(writer, 16);

            return single;
        }

 private static IEdmTypeReference GetNullablePayloadTypeReference(IEdmType payloadType)
 {
     if (payloadType != null)
     {
         return payloadType.ToTypeReference(true);
     }
     return null;
 }

 internal ClientTypeAnnotation(IEdmType edmType, Type type, string qualifiedName, DataServiceProtocolVersion maxProtocolVersion)
 {
     this.EdmType = edmType;
     this.ElementTypeName = qualifiedName;
     this.ElementType = Nullable.GetUnderlyingType(type) ?? type;
     this.MaxProtocolVersion = maxProtocolVersion;
     this.epmLazyLoader = new EpmLazyLoader(this);
 }

 protected override ODataPathSegment ParseAtEntityCollection(IEdmModel model, ODataPathSegment previous, IEdmType previousEdmType, string segment)
 {
     if (segment == "$count")
     {
         return new CountPathSegment();
     }
     return base.ParseAtEntityCollection(model, previous, previousEdmType, segment);
 }

 /// <summary>Constructor, creates a new resource with preinitialized properties.</summary>
 /// <param name="resourceType">The type of the resource to create.</param>
 /// <param name="values">The properties to initialize.</param>
 public DSPResource(IEdmType resourceType, IEnumerable<KeyValuePair<string, object>> values)
     : this(resourceType)
 {
     foreach (var value in values)
     {
         this.properties.Add(value.Key, value.Value);
     }
 }

 /// <summary>
 /// Gets the EDM type for this segment.
 /// </summary>
 /// <param name="previousEdmType">The EDM type of the previous path segment.</param>
 /// <returns>
 /// The EDM type for this segment.
 /// </returns>
 public override IEdmType GetEdmType(IEdmType previousEdmType)
 {
     if (Property != null)
     {
         return Property.Type.Definition;
     }
     return null;
 }

 /// <summary>
 /// Gets the EDM type for this segment.
 /// </summary>
 /// <param name="previousEdmType">The EDM type of the previous path segment.</param>
 /// <returns>
 /// The EDM type for this segment.
 /// </returns>
 public override IEdmType GetEdmType(IEdmType previousEdmType)
 {
     if (EntitySet != null)
     {
         return EntitySet.ElementType.GetCollection();
     }
     return null;
 }

        /// <summary>
        /// Gets the EDM type for this segment.
        /// </summary>
        /// <param name="previousEdmType">The EDM type of the previous path segment.</param>
        /// <returns>
        /// The EDM type for this segment.
        /// </returns>
        public override IEdmType GetEdmType(IEdmType previousEdmType)
        {
            if (EntitySetBase != null)
            {
                return EntitySetBase.EntityType().GetCollection();
            }

            return null;
        }

 /// <summary>
 /// Gets the EDM type for this segment.
 /// </summary>
 /// <param name="previousEdmType">The EDM type of the previous path segment.</param>
 /// <returns>
 /// The EDM type for this segment.
 /// </returns>
 public override IEdmType GetEdmType(IEdmType previousEdmType)
 {
     IEdmCollectionType previousCollectionType = previousEdmType as IEdmCollectionType;
     if (previousCollectionType != null)
     {
         return previousCollectionType.ElementType.Definition;
     }
     return null;
 }

 /// <summary>
 /// Check whether the parent and child are properly related types
 /// </summary>
 /// <param name="parentType">the parent type</param>
 /// <param name="childType">the child type</param>
 /// <exception cref="ODataException">Throws if the two types are not related.</exception>
 public static void CheckRelatedTo(IEdmType parentType, IEdmType childType)
 {
     if (!IsRelatedTo(parentType, childType))
     {
         // If the parentType is an open property, parentType will be null and can't have an ODataFullName.
         string parentTypeName = (parentType != null) ? parentType.ODataFullName() : "<null>";
         throw new ODataException(OData.Core.Strings.MetadataBinder_HierarchyNotFollowed(childType.FullTypeName(), parentTypeName));
     }
 }

        public static IEnumerable<IEdmOperation> FindMatchedOperations(this IEdmModel model, string identifier, IEdmType bindingType)
        {
            Contract.Assert(model != null);
            Contract.Assert(identifier != null);
            Contract.Assert(bindingType != null);

            IEnumerable<IEdmOperation> operations = model.SchemaElements.OfType<IEdmOperation>();
            return operations.GetMatchedOperations(identifier, bindingType);
        }