internal static string Type(System.Type type, bool dropNamespaces = false) { string assemblyQualifiedName; Exception exception; if (type == null) { return string.Empty; } if (type.IsGenericType && !type.IsGenericTypeDefinition) { string str2 = Type(type.GetGenericTypeDefinition(), dropNamespaces); int num = str2.LastIndexOf('`'); int length = str2.Length - (str2.Length - num); StringBuilder builder = new StringBuilder(str2, 0, length, 0x200); builder.Append('['); bool flag = true; foreach (System.Type type2 in type.GetGenericArguments()) { if (!flag) { builder.Append(','); } flag = false; builder.Append(Type(type2, dropNamespaces)); } builder.Append(']'); assemblyQualifiedName = builder.ToString(); } else if (type.IsArray) { string str3 = Type(type.GetElementType(), dropNamespaces); StringBuilder builder2 = new StringBuilder(str3, str3.Length + 10); builder2.Append("["); for (int i = 0; i < (type.GetArrayRank() - 1); i++) { builder2.Append(","); } builder2.Append("]"); assemblyQualifiedName = builder2.ToString(); } else { assemblyQualifiedName = TypeAccelerators.FindBuiltinAccelerator(type) ?? (dropNamespaces ? type.Name : type.ToString()); } if ((!type.IsGenericParameter && !type.ContainsGenericParameters) && (!dropNamespaces && (LanguagePrimitives.ConvertStringToType(assemblyQualifiedName, out exception) != type))) { assemblyQualifiedName = type.AssemblyQualifiedName; } return assemblyQualifiedName; }
private static string ProcessArray(System.Type type, WsdlGenerator.XMLNamespace xns) { string wireQname = null; bool flag = false; System.Type elementType = type.GetElementType(); string str2 = "ArrayOf"; while (elementType.IsArray) { str2 = str2 + "ArrayOf"; elementType = elementType.GetElementType(); } wireQname = TypeName(elementType, true, xns); int index = wireQname.IndexOf(":"); wireQname.Substring(0, index); string str3 = wireQname.Substring(index + 1); int arrayRank = type.GetArrayRank(); string str4 = ""; if (arrayRank > 1) { str4 = arrayRank.ToString(CultureInfo.InvariantCulture); } string name = (str2 + str3.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture) + str3.Substring(1) + str4).Replace('+', 'N'); if (xns.LookupArraySchemaType(name) == null) { WsdlGenerator.ArraySchemaType asType = new WsdlGenerator.ArraySchemaType(type, name, SchemaBlockType.ComplexContent, false); WsdlGenerator.Restriction particle = new WsdlGenerator.Restriction(); WsdlGenerator.SchemaAttribute attribute = new WsdlGenerator.SchemaAttribute(); if (flag) { attribute.AddArray(wireQname); } else { string str6 = type.Name; index = str6.IndexOf("["); attribute.AddArray(wireQname + str6.Substring(index)); } particle.AddArray(attribute); asType.AddParticle(particle); xns.AddArraySchemaType(asType); } return (xns.Prefix + ":" + name); }
private Type ImportImpl(System.Type type) { if (type.Assembly == typeof(IKVM.Reflection.Type).Assembly) { throw new ArgumentException("Did you really want to import " + type.FullName + "?"); } if (type.HasElementType) { if (type.IsArray) { if (type.Name.EndsWith("[]")) { return Import(type.GetElementType()).MakeArrayType(); } else { return Import(type.GetElementType()).MakeArrayType(type.GetArrayRank()); } } else if (type.IsByRef) { return Import(type.GetElementType()).MakeByRefType(); } else if (type.IsPointer) { return Import(type.GetElementType()).MakePointerType(); } else { throw new InvalidOperationException(); } } else if (type.IsGenericParameter) { if (type.DeclaringMethod != null) { throw new NotImplementedException(); } else { return Import(type.DeclaringType).GetGenericArguments()[type.GenericParameterPosition]; } } else if (type.IsGenericType && !type.IsGenericTypeDefinition) { System.Type[] args = type.GetGenericArguments(); Type[] importedArgs = new Type[args.Length]; for (int i = 0; i < args.Length; i++) { importedArgs[i] = Import(args[i]); } return Import(type.GetGenericTypeDefinition()).MakeGenericType(importedArgs); } else { return Import(type.Assembly).GetType(type.FullName); } }
internal System.Type ToReferenceContext(System.Type type) { if (this.InReferenceContext(type)) { return type; } if (type.IsArray) { return Microsoft.JScript.Convert.ToType(Microsoft.JScript.TypedArray.ToRankString(type.GetArrayRank()), this.ToReferenceContext(type.GetElementType())); } return this.JScriptReferenceModule.ResolveType(type.MetadataToken, null, null); }
private static Hashtable typeMap; //contains weak references /// <summary> /// Gets a TypeNode instance corresponding to the given System.Type instance. /// </summary> /// <param name="type">A runtime type.</param> /// <returns>A TypeNode instance.</returns> public static TypeNode GetTypeNode(System.Type type) { if(type == null) return null; Hashtable typeMap = TypeNode.typeMap; if(typeMap == null) TypeNode.typeMap = typeMap = Hashtable.Synchronized(new Hashtable()); TypeNode result = null; WeakReference wr = (WeakReference)typeMap[type]; if(wr != null) { result = wr.Target as TypeNode; if(result == Class.DoesNotExist) return null; if(result != null) return result; } if(type.IsGenericType && !type.IsGenericTypeDefinition) { try { TypeNode template = TypeNode.GetTypeNode(type.GetGenericTypeDefinition()); if(template == null) return null; TypeNodeList templateArguments = new TypeNodeList(); foreach(Type arg in type.GetGenericArguments()) templateArguments.Add(TypeNode.GetTypeNode(arg)); return template.GetGenericTemplateInstance(template.DeclaringModule, templateArguments); } catch { //TODO: log error return null; } } if(type.IsGenericParameter) { try { int parIndx = type.GenericParameterPosition; System.Reflection.MethodInfo mi = type.DeclaringMethod as System.Reflection.MethodInfo; if(mi != null) { Method m = Method.GetMethod(mi); if(m == null) return null; if(m.TemplateParameters != null && m.TemplateParameters.Count > parIndx) return m.TemplateParameters[parIndx]; } else { System.Type ti = type.DeclaringType; TypeNode t = TypeNode.GetTypeNode(ti); if(t == null) return null; if(t.TemplateParameters != null && t.TemplateParameters.Count > parIndx) return t.TemplateParameters[parIndx]; } return null; } catch { //TODO: log error return null; } } if(type.HasElementType) { TypeNode elemType = TypeNode.GetTypeNode(type.GetElementType()); if(elemType == null) return null; if(type.IsArray) result = elemType.GetArrayType(type.GetArrayRank()); else if(type.IsByRef) result = elemType.GetReferenceType(); else if(type.IsPointer) result = elemType.GetPointerType(); else { Debug.Assert(false); result = null; } } else if(type.DeclaringType != null) { TypeNode dType = TypeNode.GetTypeNode(type.DeclaringType); if(dType == null) return null; result = dType.GetNestedType(Identifier.For(type.Name)); } else { AssemblyNode assem = AssemblyNode.GetAssembly(type.Assembly); if(assem != null) { result = assem.GetType(Identifier.For(type.Namespace), Identifier.For(type.Name)); } } if(result == null) typeMap[type] = new WeakReference(Class.DoesNotExist); else typeMap[type] = new WeakReference(result); return result; }
// Create an array node given an existing CLR array type public ArrayTypeSig(System.Type tArray, ISemanticResolver s) { Debug.Assert(tArray != null); m_filerange = null; m_cDimension = tArray.GetArrayRank(); Debug.Assert(m_cDimension == 1, "@todo - only 1d arrays currently implemented"); m_ArrayTypeRec = s.ResolveCLRTypeToBlueType(tArray).AsArrayType; m_sigBase = null; // left as null. }
private void GetTypeParts(System.Type type, out System.Type baseType, out ParameterData[] parameterDataArray, out int[] arrayRanks) { baseType = null; parameterDataArray = null; arrayRanks = null; if (type.IsArray) { ArrayList list = new ArrayList(); this.GetTypeParts(type.GetElementType(), out baseType, out parameterDataArray, out arrayRanks); if (arrayRanks != null) { list.AddRange(arrayRanks); } list.Add(type.GetArrayRank()); arrayRanks = (int[]) list.ToArray(typeof(int)); } else if (type.IsGenericType) { System.Type underlyingSystemType = null; System.Type type3 = null; if (type.ContainsGenericParameters) { type3 = null; underlyingSystemType = type.UnderlyingSystemType; } else { type3 = type; underlyingSystemType = type.GetGenericTypeDefinition().UnderlyingSystemType; } ArrayList list2 = new ArrayList(); for (int i = 0; i < underlyingSystemType.GetGenericArguments().Length; i++) { ParameterData data = new ParameterData { ParameterType = underlyingSystemType.GetGenericArguments()[i] }; if (type3 != null) { data.Type = type.GetGenericArguments()[i]; } list2.Add(data); } parameterDataArray = (ParameterData[]) list2.ToArray(typeof(ParameterData)); baseType = underlyingSystemType; } else { baseType = type; } }