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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
// 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
{
// Gets the collection element type.
public static Type GetInnerElementType(this Type type)
{
Type elementType;
type.IsCollection(out elementType);
Contract.Assert(elementType != null);
return elementType;
}
public static bool IsCollection(this Type type)
{
Type elementType;
return type.IsCollection(out elementType);
}
public static bool IsCollection(this Type type, out Type elementType)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
elementType = type;
// see if this type should be ignored.
if (type == typeof(string))
{
return false;
}
Type collectionInterface
= type.GetInterfaces()
.Union(new[] { type })
.FirstOrDefault(
t => t.IsGenericType
&& t.GetGenericTypeDefinition() == typeof(IEnumerable<>));
if (collectionInterface != null)
{
elementType = collectionInterface.GetGenericArguments().Single();
return true;
}
return false;
}
/// <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;
}
}
}
|
