/// <summary>
/// Adds a new <see cref="ServiceOperation"/> based on the specified <paramref name="method"/>
/// instance.
/// </summary>
/// <param name="method">Method to expose as a service operation.</param>
/// <param name="protocolMethod">Protocol (for example HTTP) method the service operation responds to.</param>
private void AddServiceOperation(MethodInfo method, string protocolMethod)
{
Debug.Assert(method != null, "method != null");
Debug.Assert(!method.IsAbstract, "!method.IsAbstract - if method is abstract, the type is abstract - already checked");
// This method is only called for V1 providers, since in case of custom providers,
// they are suppose to load the metadata themselves.
if (this.metadata.ServiceOperations.ContainsKey(method.Name))
{
throw new InvalidOperationException(Strings.BaseServiceProvider_OverloadingNotSupported(this.Type, method));
}
bool hasSingleResult = SingleResultAttribute.MethodHasSingleResult(method);
ServiceOperationResultKind resultKind;
ResourceType resourceType = null;
if (method.ReturnType == typeof(void))
{
resultKind = ServiceOperationResultKind.Void;
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
else
{
// Load the metadata of the resource type on the fly.
// For Edm provider, it might not mean anything, but for reflection service provider, we need to
// load the metadata of the type if its used only in service operation case
Type resultType = null;
if (WebUtil.IsPrimitiveType(method.ReturnType))
{
resultKind = ServiceOperationResultKind.DirectValue;
resultType = method.ReturnType;
resourceType = ResourceType.GetPrimitiveResourceType(resultType);
}
else
{
Type queryableElement = GetGenericInterfaceElementType(method.ReturnType, IQueryableTypeFilter);
if (queryableElement != null)
{
resultKind = hasSingleResult ?
ServiceOperationResultKind.QueryWithSingleResult :
ServiceOperationResultKind.QueryWithMultipleResults;
resultType = queryableElement;
}
else
{
Type enumerableElement = GetIEnumerableElement(method.ReturnType);
if (enumerableElement != null)
{
resultKind = ServiceOperationResultKind.Enumeration;
resultType = enumerableElement;
}
else
{
resultType = method.ReturnType;
resultKind = ServiceOperationResultKind.DirectValue;
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
}
Debug.Assert(resultType != null, "resultType != null");
resourceType = ResourceType.GetPrimitiveResourceType(resultType);
if (resourceType == null)
{
resourceType = this.PopulateMetadataForType(resultType, this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
}
}
if (resourceType == null)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));
}
if (resultKind == ServiceOperationResultKind.Enumeration && hasSingleResult)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_IEnumerableAlwaysMultiple(this.Type, method));
}
if (hasSingleResult ||
(!hasSingleResult &&
(resourceType.ResourceTypeKind == ResourceTypeKind.ComplexType ||
resourceType.ResourceTypeKind == ResourceTypeKind.Primitive)))
{
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
}
ParameterInfo[] parametersInfo = method.GetParameters();
ServiceOperationParameter[] parameters = new ServiceOperationParameter[parametersInfo.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameterInfo = parametersInfo[i];
if (parameterInfo.IsOut || parameterInfo.IsRetval)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_ParameterNotIn(method, parameterInfo));
}
ResourceType parameterType = ResourceType.GetPrimitiveResourceType(parameterInfo.ParameterType);
if (parameterType == null)
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ParameterTypeNotSupported(method, parameterInfo, parameterInfo.ParameterType));
}
string parameterName = parameterInfo.Name ?? "p" + i.ToString(CultureInfo.InvariantCulture);
parameters[i] = new ServiceOperationParameter(parameterName, parameterType);
}
ResourceSet container = null;
if (resourceType != null && resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
if (!this.TryFindAnyContainerForType(resourceType, out container))
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ServiceOperationMissingSingleEntitySet(method, resourceType.FullName));
}
}
ServiceOperation operation = new ServiceOperation(method.Name, resultKind, resourceType, container, protocolMethod, parameters);
operation.CustomState = method;
MimeTypeAttribute attribute = MimeTypeAttribute.GetMimeTypeAttribute(method);
if (attribute != null)
{
operation.MimeType = attribute.MimeType;
}
this.metadata.ServiceOperations.Add(method.Name, operation);
}
private void AddServiceOperation(MethodInfo method, string protocolMethod)
{
ServiceOperationResultKind @void;
if (this.metadata.ServiceOperations.ContainsKey(method.Name))
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_OverloadingNotSupported(this.Type, method));
}
bool flag = SingleResultAttribute.MethodHasSingleResult(method);
ResourceType primitive = null;
if (method.ReturnType == typeof(void))
{
@void = ServiceOperationResultKind.Void;
}
else
{
System.Type returnType;
if (WebUtil.IsPrimitiveType(method.ReturnType))
{
@void = ServiceOperationResultKind.DirectValue;
returnType = method.ReturnType;
primitive = ResourceType.PrimitiveResourceTypeMap.GetPrimitive(returnType);
}
else
{
System.Type genericInterfaceElementType = GetGenericInterfaceElementType(method.ReturnType, new TypeFilter(BaseServiceProvider.IQueryableTypeFilter));
if (genericInterfaceElementType != null)
{
@void = flag ? ServiceOperationResultKind.QueryWithSingleResult : ServiceOperationResultKind.QueryWithMultipleResults;
returnType = genericInterfaceElementType;
}
else
{
System.Type iEnumerableElement = GetIEnumerableElement(method.ReturnType);
if (iEnumerableElement != null)
{
@void = ServiceOperationResultKind.Enumeration;
returnType = iEnumerableElement;
}
else
{
returnType = method.ReturnType;
@void = ServiceOperationResultKind.DirectValue;
}
}
primitive = ResourceType.PrimitiveResourceTypeMap.GetPrimitive(returnType);
if (primitive == null)
{
primitive = this.PopulateMetadataForType(returnType, this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
}
}
if (primitive == null)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));
}
if ((@void == ServiceOperationResultKind.Enumeration) && flag)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_IEnumerableAlwaysMultiple(this.Type, method));
}
}
ParameterInfo[] parameters = method.GetParameters();
ServiceOperationParameter[] parameterArray = new ServiceOperationParameter[parameters.Length];
for (int i = 0; i < parameterArray.Length; i++)
{
ParameterInfo info = parameters[i];
if (info.IsOut || info.IsRetval)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_ParameterNotIn(method, info));
}
ResourceType parameterType = ResourceType.PrimitiveResourceTypeMap.GetPrimitive(info.ParameterType);
if (parameterType == null)
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_ParameterTypeNotSupported(method, info, info.ParameterType));
}
string name = info.Name ?? ("p" + i.ToString(CultureInfo.InvariantCulture));
parameterArray[i] = new ServiceOperationParameter(name, parameterType);
}
ResourceSet container = null;
if (((primitive != null) && (primitive.ResourceTypeKind == ResourceTypeKind.EntityType)) && !this.TryFindAnyContainerForType(primitive, out container))
{
throw new InvalidOperationException(System.Data.Services.Strings.BaseServiceProvider_ServiceOperationMissingSingleEntitySet(method, primitive.FullName));
}
ServiceOperation operation = new ServiceOperation(method.Name, @void, primitive, container, protocolMethod, parameterArray)
{
CustomState = method
};
MimeTypeAttribute mimeTypeAttribute = MimeTypeAttribute.GetMimeTypeAttribute(method);
if (mimeTypeAttribute != null)
{
operation.MimeType = mimeTypeAttribute.MimeType;
}
this.metadata.ServiceOperations.Add(method.Name, operation);
}
