1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using System.Web.Http.Dispatcher;
using System.Web.Http.OData.Formatter;
namespace System.Web.Http
{
internal static class TypeHelper
{
/// <summary>
/// Determines whether the given type is a primitive type or
/// is a <see cref="string"/>, <see cref="DateTime"/>, <see cref="Decimal"/>,
/// <see cref="Guid"/>, <see cref="DateTimeOffset"/> or <see cref="TimeSpan"/>.
/// </summary>
/// <param name="type">The type</param>
/// <returns><c>true</c> if the type is a primitive type.</returns>
internal static bool IsQueryPrimitiveType(Type type)
{
Contract.Assert(type != null);
type = GetInnerMostElementType(type);
return type.IsEnum ||
type.IsPrimitive ||
type == typeof(Uri) ||
(EdmLibHelpers.GetEdmPrimitiveTypeOrNull(type) != null);
}
/// <summary>
/// Returns the innermost element type for a given type, dealing with
/// nullables, arrays, etc.
/// </summary>
/// <param name="type">The type from which to get the innermost type.</param>
/// <returns>The innermost element type</returns>
internal static Type GetInnerMostElementType(Type type)
{
Contract.Assert(type != null);
while (true)
{
Type nullableUnderlyingType = Nullable.GetUnderlyingType(type);
if (nullableUnderlyingType != null)
{
type = nullableUnderlyingType;
}
else if (type.HasElementType)
{
type = type.GetElementType();
}
else
{
return type;
}
}
}
/// <summary>
/// Returns type of T if the type implements IEnumerable of T, otherwise, return null.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static Type GetImplementedIEnumerableType(Type type)
{
// get inner type from Task<T>
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>))
{
type = type.GetGenericArguments().First();
}
if (type.IsGenericType && type.IsInterface &&
(type.GetGenericTypeDefinition() == typeof(IEnumerable<>) ||
type.GetGenericTypeDefinition() == typeof(IQueryable<>)))
{
// special case the IEnumerable<T>
return GetInnerGenericType(type);
}
else
{
// for the rest of interfaces and strongly Type collections
Type[] interfaces = type.GetInterfaces();
foreach (Type interfaceType in interfaces)
{
if (interfaceType.IsGenericType &&
(interfaceType.GetGenericTypeDefinition() == typeof(IEnumerable<>) ||
interfaceType.GetGenericTypeDefinition() == typeof(IQueryable<>)))
{
// special case the IEnumerable<T>
return GetInnerGenericType(interfaceType);
}
}
}
return null;
}
[SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Catching all exceptions in this case is the right to do.")]
// This code is copied from DefaultHttpControllerTypeResolver.GetControllerTypes.
internal static IEnumerable<Type> GetLoadedTypes(IAssembliesResolver assembliesResolver)
{
List<Type> result = new List<Type>();
// Go through all assemblies referenced by the application and search for types matching a predicate
ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
Type[] exportedTypes = null;
if (assembly == null || assembly.IsDynamic)
{
// can't call GetExportedTypes on a dynamic assembly
continue;
}
try
{
exportedTypes = assembly.GetExportedTypes();
}
catch (ReflectionTypeLoadException ex)
{
exportedTypes = ex.Types;
}
catch
{
continue;
}
if (exportedTypes != null)
{
result.AddRange(exportedTypes.Where(t => t != null));
}
}
return result;
}
private static Type GetInnerGenericType(Type interfaceType)
{
// Getting the type T definition if the returning type implements IEnumerable<T>
Type[] parameterTypes = interfaceType.GetGenericArguments();
if (parameterTypes.Length == 1)
{
return parameterTypes[0];
}
return null;
}
}
}
|
