1394 lines
52 KiB
C#
1394 lines
52 KiB
C#
/*
|
||
Copyright (c) Microsoft Corporation
|
||
|
||
All rights reserved.
|
||
|
||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
|
||
compliance with the License. You may obtain a copy of the License
|
||
at http://www.apache.org/licenses/LICENSE-2.0
|
||
|
||
|
||
THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
|
||
EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF
|
||
TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
|
||
|
||
|
||
See the Apache Version 2.0 License for specific language governing permissions and
|
||
limitations under the License.
|
||
|
||
*/
|
||
|
||
//
|
||
// <20> Microsoft Corporation. All rights reserved.
|
||
//
|
||
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Text;
|
||
using System.Linq;
|
||
using System.Linq.Expressions;
|
||
using System.Reflection;
|
||
using System.Reflection.Emit;
|
||
using System.Runtime.Serialization;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Data.SqlTypes;
|
||
using System.Diagnostics;
|
||
using Microsoft.Research.DryadLinq.Internal;
|
||
|
||
namespace Microsoft.Research.DryadLinq
|
||
{
|
||
internal class TypeHelper<T>
|
||
{
|
||
private static T instanceHandle = (T)System.Runtime.Serialization.FormatterServices.GetUninitializedObject(typeof(T));
|
||
|
||
// Return the instance of type T created as a handle
|
||
internal static T InstanceHandle
|
||
{
|
||
get { return instanceHandle; }
|
||
}
|
||
|
||
// Create a new fresh instance of type T
|
||
internal static T Instance
|
||
{
|
||
get { return (T)System.Runtime.Serialization.FormatterServices.GetUninitializedObject(typeof(T)); }
|
||
}
|
||
}
|
||
|
||
internal class IdentityFunction
|
||
{
|
||
internal static LambdaExpression Instance(Type type, string paramName)
|
||
{
|
||
ParameterExpression param = Expression.Parameter(type, paramName);
|
||
Type delegateType = typeof(Func<,>).MakeGenericType(type, type);
|
||
return Expression.Lambda(delegateType, param, param);
|
||
}
|
||
|
||
internal static LambdaExpression Instance(Type type)
|
||
{
|
||
return IdentityFunction.Instance(type, "x");
|
||
}
|
||
|
||
internal static bool IsIdentity(LambdaExpression expr)
|
||
{
|
||
return (expr.Parameters.Count == 1 &&
|
||
expr.Parameters[0] == expr.Body);
|
||
}
|
||
}
|
||
|
||
internal static class TypeSystem
|
||
{
|
||
private static Dictionary<Type, int> s_sizeOfKnownTypes;
|
||
private static HashSet<string> s_systemAssemblies;
|
||
|
||
static TypeSystem()
|
||
{
|
||
//
|
||
// Add the sizes of built in types into s_sizeOfKnownTypes. Entries in this dictionary will be
|
||
// used by TypeSystem.GetSize() to compute the fixed size of a TRecord.
|
||
// TypeSystem.GetSize() returns -1 if the type's size isn't fixed due to a variable size field it contains.
|
||
// To support that, we add -1 entries in s_sizeOfKnownTypes for string and object.
|
||
//
|
||
s_sizeOfKnownTypes = new Dictionary<Type, int>(20);
|
||
s_sizeOfKnownTypes.Add(typeof(bool), sizeof(bool));
|
||
s_sizeOfKnownTypes.Add(typeof(char), sizeof(char));
|
||
s_sizeOfKnownTypes.Add(typeof(sbyte), sizeof(sbyte));
|
||
s_sizeOfKnownTypes.Add(typeof(byte), sizeof(byte));
|
||
s_sizeOfKnownTypes.Add(typeof(short), sizeof(Int16));
|
||
s_sizeOfKnownTypes.Add(typeof(ushort), sizeof(UInt16));
|
||
s_sizeOfKnownTypes.Add(typeof(int), sizeof(Int32));
|
||
s_sizeOfKnownTypes.Add(typeof(uint), sizeof(UInt32));
|
||
s_sizeOfKnownTypes.Add(typeof(long), sizeof(Int64));
|
||
s_sizeOfKnownTypes.Add(typeof(ulong),sizeof(UInt64));
|
||
s_sizeOfKnownTypes.Add(typeof(float), sizeof(float));
|
||
s_sizeOfKnownTypes.Add(typeof(double), sizeof(double));
|
||
s_sizeOfKnownTypes.Add(typeof(decimal), sizeof(decimal));
|
||
s_sizeOfKnownTypes.Add(typeof(DateTime), sizeof(Int64));
|
||
s_sizeOfKnownTypes.Add(typeof(SqlDateTime), sizeof(Int64));
|
||
s_sizeOfKnownTypes.Add(typeof(string), -1);
|
||
s_sizeOfKnownTypes.Add(typeof(object), -1);
|
||
|
||
s_systemAssemblies = new HashSet<string>();
|
||
s_systemAssemblies.Add("mscorlib");
|
||
s_systemAssemblies.Add("System");
|
||
s_systemAssemblies.Add("Accessibility");
|
||
s_systemAssemblies.Add("SMDiagnostics");
|
||
}
|
||
|
||
internal static IEnumerable<string> GetLoadedNonSystemAssemblyPaths()
|
||
{
|
||
List<string> names = new List<string>();
|
||
foreach (Assembly asm in TypeSystem.GetAllAssemblies())
|
||
{
|
||
if (!TypeSystem.IsSystemAssembly(asm))
|
||
{
|
||
names.Add(asm.Location);
|
||
}
|
||
}
|
||
return names.ToArray();
|
||
}
|
||
|
||
internal static bool IsSystemAssembly(Assembly asm)
|
||
{
|
||
string name = asm.GetName().Name;
|
||
return (s_systemAssemblies.Contains(name) ||
|
||
name.StartsWith("Microsoft.", StringComparison.Ordinal) ||
|
||
name.StartsWith("System.", StringComparison.Ordinal) ||
|
||
name == "WindowsBase");
|
||
}
|
||
|
||
internal static Type FindGenericType(Type definition, Type type)
|
||
{
|
||
while (type != null && type != typeof(object))
|
||
{
|
||
if (type.IsGenericType && type.GetGenericTypeDefinition() == definition)
|
||
{
|
||
return type;
|
||
}
|
||
if (definition.IsInterface)
|
||
{
|
||
foreach (Type itype in type.GetInterfaces())
|
||
{
|
||
Type found = FindGenericType(definition, itype);
|
||
if (found != null)
|
||
{
|
||
return found;
|
||
}
|
||
}
|
||
}
|
||
type = type.BaseType;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
internal static Type GetElementType(Type seqType)
|
||
{
|
||
Type ienumType = FindGenericType(typeof(IEnumerable<>), seqType);
|
||
if (ienumType == null)
|
||
{
|
||
return seqType;
|
||
}
|
||
return ienumType.GetGenericArguments()[0];
|
||
}
|
||
|
||
internal static bool IsSameOrSubclass(Type type, Type subType)
|
||
{
|
||
return (type == subType) || subType.IsSubclassOf(type);
|
||
}
|
||
|
||
// This should be the only method used to find out the real type.
|
||
internal static bool IsRealType(Type type)
|
||
{
|
||
if (type.IsAbstract)
|
||
{
|
||
if (type.IsGenericType)
|
||
{
|
||
Type typedef = type.GetGenericTypeDefinition();
|
||
if (typedef == typeof(IGrouping<,>) ||
|
||
typedef == typeof(IEnumerable<>) ||
|
||
typedef == typeof(IList<>))
|
||
{
|
||
return type.GetGenericArguments().All(x => IsRealType(x));
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
return (!type.IsGenericType ||
|
||
type.GetGenericArguments().All(x => IsRealType(x)));
|
||
|
||
}
|
||
|
||
internal static int GetInMemSize(Type type)
|
||
{
|
||
if (!type.IsValueType) return 8;
|
||
|
||
int size = 0;
|
||
bool found = s_sizeOfKnownTypes.TryGetValue(type, out size);
|
||
if (found) return size;
|
||
|
||
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
||
foreach (FieldInfo field in fields)
|
||
{
|
||
size += GetInMemSize(field.FieldType);
|
||
}
|
||
return size;
|
||
}
|
||
|
||
// Returns the size of the type if it has a fixed layout.
|
||
// Returns -1 if the type has a variable size (due to fields of string, object or arrays)
|
||
// Note that this is the number of bytes used by DryadLINQ serialization
|
||
internal static int GetSize(Type type)
|
||
{
|
||
return GetSize(type, new Dictionary<Type, int>());
|
||
}
|
||
|
||
private static int GetSize(Type type, Dictionary<Type, int> typeSizeMap)
|
||
{
|
||
int size = 0;
|
||
bool found = s_sizeOfKnownTypes.TryGetValue(type, out size);
|
||
if (found) return size;
|
||
found = typeSizeMap.TryGetValue(type, out size);
|
||
if (found) return size;
|
||
|
||
if (type.IsArray) return -1;
|
||
|
||
typeSizeMap[type] = -1;
|
||
size = 0;
|
||
FieldInfo[] fields = type.GetFields(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
|
||
foreach (FieldInfo field in fields)
|
||
{
|
||
int fsize = GetSize(field.FieldType, typeSizeMap);
|
||
if (fsize == -1) return -1;
|
||
size += fsize;
|
||
}
|
||
typeSizeMap[type] = size;
|
||
return size;
|
||
}
|
||
|
||
internal static bool StructContainsNoReference(Type type)
|
||
{
|
||
if (!type.IsValueType) return false;
|
||
|
||
int size = 0;
|
||
bool found = s_sizeOfKnownTypes.TryGetValue(type, out size);
|
||
if (found) return true;
|
||
|
||
FieldInfo[] fields = type.GetFields(BindingFlags.Instance|BindingFlags.Public|BindingFlags.NonPublic);
|
||
foreach (FieldInfo finfo in fields)
|
||
{
|
||
if (!StructContainsNoReference(finfo.FieldType)) return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
internal static bool ContainsNoLazyValue(Type type)
|
||
{
|
||
return ContainsNoLazyValue(type, new HashSet<Type>());
|
||
}
|
||
|
||
internal static bool ContainsNoLazyValue(Type type, HashSet<Type> seen)
|
||
{
|
||
while (type.IsArray)
|
||
{
|
||
type = type.GetElementType();
|
||
}
|
||
if (type.IsPrimitive ||
|
||
seen.Contains(type) ||
|
||
type == typeof(System.Reflection.Pointer))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (typeof(IEnumerable).IsAssignableFrom(type) &&
|
||
!typeof(IList).IsAssignableFrom(type))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
seen.Add(type);
|
||
FieldInfo[] finfos = TypeSystem.GetAllFields(type);
|
||
foreach (FieldInfo finfo in finfos)
|
||
{
|
||
if (!ContainsNoLazyValue(finfo.FieldType, seen))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Returns true iff the method is a property.
|
||
internal static bool IsProperty(MethodInfo minfo)
|
||
{
|
||
if (minfo.Name.StartsWith("get_", StringComparison.Ordinal))
|
||
{
|
||
Type declType = minfo.DeclaringType;
|
||
ParameterInfo[] paramInfos = minfo.GetParameters();
|
||
|
||
PropertyInfo[] pinfos = declType.GetProperties();
|
||
foreach (var pinfo in pinfos)
|
||
{
|
||
MethodInfo[] accessors = pinfo.GetAccessors();
|
||
foreach (MethodInfo ac in accessors)
|
||
{
|
||
if (ac.Name == minfo.Name)
|
||
{
|
||
ParameterInfo[] paramInfos1 = ac.GetParameters();
|
||
if (paramInfos.Length != paramInfos1.Length) break;
|
||
for (int i = 0; i < paramInfos.Length; i++)
|
||
{
|
||
if (paramInfos[i].ParameterType != paramInfos1[i].ParameterType) break;
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Compare two assemblies for equality.
|
||
/// </summary>
|
||
internal class AssemblyComparer : IEqualityComparer<Assembly>
|
||
{
|
||
public bool Equals(Assembly x, Assembly y)
|
||
{
|
||
// some Assembly objects loaded as reflection only may have different pointers
|
||
// what matters is that their fully qualified names match
|
||
|
||
return ReferenceEquals(x, y) || x.FullName == y.FullName;
|
||
}
|
||
|
||
public int GetHashCode(Assembly obj)
|
||
{
|
||
return obj.FullName.GetHashCode();
|
||
}
|
||
}
|
||
|
||
private static bool IsDynamicAssembly(Assembly asm)
|
||
{
|
||
if (asm is AssemblyBuilder) return true;
|
||
|
||
try
|
||
{
|
||
if (asm.Location != null) return false;
|
||
}
|
||
catch
|
||
{
|
||
// if we get an exception from asm.Location it's a dynamic assembly.
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static HashSet<Assembly> s_allReferencedAssemblies = null;
|
||
|
||
/// <summary>
|
||
/// Compute all referenced assemblies (transitive closure) and cache them.
|
||
/// </summary>
|
||
/// <returns>List of all referenced assemblies.</returns>
|
||
internal static HashSet<Assembly> GetAllAssemblies()
|
||
{
|
||
if (s_allReferencedAssemblies == null)
|
||
{
|
||
// compute transitive closure
|
||
HashSet<Assembly> referencedAssemblies = new HashSet<Assembly>(new AssemblyComparer());
|
||
Queue<Assembly> toscan = new Queue<Assembly>(10);
|
||
|
||
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
|
||
foreach (Assembly asm in assemblies)
|
||
{
|
||
if (!referencedAssemblies.Contains(asm) && !IsDynamicAssembly(asm))
|
||
{
|
||
toscan.Enqueue(asm);
|
||
referencedAssemblies.Add(asm);
|
||
}
|
||
}
|
||
|
||
while (toscan.Count > 0)
|
||
{
|
||
Assembly asm = toscan.Dequeue();
|
||
AssemblyName[] names = asm.GetReferencedAssemblies();
|
||
foreach (AssemblyName asmName in names)
|
||
{
|
||
try
|
||
{
|
||
Assembly refAssembly = Assembly.ReflectionOnlyLoad(asmName.FullName);
|
||
if (!referencedAssemblies.Contains(refAssembly))
|
||
{
|
||
toscan.Enqueue(refAssembly);
|
||
referencedAssemblies.Add(refAssembly);
|
||
}
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// Console.WriteLine("Warning: Could not load referenced assembly " + asmName);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Due to the use of FullName in the ReflectionOnlyLoad call, we may end up with multiple versions of the same assembly in the list
|
||
// if the client is running against a newer .NET version than what Microsoft.Research.DryadLinq.DLL is compiled against
|
||
// We need to filter the list by selecting the newest version of each assembly
|
||
var newestAssemblies = referencedAssemblies.GroupBy(asm => asm.GetName().Name).Select(grp => grp.OrderByDescending(asm => asm.GetName().Version).First());
|
||
s_allReferencedAssemblies = new HashSet<Assembly>(new AssemblyComparer());
|
||
foreach (var asm in newestAssemblies)
|
||
{
|
||
s_allReferencedAssemblies.Add(asm);
|
||
}
|
||
}
|
||
return s_allReferencedAssemblies;
|
||
}
|
||
|
||
private static Dictionary<Type, Type[]> s_typeMap = null;
|
||
|
||
internal static Dictionary<Type, Type[]> BuildTypeHierarchy()
|
||
{
|
||
if (s_typeMap != null) return s_typeMap;
|
||
|
||
Dictionary<Type, Type[]> typeMap = new Dictionary<Type, Type[]>();
|
||
HashSet<Assembly> assemblies = TypeSystem.GetAllAssemblies();
|
||
foreach (Assembly asm in assemblies)
|
||
{
|
||
foreach (Type type in asm.GetTypes())
|
||
{
|
||
if (!type.IsInterface)
|
||
{
|
||
Type[] baseTypes = type.GetInterfaces();
|
||
if (type.BaseType != null && type.BaseType != typeof(object))
|
||
{
|
||
Type[] newBaseTypes = new Type[baseTypes.Length + 1];
|
||
Array.Copy(baseTypes, newBaseTypes, baseTypes.Length);
|
||
newBaseTypes[baseTypes.Length] = type.BaseType;
|
||
baseTypes = newBaseTypes;
|
||
}
|
||
for (int i = 0; i < baseTypes.Length; i++)
|
||
{
|
||
Type baseType = baseTypes[i];
|
||
if (baseType.IsGenericType)
|
||
{
|
||
baseType = baseType.GetGenericTypeDefinition();
|
||
baseTypes[i] = baseType;
|
||
}
|
||
|
||
bool isNew = true;
|
||
for (int j = 0; j < i; j++)
|
||
{
|
||
if (baseTypes[j] == baseType)
|
||
{
|
||
isNew = false;
|
||
break;
|
||
}
|
||
}
|
||
if (isNew)
|
||
{
|
||
Type[] deriveds = null;
|
||
if (typeMap.TryGetValue(baseType, out deriveds))
|
||
{
|
||
Type[] newDeriveds = new Type[deriveds.Length + 1];
|
||
Array.Copy(deriveds, newDeriveds, deriveds.Length);
|
||
newDeriveds[deriveds.Length] = type;
|
||
deriveds = newDeriveds;
|
||
}
|
||
else
|
||
{
|
||
deriveds = new Type[1] { type };
|
||
}
|
||
typeMap[baseType] = deriveds;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
s_typeMap = typeMap;
|
||
return s_typeMap;
|
||
}
|
||
|
||
internal static bool HasSubtypes(Type type)
|
||
{
|
||
Type typeDef = type;
|
||
if (type.IsGenericType)
|
||
{
|
||
typeDef = type.GetGenericTypeDefinition();
|
||
}
|
||
Dictionary<Type, Type[]> typeMap = TypeSystem.BuildTypeHierarchy();
|
||
return typeMap.ContainsKey(typeDef);
|
||
}
|
||
|
||
internal static bool IsASubType(Type type)
|
||
{
|
||
return (type.BaseType != null &&
|
||
type.BaseType != typeof(object) &&
|
||
!(typeof(System.ValueType).IsAssignableFrom(type.BaseType)) &&
|
||
!type.IsArray);
|
||
}
|
||
|
||
internal static Type GetType(string name)
|
||
{
|
||
Type type = null;
|
||
Assembly callingAssembly = Assembly.GetCallingAssembly();
|
||
if (callingAssembly != null)
|
||
{
|
||
type = callingAssembly.GetType(name);
|
||
if (type != null) return type;
|
||
}
|
||
Assembly executingAssembly = Assembly.GetExecutingAssembly();
|
||
if (executingAssembly != null)
|
||
{
|
||
type = executingAssembly.GetType(name);
|
||
if (type != null) return type;
|
||
}
|
||
Assembly entryAssembly = Assembly.GetEntryAssembly();
|
||
if (entryAssembly != null)
|
||
{
|
||
type = entryAssembly.GetType(name);
|
||
if (type != null) return type;
|
||
}
|
||
|
||
foreach (Assembly asm in GetAllAssemblies())
|
||
{
|
||
type = asm.GetType(name);
|
||
if (type != null) return type;
|
||
}
|
||
return type;
|
||
}
|
||
|
||
// Get the current value of a static field
|
||
internal static object GetFieldValue(string name)
|
||
{
|
||
int idx = name.LastIndexOf('.');
|
||
if (idx <= 0)
|
||
{
|
||
throw new ArgumentException("Internal: The argument is not a reference to static field");
|
||
}
|
||
string tname = name.Substring(0, idx);
|
||
string fname = name.Substring(idx+1);
|
||
|
||
Type type = TypeSystem.GetType(tname);
|
||
if (type == null)
|
||
{
|
||
throw new ArgumentException("Internal: The argument is not a reference to static field");
|
||
}
|
||
FieldInfo finfo = type.GetField(fname);
|
||
if (finfo == null || !finfo.IsStatic)
|
||
{
|
||
throw new ArgumentException("Internal: The argument is not a reference to static field");
|
||
}
|
||
return finfo.GetValue(null);
|
||
}
|
||
|
||
internal static LambdaExpression GetExpression(string name)
|
||
{
|
||
if (name == null) return null;
|
||
object val = TypeSystem.GetFieldValue(name);
|
||
if (val == null)
|
||
{
|
||
throw new ArgumentException("Internal: The argument is not defined");
|
||
}
|
||
if (!(val is LambdaExpression))
|
||
{
|
||
throw new ArgumentException("Internal: The argument is not a lambda expression");
|
||
}
|
||
return (LambdaExpression)val;
|
||
}
|
||
|
||
internal static MethodInfo FindStaticMethod(Type type, string name, Type[] paramTypes, params Type[] genericTypeArgs)
|
||
{
|
||
MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public);
|
||
foreach (MethodInfo minfo in methods)
|
||
{
|
||
if (minfo.Name == name)
|
||
{
|
||
MethodInfo matchedInfo = MatchArgs(minfo, paramTypes, genericTypeArgs);
|
||
if (matchedInfo != null)
|
||
{
|
||
return matchedInfo;
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
internal static MethodInfo FindStaticMethod(string methodName, Type[] paramTypes)
|
||
{
|
||
int index = methodName.LastIndexOf('.');
|
||
if (index == -1) return null;
|
||
|
||
string className = methodName.Substring(0, index);
|
||
methodName = methodName.Substring(index + 1);
|
||
Type classType = TypeSystem.GetType(className);
|
||
if (classType == null) return null;
|
||
return TypeSystem.FindStaticMethod(classType, methodName, paramTypes);
|
||
}
|
||
|
||
private static MethodInfo MatchArgs(MethodInfo minfo, Type[] paramTypes, Type[] genericTypeArgs)
|
||
{
|
||
ParameterInfo[] mParams = minfo.GetParameters();
|
||
if (mParams.Length != paramTypes.Length)
|
||
{
|
||
return null;
|
||
}
|
||
if (!minfo.IsGenericMethodDefinition && minfo.IsGenericMethod && minfo.ContainsGenericParameters)
|
||
{
|
||
minfo = minfo.GetGenericMethodDefinition();
|
||
}
|
||
if (minfo.IsGenericMethodDefinition)
|
||
{
|
||
if (genericTypeArgs == null ||
|
||
genericTypeArgs.Length == 0 ||
|
||
minfo.GetGenericArguments().Length != genericTypeArgs.Length)
|
||
{
|
||
return null;
|
||
}
|
||
minfo = minfo.MakeGenericMethod(genericTypeArgs);
|
||
mParams = minfo.GetParameters();
|
||
}
|
||
else if (genericTypeArgs != null && genericTypeArgs.Length > 0)
|
||
{
|
||
return null;
|
||
}
|
||
for (int i = 0; i < paramTypes.Length; i++)
|
||
{
|
||
Type parameterType = mParams[i].ParameterType;
|
||
if (parameterType == null ||
|
||
(paramTypes[i].IsByRef && parameterType != paramTypes[i]) ||
|
||
!parameterType.IsAssignableFrom(paramTypes[i]))
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
return minfo;
|
||
}
|
||
|
||
internal static string TypeName(Type type)
|
||
{
|
||
return TypeName(type, new Dictionary<Type, string>());
|
||
}
|
||
|
||
internal static string TypeName(Type type, Dictionary<Type, string> typeToName)
|
||
{
|
||
string name = null;
|
||
if (typeToName.TryGetValue(type, out name))
|
||
{
|
||
return name;
|
||
}
|
||
|
||
if (type.IsGenericParameter)
|
||
{
|
||
return type.Name;
|
||
}
|
||
|
||
if (type.IsArray)
|
||
{
|
||
Type baseType = type.GetElementType();
|
||
while (baseType.IsArray)
|
||
{
|
||
baseType = baseType.GetElementType();
|
||
}
|
||
string tname = TypeName(baseType, typeToName);
|
||
|
||
Type elemType = type;
|
||
do
|
||
{
|
||
string ranks = new string(',', (elemType.GetArrayRank() - 1));
|
||
tname += "[" + ranks + "]";
|
||
elemType = elemType.GetElementType();
|
||
}
|
||
while (elemType.IsArray);
|
||
return tname;
|
||
}
|
||
|
||
List<Type> nestedTypes = new List<Type>();
|
||
nestedTypes.Add(type);
|
||
Type declaringType = type;
|
||
while (declaringType.IsNested)
|
||
{
|
||
declaringType = declaringType.DeclaringType;
|
||
nestedTypes.Add(declaringType);
|
||
}
|
||
|
||
StringBuilder processedName = new StringBuilder();
|
||
Type[] typeArgs = type.GetGenericArguments();
|
||
int typeArgIndex = 0;
|
||
bool isFirst = true;
|
||
for (int i = nestedTypes.Count - 1; i >= 0; i--)
|
||
{
|
||
Type curType = nestedTypes[i];
|
||
name = (curType.IsNested) ? curType.Name : curType.FullName;
|
||
|
||
int lastIndex = name.IndexOf('`');
|
||
if (lastIndex != -1)
|
||
{
|
||
name = name.Substring(0, lastIndex);
|
||
}
|
||
if (isFirst)
|
||
{
|
||
isFirst = false;
|
||
}
|
||
else
|
||
{
|
||
processedName.Append('.');
|
||
}
|
||
processedName.Append(name);
|
||
|
||
if (curType.IsGenericType)
|
||
{
|
||
int len = curType.GetGenericArguments().Length;
|
||
if (typeArgIndex < len)
|
||
{
|
||
processedName.Append('<');
|
||
processedName.Append(TypeName(typeArgs[typeArgIndex], typeToName));
|
||
typeArgIndex++;
|
||
while (typeArgIndex < len)
|
||
{
|
||
processedName.Append(',');
|
||
processedName.Append(TypeName(typeArgs[typeArgIndex], typeToName));
|
||
typeArgIndex++;
|
||
}
|
||
processedName.Append('>');
|
||
}
|
||
}
|
||
}
|
||
|
||
return processedName.ToString();
|
||
}
|
||
|
||
internal static IComparer<T> GetComparer<T>(object comparer)
|
||
{
|
||
IComparer<T> res = comparer as IComparer<T>;
|
||
if (res == null && HasDefaultComparer(typeof(T)))
|
||
{
|
||
if (typeof(T) == typeof(string))
|
||
{
|
||
res = (IComparer<T>)StringComparer.Ordinal;
|
||
}
|
||
else
|
||
{
|
||
res = Comparer<T>.Default;
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
internal static bool IsComparer(object comparer, Type type)
|
||
{
|
||
Type comparerType = comparer.GetType();
|
||
return typeof(IComparer<>).MakeGenericType(type).IsAssignableFrom(comparerType);
|
||
}
|
||
|
||
internal static IEqualityComparer<T> GetEqualityComparer<T>(object comparer)
|
||
{
|
||
IEqualityComparer<T> res = comparer as IEqualityComparer<T>;
|
||
if (res == null && HasDefaultEqualityComparer(typeof(T)))
|
||
{
|
||
res = EqualityComparer<T>.Default;
|
||
}
|
||
return res;
|
||
}
|
||
|
||
internal static bool IsEqualityComparer(object comparer, Type type)
|
||
{
|
||
Type comparerType = comparer.GetType();
|
||
return typeof(IEqualityComparer<>).MakeGenericType(type).IsAssignableFrom(comparerType);
|
||
}
|
||
|
||
internal static bool HasDefaultComparer(Type type)
|
||
{
|
||
// true if T implements IComparable<T>
|
||
if (typeof(IComparable<>).MakeGenericType(type).IsAssignableFrom(type))
|
||
{
|
||
return true;
|
||
}
|
||
// true if T is a Nullable<U> where U implements IComparable<U>
|
||
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
|
||
{
|
||
Type u = type.GetGenericArguments()[0];
|
||
if (typeof(IComparable<>).MakeGenericType(u).IsAssignableFrom(u))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
// true if T implements IComparable
|
||
return typeof(IComparable).IsAssignableFrom(type);
|
||
}
|
||
|
||
internal static bool HasDefaultEqualityComparer(Type type)
|
||
{
|
||
// true if T implements IEquatable<T>
|
||
if (typeof(IEquatable<>).MakeGenericType(type).IsAssignableFrom(type))
|
||
{
|
||
return HasOverrideHashCode(type);
|
||
}
|
||
// true if T is a Nullable<U> where U implements IEquatable<U>
|
||
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
|
||
{
|
||
Type u = type.GetGenericArguments()[0];
|
||
if (typeof(IEquatable<>).MakeGenericType(u).IsAssignableFrom(u))
|
||
{
|
||
return HasOverrideHashCode(type);
|
||
}
|
||
}
|
||
// true if Equals is overridden in T
|
||
if (type.IsAbstract)
|
||
{
|
||
Dictionary<Type, Type[]> typeMap = BuildTypeHierarchy();
|
||
Type[] subtypes;
|
||
if (typeMap.TryGetValue(type, out subtypes))
|
||
{
|
||
foreach (Type subtype in subtypes)
|
||
{
|
||
if (!HasDefaultEqualityComparer(subtype))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
MethodInfo minfo = type.GetMethod("Equals", new Type[] { typeof(object) });
|
||
if (minfo.DeclaringType != type)
|
||
{
|
||
return false;
|
||
}
|
||
minfo = type.GetMethod("GetHashCode");
|
||
if (minfo.DeclaringType != type)
|
||
{
|
||
return false;
|
||
}
|
||
if (type.IsGenericType)
|
||
{
|
||
Type[] typeArgs = type.GetGenericArguments();
|
||
foreach (Type targ in typeArgs)
|
||
{
|
||
if (!HasDefaultEqualityComparer(targ))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private static bool HasOverrideHashCode(Type type)
|
||
{
|
||
if (type.IsAbstract)
|
||
{
|
||
Dictionary<Type, Type[]> typeMap = BuildTypeHierarchy();
|
||
Type[] subtypes;
|
||
if (typeMap.TryGetValue(type, out subtypes))
|
||
{
|
||
foreach (Type subtype in subtypes)
|
||
{
|
||
if (!HasOverrideHashCode(subtype))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
MethodInfo minfo = type.GetMethod("GetHashCode");
|
||
if (minfo.DeclaringType != type)
|
||
{
|
||
return false;
|
||
}
|
||
if (type.IsGenericType)
|
||
{
|
||
Type[] typeArgs = type.GetGenericArguments();
|
||
foreach (Type targ in typeArgs)
|
||
{
|
||
if (!HasOverrideHashCode(targ))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
internal static bool IsTypeSerializable(Type type)
|
||
{
|
||
return (!type.IsPointer &&
|
||
type != typeof(IntPtr) &&
|
||
!typeof(System.Delegate).IsAssignableFrom(type));
|
||
}
|
||
|
||
internal static bool IsFieldSerialized(FieldInfo finfo)
|
||
{
|
||
return (finfo.Attributes & FieldAttributes.NotSerialized) != FieldAttributes.NotSerialized;
|
||
}
|
||
|
||
internal static Type GetNonserializable(object obj)
|
||
{
|
||
return GetNonserializable(obj, new HashSet<object>(new ReferenceEqualityComparer<object>()));
|
||
}
|
||
|
||
internal static Type GetNonserializable(object obj, HashSet<object> seen)
|
||
{
|
||
if (obj == null || seen.Contains(obj))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
Type type = obj.GetType();
|
||
if (type.IsPrimitive)
|
||
{
|
||
return null;
|
||
}
|
||
if (!type.IsSerializable)
|
||
{
|
||
return type;
|
||
}
|
||
Type[] argTypes = new Type[] { typeof(SerializationInfo), typeof(StreamingContext) };
|
||
if (type.GetMethod("GetObjectData", argTypes) != null)
|
||
{
|
||
return null;
|
||
}
|
||
if (type.IsArray)
|
||
{
|
||
return GetTypeNonserializable(type);
|
||
}
|
||
seen.Add(obj);
|
||
FieldInfo[] fields = GetAllFields(type);
|
||
foreach (FieldInfo finfo in fields)
|
||
{
|
||
if ((finfo.Attributes & FieldAttributes.NotSerialized) != FieldAttributes.NotSerialized)
|
||
{
|
||
object fval = finfo.GetValue(obj);
|
||
if (!(fval is Pointer))
|
||
{
|
||
type = GetNonserializable(fval, seen);
|
||
if (type != null)
|
||
{
|
||
return type;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
internal static Type GetTypeNonserializable(Type type)
|
||
{
|
||
return GetTypeNonserializable(type, new HashSet<Type>());
|
||
}
|
||
|
||
internal static Type GetTypeNonserializable(Type type, HashSet<Type> seen)
|
||
{
|
||
while (type.IsArray)
|
||
{
|
||
type = type.GetElementType();
|
||
}
|
||
if (type.IsPrimitive || seen.Contains(type))
|
||
{
|
||
return null;
|
||
}
|
||
if (!type.IsSerializable)
|
||
{
|
||
return type;
|
||
}
|
||
Type[] argTypes = new Type[] { typeof(SerializationInfo), typeof(StreamingContext) };
|
||
if (type.GetMethod("GetObjectData", argTypes) != null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
seen.Add(type);
|
||
FieldInfo[] fields = GetAllFields(type);
|
||
foreach (FieldInfo finfo in fields)
|
||
{
|
||
if ((finfo.Attributes & FieldAttributes.NotSerialized) != FieldAttributes.NotSerialized)
|
||
{
|
||
if (finfo.FieldType != typeof(System.Reflection.Pointer))
|
||
{
|
||
type = GetTypeNonserializable(finfo.FieldType, seen);
|
||
if (type != null)
|
||
{
|
||
return type;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
internal static bool IsQueryOperatorCall(MethodCallExpression expression)
|
||
{
|
||
Type declType = expression.Method.DeclaringType;
|
||
return (declType == typeof(System.Linq.Enumerable) ||
|
||
declType == typeof(System.Linq.Queryable) ||
|
||
declType == typeof(Microsoft.Research.DryadLinq.HpcLinqQueryable));
|
||
}
|
||
|
||
internal static FieldInfo[] GetAllFields(Type type)
|
||
{
|
||
List<FieldInfo> res = new List<FieldInfo>();
|
||
while (type != typeof(object) && type != null)
|
||
{
|
||
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
|
||
foreach (FieldInfo finfo in fields)
|
||
{
|
||
if (finfo.DeclaringType == type)
|
||
{
|
||
res.Add(finfo);
|
||
}
|
||
}
|
||
type = type.BaseType;
|
||
}
|
||
return res.ToArray();
|
||
}
|
||
|
||
internal static bool HasFieldOfNonPublicType(Type type)
|
||
{
|
||
FieldInfo[] fields = GetAllFields(type);
|
||
foreach (FieldInfo finfo in fields)
|
||
{
|
||
if (!finfo.FieldType.IsPublic && !finfo.FieldType.IsNestedPublic)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
|
||
// Checks whether the given type contains a field that refers to itself. Fields will be traversed recursively, and any field that referes back to
|
||
// the original type (either as a direct reference, or as an array reference) will cause the check to return true. Static fields are skipped.
|
||
//
|
||
// However types of the fields traversed will not be checked for circularity themselves. This is meant to allow the user to handle a circular UDT
|
||
// with a custom serializer, and still rely on autoserialization for types that contain it.
|
||
// See last example below for this case.. B is circular, and A contains B. If B has a custom serializer, A can still be autoserialized.
|
||
//
|
||
// But such "contained circularity" (e.g. B or C) doesn't escape the check in case there are no custom serializers involved,
|
||
// because codegen has to call IsCircular for each of those contained circular types before generating autoserializaton code for them.
|
||
//
|
||
// Here are some examples:
|
||
//
|
||
// class A { A m_f1;} => returns TRUE for class A
|
||
// class A { A[] m_f1;} => returns TRUE for class A
|
||
// class A { B m_f1;} class B { A m_f2;} => returns TRUE for both class A and class B (both are second level circular)
|
||
// class A { B m_f1;} class B { C m_f2;} class C { B m_f3;} => returns FALSE for class A (as neither B nor C contain references to A)
|
||
// => but returns TRUE for both class B and class C (both are second level circular)
|
||
internal static bool IsCircularType(Type type)
|
||
{
|
||
return DoCircularTypeCheck(type, type, null);
|
||
}
|
||
|
||
// Returns true if "typeToCheck" contains a direct reference to "parentType", or an array of it
|
||
// The hashset visitedTypes is meant to prevent multiple visits to the same type within this recursion (allocated on demand)
|
||
private static bool DoCircularTypeCheck(Type typeToCheck, Type parentType, HashSet<Type> visitedTypes)
|
||
{
|
||
if (visitedTypes == null)
|
||
{
|
||
visitedTypes = new HashSet<Type>();
|
||
}
|
||
|
||
// if typeToCheck is in visitedTypes it means either we visited this type and haven't encountered the parent, or a visit is in progress
|
||
// In both cases it's OK to return false. If a visit is already in progress and typeToCheck is actually an offender, it will be caught in that callstack level which is performing the visit.
|
||
if (visitedTypes.Contains(typeToCheck))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Before starting to visit all fields of "typeToCheck", we need to mark it as already visited to guard against infinite recursion.
|
||
visitedTypes.Add(typeToCheck);
|
||
|
||
foreach (FieldInfo fi in typeToCheck.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly))
|
||
{
|
||
Type fieldType = fi.FieldType;
|
||
|
||
// if this field is a reference to the parentType it means parentType is circular. Return true and unwind everyone.
|
||
if (fieldType == parentType ||
|
||
(fieldType.IsArray && fieldType.GetElementType() == parentType) ||
|
||
DoCircularTypeCheck(fieldType, parentType, visitedTypes) ) // Otherwise recurse for this field's type, keeping the same parentType because
|
||
// we are only interested in whether fieldType is circular wrt parentType (we don't want to check whether fieldType is circular wrt itself)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// Assume: t1.GetGenericTypeDefinition() == t2.GetGenericTypeDefinition()
|
||
internal static bool TypeMatch(Type t1, Type t2, Dictionary<Type, Type> map)
|
||
{
|
||
Type[] typeArgs1 = t1.GetGenericArguments();
|
||
Type[] typeArgs2 = t2.GetGenericArguments();
|
||
|
||
if (typeArgs1.Length != typeArgs2.Length)
|
||
{
|
||
return false;
|
||
}
|
||
for (int i = 0; i < typeArgs1.Length; i++)
|
||
{
|
||
if (typeArgs1[i].IsGenericParameter)
|
||
{
|
||
Type t;
|
||
if (map.TryGetValue(typeArgs1[i], out t))
|
||
{
|
||
if (t != typeArgs2[i]) return false;
|
||
}
|
||
else
|
||
{
|
||
map[typeArgs1[i]] = typeArgs2[i];
|
||
}
|
||
}
|
||
else if (typeArgs1[i].ContainsGenericParameters)
|
||
{
|
||
bool matched = TypeMatch(typeArgs1[i], typeArgs2[i], map);
|
||
if (!matched) return false;
|
||
}
|
||
else if (typeArgs1[i] != typeArgs2[i])
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// Assume: type.IsGenericType
|
||
internal static Type MakeGenericInstance(Type type, Dictionary<Type, Type> map)
|
||
{
|
||
Type[] typeArgs = type.GetGenericArguments();
|
||
Type[] args = new Type[typeArgs.Length];
|
||
for (int i = 0; i < args.Length; i++)
|
||
{
|
||
if (typeArgs[i].IsGenericParameter)
|
||
{
|
||
Type t;
|
||
if (map.TryGetValue(typeArgs[i], out t))
|
||
{
|
||
args[i] = t;
|
||
}
|
||
else
|
||
{
|
||
args[i] = typeArgs[i];
|
||
}
|
||
}
|
||
else if (typeArgs[i].ContainsGenericParameters)
|
||
{
|
||
args[i] = MakeGenericInstance(typeArgs[i], map);
|
||
}
|
||
else
|
||
{
|
||
args[i] = typeArgs[i];
|
||
}
|
||
}
|
||
|
||
// kluggy, need to rewrite.
|
||
try
|
||
{
|
||
return type.GetGenericTypeDefinition().MakeGenericType(args);
|
||
}
|
||
catch (ArgumentException)
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
internal static MethodBase GetBaseMethod(Type baseType, MethodBase method)
|
||
{
|
||
if (method.IsStatic || method.IsConstructor)
|
||
{
|
||
return (method.DeclaringType == baseType) ? method : null;
|
||
}
|
||
Type[] argTypes = new Type[method.GetParameters().Length];
|
||
for (int i = 0; i < argTypes.Length; i++)
|
||
{
|
||
argTypes[i] = method.GetParameters()[i].ParameterType;
|
||
}
|
||
|
||
MethodInfo[] minfos = baseType.GetMethods(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance);
|
||
foreach (MethodInfo minfo in minfos)
|
||
{
|
||
ParameterInfo[] mparams = minfo.GetParameters();
|
||
if (minfo.Name == method.Name && mparams.Length == argTypes.Length)
|
||
{
|
||
bool found = true;
|
||
for (int i = 0; i < argTypes.Length; i++)
|
||
{
|
||
if (argTypes[i].IsGenericParameter)
|
||
{
|
||
if (!mparams[i].ParameterType.IsGenericParameter) return null;
|
||
}
|
||
else if (argTypes[i] != mparams[i].ParameterType)
|
||
{
|
||
found = false;
|
||
break;
|
||
}
|
||
}
|
||
if (found) return minfo;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
internal static List<MethodBase> GetAllOverrides(Type baseType, MethodBase method, Dictionary<Type, Type[]> typeMap)
|
||
{
|
||
List<MethodBase> methods = new List<MethodBase>();
|
||
GetAllOverrides(baseType, method, typeMap, methods);
|
||
return methods;
|
||
}
|
||
|
||
private static void GetAllOverrides(Type baseType, MethodBase method, Dictionary<Type, Type[]> typeMap, List<MethodBase> methods)
|
||
{
|
||
if (method.IsStatic || method.IsFinal || method.IsConstructor)
|
||
{
|
||
return;
|
||
}
|
||
|
||
Type type = baseType;
|
||
if (type.IsGenericType)
|
||
{
|
||
type = type.GetGenericTypeDefinition();
|
||
}
|
||
Type[] subtypes = null;
|
||
if (typeMap.TryGetValue(type, out subtypes))
|
||
{
|
||
Type[] argTypes = new Type[method.GetParameters().Length];
|
||
for (int i = 0; i < argTypes.Length; i++)
|
||
{
|
||
argTypes[i] = method.GetParameters()[i].ParameterType;
|
||
}
|
||
Type[] genericArgTypes = method.GetGenericArguments();
|
||
foreach (Type subtype in subtypes)
|
||
{
|
||
// TBD: We could make subtype more precise by unifying with baseType
|
||
MethodInfo[] minfos = subtype.GetMethods(BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.DeclaredOnly);
|
||
foreach (MethodInfo minfo in minfos)
|
||
{
|
||
if (minfo.Name == method.Name && minfo.IsVirtual)
|
||
{
|
||
MethodInfo minfo1 = MatchAndInstantiate(minfo, argTypes, genericArgTypes);
|
||
if (minfo1 != null)
|
||
{
|
||
methods.Add(minfo1);
|
||
GetAllOverrides(subtype, minfo1, typeMap, methods);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private static MethodInfo MatchAndInstantiate(MethodInfo minfo, Type[] argTypes, Type[] genericArgTypes)
|
||
{
|
||
ParameterInfo[] mParams = minfo.GetParameters();
|
||
if (mParams.Length != argTypes.Length)
|
||
{
|
||
return null;
|
||
}
|
||
if (minfo.IsGenericMethod)
|
||
{
|
||
Type[] genericArgs = minfo.GetGenericArguments();
|
||
if (genericArgs.Length != genericArgTypes.Length)
|
||
{
|
||
return null;
|
||
}
|
||
if (!minfo.IsGenericMethodDefinition)
|
||
{
|
||
bool hasGenericParameter = false;
|
||
foreach (Type arg in genericArgs)
|
||
{
|
||
if (arg.IsGenericParameter)
|
||
{
|
||
hasGenericParameter = true;
|
||
break;
|
||
}
|
||
}
|
||
if (hasGenericParameter)
|
||
{
|
||
minfo = minfo.GetGenericMethodDefinition();
|
||
}
|
||
}
|
||
|
||
// kluggy, need to rewrite.
|
||
try
|
||
{
|
||
minfo = minfo.MakeGenericMethod(genericArgTypes);
|
||
}
|
||
catch (ArgumentException)
|
||
{
|
||
return null;
|
||
}
|
||
mParams = minfo.GetParameters();
|
||
}
|
||
for (int i = 0; i < argTypes.Length; i++)
|
||
{
|
||
Type paramType = mParams[i].ParameterType;
|
||
if (paramType.IsGenericParameter)
|
||
{
|
||
if (!argTypes[i].IsGenericParameter)
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
else if (paramType != argTypes[i])
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
return minfo;
|
||
}
|
||
|
||
internal static Type FindConstrainedType(Type type)
|
||
{
|
||
if (type.IsInterface) return null;
|
||
if (type.IsGenericParameter)
|
||
{
|
||
Type[] constraints = type.GetGenericParameterConstraints();
|
||
foreach (Type ctype in constraints)
|
||
{
|
||
Type constrainedType = FindConstrainedType(ctype);
|
||
if (constrainedType != null) return constrainedType;
|
||
}
|
||
}
|
||
return type;
|
||
}
|
||
|
||
// A hack to detect anonymous types
|
||
internal static bool IsAnonymousType(Type type)
|
||
{
|
||
return (Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute), false) &&
|
||
type.IsGenericType && type.Name.Contains("AnonymousType") &&
|
||
(type.Name.StartsWith("<>", StringComparison.Ordinal) || type.Name.StartsWith("VB$", StringComparison.Ordinal)) &&
|
||
(type.Attributes & TypeAttributes.NotPublic) == TypeAttributes.NotPublic);
|
||
}
|
||
|
||
// A hack to detect transparent identifiers
|
||
internal static bool IsTransparentIdentifier(string name)
|
||
{
|
||
return name.StartsWith("<>h__TransparentIdentifier", StringComparison.Ordinal);
|
||
}
|
||
|
||
// A hack to detect backing field names
|
||
internal static bool IsBackingField(string fieldName)
|
||
{
|
||
return fieldName.StartsWith("<", StringComparison.Ordinal) && fieldName.Contains("BackingField");
|
||
}
|
||
|
||
internal static bool ContainsAnonymousType(IEnumerable<Type> types)
|
||
{
|
||
foreach (Type type in types)
|
||
{
|
||
if (IsAnonymousType(type)) return true;
|
||
if (type.IsGenericType &&
|
||
ContainsAnonymousType(type.GetGenericArguments()))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
internal static bool IsTypeOrAnyGenericParamsAnonymous(Type type)
|
||
{
|
||
if (IsAnonymousType(type))
|
||
{
|
||
return true;
|
||
}
|
||
if (type.IsGenericType)
|
||
{
|
||
foreach (Type typeArg in type.GetGenericArguments())
|
||
{
|
||
if (IsTypeOrAnyGenericParamsAnonymous(typeArg)) return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
internal static string FieldName(string fieldName)
|
||
{
|
||
if (!IsBackingField(fieldName))
|
||
{
|
||
return fieldName;
|
||
}
|
||
int idx = fieldName.IndexOf(">", StringComparison.Ordinal);
|
||
if (idx == -1) idx = fieldName.Length;
|
||
return fieldName.Substring(1, idx - 1);
|
||
}
|
||
}
|
||
}
|