Type

microsoft\win32\oavariantlib.cs (3)

37internal static readonly Type [] ClassTypes = { 79internal static Variant ChangeType(Variant source, Type targetClass, short options, CultureInfo culture) 102private static int GetCVTypeFromClass(Type ctype)

system\activator.cs (12)

55static public Object CreateInstance(Type type, 66static public Object CreateInstance(Type type, 110static public Object CreateInstance(Type type, params Object[] args) 120static public Object CreateInstance(Type type, 132static public Object CreateInstance(Type type) 181static public Object CreateInstance(Type type, bool nonPublic) 321Type type = null; 333type = Type.GetType(typeName + ", " + assemblyString, true /*throwOnError*/, ignoreCase); 439Type t = assembly.GetType(typeName, true, ignoreCase); 639Type t = assembly.GetType(typeName, true, false); 674static public Object GetObject(Type type, String url) 682static public Object GetObject(Type type, String url, Object state)

system\appdomain.cs (2)

2160internal EvidenceBase GetHostEvidence(Type type) 4867public new Type GetType()

system\argiterator.cs (1)

129return new RuntimeTypeHandle(Type.GetTypeFromHandleUnsafe((IntPtr)_GetNextArgType()));

system\array.cs (10)

system\attribute.cs (53)

system\boolean.cs (1)

306Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\byte.cs (1)

259Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\char.cs (1)

504Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\collections\arraylist.cs (6)

770public virtual Array ToArray(Type type) { 1128public override Array ToArray(Type type) 1472public override Array ToArray(Type type) { 1836public override Array ToArray(Type type) { 2090public override Array ToArray(Type type) { 2525public override Array ToArray(Type type) {

system\Collections\Concurrent\ConcurrentDictionary.cs (2)

138Type valueType = typeof(TValue); 150switch (Type.GetTypeCode(valueType))

system\collections\generic\arraysorthelper.cs (2)

117defaultArraySortHelper = (IArraySortHelper<T>)RuntimeTypeHandle.Allocate(typeof(GenericArraySortHelper<string>).TypeHandle.Instantiate(new Type[] { typeof(T) })); 895defaultArraySortHelper = (IArraySortHelper<TKey, TValue>)RuntimeTypeHandle.Allocate(typeof(GenericArraySortHelper<string, string>).TypeHandle.Instantiate(new Type[] { typeof(TKey), typeof(TValue) }));

system\collections\generic\equalitycomparer.cs (2)

62TypeCode underlyingTypeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t)); 407if (Type.GetTypeCode(Enum.GetUnderlyingType(typeof(T))) != TypeCode.Int32) {

system\collections\objectmodel\collection.cs (2)

206Type targetType = array.GetType().GetElementType(); 207Type sourceType = typeof(T);

system\collections\objectmodel\readonlycollection.cs (2)

151Type targetType = array.GetType().GetElementType(); 152Type sourceType = typeof(T);

system\collections\objectmodel\readonlydictionary.cs (2)

598Type targetType = array.GetType().GetElementType(); 599Type sourceType = typeof(T);

system\convert.cs (3)

261internal static Object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { 321public static Object ChangeType(Object value, Type conversionType) { 325public static Object ChangeType(Object value, Type conversionType, IFormatProvider provider) {

system\datetime.cs (1)

1649Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\dbnull.cs (1)

118Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\decimal.cs (1)

1272Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\defaultbinder.cs (36)

84Type[] paramArrayTypes = new Type[candidates.Length]; 86Type[] argTypes = new Type[args.Length]; 105Type paramArrayType = null; 196Type pCls = null; 214if (defaultValueBinding && args[paramOrder[i][j]] == Type.Missing) 452Type valueType = null; 461Type pCls = candidates[i].FieldType; 519public override MethodBase SelectMethod(BindingFlags bindingAttr,MethodBase[] match,Type[] types,ParameterModifier[] modifiers) 524Type[] realTypes = new Type[types.Length]; 546Type pCls = par[j].ParameterType; 594public override PropertyInfo SelectProperty(BindingFlags bindingAttr,PropertyInfo[] match,Type returnType, 595Type[] indexes,ParameterModifier[] modifiers) 598if (indexes != null && !Contract.ForAll(indexes, delegate(Type t) { return t != null; })) 629Type pCls = par[j]. ParameterType; 706public override Object ChangeType(Object value,Type type,CultureInfo cultureInfo) 740public static MethodBase ExactBinding(MethodBase[] match,Type[] types,ParameterModifier[] modifiers) 755Type pCls = par[j]. ParameterType; 780public static PropertyInfo ExactPropertyBinding(PropertyInfo[] match,Type returnType,Type[] types,ParameterModifier[] modifiers) 792Type pCls = par[j].ParameterType; 811private static int FindMostSpecific(ParameterInfo[] p1, int[] paramOrder1, Type paramArrayType1, 812ParameterInfo[] p2, int[] paramOrder2, Type paramArrayType2, 813Type[] types, Object[] args) 826if (args != null && args[i] == Type.Missing) 829Type c1, c2; 888private static int FindMostSpecificType(Type c1, Type c2, Type t) 951private static int FindMostSpecificMethod(MethodBase m1, int[] paramOrder1, Type paramArrayType1, 952MethodBase m2, int[] paramOrder2, Type paramArrayType2, 953Type[] types, Object[] args) 1050internal static int GetHierarchyDepth(Type t) 1054Type currentType = t;

system\delegate.cs (17)

system\delegateserializationholder.cs (2)

23SerializationInfo info, Type delegateType, Object target, MethodInfo method, int targetIndex) 34Type c = delegateType.BaseType;

system\deployment\isolationinterop.cs (2)

2511System.Type t = o.GetType(); 2980internal static Guid GetGuidOfType(Type type)

system\diagnostics\contracts\contracts.cs (6)

70private Type _typeWithContracts; 72public ContractClassAttribute(Type typeContainingContracts) 77public Type TypeContainingContracts { 89private Type _typeIAmAContractFor; 91public ContractClassForAttribute(Type typeContractsAreFor) 96public Type TypeContractsAreFor {

system\diagnostics\debuggerattributes.cs (12)

166private Type target; 168public DebuggerTypeProxyAttribute(Type type) 187public Type Target 227private Type target; 258public Type Target 293private Type target; 304public DebuggerVisualizerAttribute(string visualizerTypeName, Type visualizerObjectSource) 313public DebuggerVisualizerAttribute(Type visualizer) 321public DebuggerVisualizerAttribute(Type visualizer, Type visualizerObjectSource) 333public DebuggerVisualizerAttribute(Type visualizer, string visualizerObjectSourceTypeName) 357public Type Target

system\diagnostics\eventing\eventprovider.cs (1)

841Type underlyingType = Enum.GetUnderlyingType(data.GetType());

system\diagnostics\eventing\eventsource.cs (23)

392public static Guid GetGuid(Type eventSourceType) 428public static string GetName(Type eventSourceType) 443public static string GenerateManifest(Type eventSourceType, string assemblyPathToIncludeInManifest) 459public static string GenerateManifest(Type eventSourceType, string assemblyPathToIncludeInManifest, EventManifestOptions flags) 754var myType = this.GetType(); 1561private static string GetName(Type eventSourceType, EventManifestOptions flags) 1770Type dataType = m_eventData[eventId].Parameters[parameterId].ParameterType; 2096Type pType = infos[i].ParameterType; 2233var tlet = new TraceLoggingEventTypes(eventName, EventTags.None, new Type[] { msg.GetType() }); 3140internal static Attribute GetCustomAttributeHelper(MemberInfo member, Type attributeType, EventManifestOptions flags = EventManifestOptions.None) 3181Type t = attr.GetType(); 3216private static bool AttributeTypeNamesMatch(Type attributeType, Type reflectedAttributeType) 3234private static Type GetEventSourceBaseType(Type eventSourceType, bool allowEventSourceOverride, bool reflectionOnly) 3268private static byte[] CreateManifestAndDescriptors(Type eventSourceType, string eventSourceDllName, EventSource source, 3331Type nestedType = eventSourceType.GetNestedType(providerEnumKind); 3601Type staticFieldType = staticField.FieldType; 6207public void AddEventParameter(Type type, string name) 6237mapsTab = new Dictionary<string, Type>(); 6412foreach (Type enumType in mapsTab.Values) 6724private string GetTypeName(Type type) 6894Dictionary<string, Type> mapsTab;

system\diagnostics\eventing\StubEnvironment.cs (8)

203public static bool IsEnum(this Type type) { return type.IsEnum; } 204public static bool IsAbstract(this Type type) { return type.IsAbstract; } 205public static bool IsSealed(this Type type) { return type.IsSealed; } 206public static Type BaseType(this Type type) { return type.BaseType; } 207public static Assembly Assembly(this Type type) { return type.Assembly; } 208public static TypeCode GetTypeCode(this Type type) { return Type.GetTypeCode(type); }

System\Diagnostics\Eventing\TraceLogging\PropertyAccessor.cs (1)

29var retType = property.getterInfo.ReturnType;

System\Diagnostics\Eventing\TraceLogging\SimpleTypeInfos.cs (2)

980public KeyValuePairTypeInfo(List<Type> recursionCheck) 1026public NullableTypeInfo(List<Type> recursionCheck)

System\Diagnostics\Eventing\TraceLogging\Statics.cs (23)

359public static object CreateInstance(Type type, params object[] parameters) 364public static bool IsValueType(Type type) 375public static bool IsEnum(Type type) 386public static IEnumerable<PropertyInfo> GetProperties(Type type) 408public static MethodInfo GetDeclaredStaticMethod(Type declaringType, string name) 423Type attributeType) 457public static AttributeType GetCustomAttribute<AttributeType>(Type type) 477public static Type[] GetGenericArguments(Type type) 486public static Type FindEnumerableElementType(Type type) 488Type elementType = null; 502foreach (var ifaceType in ifaceTypes) 525public static bool IsGenericMatch(Type type, object openType) 533return isGeneric && type.GetGenericTypeDefinition() == (Type)openType; 536public static Delegate CreateDelegate(Type delegateType, MethodInfo methodInfo) 550public static TraceLoggingTypeInfo GetTypeInfoInstance(Type dataType, List<Type> recursionCheck) 579List<Type> recursionCheck) 582var dataType = typeof(DataType); 600var elementType = dataType.GetElementType(); 670var underlyingType = Enum.GetUnderlyingType(dataType); 809var elementType = FindEnumerableElementType(dataType);

System\Diagnostics\Eventing\TraceLogging\TraceLoggingEventTypes.cs (4)

53params Type[] types) 216var recursionCheck = new List<Type>(paramInfos.Length); 226private static TraceLoggingTypeInfo[] MakeArray(Type[] types) 235var recursionCheck = new List<Type>(types.Length);

System\Diagnostics\Eventing\TraceLogging\TraceLoggingTypeInfo.cs (4)

27private readonly Type dataType; 29internal TraceLoggingTypeInfo(Type dataType) 43Type dataType, 118internal Type DataType

System\Diagnostics\Eventing\TraceLogging\TraceLoggingTypeInfo_T.cs (2)

140internal static TraceLoggingTypeInfo<DataType> GetInstance(List<Type> recursionCheck) 155return GetInstance(new List<Type>());

System\Diagnostics\Eventing\TraceLogging\TypeAnalysis.cs (3)

25Type dataType, 27List<Type> recursionCheck) 56var propertyType = propertyInfo.PropertyType;

system\diagnostics\stackframe.cs (1)

258Type[] typars = ((MethodInfo)method).GetGenericArguments();

system\diagnostics\stacktrace.cs (7)

140Type symbolsType = Type.GetType( 150new Type[] { typeof(string), 167new Type[] { typeof(string), 499Type t = mb.DeclaringType; 666Type t = mb.DeclaringType; 678Type[] typars = ((MethodInfo)mb).GetGenericArguments();

system\double.cs (1)

373Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\enum.cs (31)

system\exception.cs (3)

483Type t = rci.ReflectedType; 499Type t = rmi.DeclaringType; 944public new Type GetType()

system\globalization\cultureinfo.cs (1)

1365public virtual Object GetFormat(Type formatType) {

system\globalization\datetimeformatinfo.cs (1)

556public Object GetFormat(Type formatType)

system\globalization\numberformatinfo.cs (1)

794public Object GetFormat(Type formatType) {

system\iappdomain.cs (1)

59Type GetType ();

system\iconvertible.cs (1)

68Object ToType(Type conversionType, IFormatProvider provider);

system\iformatprovider.cs (1)

23Object GetFormat(Type formatType);

system\int16.cs (1)

272Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\int32.cs (1)

245Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\int64.cs (1)

224Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\io\isolatedstorage\isolatedstorage.cs (11)

558Type domainEvidenceType, 559Type assemblyEvidenceType) 613Type appEvidenceType) 729Evidence domainEv, Type domainEvidenceType, 730Evidence assemEv, Type assemEvidenceType, 731Evidence appEv, Type appEvidenceType) 805Evidence domainEv, Type domainEvidenceType, 806Evidence assemEv, Type assemblyEvidenceType, 807Evidence appEv, Type appEvidenceType) 869Evidence evidence, Type evidenceType, IsolatedStorageScope fAssmDomApp, 961Evidence evidence, Type evidenceType, IsolatedStorageScope fAssmDomApp,

system\io\isolatedstorage\isolatedstoragefile.cs (5)

163Type domainEvidenceType, Type assemblyEvidenceType) 209Evidence domainEvidence, Type domainEvidenceType, 210Evidence assemblyEvidence, Type assemblyEvidenceType) 234Type applicationEvidenceType)

system\iserviceobjectprovider.cs (1)

15Object GetService(Type serviceType);

system\marshalbyrefobject.cs (4)

72internal bool IsInstanceOfType(Type T) 83Type t = GetType(); 186public virtual ObjRef CreateObjRef(Type requestedType) 202Type castType = SoapServices.GetInteropTypeFromXmlType(xmlTypeName, xmlTypeNamespace);

system\multicastdelegate.cs (1)

38protected MulticastDelegate(Type target, String method) : base(target, method)

system\nullable.cs (4)

132public static Type GetUnderlyingType(Type nullableType) { 137Type result = null; 140Type genericType = nullableType.GetGenericTypeDefinition();

system\object.cs (2)

105public extern Type GetType(); 184Type t = GetType();

system\oleautbinder.cs (2)

25public override Object ChangeType(Object value, Type type, CultureInfo cultureInfo) 53Type srcType = value.GetType();

system\reflection\__filters.cs (2)

31public virtual bool FilterTypeName(Type cls,Object filterCriteria) 51public virtual bool FilterTypeNameIgnoreCase(Type cls, Object filterCriteria)

system\reflection\assembly.cs (30)

73public static Assembly GetAssembly(Type type) 293internal static Type GetType_Compat(String assemblyString, String typeName) 308return Type.GetType(typeName + ", " + assemblyString, true /*throwOnError*/, false /*ignoreCase*/); 742Type _Assembly.GetType() 748public virtual Type GetType(String name) 753public virtual Type GetType(String name, bool throwOnError) 758public virtual Type GetType(String name, bool throwOnError, bool ignoreCase) 763public virtual IEnumerable<Type> ExportedTypes 771public virtual Type[] GetExportedTypes() 780Type[] types = GetTypes(); 800public virtual Type[] GetTypes() 806Type[][] ModuleTypes = new Type[iNumModules][]; 815Type[] ret = new Type[iFinalLength]; 827public virtual Stream GetManifestResourceStream(Type type, String name) 922public virtual Object[] GetCustomAttributes(Type attributeType, bool inherit) 928public virtual bool IsDefined(Type attributeType, bool inherit) 1015Type t = GetType(typeName, false, ignoreCase); 1288Type invocableAttribute = GetType("__DynamicallyInvokableAttribute", false); 1293ConstructorInfo ctor = invocableAttribute.GetConstructor(Type.EmptyTypes); 1489public override Type GetType(String name, bool throwOnError, bool ignoreCase) 1513public override Type[] GetExportedTypes() 1515Type[] types = null; 1541public override Stream GetManifestResourceStream(Type type, String name) 1651public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 1665public override bool IsDefined(Type attributeType, bool inherit) 2467Type type, 2482sb.Append(Type.Delimiter); 2813Type type = sys.GetType("System.Net.NetworkAccess", true);

system\reflection\binder.cs (4)

41Type[] types,ParameterModifier[] modifiers); 46Type returnType,Type[] indexes,ParameterModifier[] modifiers); 51public abstract Object ChangeType(Object value,Type type,CultureInfo culture);

system\reflection\cominterfaces.cs (84)

system\reflection\ConstructorInfo.cs (10)

82internal virtual Type GetReturnType() { throw new NotImplementedException(); } 111Type _ConstructorInfo.GetType() 219Type declaringType = DeclaringType; 401public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 416public override bool IsDefined(Type attributeType, bool inherit) 446public override Type DeclaringType 454public override Type ReflectedType 480internal override Type GetReturnType() { return Signature.ReturnType; } 513Type declaringType = DeclaringType; 536internal static void CheckCanCreateInstance(Type declaringType, bool isVarArg)

system\reflection\customattribute.cs (29)

229if (type == (RuntimeType)typeof(Type)) 340internal static CustomAttributeTypedArgument Filter(IList<CustomAttributeData> attrs, Type caType, int parameter) 414Type type = typeof(DllImportAttribute); 444Type type = typeof(MarshalAsAttribute); 481Type type = typeof(TypeForwardedToAttribute); 483Type[] sig = new Type[] { typeof(Type) }; 487typedArgs[0] = new CustomAttributeTypedArgument(typeof(Type), forwardedTo.Destination); 525public Type AttributeType { get { return Constructor.DeclaringType; } } 613Type type = null; 657internal Type ArgumentType 693private static Type CustomAttributeEncodingToType(CustomAttributeEncoding encodedType) 707return typeof(Type); 812private Type m_argumentType; 816public CustomAttributeTypedArgument(Type argumentType, object value) 866m_argumentType = typeof(Type); 876Type elementType; 930else if (ArgumentType == typeof(Type)) 931return String.Format(CultureInfo.CurrentCulture, "typeof({0})", ((Type)Value).FullName); 938Type elementType = ArgumentType.GetElementType(); 961public Type ArgumentType 1182private static RuntimeType Type_Type = (RuntimeType)typeof(Type); 1356Type arrayType = useObjectArray ? typeof(object) : caType; 1457Type arrayType = useObjectArray ? typeof(object) : caType; 1665Type arrayType = useObjectArray ? typeof(object) : attributeFilterType; 1785property = attributeType.GetProperty(name, type, Type.EmptyTypes) as RuntimePropertyInfo; 1816field.UnsafeSetValue(attribute, value, BindingFlags.Default, Type.DefaultBinder, null); 2092private static object[] CreateAttributeArrayHelper(Type elementType, int elementCount)

system\reflection\CustomAttributeExtensions.cs (18)

system\reflection\emit\aqnbuilder.cs (9)

103internal static string ToString(Type type, Format format) 132private void AddElementType(Type elementType) 151private void ConstructAssemblyQualifiedNameWorker(Type type, Format format) 153Type rootType = type; 159List<Type> nestings = new List<Type>(); 160for (Type t = rootType; t != null; t = t.IsGenericParameter ? null : t.DeclaringType) 165Type enclosingType = nestings[i]; 177Type[] genericArguments = rootType.GetGenericArguments();

system\reflection\emit\assemblybuilder.cs (18)

119public override Stream GetManifestResourceStream(Type type, String name) 156public override Type[] GetExportedTypes() 707Type symWriter = assem.GetType("System.Diagnostics.SymbolStore.SymWriter", true, false); 911Type symWriter = assem.GetType("System.Diagnostics.SymbolStore.SymWriter", true, false); 957internal void CheckContext(params Type[][] typess) 962foreach(Type[] types in typess) 967internal void CheckContext(params Type[] types) 972foreach (Type type in types) 1182public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 1187public override bool IsDefined(Type attributeType, bool inherit) 1221public override Stream GetManifestResourceStream(Type type, String name) 1277public override Type[] GetExportedTypes() 1300public override Type GetType(String name, bool throwOnError, bool ignoreCase) 1778Type type; 2121private int DefineNestedComType(Type type, int tkResolutionScope, int tkTypeDef) 2123Type enclosingType = type.DeclaringType; 2136internal int DefineExportedTypeInMemory(Type type, int tkResolutionScope, int tkTypeDef) 2138Type enclosingType = type.DeclaringType;

system\reflection\emit\assemblybuilderdata.cs (6)

146Type conType = m_CABuilders[i].m_con.DeclaringType; 420internal void AddPublicComType(Type type) 456m_publicComTypeList = new Type[m_iInitialSize]; 460Type[] tempTypeList = new Type[m_iPublicComTypeCount * 2]; 472internal Type[] m_publicComTypeList;

system\reflection\emit\constructorbuilder.cs (11)

38Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, ModuleBuilder mod, TypeBuilder type) 56Type[] parameterTypes, ModuleBuilder mod, TypeBuilder type) : 64internal override Type[] GetParameterTypes() 99public override Type ReflectedType 104public override Type DeclaringType 160public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 165public override bool IsDefined (Type attributeType, bool inherit) 271public Type ReturnType 277internal override Type GetReturnType()

system\reflection\emit\customattributebuilder.cs (24)

73private bool ValidateType(Type t) 75if (t.IsPrimitive || t == typeof(String) || t == typeof(Type)) 79switch (Type.GetTypeCode(Enum.GetUnderlyingType(t))) 137Type[] paramTypes; 157TypeCode paramTC = Type.GetTypeCode(paramTypes[i]); 158if (paramTC != Type.GetTypeCode(constructorArgs[i].GetType())) 185Type propType = namedProperties[i].PropertyType; 221Type.GetTypeCode(propertyValues[i].GetType()) != Type.GetTypeCode(propType)) 241Type fldType = namedFields[i].FieldType; 273Type.GetTypeCode(fieldValues[i].GetType()) != Type.GetTypeCode(fldType)) 289private void EmitType(BinaryWriter writer, Type type) 293switch (Type.GetTypeCode(type)) 345else if (type == typeof(Type)) 385private void EmitValue(BinaryWriter writer, Type type, Object value) 389switch (Type.GetTypeCode(Enum.GetUnderlyingType(type))) 427else if (type == typeof(Type)) 433String typeName = TypeNameBuilder.ToString((Type)value, TypeNameBuilder.Format.AssemblyQualifiedName); 447Type et = type.GetElementType(); 455switch (Type.GetTypeCode(type)) 504Type ot = value == null ? typeof(String) : value is Type ? typeof(Type) : value.GetType();

system\reflection\emit\dynamicilgenerator.cs (16)

63public override LocalBuilder DeclareLocal(Type localType, bool pinned) 178public override void Emit(OpCode opcode, Type type) 236Type returnType, 237Type[] parameterTypes, 238Type[] optionalParameterTypes) 277Type returnType, 278Type[] parameterTypes) 313public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes) 403public override void BeginCatchBlock(Type exceptionType) 488private int GetMemberRefToken(MethodBase methodInfo, Type[] optionalParameterTypes) 490Type[] parameterTypes; 504parameterTypes = new Type[paramInfo.Length]; 527Type returnType, 528Type[] parameterTypes, 529Type[] optionalParameterTypes) 1240Type t = m.DeclaringType.GetGenericTypeDefinition();

