/// <summary>Gets the type name to be used in the URI for the given <paramref name="type"/>.</summary>
/// <param name="type">Type to get name for.</param>
/// <param name="context">Data context used to generate type names for types.</param>
/// <returns>The name for the <paramref name="type"/>, suitable for including in a URI.</returns>
internal static string GetTypeNameForUri(Type type, DataServiceContext context)
{
Debug.Assert(type != null, "type != null");
Debug.Assert(context != null, "context != null");
type = Nullable.GetUnderlyingType(type) ?? type;
PrimitiveType pt;
if (PrimitiveType.TryGetPrimitiveType(type, out pt))
{
if (pt.HasReverseMapping)
{
return(pt.EdmTypeName);
}
else
{
// unsupported primitive type
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(type.Name));
}
}
else
{
return(context.ResolveNameFromTypeInternal(type) ?? ClientTypeUtil.GetServerDefinedlTypeFullName(type));
}
}
/// <summary>type edm type string for content</summary>
/// <param name="propertyType">type to analyze</param>
/// <returns>edm type string for payload, null for unknown</returns>
internal static string GetEdmType(Type propertyType)
{
PrimitiveType primitiveType;
if (PrimitiveType.TryGetPrimitiveType(propertyType, out primitiveType))
{
// Map DateTime to DateTimeOffset
if (primitiveType.ClrType == typeof(DateTime))
{
return(XmlConstants.EdmDateTimeOffsetTypeName);
}
if (primitiveType.EdmTypeName != null)
{
return(primitiveType.EdmTypeName);
}
else
{
// case StorageType.UInt16:
// case StorageType.UInt32:
// case StorageType.UInt64:
// don't support reverse mappings for these types in this version
// allows us to add real server support in the future without a
// "breaking change" in the future client
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(propertyType.Name));
}
}
else
{
Debug.Assert(false, "knowntype without reverse mapping");
return(null);
}
}
/// <summary>
/// Returns the primitive property value.
/// </summary>
/// <param name="propertyValue">Value of the property.</param>
/// <param name="propertyType">Type of the property.</param>
/// <returns>Returns the value of the primitive property.</returns>
internal static object ConvertPrimitiveValueToRecognizedODataType(object propertyValue, Type propertyType)
{
Debug.Assert(PrimitiveType.IsKnownNullableType(propertyType), "GetPrimitiveValue must be called only for primitive types");
Debug.Assert(propertyValue == null || PrimitiveType.IsKnownType(propertyValue.GetType()), "GetPrimitiveValue method must be called for primitive values only");
if (propertyValue == null)
{
return(null);
}
PrimitiveType primitiveType;
PrimitiveType.TryGetPrimitiveType(propertyType, out primitiveType);
Debug.Assert(primitiveType != null, "must be a known primitive type");
// Do the conversion for types that are not supported by ODataLib e.g. char[], char, etc
if (propertyType == typeof(Char) ||
propertyType == typeof(Char[]) ||
propertyType == typeof(Type) ||
propertyType == typeof(Uri) ||
propertyType == typeof(System.Xml.Linq.XDocument) ||
propertyType == typeof(System.Xml.Linq.XElement))
{
return(primitiveType.TypeConverter.ToString(propertyValue));
}
else if (propertyType == typeof(DateTime))
{
return(PlatformHelper.ConvertDateTimeToDateTimeOffset((DateTime)propertyValue));
}
#if !PORTABLELIB
else if (propertyType.FullName == "System.Data.Linq.Binary")
{
// For System.Data.Linq.Binary, it is a delay loaded type. Hence checking it based on name.
// PrimitiveType.IsKnownType checks for binary type based on name and assembly. Hence just
// checking name here is sufficient, since any other type with the same name, but in different
// assembly will return false for PrimitiveType.IsKnownNullableType.
// Since ODataLib does not understand binary type, we need to convert the value to byte[].
return(((BinaryTypeConverter)primitiveType.TypeConverter).ToArray(propertyValue));
}
#endif
else if (primitiveType.EdmTypeName == null)
{
// case StorageType.DateTimeOffset:
// case StorageType.TimeSpan:
// case StorageType.UInt16:
// case StorageType.UInt32:
// case StorageType.UInt64:
// don't support reverse mappings for these types in this version
// allows us to add real server support in the future without a
// "breaking change" in the future client
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(propertyType.Name));
}
return(propertyValue);
}