/// <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.ResolveNameFromType(type) ?? type.FullName);
}
}
/// <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))
{
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>
private 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(Xml.Linq.XDocument) ||
propertyType == typeof(Xml.Linq.XElement))
{
return(primitiveType.TypeConverter.ToString(propertyValue));
}
#if !ASTORIA_LIGHT && !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);
}
internal static string GetEdmType(Type propertyType)
{
PrimitiveType type;
if (!PrimitiveType.TryGetPrimitiveType(propertyType, out type))
{
return(null);
}
if (type.EdmTypeName == null)
{
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(propertyType.Name));
}
return(type.EdmTypeName);
}
internal static string GetTypeNameForUri(Type type, DataServiceContext context)
{
PrimitiveType type2;
type = Nullable.GetUnderlyingType(type) ?? type;
if (PrimitiveType.TryGetPrimitiveType(type, out type2))
{
if (!type2.HasReverseMapping)
{
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(type.Name));
}
return(type2.EdmTypeName);
}
return(context.ResolveNameFromType(type) ?? type.FullName);
}
private string TypeNameForUri(Type type)
{
Debug.Assert(type != null, "type != null");
type = Nullable.GetUnderlyingType(type) ?? type;
if (ClientConvert.IsKnownType(type))
{
if (ClientConvert.IsSupportedPrimitiveTypeForUri(type))
{
return(ClientConvert.ToTypeName(type));
}
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(type.Name));
}
else
{
return(this.context.ResolveNameFromType(type) ?? type.FullName);
}
}
internal static string GetEdmType(Type propertyType)
{
switch ((StorageType)IndexOfStorage(propertyType))
{
case StorageType.Boolean:
return(XmlConstants.EdmBooleanTypeName);
case StorageType.Byte:
return(XmlConstants.EdmByteTypeName);
#if !ASTORIA_LIGHT
case StorageType.Binary:
#endif
case StorageType.ByteArray:
return(XmlConstants.EdmBinaryTypeName);
case StorageType.DateTime:
return(XmlConstants.EdmDateTimeTypeName);
case StorageType.Decimal:
return(XmlConstants.EdmDecimalTypeName);
case StorageType.Double:
return(XmlConstants.EdmDoubleTypeName);
case StorageType.Guid:
return(XmlConstants.EdmGuidTypeName);
case StorageType.Int16:
return(XmlConstants.EdmInt16TypeName);
case StorageType.Int32:
return(XmlConstants.EdmInt32TypeName);
case StorageType.Int64:
return(XmlConstants.EdmInt64TypeName);
case StorageType.Single:
return(XmlConstants.EdmSingleTypeName);
case StorageType.SByte:
return(XmlConstants.EdmSByteTypeName);
case StorageType.DateTimeOffset:
case StorageType.TimeSpan:
case StorageType.UInt16:
case StorageType.UInt32:
case StorageType.UInt64:
throw new NotSupportedException(Strings.ALinq_CantCastToUnsupportedPrimitive(propertyType.Name));
case StorageType.Char:
case StorageType.CharArray:
case StorageType.String:
case StorageType.Type:
case StorageType.Uri:
case StorageType.XDocument:
case StorageType.XElement:
return(null);
default:
Debug.Assert(false, "knowntype without reverse mapping");
return(null);
}
}
/// <summary>type edm type string for content</summary>
/// <param name="propertyType">type to analyze</param>
/// <returns>edm type string for payload, null for string and unknown</returns>
internal static string GetEdmType(Type propertyType)
{
switch ((StorageType)IndexOfStorage(propertyType))
{
case StorageType.Boolean:
return(XmlConstants.EdmBooleanTypeName);
case StorageType.Byte:
return(XmlConstants.EdmByteTypeName);
#if !ASTORIA_LIGHT // System.Data.Linq not available
case StorageType.Binary:
#endif
case StorageType.ByteArray:
return(XmlConstants.EdmBinaryTypeName);
case StorageType.DateTime:
return(XmlConstants.EdmDateTimeTypeName);
case StorageType.Decimal:
return(XmlConstants.EdmDecimalTypeName);
case StorageType.Double:
return(XmlConstants.EdmDoubleTypeName);
case StorageType.Guid:
return(XmlConstants.EdmGuidTypeName);
case StorageType.Int16:
return(XmlConstants.EdmInt16TypeName);
case StorageType.Int32:
return(XmlConstants.EdmInt32TypeName);
case StorageType.Int64:
return(XmlConstants.EdmInt64TypeName);
case StorageType.Single:
return(XmlConstants.EdmSingleTypeName);
case StorageType.SByte:
return(XmlConstants.EdmSByteTypeName);
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));
case StorageType.Char:
case StorageType.CharArray:
case StorageType.String:
case StorageType.Type:
case StorageType.Uri:
case StorageType.XDocument:
case StorageType.XElement:
return(null); // returning null which implies typeof(string)
default:
Debug.Assert(false, "knowntype without reverse mapping");
return(null);
}
}