system\reflection\emit\dynamicmethod.cs (40)

80Type returnType, 81Type[] parameterTypes) 100Type returnType, 101Type[] parameterTypes, 125Type returnType, 126Type[] parameterTypes, 149Type returnType, 150Type[] parameterTypes, 176Type returnType, 177Type[] parameterTypes, 201Type returnType, 202Type[] parameterTypes, 203Type owner) { 225Type returnType, 226Type[] parameterTypes, 227Type owner, 252Type returnType, 253Type[] parameterTypes, 254Type owner, 303ConstructorInfo transparencyCtor = typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes); 317ConstructorInfo securityRulesCtor = typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }); 347Type returnType, 348Type[] signature, 349Type owner, 485private void PerformSecurityCheck(Type owner, ref StackCrawlMark stackMark, bool skipVisibility) 532public sealed override Delegate CreateDelegate(Type delegateType) { 548public sealed override Delegate CreateDelegate(Type delegateType, Object target) { 606public override Type DeclaringType { get { return m_dynMethod.DeclaringType; } } 608public override Type ReflectedType { get { return m_dynMethod.ReflectedType; } } 758public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 765public override bool IsDefined(Type attributeType, bool inherit) { return m_dynMethod.IsDefined(attributeType, inherit); } 767public override Type ReturnType { get { return m_dynMethod.ReturnType; } } 884public override Type DeclaringType { 888public override Type ReflectedType { 934public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { 950public override bool IsDefined(Type attributeType, bool inherit) { 976public override Type ReturnType 998Type[] parameterTypes = m_owner.m_parameterTypes; 1019Object[] ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit) { 1027bool ICustomAttributeProvider.IsDefined (Type attributeType, bool inherit) {

system\reflection\emit\enumbuilder.cs (23)

system\reflection\emit\fieldbuilder.cs (9)

30private Type m_fieldType; 35internal FieldBuilder(TypeBuilder typeBuilder, String fieldName, Type type, 36Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes) 99public override Type DeclaringType 110public override Type ReflectedType 124public override Type FieldType 166public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 172public override bool IsDefined(Type attributeType, bool inherit)

system\reflection\emit\fieldtoken.cs (1)

46internal FieldToken (int field, Type fieldClass) {

system\reflection\emit\generictypeparameterbuilder.cs (28)

system\reflection\emit\ilgenerator.cs (38)

223private int GetMethodToken(MethodBase method, Type[] optionalParameterTypes, bool useMethodDef) 229internal virtual SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, 230Type[] parameterTypes, Type[] optionalParameterTypes) 236private SignatureHelper GetMemberRefSignature(CallingConventions call, Type returnType, 237Type[] parameterTypes, Type[] optionalParameterTypes, int cGenericParameters) 519Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes) 561public virtual void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes) 607public virtual void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes) 627Type[] parameters = methodInfo.GetParameterTypes(); 713Type[] parameters = con.GetParameterTypes(); 724public virtual void Emit(OpCode opcode, Type cls) 1046public virtual void BeginCatchBlock(Type exceptionType) 1161public virtual void ThrowException(Type excType) 1173ConstructorInfo con = excType.GetConstructor(Type.EmptyTypes); 1186Type[] parameterTypes = new Type[1]; 1208Type[] parameterTypes = new Type[1]; 1213parameterTypes[0] = (Type)cls; 1246Type[] parameterTypes = new Type[1]; 1251parameterTypes[0] = (Type)cls; 1262public virtual LocalBuilder DeclareLocal(Type localType) 1267public virtual LocalBuilder DeclareLocal(Type localType, bool pinned) 1416internal Type []m_catchClass; 1446m_catchClass=new Type[4]; 1454private static Type[] EnlargeArray(Type[] incoming) 1456Type[] temp = new Type[incoming.Length * 2]; 1464Type catchClass, // catch exception type 1524internal void MarkCatchAddr(int catchAddr, Type catchException) { 1575internal Type [] GetCatchClass() {

system\reflection\emit\localbuilder.cs (4)

21private Type m_localType; 28internal LocalBuilder(int localIndex, Type localType, MethodInfo methodBuilder) 30internal LocalBuilder(int localIndex, Type localType, MethodInfo methodBuilder, bool isPinned) 52public override Type LocalType

system\reflection\emit\methodbuilder.cs (47)

system\reflection\emit\methodbuilderinstantiation.cs (12)

20internal static MethodInfo MakeGenericMethod(MethodInfo method, Type[] inst) 33private Type[] m_inst; 37internal MethodBuilderInstantiation(MethodInfo method, Type[] inst) 44internal override Type[] GetParameterTypes() 52public override Type DeclaringType { get { return m_method.DeclaringType; } } 53public override Type ReflectedType { get { return m_method.ReflectedType; } } 55public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); } 56public override bool IsDefined(Type attributeType, bool inherit) { return m_method.IsDefined(attributeType, inherit); } 58public new Type GetType() { return base.GetType(); } 72public override Type[] GetGenericArguments() { return m_inst; } 92public override MethodInfo MakeGenericMethod(params Type[] arguments) 102public override Type ReturnType

system\reflection\emit\methodrental.cs (1)

49Type cls, // [in] class containing the method

system\reflection\emit\modulebuilder.cs (107)

system\reflection\emit\propertybuilder.cs (7)

47Type returnType, // return type of the property. 231public override Type PropertyType { 251public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 256public override bool IsDefined (Type attributeType, bool inherit) 287public override Type DeclaringType { 291public override Type ReflectedType { 302private Type m_returnType; // property's return type

system\reflection\emit\signaturehelper.cs (62)

system\reflection\emit\symbolmethod.cs (15)

21private Type m_containingType; 24private Type m_returnType; 26private Type[] m_parameterTypes; 32internal SymbolMethod(ModuleBuilder mod, MethodToken token, Type arrayClass, String methodName, 33CallingConventions callingConvention, Type returnType, Type[] parameterTypes) 48m_parameterTypes = new Type[parameterTypes.Length]; 53m_parameterTypes = EmptyArray<Type>.Value; 67internal override Type[] GetParameterTypes() 85public override Type ReflectedType 87get { return m_containingType as Type; } 95public override Type DeclaringType 131public override Type ReturnType 161public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 166public override bool IsDefined(Type attributeType, bool inherit)

system\reflection\emit\symboltype.cs (26)

system\reflection\emit\typebuilder.cs (149)

system\reflection\emit\typebuilderinstantiation.cs (41)

system\reflection\emit\xxxontypebuilderinstantiation.cs (25)

system\reflection\eventinfo.cs (10)

159public virtual Type EventHandlerType 167Type del = typeof(Delegate); 171Type c = p[i].ParameterType; 191Type cl = EventHandlerType; 192Type mc = typeof(MulticastDelegate); 199Type _EventInfo.GetType() 309public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 324public override bool IsDefined(Type attributeType, bool inherit) 357public override Type DeclaringType { get { return m_declaringType; } } 358public override Type ReflectedType

system\reflection\fieldinfo.cs (21)

system\reflection\icustomattributeprovider.cs (2)

27Object[] GetCustomAttributes(Type attributeType, bool inherit); 35bool IsDefined (Type attributeType, bool inherit);

system\reflection\interfacemapping.cs (2)

23public Type TargetType; // The type implementing the interface 25public Type InterfaceType; // The type representing the interface

system\reflection\introspectionextensions.cs (1)

24 public static TypeInfo GetTypeInfo(this Type type){

system\reflection\ireflect.cs (4)

34Type[] types,ParameterModifier[] modifiers); 66Type returnType, 67Type[] types, 117Type UnderlyingSystemType {

system\reflection\memberinfo.cs (10)

43public abstract Type DeclaringType { get; } 45public abstract Type ReflectedType { get; } 56public abstract Object[] GetCustomAttributes(Type attributeType, bool inherit); 58public abstract bool IsDefined(Type attributeType, bool inherit); 71if (this is Type) 72return ((Type)this).Module; 91Type type1, type2; 97if ((type1 = left as Type) != null && (type2 = right as Type) != null) 129Type _MemberInfo.GetType()

system\reflection\memberinfoserializationholder.cs (5)

33Type[] genericArguments) 49info.AddValue("GenericArguments", genericArguments, typeof(Type[])); 207Type[] genericArguments = m_info.GetValueNoThrow("GenericArguments", typeof(Type[])) as Type[];

system\reflection\methodbase.cs (9)

69Type declaringType = m.DeclaringType; 184public virtual Type[] GetGenericArguments() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); } 264internal static string ConstructParameters(Type[] parameterTypes, CallingConventions callingConvention, bool serialization) 271Type t = parameterTypes[i]; 326internal virtual Type[] GetParameterTypes() 330Type[] parameterTypes = new Type[paramInfo.Length]; 350if (arg == Type.Missing) 367Type _MethodBase.GetType() { return base.GetType(); }

