/// <summary>
/// Returns the resource type for the corresponding clr type.
/// If the given clr type is a collection, then resource type describes the element type of the collection.
/// </summary>
/// <param name="type">clrType whose corresponding resource type needs to be returned</param>
/// <returns>Returns the resource type</returns>
private ResourceType GetNonPrimitiveType(Type type)
{
Debug.Assert(type != null, "type != null");
// Check for the type directly first
ResourceType resourceType = this.ResolveNonPrimitiveType(type);
if (resourceType == null)
{
// check for ienumerable types
Type elementType = BaseServiceProvider.GetIEnumerableElement(type);
if (elementType != null)
{
resourceType = PrimitiveResourceTypeMap.TypeMap.GetPrimitive(elementType);
if (resourceType == null)
{
resourceType = this.ResolveNonPrimitiveType(elementType);
}
}
}
return(resourceType);
}
/// <summary>
/// Returns 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>
/// <returns>Service operation corresponding to give <paramref name="method"/>.</returns>
private ServiceOperation GetServiceOperationForMethod(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");
bool hasSingleResult = BaseServiceProvider.MethodHasSingleResult(method);
ServiceOperationResultKind resultKind;
ResourceType resourceType = null;
if (method.ReturnType == typeof(void))
{
resultKind = ServiceOperationResultKind.Void;
}
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;
if (WebUtil.IsPrimitiveType(method.ReturnType))
{
resultKind = ServiceOperationResultKind.DirectValue;
resultType = method.ReturnType;
resourceType = PrimitiveResourceTypeMap.TypeMap.GetPrimitive(resultType);
}
else
{
Type queryableElement = BaseServiceProvider.GetIQueryableElement(method.ReturnType);
if (queryableElement != null)
{
resultKind = hasSingleResult ?
ServiceOperationResultKind.QueryWithSingleResult :
ServiceOperationResultKind.QueryWithMultipleResults;
resultType = queryableElement;
}
else
{
Type enumerableElement = BaseServiceProvider.GetIEnumerableElement(method.ReturnType);
if (enumerableElement != null)
{
resultKind = ServiceOperationResultKind.Enumeration;
resultType = enumerableElement;
}
else
{
resultType = method.ReturnType;
resultKind = ServiceOperationResultKind.DirectValue;
}
}
Debug.Assert(resultType != null, "resultType != null");
resourceType = PrimitiveResourceTypeMap.TypeMap.GetPrimitive(resultType);
if (resourceType == null)
{
resourceType = this.ResolveResourceType(resultType);
}
}
if (resourceType == null)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));
}
if (resultKind == ServiceOperationResultKind.Enumeration && hasSingleResult)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_IEnumerableAlwaysMultiple(type, method));
}
}
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 = PrimitiveResourceTypeMap.TypeMap.GetPrimitive(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 resourceSet = null;
if (resourceType != null && resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
resourceSet = this.ResolveResourceSet(resourceType, method);
if (resourceSet == null)
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ServiceOperationMissingSingleEntitySet(method, resourceType.FullName));
}
}
ServiceOperation operation = new ServiceOperation(method.Name, resultKind, resourceType, resourceSet, protocolMethod, parameters);
operation.CustomState = method;
MimeTypeAttribute attribute = BaseServiceProvider.GetMimeTypeAttribute(method);
if (attribute != null)
{
operation.MimeType = attribute.MimeType;
}
return(operation);
}