system\reflection\methodbody.cs (4)

64public virtual Type CatchType 71Type type = null; 75Type declaringType = m_methodBody.m_methodBase.DeclaringType; 165public virtual Type LocalType { get { Contract.Assert(m_type != null, "type must be set!"); return m_type; } }

system\reflection\methodinfo.cs (29)

79public virtual Type ReturnType { get { throw new NotImplementedException(); } } 88public override Type[] GetGenericArguments() { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); } 93public virtual MethodInfo MakeGenericMethod(params Type[] typeArguments) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); } 95public virtual Delegate CreateDelegate(Type delegateType) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); } 96public virtual Delegate CreateDelegate(Type delegateType, Object target) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_SubclassOverride")); } 100Type _MethodInfo.GetType() 166foreach (Type t in GetGenericArguments()) 194Type declaringType = DeclaringType; 222Type[] genericArguments = GetGenericArguments(); 454Type[] lhs = GetGenericArguments(); 455Type[] rhs = mi.GetGenericArguments(); 484public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 498public override bool IsDefined(Type attributeType, bool inherit) 531public override Type DeclaringType 542public override Type ReflectedType 620Type declaringType = DeclaringType; 672Type declaringType = DeclaringType; 804public override Type ReturnType 853public override Delegate CreateDelegate(Type delegateType) 873public override Delegate CreateDelegate(Type delegateType, Object target) 890private Delegate CreateDelegateInternal(Type delegateType, Object firstArgument, DelegateBindingFlags bindingFlags, ref StackCrawlMark stackMark) 917public override MethodInfo MakeGenericMethod(params Type[] methodInstantiation) 931Type methodInstantiationElem = methodInstantiation[i]; 940Type[] methodInstantiationCopy = new Type[methodInstantiation.Length]; 975public override Type[] GetGenericArguments() 977Type[] types = RuntimeMethodHandle.GetMethodInstantiationPublic(this); 981types = EmptyArray<Type>.Value; 1015Type[] pis = GetGenericArguments();

system\reflection\module.cs (45)

system\reflection\parameterinfo.cs (18)

32protected Type ClassImpl; 75public virtual Type ParameterType 130public virtual Type[] GetRequiredCustomModifiers() 132return EmptyArray<Type>.Value; 135public virtual Type[] GetOptionalCustomModifiers() 137return EmptyArray<Type>.Value; 161public virtual Object[] GetCustomAttributes(Type attributeType, bool inherit) 170public virtual bool IsDefined(Type attributeType, bool inherit) 371private static readonly Type s_DecimalConstantAttributeType = typeof(DecimalConstantAttribute); 372private static readonly Type s_CustomConstantAttributeType = typeof(CustomConstantAttribute); 492internal RuntimeParameterInfo(MethodInfo owner, String name, Type parameterType, int position) 507public override Type ParameterType 591defaultValue = Type.Missing; 651Type attrType = attr.Constructor.DeclaringType; 716public override Type[] GetRequiredCustomModifiers() 721public override Type[] GetOptionalCustomModifiers() 737public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 755public override bool IsDefined(Type attributeType, bool inherit)

system\reflection\pointer.cs (1)

43public static unsafe Object Box(void *ptr,Type type) {

system\reflection\propertyinfo.cs (13)

82public abstract Type PropertyType { get; } 132public virtual Type[] GetRequiredCustomModifiers() { return EmptyArray<Type>.Value; } 134public virtual Type[] GetOptionalCustomModifiers() { return EmptyArray<Type>.Value; } 162Type _PropertyInfo.GetType() 378public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 393public override bool IsDefined(Type attributeType, bool inherit) 426public override Type DeclaringType 434public override Type ReflectedType 460public override Type[] GetRequiredCustomModifiers() 465public override Type[] GetOptionalCustomModifiers() 507public override Type PropertyType

system\reflection\reflectiontypeloadexception.cs (7)

29private Type[] _classes; 43public ReflectionTypeLoadException(Type[] classes, Exception[] exceptions) : base(null) 50public ReflectionTypeLoadException(Type[] classes, Exception[] exceptions, String message) : base(message) 58_classes = (Type[])(info.GetValue("Types", typeof(Type[]))); 62public Type[] Types { 77info.AddValue("Types", _classes, typeof(Type[]));

system\reflection\RuntimeReflectionExtensions.cs (11)

10private static void CheckAndThrow(Type t) 22public static IEnumerable<PropertyInfo> GetRuntimeProperties(this Type type) 27public static IEnumerable<EventInfo> GetRuntimeEvents(this Type type) 33public static IEnumerable<MethodInfo> GetRuntimeMethods(this Type type) 39public static IEnumerable<FieldInfo> GetRuntimeFields(this Type type) 45public static PropertyInfo GetRuntimeProperty(this Type type, string name) 50public static EventInfo GetRuntimeEvent(this Type type, string name) 55public static MethodInfo GetRuntimeMethod(this Type type, string name, Type[] parameters) 60public static FieldInfo GetRuntimeField(this Type type, string name) 70public static InterfaceMapping GetRuntimeInterfaceMap(this TypeInfo typeInfo, Type interfaceType)

system\reflection\typedelegator.cs (16)

27protected Type typeImpl; 34public TypeDelegator(Type delegatingType) { 84public override Type BaseType { 89CallingConventions callConvention, Type[] types,ParameterModifier[] modifiers) 101CallingConventions callConvention, Type[] types,ParameterModifier[] modifiers) 126public override Type GetInterface(String name, bool ignoreCase) 131public override Type[] GetInterfaces() 147Type returnType, Type[] types, ParameterModifier[] modifiers) 165public override Type[] GetNestedTypes(BindingFlags bindingAttr) 170public override Type GetNestedType(String name, BindingFlags bindingAttr) 228public override Type GetElementType() 238public override Type UnderlyingSystemType 249public override Object[] GetCustomAttributes(Type attributeType, bool inherit) 254public override bool IsDefined(Type attributeType, bool inherit) 260public override InterfaceMapping GetInterfaceMap(Type interfaceType)

system\reflection\typefilter.cs (1)

22public delegate bool TypeFilter(Type m, Object filterCriteria);

system\reflection\typeinfo.cs (21)

system\resources\manifestbasedresourcegroveler.cs (7)

185resName = _mediator.LocationInfo.Namespace + Type.Delimiter + defaultResName; 348Type readerType = Type.GetType(readerTypeName, true); 363Type resSetType; 367resSetType = Type.GetType(resSetTypeName, true, false); 468sb.Append(Type.Delimiter); 685resName = _mediator.LocationInfo.Namespace + Type.Delimiter;

system\resources\resourcemanager.cs (13)

194private Type _locationInfo; // For Assembly or type-based directory layout 195private Type _userResourceSet; // Which ResourceSet instance to create 259private static readonly Type _minResourceSet = typeof(ResourceSet); 309private ResourceManager(String baseName, String resourceDir, Type usingResourceSet) { 384public ResourceManager(String baseName, Assembly assembly, Type usingResourceSet) 420public ResourceManager(Type resourceSource) 529outputResName = _locationInfo.Namespace + Type.Delimiter + defaultResName; 555public virtual Type ResourceSetType { 618public static ResourceManager CreateFileBasedResourceManager(String baseName, String resourceDir, Type usingResourceSet) 1016Type WinRTResourceManagerType = Type.GetType("System.Resources.WindowsRuntimeResourceManager, " + AssemblyRef.SystemRuntimeWindowsRuntime, true); 1626internal Type LocationInfo 1631internal Type UserResourceSet

system\resources\resourcereader.cs (4)

1088_typeTable[typeIndex] = (RuntimeType)Type.GetType(typeName, true); 1132RuntimeType resourceType = (RuntimeType)Type.GetType(typeName, false); 1300public override Type BindToType(string assemblyName, string typeName) 1316Type t = ObjectReader.FastBindToType(assemblyName, typeName);

system\resources\resourceset.cs (2)

184public virtual Type GetDefaultReader() 193public virtual Type GetDefaultWriter()

system\resources\resourcewriter.cs (3)

49private Func<Type, String> typeConverter; 52public Func<Type, String> TypeNameConverter 530Type type = value.GetType();

system\rttype.cs (89)

system\runtime\compilerservices\AsyncStateMachineAttribute.cs (1)

14public AsyncStateMachineAttribute(Type stateMachineType)

system\runtime\compilerservices\fixedbufferattribute.cs (3)

24private Type elementType; 27public FixedBufferAttribute(Type elementType, int length) 33public Type ElementType {

system\runtime\compilerservices\IteratorStateMachineAttribute.cs (1)

14public IteratorStateMachineAttribute(Type stateMachineType)

system\runtime\compilerservices\requiredattributeattribute.cs (3)

16private Type requiredContract; 18public RequiredAttributeAttribute (Type requiredContract) 22public Type RequiredContract

system\runtime\compilerservices\StateMachineAttribute.cs (2)

14public Type StateMachineType { get; private set; } 16public StateMachineAttribute(Type stateMachineType)

system\runtime\compilerservices\TypeForwardedToAttribute.cs (4)

16private Type _destination; 18public TypeForwardedToAttribute(Type destination) 23public Type Destination 33Type[] types = null;

system\runtime\designerservices\windowsruntimedesignercontext.cs (1)

154public Type GetType(String typeName)

system\runtime\interopservices\attributes.cs (28)

system\Runtime\InteropServices\ComEventsMethod.cs (3)

42private Type[] _cachedTargetTypes; 77Type[] enumTypes = new Type[_expectedParamsCount];

system\runtime\interopservices\ComTypes\ireflect.cs (4)

29Type[] types,ParameterModifier[] modifiers); 51Type returnType, 52Type[] types, 75Type UnderlyingSystemType

system\runtime\interopservices\icustomfactory.cs (1)

15MarshalByRefObject CreateInstance(Type serverType);

system\runtime\interopservices\iexception.cs (1)

36Type GetType ();

system\runtime\interopservices\iregistrationservices.cs (5)

43Type[] GetRegistrableTypesInAssembly(Assembly assembly); 46String GetProgIdForType(Type type); 49void RegisterTypeForComClients(Type type, ref Guid g); 54bool TypeRequiresRegistration(Type type); 56bool TypeRepresentsComType(Type type);

system\runtime\interopservices\marshal.cs (40)

215public static int SizeOf(Type t) 259internal static extern uint SizeOfType(Type type); 266private static extern uint AlignedSizeOfType(Type type); 274internal static extern int SizeOfHelper(Type t, bool throwIfNotMarshalable); 279public static IntPtr OffsetOf(Type t, String fieldName) 878public static void PrelinkAll(Type c) 973public static Object PtrToStructure(IntPtr ptr, Type structureType) 1017public static extern void DestroyStructure(IntPtr ptr, Type structuretype); 1587private static extern Type GetLoadedTypeForGUID(ref Guid guid); 1594public static Type GetTypeForITypeInfo(IntPtr /* ITypeInfo* */ piTypeInfo) 1598Type TypeObj = null; 1678public static Type GetTypeFromCLSID(Guid clsid) 1689public static extern IntPtr /* ITypeInfo* */ GetITypeInfoForType(Type t); 1750public static IntPtr /* IUnknown* */ GetComInterfaceForObject(Object o, Type T) 1767public static IntPtr /* IUnknown* */ GetComInterfaceForObject(Object o, Type T, CustomQueryInterfaceMode mode) 1780public static IntPtr /* IUnknown* */ GetComInterfaceForObjectInContext(Object o, Type t) 1787private static extern IntPtr /* IUnknown* */ GetComInterfaceForObjectNative(Object o, Type t, bool onlyInContext, bool fEnalbeCustomizedQueryInterface); 1818public static extern Object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type t); 2088public static Object CreateWrapperOfType(Object o, Type t) 2146private static extern Object InternalCreateWrapperOfType(Object o, Type t); 2165public static extern bool IsTypeVisibleFromCom(Type t); 2268public static extern int GetStartComSlot(Type t); 2276public static extern int GetEndComSlot(Type t); 2288public static extern MemberInfo GetMethodInfoForComSlot(Type t, int slot, ref ComMemberType memberType); 2323public static Guid GenerateGuidForType(Type type) 2333private static extern void FCallGenerateGuidForType(ref Guid result, Type type); 2342public static String GenerateProgIdForType(Type type) 2480Type t = sys.GetType("System.ComponentModel.LicenseManager"); 2509internal static extern object GetNativeActivationFactory(Type type); 2547internal static System.Type GetCachedWinRTTypeByIid( 2555System.Type res = Type.GetTypeFromHandleUnsafe(rthHandle); 2573internal static System.Type[] GetCachedWinRTTypes( 2583System.Type[] result = new System.Type[res.Length]; 2586result[i] = Type.GetTypeFromHandleUnsafe(res[i]); 2593internal static System.Type[] GetCachedWinRTTypes( 2604public static Delegate GetDelegateForFunctionPointer(IntPtr ptr, Type t) 2620Type c = t.BaseType; 2635internal static extern Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Type t);

system\runtime\interopservices\registrationservices.cs (30)

128Type[] aTypes = GetRegistrableTypesInAssembly(assembly); 179Type[] aTypes = GetRegistrableTypesInAssembly(assembly); 222public virtual Type[] GetRegistrableTypesInAssembly(Assembly assembly) 233Type[] aTypes = assembly.GetExportedTypes(); 242Type CurrentType = aTypes[cTypes]; 248Type[] RetArray = new Type[TypeList.Count]; 254public virtual String GetProgIdForType(Type type) 260public virtual void RegisterTypeForComClients(Type type, ref Guid g) 284public virtual bool TypeRequiresRegistration(Type type) 290public virtual bool TypeRepresentsComType(Type type) 302Type baseComImportType = GetBaseComImportType(type); 316public virtual int RegisterTypeForComClients(Type type, RegistrationClassContext classContext, RegistrationConnectionType flags) 348internal static bool TypeRequiresRegistrationHelper(Type type) 360if (!type.IsValueType && type.GetConstructor(BindingFlags.Instance | BindingFlags.Public,null,new Type[0],null) == null) 375private void RegisterValueType(Type type, String strAsmName, String strAsmVersion, String strAsmCodeBase, String strRuntimeVersion) 409private void RegisterManagedType(Type type, String strAsmName, String strAsmVersion, String strAsmCodeBase, String strRuntimeVersion) 497private void RegisterComImportedType(Type type, String strAsmName, String strAsmVersion, String strAsmCodeBase, String strRuntimeVersion) 541private bool UnregisterValueType(Type type, String strAsmVersion) 600private bool UnregisterManagedType(Type type,String strAsmVersion) 796private bool UnregisterComImportedType(Type type, String strAsmVersion) 994private void CallUserDefinedRegistrationMethod(Type type, bool bRegister) 1000Type RegFuncAttrType = null; 1006for(Type currType = type; !bFunctionCalled && currType != null; currType = currType.BaseType) 1034(aParams[0].ParameterType != typeof(String) && aParams[0].ParameterType != typeof(Type))) 1074private Type GetBaseComImportType(Type type) 1080private bool IsRegisteredAsValueType(Type type) 1099private static extern void RegisterTypeForComClientsNative(Type type,ref Guid g); 1106private static extern int RegisterTypeForComClientsExNative(Type t, RegistrationClassContext clsContext, RegistrationConnectionType flags);

system\runtime\interopservices\tceadaptergen\eventitfinfo.cs (4)

27public Type GetEventItfType() 29Type t = m_asmImport.GetType(m_strEventItfName, true, false); 35public Type GetSrcItfType() 37Type t = m_asmSrcItf.GetType(m_strSrcItfName, true, false);

system\runtime\interopservices\tceadaptergen\eventproviderwriter.cs (31)

20private readonly Type[] MonitorEnterParamTypes = new Type[] { typeof(Object), Type.GetType("System.Boolean&") }; 22public EventProviderWriter( ModuleBuilder OutputModule, String strDestTypeName, Type EventItfType, Type SrcItfType, Type SinkHelperType ) 31public Type Perform() 38new Type[]{m_EventItfType, typeof(IDisposable)} 94private MethodBuilder DefineAddEventMethod( TypeBuilder OutputTypeBuilder, MethodInfo SrcItfMethod, Type SinkHelperClass, FieldBuilder fbSinkHelperArray, FieldBuilder fbEventCP, MethodBuilder mbInitSrcItf ) 96Type[] aParamTypes; 107ConstructorInfo SinkHelperCons = SinkHelperClass.GetConstructor(EventProviderWriter.DefaultLookup | BindingFlags.NonPublic, null, new Type[0], null ); 115aParamTypes = new Type[1]; 130Type[] parameterTypes; 131parameterTypes = new Type[1]; 237private MethodBuilder DefineRemoveEventMethod( TypeBuilder OutputTypeBuilder, MethodInfo SrcItfMethod, Type SinkHelperClass, FieldBuilder fbSinkHelperArray, FieldBuilder fbEventCP ) 239Type[] aParamTypes; 250aParamTypes = new Type[1]; 290Type[] parameterTypes; 291parameterTypes = new Type[1]; 463private MethodBuilder DefineInitSrcItfMethod( TypeBuilder OutputTypeBuilder, Type SourceInterface, FieldBuilder fbSinkHelperArray, FieldBuilder fbEventCP, FieldBuilder fbCPC ) 466ConstructorInfo DefaultArrayListCons = typeof(ArrayList).GetConstructor(EventProviderWriter.DefaultLookup, null, new Type[0], null ); 473Type[] aParamTypes = new Type[1]; 556ConstructorInfo DefaultBaseClsCons = typeof(Object).GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new Type[0], null ); 565new Type[]{typeof(Object)} ); 584private MethodBuilder DefineFinalizeMethod( TypeBuilder OutputTypeBuilder, Type SinkHelperClass, FieldBuilder fbSinkHelper, FieldBuilder fbEventCP ) 615Type[] aParamTypes = new Type[1]; 770private Type m_EventItfType; 771private Type m_SrcItfType; 772private Type m_SinkHelperType;

system\runtime\interopservices\tceadaptergen\eventsinkhelperwriter.cs (17)

17public EventSinkHelperWriter( ModuleBuilder OutputModule, Type InputType, Type EventItfType ) 24public Type Perform() 27Type[] aInterfaces = new Type[1]; 70Type DelegateCls = aParams[0].ParameterType; 100Type[] parameters = new Type[PIs.Length]; 119private void DefineEventMethod( TypeBuilder OutputTypeBuilder, MethodInfo Method, Type DelegateCls, FieldBuilder fbDelegate ) 126Type ReturnType = Method.ReturnType; 130Type[] parameterTypes; 133parameterTypes = new Type[paramInfos.Length]; 191private void AddReturn(Type ReturnType, ILGenerator il, MethodBuilder Meth) 200switch (System.Type.GetTypeCode(ReturnType)) 257ConstructorInfo DefaultBaseClsCons = typeof(Object).GetConstructor(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public, null, new Type[0], null ); 294private Type m_InputType; 295private Type m_EventItfType;

system\runtime\interopservices\tceadaptergen\tceadaptergenerator.cs (11)

29Type EventItfType = CurrEventItf.GetEventItfType(); 30Type SrcItfType = CurrEventItf.GetSrcItfType(); 34Type SinkHelperType = new EventSinkHelperWriter( m_Module, SrcItfType, EventItfType ).Perform(); 46Type []aConsParams = new Type[1]; 59internal static TypeBuilder DefineUniqueType(String strInitFullName, TypeAttributes attrs, Type BaseType, Type[] aInterfaceTypes, ModuleBuilder mb) 76Type []aConsParams = new Type[1]; 88internal static MethodInfo[] GetNonPropertyMethods(Type type) 114internal static MethodInfo[] GetPropertyMethods(Type type)

system\runtime\interopservices\typelibconverter.cs (10)

262ConstructorInfo securityRulesCtor = typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }); 359Type[] aTypes = modBldr.GetTypes(); 370Type []aConsParams = new Type[1] {typeof(String)}; 385Type []aConsParams = new Type[1] {typeof(String)}; 402Type []aConsParams = new Type[2] {typeof(int), typeof(int)}; 449Type []aConsParams = new Type[2] {typeof(int), typeof(int)};

system\runtime\interopservices\ucomireflect.cs (4)

30Type[] types,ParameterModifier[] modifiers); 52Type returnType, 53Type[] types, 76Type UnderlyingSystemType {

system\runtime\interopservices\windowsruntime\attributes.cs (6)

19private Type m_defaultInterface; 21public DefaultInterfaceAttribute(Type defaultInterface) 26public Type DefaultInterface 52public InterfaceImplementedInVersionAttribute(Type interfaceType, byte majorVersion, byte minorVersion, byte buildVersion, byte revisionVersion) 61public Type InterfaceType 86private Type m_interfaceType;

system\runtime\interopservices\windowsruntime\clripropertyvalueimpl.cs (17)

system\runtime\interopservices\windowsruntime\clrireferenceimpl.cs (19)

54ICustomProperty ICustomPropertyProvider.GetIndexedProperty(string name, Type indexParameterType) 67Type ICustomPropertyProvider.Type 138ICustomProperty ICustomPropertyProvider.GetIndexedProperty(string name, Type indexParameterType) 151Type ICustomPropertyProvider.Type 286internal static readonly Type s_pointType = Type.GetType("Windows.Foundation.Point, " + AssemblyRef.SystemRuntimeWindowsRuntime); 287internal static readonly Type s_rectType = Type.GetType("Windows.Foundation.Rect, " + AssemblyRef.SystemRuntimeWindowsRuntime); 288internal static readonly Type s_sizeType = Type.GetType("Windows.Foundation.Size, " + AssemblyRef.SystemRuntimeWindowsRuntime); 296Type type = obj.GetType(); 335return new CLRIReferenceImpl<Type>(PropertyType.Other, (Type)obj); 359Type specificType = typeof(CLRIReferenceImpl<>).MakeGenericType(type); 374Type type = obj.GetType().GetElementType(); 408if (type == typeof(Type)) 410return new CLRIReferenceArrayImpl<Type>(PropertyType.OtherArray, (Type[])obj); 454Type specificType = typeof(CLRIReferenceArrayImpl<>).MakeGenericType(type);

system\runtime\interopservices\windowsruntime\custompropertyimpl.cs (1)

132public Type Type

system\runtime\interopservices\windowsruntime\icustomproperty.cs (1)

19Type Type

system\runtime\interopservices\windowsruntime\icustompropertyprovider.cs (7)

30ICustomProperty GetIndexedProperty(string name, Type indexParameterType); 35Type Type 77Type indexedParamType = null; 83static internal ICustomProperty CreateIndexedProperty(object target, string propertyName, Type indexedParamType) 94new Type[] { indexedParamType }, // indexed parameter type 209ICustomProperty ICustomPropertyProvider.GetIndexedProperty(string name, Type indexParameterType) 219Type ICustomPropertyProvider.Type

system\runtime\interopservices\windowsruntime\managedactivationfactory.cs (2)

38private Type m_type; 41internal ManagedActivationFactory(Type type)

system\runtime\interopservices\windowsruntime\windowsruntimemarshal.cs (3)

1208internal static IntPtr GetActivationFactoryForType(Type type) 1215internal static ManagedActivationFactory GetManagedActivationFactory(Type type) 1276public static IActivationFactory GetActivationFactory(Type type)

system\runtime\interopservices\windowsruntime\winrtclassactivator.cs (3)

50private Type LoadWinRTType(string acid) 52Type winrtType = Type.GetType(acid + ", Windows, ContentType=WindowsRuntime");

system\runtime\remoting\activationservices.cs (15)

43private static readonly Type proxyAttributeType = typeof(System.Runtime.Remoting.Proxies.ProxyAttribute); 395internal static ProxyAttribute GetProxyAttribute(Type serverType) 761Type serverType = reqMsg.ActivationType; 809Type serverType, IMessage msg, ServerIdentity srvIdToBind, 967internal static IContextAttribute[] GetContextAttributesForType(Type serverType) 975Type currType = serverType; 990Type attrType = attr.GetType(); 1080internal static void PushActivationAttributes(Type serverType, Object[] attributes) 1090internal static Object[] PeekActivationAttributes(Type serverType) 1101internal static void PopActivationAttributes(Type serverType) 1334Type activationType = ctorMsg.ActivationType; 1489Type activationType = ctorMsg.ActivationType; 1738internal void Push(Type typ, Object[] attr) 1759internal Object[] Peek(Type typ) 1772internal void Pop(Type typ)

system\runtime\remoting\callcontext.cs (1)

280private static Type s_callContextType = typeof(LogicalCallContext);

system\runtime\remoting\channelservices.cs (1)

633foreach (Type t in mi.GetGenericArguments())

system\runtime\remoting\configuration.cs (11)

456Type type = RemotingConfigInfo.LoadType(entry.TypeName, entry.AssemblyName); 593Type type = RemotingConfigInfo.LoadType(entry.TypeName, entry.AssemblyName); 867internal static Type GetServerTypeForUri(String URI) 969Type type = assembly.GetType(entry.UrtTypeName); 980Type type = assembly.GetType(entry.UrtTypeName); 993Type type = assembly.GetType(entry.TypeName); 1496internal Type GetServerTypeForUri(String URI) 1500Type serverType = null; 1557Type serverType = LoadType(svrTypeName, asmName); 1692internal static Type LoadType(String typeName, String assemblyName) 1715Type type = asm.GetType(typeName, false, false);

system\runtime\remoting\iactivator.cs (1)

79Type ActivationType

system\runtime\remoting\message.cs (47)

70private Type[] _MethodSignature; // Array of parameter types 443_MethodBase = RuntimeType.GetMethodBase(Type.GetTypeFromHandleUnsafe(_governingType), mh); 470internal static Type[] GenerateMethodSignature(MethodBase mb) 476Type[] methodSig = new Type[paramArray.Length]; 531Type pt = currentPi.ParameterType; 541Type paramType = pt.GetElementType(); 585internal static Object CoerceArg(Object value, Type pt) 643internal static Object SoapCoerceArg(Object value, Type pt, Hashtable keyToNamespaceTable) 1041public Type ActivationType 2541internal Type[] _methodSignature; 2827private Type[] instArgs; 2829private Type[] methodSignature; 2906methodSignature = (Type[])smuggledMsg.GetMethodSignature(deserializedArgs); 2938methodSignature = (Type[])smuggledMsg.MethodSignature; 3004private static Type ResolveTypeRelativeTo(String typeName, int offset, int count, Type serverType) 3006Type type = ResolveTypeRelativeToBaseTypes(typeName, offset, count, serverType); 3011Type[] interfaces = serverType.GetInterfaces(); 3012foreach (Type iface in interfaces) 3029private static Type ResolveTypeRelativeToBaseTypes(String typeName, int offset, int count, Type serverType) 3052internal Type ResolveType() 3055Type t = null; 3062Type serverType = srvID.GetLastCalledType(typeName); 3171MemberInfo [] methods = t.FindMembers(MemberTypes.Method, MethodCall.LookupAll, Type.FilterName, methodName); 3209MI = Type.DefaultBinder.SelectMethod(MethodCall.LookupAll, 3358Type parameterType = parameters[j].ParameterType; 3529Type type = parameterInfos[outArg].ParameterType.GetElementType(); 3828methodSignature = (Type[]) value; 3922internal Type _activationType; 4017public Type ActivationType 4101private Type[] methodSignature; 4169methodSignature = (Type[])msg.MethodSignature; 4200methodSignature = (Type[])msg.MethodSignature; 4255Type retType = null; 4269Type[] paramTypes = new Type[outParamsCount]; 4382Type exceptionType = Type.GetType(serverFault.ExceptionType, false, false); 4426Type retType = mi.ReturnType; 4758methodSignature = (Type[]) value; 4850internal Type[] fieldTypes = null; 4875public Type[] FieldTypes 5329internal Type[] ArgTypes 5333Type[] ret = null; 5337ret = new Type[_map.Length];

system\runtime\remoting\messagesmuggler.cs (4)

117Type elementType = array.GetType().GetElementType(); 313Type[] inst = mcm.MethodBase.GetGenericArguments(); 389internal Type[] GetInstantiation(ArrayList deserializedArgs) 392return (Type[])deserializedArgs[_instantiation.Index];

system\runtime\remoting\objref.cs (12)

54bool CanCastTo(Type fromType, Object o); 110public virtual bool CanCastTo(Type castType, Object o) 215Type[] interfaces = typeOfObj.GetInterfaces(); 253private bool CompareTypes(Type type1, String type2) 255Type type = RemotingServices.InternalGetTypeFromQualifiedTypeName(type2); 261private bool CanCastTo(Type castType, String[] types) 293public override bool CanCastTo(Type castType, Object o) 430private static Type orType = typeof(ObjRef); 449public ObjRef(MarshalByRefObject o, Type requestedType) 553Type typeOfTypeInfo = null; 557Type typeOfChannelInfo = null; 798Type serverType = asm.GetType(typeName, false, false);

system\runtime\remoting\proxyattribute.cs (3)

39public virtual MarshalByRefObject CreateInstance(Type serverType) 73Type serverType, 95Type t = serverType;

system\runtime\remoting\realproxy.cs (7)

108protected RealProxy(Type classToProxy) : this(classToProxy, (IntPtr)0, null) 113protected RealProxy(Type classToProxy, IntPtr stub, Object stubData) 182Type svrType = GetProxiedType(); 388public extern Type GetProxiedType(); 395public virtual ObjRef CreateObjRef(Type requestedType) 527Type returnType = cache.ReturnType; 537private static void ValidateReturnArg(Object arg, Type paramType)

system\runtime\remoting\redirectionproxy.cs (4)

22private Type _serverType; 26internal RedirectionProxy(MarshalByRefObject proxy, Type serverType) 104private Type _serverType; 106internal ComRedirectionProxy(MarshalByRefObject comObject, Type serverType)

system\runtime\remoting\remotingattributes.cs (7)

256private Type _returnType = null; // null if return type is void or .ctor 485internal Type ReturnType 494Type returnType = mi.ReturnType; 590_XmlElementName = GetTypeName((Type)ReflectInfo); 626_XmlTypeName = GetTypeName((Type)ReflectInfo); 672private static string GetTypeName(Type t) { 801Type declaringType = ((MemberInfo)ReflectInfo).DeclaringType;

system\runtime\remoting\remotingconfigparser.cs (1)

390Type type = asm.GetType(typeName, false, false);

system\runtime\remoting\remotingconfiguration.cs (15)

124public static void RegisterActivatedServiceType(Type type) 150Type type, String objectUri, WellKnownObjectMode mode) 169public static void RegisterActivatedClientType(Type type, String appUrl) 193public static void RegisterWellKnownClientType(Type type, String objectUrl) 246public static ActivatedClientTypeEntry IsRemotelyActivatedClientType(Type svrType) 273public static WellKnownClientTypeEntry IsWellKnownClientType(Type svrType) 299public static bool IsActivationAllowed(Type svrType) 362public ActivatedClientTypeEntry(Type type, String appUrl) 381public Type ObjectType 423public ActivatedServiceTypeEntry(Type type) 437public Type ObjectType 485public WellKnownClientTypeEntry(Type type, String objectUrl) 504public Type ObjectType 556public WellKnownServiceTypeEntry(Type type, String objectUri, WellKnownObjectMode mode) 577public Type ObjectType

system\runtime\remoting\remotingproxy.cs (4)

45public RemotingProxy(Type serverType) 269Type t = GetProxiedType(); 639public bool CanCastTo(Type castType, Object o) 702bool CanCastToWK(Type castType)

system\runtime\remoting\remotingservices.cs (30)

207Type typeToProxy, 248Type objectType) 276Type objectType) 477public static ObjRef Marshal(MarshalByRefObject Obj, String ObjURI, Type RequestedType) 484internal static ObjRef MarshalInternal(MarshalByRefObject Obj, String ObjURI, Type RequestedType) 490internal static ObjRef MarshalInternal(MarshalByRefObject Obj, String ObjURI, Type RequestedType, bool updateChannelData) 497internal static ObjRef MarshalInternal(MarshalByRefObject Obj, String ObjURI, Type RequestedType, bool updateChannelData, bool isInitializing) 846public static Object Connect(Type classToProxy, String url) 853public static Object Connect(Type classToProxy, String url, Object data) 957internal static Object Unmarshal(Type classToProxy, String url) 964internal static Object Unmarshal(Type classToProxy, String url, Object data) 1334Type serverType; 1426private static Object GetOrCreateProxy(Type classToProxy, Identity idObj) 1456Type serverType = serverID.ServerType; 1479Identity idObj, Type classToProxy, Object proxy) 1885Type t = RemotingServices.InternalGetTypeFromQualifiedTypeName(msg.TypeName); 1898Type[] signature = (Type[])msg.MethodSignature; 1913private static MethodBase GetMethodBase(IMethodMessage msg, Type t, Type[] signature) 2060Type beginReturnType = typeof(IAsyncResult); 2061Type endReturnType = method.ReturnType; 2086Type type = method.DeclaringType; 2143if (((Type)obj != param.ParameterType) && param.IsIn) 2153public static Type GetServerTypeForUri(String URI) 2155Type svrType = null; 2350Type serverType = null; 2507internal static String DetermineDefaultQualifiedTypeName(Type type) 2678internal static Type InternalGetTypeFromQualifiedTypeName(String qualifiedTypeName) 2689return (RuntimeType)Type.GetType(typeName, false);

system\runtime\remoting\remotingsurrogateselector.cs (17)

system\runtime\remoting\serveridentity.cs (7)

33public Type type; 47internal Type _srvType; // type of server object 54internal Type GetLastCalledType(String newTypeName) 61Type t = lastType.type; 72internal void SetLastCalledType(String newTypeName, Type newType) 278Activator.CreateInstance((Type)_srvType, true); 340internal Type ServerType

system\runtime\remoting\soap.cs (21)

82public Type Type; 85public FieldEntry(Type type, String name) 98public void AddXmlElement(Type fieldType, String fieldName, 106public void AddXmlAttribute(Type fieldType, String fieldName, 115out Type type, out String name) 132out Type type, out String name) 152Type type) 161Type type) 169public static void PreLoad(Type type) 236Type[] types = assembly.GetTypes(); 237foreach (Type type in types) 244public static Type GetInteropTypeFromXmlElement(String xmlElement, String xmlNamespace) 246return (Type)_interopXmlElementToType[CreateKey(xmlElement, xmlNamespace)]; 251public static Type GetInteropTypeFromXmlType(String xmlType, String xmlTypeNamespace) 253return (Type)_interopXmlTypeToType[CreateKey(xmlType, xmlTypeNamespace)]; 257public static void GetInteropFieldTypeAndNameFromXmlElement(Type containingType, 259out Type type, out String name) 282public static void GetInteropFieldTypeAndNameFromXmlAttribute(Type containingType, 284out Type type, out String name) 308public static bool GetXmlElementForInteropType(Type type, 340public static bool GetXmlTypeForInteropType(Type type,

system\runtime\remoting\soapinteroptypes.cs (30)

system\runtime\remoting\stackbuildersink.cs (1)

378Type srvType = srvId.ServerType;

system\runtime\serialization\formatter.cs (4)

92protected abstract void WriteArray(Object obj, String name, Type memberType); 124protected abstract void WriteObjectRef(Object obj, String name, Type memberType); 137Type varType = data.GetType(); 205protected abstract void WriteValueType(Object obj, String name, Type memberType);

system\runtime\serialization\formatterconverter.cs (1)

28public Object Convert(Object value, Type type) {

system\runtime\serialization\formatters\binary\binarycommonclasses.cs (20)

38internal static BinaryTypeEnum GetBinaryTypeInfo(Type type, WriteObjectInfo objectInfo, String typeName, ObjectWriter objectWriter, out Object typeInformation, out int assemId) 105internal static BinaryTypeEnum GetParserBinaryTypeInfo(Type type, out Object typeInformation) 218out Type type, 317internal static void WriteWithCode(Type type, Object value, __BinaryWriter sout) 645Type[] instArgs; 651Type[] argTypes; 658internal Object[] WriteArray(String uri, String methodName, String typeName, Type[] instArgs, Object[] args, Object methodSignature, Object callContext, Object[] properties) 674argTypes = new Type[args.Length]; 833instArgs = (Type[])callA[arrayPosition++]; 907Type[] argTypes; 911Type returnType; 940argTypes = new Type[args.Length]; 2072internal Type objectType; 2076internal Type[] memberTypes; 2085internal ObjectMap(String objectName, Type objectType, String[] memberNames, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo) 2127memberTypes = new Type[memberNames.Length]; 2133Type type; 2167internal static ObjectMap Create(String name, Type objectType, String[] memberNames, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo) 2200internal Type dtType; 2216internal Type[] memberTypes;

system\runtime\serialization\formatters\binary\binaryconverter.cs (52)

system\runtime\serialization\formatters\binary\binaryformatter.cs (6)

53private static Dictionary<Type, TypeInformation> typeNameCache = new Dictionary<Type, TypeInformation>(); 54private static Lazy<ConcurrentDictionary<Type, TypeInformation>> concurrentTypeNameCache = new Lazy<ConcurrentDictionary<Type, TypeInformation>>(() => new ConcurrentDictionary<Type, TypeInformation>()); 239internal static TypeInformation GetTypeInformation(Type type)

system\runtime\serialization\formatters\binary\binaryformatterwriter.cs (6)

194internal Object[] WriteCallArray(String uri, String methodName, String typeName, Type[] instArgs, Object[] args, Object methodSignature, Object callContext, Object[] properties) 222internal void WriteObject(NameInfo nameInfo, NameInfo typeNameInfo, int numMembers, String[] memberNames, Type[] memberTypes, WriteObjectInfo[] memberObjectInfos) 694internal void WriteAssembly(Type type, String assemblyString, int assemId, bool isNew) 779Type[] memberTypes; 781internal ObjectMapInfo(int objectId, int numMembers, String[] memberNames, Type[] memberTypes) 789internal bool isCompatible(int numMembers, String[] memberNames, Type[] memberTypes)

system\runtime\serialization\formatters\binary\binarymethodmessage.cs (3)

23Type[] _instArgs = null; 31internal BinaryMethodCallMessage(String uri, String methodName, String typeName, Type[] instArgs, Object[] args, Object methodSignature, LogicalCallContext callContext, Object[] properties) 63public Type[] InstantiationArgs

system\runtime\serialization\formatters\binary\binaryobjectinfo.cs (33)

43internal Type objectType; 184internal static WriteObjectInfo Serialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder) 193internal void InitSerialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder) 285cache.memberTypes = new Type[count]; 303private static void CheckTypeForwardedFrom(SerObjectInfoCache cache, Type objectType, string binderAssemblyString) 349cache.memberTypes = new Type[count]; 399internal Type GetMemberType(MemberInfo objMember) 401Type objectType = null; 421internal void GetMemberInfo(out String[] outMemberNames, out Type[] outMemberTypes, out Object[] outMemberData) 466internal Type objectType; 483internal Type[] wireMemberTypes; 497internal List<Type> memberTypesList; 518internal static ReadObjectInfo Create(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, bool bSimpleAssembly) 528internal void Init(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, bool bSimpleAssembly) 544internal static ReadObjectInfo Create(Type objectType, String[] memberNames, Type[] memberTypes, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, bool bSimpleAssembly) 553internal void Init(Type objectType, String[] memberNames, Type[] memberTypes, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, bool bSimpleAssembly) 574private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context) 614memberTypesList = new List<Type>(20); 634cache.memberTypes = new Type[count]; 667internal Type GetType(String name) 670Type type = null; 678type = (Type)memberTypesList[position]; 810internal Type[] GetMemberTypes(String[] inMemberNames, Type objectType) 821cache.memberTypes = new Type[count]; 831Type[] outMemberTypes = new Type[cache.memberInfos.Length]; 871internal Type GetMemberType(MemberInfo objMember) 873Type objectType = null; 918internal Type[] memberTypes = null; 927internal SerObjectInfoCache(Type type)

system\runtime\serialization\formatters\binary\binaryobjectreader.cs (18)

325private bool HasSurrogate(Type t){ 333private void CheckSerializable(Type t) 363internal ReadObjectInfo CreateReadObjectInfo(Type objectType) 369internal ReadObjectInfo CreateReadObjectInfo(Type objectType, String[] memberNames, Type[] memberTypes) 457Type t = pr.PRdtType; 1334internal Type Bind(String assemblyString, String typeString) 1336Type type = null; 1347public Type type; 1353internal Type FastBindToType(String assemblyName, String typeName) 1355Type type = null; 1434private static void GetSimplyNamedTypeFromAssembly(Assembly assm, string typeName, ref Type type) 1449type = Type.GetType(typeName, ObjectReader.ResolveSimpleAssemblyName, new TopLevelAssemblyTypeResolver(assm).ResolveType, false /* throwOnError */); 1456private Type previousType; 1460internal Type GetType(BinaryAssemblyInfo assemblyInfo, String name) 1462Type objectType = null; 1502private static void CheckTypeForwardedTo(Assembly sourceAssembly, Assembly destAssembly, Type resolvedType) 1549public Type ResolveType(Assembly assembly, string simpleTypeName, bool ignoreCase)

system\runtime\serialization\formatters\binary\binaryobjectwriter.cs (21)

219Type[] instArgs = null; 358Type objType = objectInfo.objectType; 380Type[] memberTypes; 406Type type; 463Type[] memberTypes, 536Type memberType, 578Type memberType = memberNameInfo.NItype; 605Type outType = null; 734Type arrayType = objectInfo.objectType; 737Type arrayElemType = arrayType.GetElementType(); 905Type dataType = null; 1092private long InternalGetId(Object obj, bool assignUniqueIdToValueType, Type type, out bool isNew) 1122private long Schedule(Object obj, bool assignUniqueIdToValueType, Type type) 1127private long Schedule(Object obj, bool assignUniqueIdToValueType, Type type, WriteObjectInfo objectInfo) 1269private NameInfo TypeToNameInfo(Type type, WriteObjectInfo objectInfo, InternalPrimitiveTypeE code, NameInfo nameInfo) 1292private NameInfo TypeToNameInfo(Type type) 1307private void TypeToNameInfo(Type type, NameInfo nameInfo) 1319Type previousType = null; 1321internal InternalPrimitiveTypeE ToCode(Type type) 1388private Type GetType(Object obj) 1390Type type = null;

system\runtime\serialization\formatters\binary\binaryparser.cs (1)

584Type objectType = objectReader.GetType(assemblyInfo, record.name);

system\runtime\serialization\formatters\binary\binaryutilclasses.cs (4)

66internal Type PRdtType; 84internal Type PRarrayElementType; 698Type type = typeof(Header); 758internal Type NItype;

system\runtime\serialization\formatters\ifieldinfo.cs (1)

34Type[] FieldTypes

system\runtime\serialization\formatters\isoapmessage.cs (1)

36Type[] ParamTypes {get; set;}

system\runtime\serialization\formatters\soapmessage.cs (2)

30internal Type[] paramTypes; 49public Type[] ParamTypes

system\runtime\serialization\formatterservices.cs (15)

178public static MemberInfo[] GetSerializableMembers(Type type) { 186public static MemberInfo[] GetSerializableMembers(Type type, StreamingContext context) { 205static readonly Type[] advancedTypes = new Type[]{ 214public static void CheckTypeSecurity(Type t, TypeFilterLevel securityLevel) { 232public static Object GetUninitializedObject(Type type) { 246public static Object GetSafeUninitializedObject(Type type) { 297private static Binder s_binder = Type.DefaultBinder; 440public static Type GetTypeFromAssembly(Assembly assem, String name) { 477internal static string GetClrAssemblyName(Type type, out bool hasTypeForwardedFrom) { 494internal static string GetClrTypeFullName(Type type) { 503static string GetClrTypeFullNameForArray(Type type) { 521static string GetClrTypeFullNameForNonArrayTypes(Type type) { 526Type[] genericArguments = type.GetGenericArguments(); 530foreach (Type genericArgument in genericArguments) {

system\runtime\serialization\iformatterconverter.cs (1)

24Object Convert(Object value, Type type);

system\runtime\serialization\isurrogateselector.cs (1)

31ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector);

system\runtime\serialization\memberholder.cs (2)

27internal Type memberType; 30internal MemberHolder(Type type, StreamingContext ctx) {

system\runtime\serialization\objectclonehelper.cs (1)

41Type objectType = null;

system\runtime\serialization\objectmanager.cs (1)

759Type selectorType=null;

system\runtime\serialization\serializationbinder.cs (2)

22public virtual void BindToName(Type serializedType, out String assemblyName, out String typeName) 28public abstract Type BindToType(String assemblyName, String typeName);

system\runtime\serialization\serializationeventscache.cs (5)

32private List<MethodInfo> GetMethodsWithAttribute(Type attribute, Type t) 35Type baseType = t; 79internal SerializationEvents(Type t) 187internal static SerializationEvents GetSerializationEventsForType(Type t)

system\runtime\serialization\serializationfieldinfo.cs (5)

59public override Type DeclaringType { 65public override Type ReflectedType { 75public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { 79public override bool IsDefined(Type attributeType, bool inherit) { 86public override Type FieldType {

system\runtime\serialization\serializationinfo.cs (33)

system\runtime\serialization\serializationinfoenumerator.cs (6)

27private Type m_type; 43public Type ObjectType { 49internal SerializationEntry(String entryName, Object entryValue, Type entryType) { 65Type[] m_types; 70internal SerializationInfoEnumerator(String[] members, Object[] info, Type[] types, int numItems) { 139public Type ObjectType {

system\runtime\serialization\surrogateselector.cs (5)

34public virtual void AddSurrogate(Type type, StreamingContext context, ISerializationSurrogate surrogate) { 175public virtual ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector) { 196public virtual void RemoveSurrogate(Type type, StreamingContext context) { 212internal Type m_type; 215internal SurrogateKey(Type type, StreamingContext context) {

system\runtime\versioning\multitargetinghelpers.cs (3)

30private static Func<Type, String> defaultConverter = (t) => t.AssemblyQualifiedName; 34internal static string GetAssemblyQualifiedName(Type type, Func<Type, String> converter)

system\runtime\versioning\resourceattributes.cs (1)

114public static String MakeVersionSafeName(String name, ResourceScope from, ResourceScope to, Type type)

system\runtimehandles.cs (14)

58internal unsafe static Type GetTypeHelper(Type typeStart, Type[] genericArgs, IntPtr pModifiers, int cModifiers) 60Type type = typeStart; 222internal static IntPtr[] CopyRuntimeTypeHandles(Type[] inHandles, out int length) 386internal extern static Type[] GetInterfaces(RuntimeType type); 395internal Type[] GetConstraints() 397Type[] types = null; 633internal static Type GetTypeByName(string name, ref StackCrawlMark stackMark) 672internal Type[] GetInstantiationPublic() 674Type[] types = null; 686internal RuntimeType Instantiate(Type[] inst) 1387internal static Type[] GetMethodInstantiationPublic(IRuntimeMethodInfo method) 2233internal extern Type[] GetCustomModifiers(int position, bool required);

system\sbyte.cs (1)

280Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\security\accesscontrol\commonobjectsecurity.cs (3)

43private AuthorizationRuleCollection GetRules( bool access, bool includeExplicit, bool includeInherited, System.Type targetType ) 678public AuthorizationRuleCollection GetAccessRules( bool includeExplicit, bool includeInherited, System.Type targetType ) 683public AuthorizationRuleCollection GetAuditRules( bool includeExplicit, bool includeInherited, System.Type targetType )

system\security\accesscontrol\cryptokeysecurity.cs (3)

218public override Type AccessRightType 223public override Type AccessRuleType 228public override Type AuditRuleType

system\security\accesscontrol\directoryobjectsecurity.cs (3)

43private AuthorizationRuleCollection GetRules(bool access, bool includeExplicit, bool includeInherited, System.Type targetType) 757public AuthorizationRuleCollection GetAccessRules(bool includeExplicit, bool includeInherited, System.Type targetType) 762public AuthorizationRuleCollection GetAuditRules(bool includeExplicit, bool includeInherited, System.Type targetType)

system\security\accesscontrol\eventwaithandlesecurity.cs (3)

262public override Type AccessRightType 267public override Type AccessRuleType 272public override Type AuditRuleType

system\security\accesscontrol\filesecurity.cs (3)

610public override Type AccessRightType 615public override Type AccessRuleType 620public override Type AuditRuleType

system\security\accesscontrol\mutexsecurity.cs (3)

258public override Type AccessRightType 263public override Type AccessRuleType 268public override Type AuditRuleType

system\security\accesscontrol\objectsecurity.cs (5)

357public IdentityReference GetOwner( System.Type targetType ) 401public IdentityReference GetGroup( System.Type targetType ) 682public abstract Type AccessRightType { get; } 683public abstract Type AccessRuleType { get; } 684public abstract Type AuditRuleType { get; }

system\security\accesscontrol\objectsecurityt.cs (3)

371public override Type AccessRightType { 375public override Type AccessRuleType { 379public override Type AuditRuleType {

system\security\accesscontrol\registrysecurity.cs (3)

314public override Type AccessRightType 319public override Type AccessRuleType 324public override Type AuditRuleType

system\security\cryptography\asymmetrickeyexchangeformatter.cs (1)

39abstract public byte[] CreateKeyExchange(byte[] data, Type symAlgType);

system\security\cryptography\cryptoconfig.cs (34)

system\security\cryptography\rsaoaepkeyexchangedeformatter.cs (1)

64_rsaOverridesDecrypt = Utils.DoesRsaKeyOverride(_rsaKey, "Decrypt", new Type[] { typeof(byte[]), typeof(RSAEncryptionPadding) });

system\security\cryptography\rsaoaepkeyexchangeformatter.cs (2)

83public override byte[] CreateKeyExchange(byte[] rgbData, Type symAlgType) { 90_rsaOverridesEncrypt = Utils.DoesRsaKeyOverride(_rsaKey, "Encrypt", new Type[] { typeof(byte[]), typeof(RSAEncryptionPadding) });

system\security\cryptography\rsapkcs1keyexchangedeformatter.cs (1)

93_rsaOverridesDecrypt = Utils.DoesRsaKeyOverride(_rsaKey, "Decrypt", new Type[] { typeof(byte[]), typeof(RSAEncryptionPadding) });

system\security\cryptography\rsapkcs1keyexchangeformatter.cs (2)

98public override byte[] CreateKeyExchange(byte[] rgbData, Type symAlgType) { 105_rsaOverridesEncrypt = Utils.DoesRsaKeyOverride(_rsaKey, "Encrypt", new Type[] { typeof(byte[]), typeof(RSAEncryptionPadding) });

system\security\cryptography\rsapkcs1signaturedeformatter.cs (1)

97_rsaOverridesVerifyHash = Utils.DoesRsaKeyOverride(_rsaKey, "VerifyHash", new Type[] { typeof(byte[]), typeof(byte[]), typeof(HashAlgorithmName), typeof(RSASignaturePadding) });

system\security\cryptography\rsapkcs1signatureformatter.cs (1)

87_rsaOverridesSignHash = Utils.DoesRsaKeyOverride(_rsaKey, "SignHash", new Type[] { typeof(byte[]), typeof(HashAlgorithmName), typeof(RSASignaturePadding) });

system\security\cryptography\utils.cs (7)

589else if (hashAlg is Type) { 616else if (hashAlg is Type) { 1032internal static bool DoesRsaKeyOverride(RSA rsaKey, string methodName, Type[] parameterTypes) 1035Type t = rsaKey.GetType(); 1059private static bool DoesRsaKeyOverrideSlowPath(Type t, string methodName, Type[] parameterTypes) 1063Type declaringType = method.DeclaringType;

system\security\hostsecuritymanager.cs (4)

194public virtual Type[] GetHostSuppliedAppDomainEvidenceTypes() { 201public virtual Type[] GetHostSuppliedAssemblyEvidenceTypes(Assembly assembly) { 208public virtual EvidenceBase GenerateAppDomainEvidence(Type evidenceType) { 215public virtual EvidenceBase GenerateAssemblyEvidence(Type evidenceType, Assembly assembly) {

system\security\permissions\permissionattributes.cs (2)

110Type t = Type.GetType(typeName, false, false);

system\security\permissionset.cs (5)

404public IPermission GetPermission(Type permClass) 409protected virtual IPermission GetPermissionImpl(Type permClass) 469Type perm_type = perm.GetType(); 502public IPermission RemovePermission(Type permClass) 507protected virtual IPermission RemovePermissionImpl(Type permClass)

system\security\permissiontoken.cs (6)

151public static PermissionToken GetToken(Type cls) 225return FindToken( Type.GetType( typeStr ) ); 239public static PermissionToken FindToken( Type cls ) 359internal PermissionToken FindToken( Type cls ) 401internal PermissionToken GetToken(Type cls, IPermission perm) 509internal PermissionToken BuiltInGetToken( int index, IPermission perm, Type cls )

system\security\policy\appdomainevidencefactory.cs (1)

51public EvidenceBase GenerateEvidence(Type evidenceType)

system\security\policy\applicationsecuritymanager.cs (2)

172Type tmClass = Type.GetType(trustManagerName, false, false);

system\security\policy\assemblyevidencefactory.cs (1)

62public EvidenceBase GenerateEvidence(Type evidenceType)

system\security\policy\evidence.cs (61)

system\security\policy\evidencebase.cs (3)

77Type EvidenceType { get; } 103public Type EvidenceType 154public Type EvidenceType

system\security\policy\hash.cs (27)

system\security\policy\iruntimeevidencefactory.cs (1)

36EvidenceBase GenerateEvidence(Type evidenceType);

system\security\policy\pefileevidencefactory.cs (1)

212public EvidenceBase GenerateEvidence(Type evidenceType)

system\security\policy\policylevel.cs (2)

1300Type type = System.Type.GetType(className, false, false);

system\security\principal\identityreference.cs (2)

33public abstract bool IsValidTargetType( Type targetType ); 35public abstract IdentityReference Translate( Type targetType );

system\security\principal\ircollection.cs (5)

154public IdentityReferenceCollection Translate( Type targetType ) 161public IdentityReferenceCollection Translate( Type targetType, bool forceSuccess ) 197Type type = Identities[i].GetType(); 260Type type = id.GetType(); 357Type type = id.GetType();

system\security\principal\ntaccount.cs (4)

102public override bool IsValidTargetType( Type targetType ) 120public override IdentityReference Translate( Type targetType ) 175internal static IdentityReferenceCollection Translate( IdentityReferenceCollection sourceAccounts, Type targetType, bool forceSuccess) 202internal static IdentityReferenceCollection Translate( IdentityReferenceCollection sourceAccounts, Type targetType, out bool someFailed )

system\security\principal\sid.cs (5)

717internal static bool IsValidTargetTypeStatic( Type targetType ) 733public override bool IsValidTargetType( Type targetType ) 781public override IdentityReference Translate( Type targetType ) 1080internal static IdentityReferenceCollection Translate( IdentityReferenceCollection sourceSids, Type targetType, bool forceSuccess) 1108internal static IdentityReferenceCollection Translate( IdentityReferenceCollection sourceSids, Type targetType, out bool someFailed )

system\security\principal\windowsidentity.cs (1)

115new Type[] { typeof(SerializationInfo) },

system\security\readonlypermissionset.cs (2)

85protected override IPermission GetPermissionImpl(Type permClass) 116protected override IPermission RemovePermissionImpl(Type permClass)

system\security\securityexception.cs (4)

41[NonSerialized] private Type m_typeOfPermissionThatFailed; 176public SecurityException(String message, Type type ) 186public SecurityException(String message, Type type, String state ) 351public Type PermissionType

system\security\util\xmlutil.cs (8)

63AddClassAttribute( SecurityElement element, Type type, String typename ) 412Type permClass = null; 484Type groupClass = null; 618Type condClass = null; 633internal static Type 650return Type.GetType(className, false, false); 658return Type.GetType(className, true, false); 683public static String BitFieldEnumToString( Type type, Object value )

system\single.cs (1)

343Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\string.cs (1)

3435Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\stubhelpers.cs (10)

810internal static unsafe void ConvertContentsToNative_Type(ref System.Type[] managedArray, IntPtr pNativeHome) 884internal static unsafe void ConvertContentsToManaged_Type(ref System.Type[] managedArray, IntPtr pNativeHome) 1001private Type layoutType; 1028Type elementType = pManagedHome.GetType().GetElementType(); 1031switch (Type.GetTypeCode(elementType)) 1397internal static extern string ConvertToWinRTTypeName(System.Type managedType, out bool isPrimitive); 1400internal static extern System.Type GetTypeFromWinRTTypeName(string typeName, out bool isPrimitive); 1407internal static unsafe void ConvertToNative(System.Type managedType, TypeNameNative *pNativeType) 1451internal static unsafe void ConvertToManaged(TypeNameNative *pNativeType, ref System.Type managedType) 1467managedType = Type.GetType(typeName, /* throwOnError = */ true);

system\threading\synchronizationcontext.cs (8)

76static Type s_cachedPreparedType1; 77static Type s_cachedPreparedType2; 78static Type s_cachedPreparedType3; 79static Type s_cachedPreparedType4; 80static Type s_cachedPreparedType5; 98Type type = this.GetType(); 323Type factoryType = Type.GetType("System.Threading.WinRTSynchronizationContextFactory, " + AssemblyRef.SystemRuntimeWindowsRuntime, true);

system\threading\Tasks\TaskExceptionHolder.cs (1)

317var t = exceptions[i].SourceException.GetType();

system\throwhelper.cs (2)

59internal static void ThrowWrongKeyTypeArgumentException(object key, Type targetType) { 63internal static void ThrowWrongValueTypeArgumentException(object value, Type targetType) {

system\type.cs (126)

system\typedreference.cs (1)

113public static Type GetTargetType (TypedReference value)

system\typenameparser.cs (11)

77internal static Type GetType( 80Func<Assembly, string, bool, Type> typeResolver, 91Type ret = null; 131private unsafe Type ConstructType( 133Func<Assembly, string, bool, Type> typeResolver, 166Type baseType = ResolveType(assembly, names, typeResolver, throwOnError, ignoreCase, ref stackMark); 177Type[] types = null; 180types = new Type[typeArguments.Length]; 247private static Type ResolveType(Assembly assembly, string[] names, Func<Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark) 251Type type = null;

system\uint16.cs (1)

247Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\uint32.cs (1)

229Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\uint64.cs (1)

224Object IConvertible.ToType(Type type, IFormatProvider provider) {

system\unityserializationholder.cs (14)

75internal Type MakeElementTypes(Type type) 109info.AddValue("DeclaringType", type.DeclaringType, typeof(Type)); 121info.AddValue("GenericArguments", type.GetGenericArguments(), typeof(Type[])); 156private Type[] m_instantiation; 159private Type m_declaringType; 181m_declaringType = info.GetValue("DeclaringType", typeof(Type)) as Type; 190m_instantiation = info.GetValue("GenericArguments", typeof(Type[])) as Type[]; 248Type definition = GetRealObject(context) as Type; 277return Type.GetType(m_data, true, false); 281Type t = assembly.GetType(m_data, true, false);

system\variant.cs (5)

90internal static readonly Type [] ClassTypes = { 117internal static readonly Variant Missing = new Variant(Variant.CV_MISSING, Type.Missing, 0, 0); 297if (obj == Type.Missing) { 353unsafe public Variant(void* voidPointer,Type pointerType) { 411return Type.Missing;