ParameterType

System\Reflection\Runtime\ParameterInfos\RuntimeParameterInfo.cs (1)

63public abstract override Type ParameterType { get; }

System\Reflection\Context\Delegation\DelegatingParameterInfo.cs (1)

43public override Type ParameterType

System\Reflection\Emit\ParameterBuilderImpl.cs (1)

84public override Type ParameterType => _type;

System\Reflection\TypeLoading\Parameters\RoParameter.cs (1)

30public abstract override Type ParameterType { get; }

AzureFunctionsTests.cs (1)

25&& parameters[1].ParameterType == typeof(IResourceBuilder<IResource>));

AzureServiceBusExtensionsTests.cs (5)

878m.GetParameters()[2].ParameterType.IsArray && 879m.GetParameters()[2].ParameterType.GetElementType()?.Name == "AzureServiceBusRole") 882var roleType = method.GetParameters()[2].ParameterType.GetElementType()!; 905m.GetParameters()[2].ParameterType.IsArray && 906m.GetParameters()[2].ParameterType.GetElementType()?.Name == "AzureServiceBusRole")

AzureStorageExtensionsTests.cs (3)

1086m.GetParameters()[2].ParameterType.IsArray && 1087m.GetParameters()[2].ParameterType.GetElementType()?.Name == "AzureStorageRole") 1090var roleType = method.GetParameters()[2].ParameterType.GetElementType()!;

AtsTypeScriptCodeGeneratorTests.cs (3)

2506parameter => Assert.Equal(typeof(AtsContext), parameter.ParameterType), 2507parameter => Assert.Equal(typeof(ApiReferenceExportOptions), parameter.ParameterType), 2510Assert.Equal(typeof(CancellationToken), parameter.ParameterType);

AddNodeAppTests.cs (1)

22&& parameters[1].ParameterType == typeof(IResourceBuilder<IResource>));

AddPostgresTests.cs (1)

739&& parameters[1].ParameterType == typeof(IResourceBuilder<IResource>));

AddQdrantTests.cs (1)

22&& parameters[1].ParameterType == typeof(IResourceBuilder<IResource>));

Ats\AtsCallbackProxyFactory.cs (8)

74var paramExprs = parameters.Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray(); 84var ctParamIndex = Array.FindIndex(parameters, p => p.ParameterType == typeof(CancellationToken)); 146if (param.ParameterType == typeof(CancellationToken)) 161Expression.Constant(param.ParameterType, typeof(Type))); 311p.ParameterType != typeof(CancellationToken) && 312_marshaller.IsDtoType(p.ParameterType)); 358if (parameters[i].ParameterType != typeof(CancellationToken)) 360nonCtParams.Add((paramExprs[i], parameters[i].ParameterType));

Ats\CapabilityDispatcher.cs (3)

341param.ParameterType, 438param.ParameterType, 717var paramType = param.ParameterType;

Ats\GenericMethodResolver.cs (1)

43var paramType = parameters[j].ParameterType;

AtsCapabilityScanner.cs (7)

2018var firstParamType = firstParam.ParameterType; 2057$"Capability '{capabilityId}' skipped: parameter '{param.Name}' has unmapped type '{param.ParameterType.FullName}'", 2101var paramType = param.ParameterType; 2188var paramType = param.ParameterType; 3076CollectResourceTypeFromType(param.ParameterType, discoveredTypes); 3181CollectResourceTypeFromType(cbParam.ParameterType, discoveredTypes); 3834builder.AppendJoin(",", parameters.Select(parameter => GetXmlDocumentationParameterTypeName(parameter.ParameterType)));

AtsCapabilityScannerTests.cs (2)

583Assert.Equal(typeof(IResourceBuilder<global::Aspire.Hosting.Yarp.YarpResource>), parameters[0].ParameterType); 584Assert.Equal(typeof(Action<global::Aspire.Hosting.IYarpConfigurationBuilder>), parameters[1].ParameterType);

AtsEventingExportsTests.cs (2)

22var firstSubscriber = CreateCallback(method.GetParameters()[1].ParameterType); 23var secondSubscriber = CreateCallback(method.GetParameters()[1].ParameterType);

DebugSupportExtensionsTests.cs (5)

49parameters[0].ParameterType == typeof(IResource) && 50parameters[1].ParameterType == typeof(string) && 51parameters[2].ParameterType == typeof(CancellationToken); 60parameters[0].ParameterType == typeof(IResource) && 61parameters[1].ParameterType == typeof(LaunchConfigurationCallbackContext);

ResourceNotificationTests.cs (2)

1822return parameters.Length != 1 || parameters[0].ParameterType != type; 1828.Select(parameter => CreateValue(parameter.ParameterType))

WithEndpointTests.cs (2)

182method.GetParameters().Select(parameter => NormalizeGenericParameterType(parameter.ParameterType)).SequenceEqual(parameterTypes)); 189constructor.GetParameters().Select(parameter => parameter.ParameterType).SequenceEqual(parameterTypes));

FrameworkFork\Microsoft.Xml\Xml\Core\SecureStringHasher.cs (4)

97if (paramTypes.Length == 1 && paramTypes[0].ParameterType == typeof(string)) 101else if (paramTypes.Length == 3 && paramTypes[0].ParameterType == typeof(string) && paramTypes[1].ParameterType == typeof(int) && paramTypes[2].ParameterType == typeof(long))

FrameworkFork\Microsoft.Xml\Xml\Serialization\TypeExtensions.cs (1)

50parameters[0].ParameterType.IsAssignableFrom(sourceType))

FrameworkFork\Microsoft.Xml\Xml\Serialization\Types.cs (1)

1369if (parameters.Length == 1 && parameters[0].ParameterType == typeof(int))

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\ClassDataContract.cs (1)

1239if (parameters == null || parameters.Length != 1 || parameters[0].ParameterType != Globals.TypeOfStreamingContext)

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\CodeGenerator.cs (2)

196paramTypes[i] = parameters[i].ParameterType; 1456ConvertValue(GetVariableType(arg), methodInfo.GetParameters()[oneBasedArgIndex - 1].ParameterType);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\CollectionDataContract.cs (1)

1235if (addMethod == null || addMethod.GetParameters()[0].ParameterType != addMethodTypeArray[0])

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\Globals.cs (1)

1025matchedMethods = matchedMethods.Where(method => TypeSequenceEqual(method.GetParameters().Select(param => param.ParameterType).ToArray(), parameterTypes));

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\ServiceReflector.cs (7)

661if (!parameter.ParameterType.IsByRef) 688return paramInfo.ParameterType.IsByRef; 826parameters[parameters.Length - 2].ParameterType != s_asyncCallbackType || 827parameters[parameters.Length - 1].ParameterType != s_objectType || 886parameters[parameters.Length - 1].ParameterType != s_asyncResultType) 943if (IsParameterDisposable(inputInfo.ParameterType)) 951return (!IsParameterDisposable(methodInfo.ReturnParameter.ParameterType));

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\TypeLoader.cs (13)

574return ((parameterInfo1.ParameterType == parameterInfo2.ParameterType) && 1131if (parameters.Length == 1 && parameters[0].ParameterType.IsDefined(typeof(MessageContractAttribute), false)) 1133messageDescription = CreateTypedMessageDescription(parameters[0].ParameterType, 1522Type parameterType = parameterInfo.ParameterType; 1607if (_syncInputs[i].ParameterType != _asyncInputs[i].ParameterType) 1624if (_syncOutputs[i].ParameterType != _asyncOutputs[i].ParameterType) 1747if (_syncInputs[i].ParameterType != _taskInputs[i].ParameterType) 1865if (_taskInputs[i].ParameterType != _asyncInputs[i].ParameterType)

FrameworkFork\System.ServiceModel\System\ServiceModel\Dispatcher\InvokerUtil.cs (1)

40if (parameters[i].ParameterType.IsByRef)

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

src\5ff452f563f7a4b9\HostFactoryResolver.cs (1)

119&& typeof(string[]).Equals(factory.GetParameters()[0].ParameterType);

MSBuildTaskBase.cs (1)

70return GetType().GetMethod(ExecuteMethodName).GetParameters().Select(p => p.ParameterType).ToArray();

RenderTree\EventArgsTypeCache.cs (1)

37var declaredType = parameterInfos[0].ParameterType;

src\aspnetcore\src\Http\Routing\src\ParameterPolicyActivator.cs (2)

202if (typeof(IConvertible).IsAssignableFrom(parameters[i].ParameterType)) 218var parameterType = parameter.ParameterType;

FormMapping\Metadata\FormDataMetadataFactory.cs (4)

165var parameters = $"({string.Join(", ", result.Constructor.GetParameters().Select(p => p.ParameterType.Name))})"; 173Log.ConstructorParameter(_logger, type, parameter.Name!, parameter.ParameterType); 174var parameterTypeInfo = GetOrCreateMetadataFor(parameter.ParameterType, options); 177Log.ConstructorParameterTypeNotSupported(_logger, type, parameter.Name!, parameter.ParameterType);

FormMapping\Metadata\FormDataParameterMetadata.cs (1)

11public Type Type { get; set; } = parameter.ParameterType;

src\aspnetcore\src\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

src\aspnetcore\src\Shared\ActivatorUtilities\ActivatorUtilities.cs (3)

122_parameters[applyIndex].ParameterType.IsAssignableFrom(givenType)) 153var value = provider.GetService(parameter.ParameterType); 158throw new InvalidOperationException($"Unable to resolve service for type '{_parameters[index].ParameterType}' while attempting to activate '{_constructor.DeclaringType}'.");

src\aspnetcore\src\Shared\ParameterDefaultValue\ParameterDefaultValue.cs (5)

34bool isNullableParameterType = parameter.ParameterType.IsGenericType && 35parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>); 38if (defaultValue == null && parameter.ParameterType.IsValueType 41defaultValue = CreateValueType(parameter.ParameterType); 47Type? underlyingType = Nullable.GetUnderlyingType(parameter.ParameterType);

src\aspnetcore\src\Shared\StackTrace\StackFrame\StackTraceHelper.cs (1)

116var parameterType = parameter.ParameterType;

Internal\Binding\JsonTranscodingServiceMethodProvider.cs (1)

70new ReflectionServiceInvokerResolver<TService>(serviceParameter.ParameterType),

Internal\ConfigureBuilder.cs (3)

34if (parameterInfo.ParameterType == typeof(IApplicationBuilder)) 42parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType); 49parameterInfo.ParameterType.FullName,

Internal\ConfigureContainerBuilder.cs (1)

32return parameters[0].ParameterType;

Internal\ConfigureServicesBuilder.cs (1)

40parameters.Any(p => p.ParameterType != typeof(IServiceCollection)))

src\aspnetcore\src\Shared\StackTrace\StackFrame\StackTraceHelper.cs (1)

116var parameterType = parameter.ParameterType;

Extensions\UseMiddlewareExtensions.cs (4)

93if (parameters.Length == 0 || parameters[0].ParameterType != typeof(HttpContext)) 206var parameterType = parameters[i].ParameterType; 229var parameterType = parameters[i].ParameterType; 306var parameterType = parameter.ParameterType;

src\aspnetcore\src\Shared\ParameterDefaultValue\ParameterDefaultValue.cs (5)

34bool isNullableParameterType = parameter.ParameterType.IsGenericType && 35parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>); 38if (defaultValue == null && parameter.ParameterType.IsValueType 41defaultValue = CreateValueType(parameter.ParameterType); 47Type? underlyingType = Nullable.GetUnderlyingType(parameter.ParameterType);

src\aspnetcore\src\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

HeaderDictionaryTypeExtensions.cs (6)

269methodInfo.ReturnParameter.ParameterType.Equals(typeof(bool))) 273&& methodParams[0].ParameterType.Equals(typeof(string)) 275&& methodParams[1].ParameterType.Equals(type.MakeByRefType())) 306&& methodInfo.ReturnParameter.ParameterType.Equals(typeof(Boolean))) 310&& methodParams[0].ParameterType.Equals(typeof(IList<string>)) 312&& methodParams[1].ParameterType.Equals(typeof(IList<T>).MakeByRefType());

RequestDelegateFactory.cs (80)

src\aspnetcore\src\Components\Endpoints\src\FormMapping\Metadata\FormDataMetadataFactory.cs (4)

165var parameters = $"({string.Join(", ", result.Constructor.GetParameters().Select(p => p.ParameterType.Name))})"; 173Log.ConstructorParameter(_logger, type, parameter.Name!, parameter.ParameterType); 174var parameterTypeInfo = GetOrCreateMetadataFor(parameter.ParameterType, options); 177Log.ConstructorParameterTypeNotSupported(_logger, type, parameter.Name!, parameter.ParameterType);

src\aspnetcore\src\Components\Endpoints\src\FormMapping\Metadata\FormDataParameterMetadata.cs (1)

11public Type Type { get; set; } = parameter.ParameterType;

src\aspnetcore\src\Shared\EndpointMetadataPopulator.cs (4)

29if (typeof(IEndpointParameterMetadataProvider).IsAssignableFrom(parameter.ParameterType)) 35PopulateMetadataForParameterMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs); 38if (typeof(IEndpointMetadataProvider).IsAssignableFrom(parameter.ParameterType)) 44PopulateMetadataForEndpointMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs);

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

210var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType); 262var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutorFSharpSupport.cs (3)

238&& TypesHaveSameIdentity(parameters[0].ParameterType, fsharpAsyncGenericType) 239&& parameters[1].ParameterType == fsharpOptionOfTaskCreationOptionsType 240&& parameters[2].ParameterType == fsharpOptionOfCancellationTokenType)

src\aspnetcore\src\Shared\ParameterBindingMethodCache.cs (3)

302var nonNullableParameterType = Nullable.GetUnderlyingType(parameter.ParameterType) ?? parameter.ParameterType; 343var key = new ParameterLookupKey(parameters[i].Name!, parameters[i].ParameterType);

src\aspnetcore\src\Shared\PropertyAsParameterInfo.cs (5)

80throw new InvalidOperationException($"Encountered a parameter of type '{parameters[i].ParameterType}' without a name. Parameters must have a name."); 97var isNullable = Nullable.GetUnderlyingType(parameters[i].ParameterType) != null || 102throw new InvalidOperationException($"The nullable type '{TypeNameHelper.GetTypeDisplayName(parameters[i].ParameterType, fullName: false)}' is not supported."); 105var (constructor, constructorParameters) = cache.FindConstructor(parameters[i].ParameterType); 119var properties = parameters[i].ParameterType.GetProperties();

JsonPatchDocument.cs (1)

232builder.Metadata.Add(new AcceptsMetadata(["application/json-patch+json"], parameter.ParameterType));

ModelBinding\Metadata\ModelMetadataIdentity.cs (1)

64=> ForParameter(parameter, parameter.ParameterType);

src\aspnetcore\src\Shared\ParameterBindingMethodCache.cs (3)

302var nonNullableParameterType = Nullable.GetUnderlyingType(parameter.ParameterType) ?? parameter.ParameterType; 343var key = new ParameterLookupKey(parameters[i].Name!, parameters[i].ParameterType);

EndpointMetadataApiDescriptionProvider.cs (4)

195Type = parameter.ParameterInfo.ParameterType, 210ParameterType = parameter.ParameterType, 218throw new InvalidOperationException($"Encountered a parameter of type '{parameter.ParameterType}' without a name. Parameters must have a name."); 255var parameterType = parameter.ParameterInfo.ParameterType;

src\aspnetcore\src\Shared\PropertyAsParameterInfo.cs (5)

80throw new InvalidOperationException($"Encountered a parameter of type '{parameters[i].ParameterType}' without a name. Parameters must have a name."); 97var isNullable = Nullable.GetUnderlyingType(parameters[i].ParameterType) != null || 102throw new InvalidOperationException($"The nullable type '{TypeNameHelper.GetTypeDisplayName(parameters[i].ParameterType, fullName: false)}' is not supported."); 105var (constructor, constructorParameters) = cache.FindConstructor(parameters[i].ParameterType); 119var properties = parameters[i].ParameterType.GetProperties();

ApiExplorer\ApiConventionMatcher.cs (2)

41if (!IsTypeMatch(methodParameters[i].ParameterType, conventionParameter.ParameterType, typeMatchBehavior) ||

ApplicationModels\ControllerActionDescriptorBuilder.cs (1)

79ParameterType = parameterModel.ParameterInfo.ParameterType,

ApplicationModels\InferParameterBindingInfoConvention.cs (1)

175metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterInfo.ParameterType);

ApplicationModels\ParameterModel.cs (2)

24: base(parameterInfo.ParameterType, attributes) 80var parameterTypeName = TypeNameHelper.GetTypeDisplayName(ParameterInfo.ParameterType, fullName: false);

Filters\MiddlewareFilterConfigurationProvider.cs (3)

98if (parameterInfo.ParameterType == typeof(IApplicationBuilder)) 106parameters[index] = serviceProvider.GetRequiredService(parameterInfo.ParameterType); 112parameterInfo.ParameterType.FullName,

Infrastructure\ParameterDefaultValues.cs (2)

30if (defaultValue == null && parameterInfo.ParameterType.IsValueType) 32defaultValue = Activator.CreateInstance(parameterInfo.ParameterType);

ModelBinding\Metadata\DefaultBindingMetadataProvider.cs (1)

129property.Property.PropertyType == parameter.ParameterType);

ModelBinding\Metadata\DefaultModelMetadataProvider.cs (3)

100=> GetMetadataForParameter(parameter, parameter.ParameterType); 244parameterTypes[i] = parameter.ParameterType; 274var parameterType = constructorParameter.ParameterType;

ModelBinding\Metadata\ModelAttributes.cs (2)

99/// <see cref="ParameterInfo.ParameterType"/>. 185var typeAttributes = GetAttributesForType(parameterInfo.ParameterType).TypeAttributes!;

ModelBinding\ParameterBinder.cs (1)

252if (modelType != parameterInfo.ParameterType)

src\aspnetcore\src\Shared\EndpointMetadataPopulator.cs (4)

29if (typeof(IEndpointParameterMetadataProvider).IsAssignableFrom(parameter.ParameterType)) 35PopulateMetadataForParameterMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs); 38if (typeof(IEndpointMetadataProvider).IsAssignableFrom(parameter.ParameterType)) 44PopulateMetadataForEndpointMethod.MakeGenericMethod(parameter.ParameterType).Invoke(null, invokeArgs);

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

210var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType); 262var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutorFSharpSupport.cs (3)

238&& TypesHaveSameIdentity(parameters[0].ParameterType, fsharpAsyncGenericType) 239&& parameters[1].ParameterType == fsharpOptionOfTaskCreationOptionsType 240&& parameters[2].ParameterType == fsharpOptionOfCancellationTokenType)

src\aspnetcore\src\Shared\ParameterDefaultValue\ParameterDefaultValue.cs (5)

34bool isNullableParameterType = parameter.ParameterType.IsGenericType && 35parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>); 38if (defaultValue == null && parameter.ParameterType.IsValueType 41defaultValue = CreateValueType(parameter.ParameterType); 47Type? underlyingType = Nullable.GetUnderlyingType(parameter.ParameterType);

src\aspnetcore\src\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

ApplicationModels\CompiledPageActionDescriptorBuilder.cs (1)

111ParameterType = parameterModel.ParameterInfo.ParameterType,

ApplicationModels\PageParameterModel.cs (1)

23: base(parameterInfo.ParameterType, attributes)

Infrastructure\PageActionInvoker.cs (2)

239parameter.ParameterInfo.ParameterType.IsValueType) 241value = Activator.CreateInstance(parameter.ParameterInfo.ParameterType);

src\5ff452f563f7a4b9\HostFactoryResolver.cs (1)

119&& typeof(string[]).Equals(factory.GetParameters()[0].ParameterType);

ViewComponents\DefaultViewComponentHelper.cs (1)

117if (descriptor.Parameters.Count == 1 && descriptor.Parameters[0].ParameterType.IsAssignableFrom(arguments.GetType()))

Services\OpenApiGenerator.cs (18)

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

210var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType); 262var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutorFSharpSupport.cs (3)

238&& TypesHaveSameIdentity(parameters[0].ParameterType, fsharpAsyncGenericType) 239&& parameters[1].ParameterType == fsharpOptionOfTaskCreationOptionsType 240&& parameters[2].ParameterType == fsharpOptionOfCancellationTokenType)

src\aspnetcore\src\Shared\ParameterBindingMethodCache.cs (3)

302var nonNullableParameterType = Nullable.GetUnderlyingType(parameter.ParameterType) ?? parameter.ParameterType; 343var key = new ParameterLookupKey(parameters[i].Name!, parameters[i].ParameterType);

src\aspnetcore\src\Shared\PropertyAsParameterInfo.cs (5)

80throw new InvalidOperationException($"Encountered a parameter of type '{parameters[i].ParameterType}' without a name. Parameters must have a name."); 97var isNullable = Nullable.GetUnderlyingType(parameters[i].ParameterType) != null || 102throw new InvalidOperationException($"The nullable type '{TypeNameHelper.GetTypeDisplayName(parameters[i].ParameterType, fullName: false)}' is not supported."); 105var (constructor, constructorParameters) = cache.FindConstructor(parameters[i].ParameterType); 119var properties = parameters[i].ParameterType.GetProperties();

ParameterPolicyActivator.cs (2)

202if (typeof(IConvertible).IsAssignableFrom(parameters[i].ParameterType)) 218var parameterType = parameter.ParameterType;

src\aspnetcore\src\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

ValidationEndpointFilterFactory.cs (1)

135var parameterType = parameterInfo.ParameterType;

src\aspnetcore\src\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

src\aspnetcore\src\Shared\StackTrace\StackFrame\StackTraceHelper.cs (1)

116var parameterType = parameter.ParameterType;

Internal\HubMethodDescriptor.cs (10)

64if (p.ParameterType == typeof(CancellationToken)) 69else if (ReflectionHelper.IsStreamingType(p.ParameterType, mustBeDirectType: true)) 76StreamingParameters.Add(ValidateParameterStreamType(p.ParameterType.GetGenericArguments()[0], p.ParameterType)); 98if (keyedServiceProvider.IsKeyedService(GetServiceType(p.ParameterType), keyedServicesAttribute.Key)) 106throw new InvalidOperationException($"'{p.ParameterType}' is not in DI as a keyed service."); 131else if (serviceProviderIsService?.IsService(GetServiceType(p.ParameterType)) == true) 137}).Select(p => p.ParameterType).ToArray(); 141OriginalParameterTypes = methodExecutor.MethodParameters.Select(p => p.ParameterType).ToArray(); 245Expression.Convert(parameters[0], methodParameters[0].ParameterType),

Internal\TypedClientBuilder.cs (2)

123var paramTypes = parameters.Select(param => param.ParameterType).ToArray(); 299if (parameter.ParameterType.IsByRef)

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

210var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType); 262var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);

src\aspnetcore\src\Shared\ObjectMethodExecutor\ObjectMethodExecutorFSharpSupport.cs (3)

238&& TypesHaveSameIdentity(parameters[0].ParameterType, fsharpAsyncGenericType) 239&& parameters[1].ParameterType == fsharpOptionOfTaskCreationOptionsType 240&& parameters[2].ParameterType == fsharpOptionOfCancellationTokenType)

src\5ff452f563f7a4b9\HostFactoryResolver.cs (1)

119&& typeof(string[]).Equals(factory.GetParameters()[0].ParameterType);

Evaluation\Expander.Function.cs (6)

630Type t = method.GetParameters()[i].ParameterType; 1016if (parameters[n].ParameterType == typeof(char[])) 1020else if (parameters[n].ParameterType.GetTypeInfo().IsEnum && args[n] is string v && v.Contains('.')) 1022Type enumType = parameters[n].ParameterType; 1037coercedArguments[n] = Convert.ChangeType(args[n], parameters[n].ParameterType, CultureInfo.InvariantCulture); 1209if (parameters[i].ParameterType != parameterTypes[i])

Evaluation\IntrinsicFunctionOverload.cs (1)

38? Type.GetTypeCode(parameters[0].ParameterType)

Loader\LoadedType.cs (1)

342string.Equals(parameters[0].ParameterType.FullName, TaskEnvironmentTypeFullName, StringComparison.Ordinal))

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

StateFileBase.cs (1)

138if (parameters.Length == 1 && parameters[0].ParameterType == typeof(ITranslator))

WriteCodeFragment.cs (1)

508.Select(c => c.GetParameters().Select(p => p.ParameterType).ToArray())

DiaSymReader\SymUnmanagedFactory.cs (1)

86if (parameters.Length == 1 && parameters[0].ParameterType == typeof(string))

InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

75.SingleOrDefault(m => !m.IsStatic && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType.Equals(property.PropertyType));

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

Hosting\ObjectFormatter\CommonObjectFormatter.cs (3)

141if (parameter.ParameterType.IsByRef) 145builder.Append(TypeNameFormatter.FormatTypeName(parameter.ParameterType.GetElementType(), options)); 149builder.Append(TypeNameFormatter.FormatTypeName(parameter.ParameterType, options));

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

Rpc\RpcServer.cs (2)

155var lastParameterIsCancellationToken = methodParameters.Length > 0 && methodParameters[^1].ParameterType == typeof(CancellationToken); 169arguments[i] = request.Parameters[i].Deserialize(methodParameters[i].ParameterType, JsonSettings.SingleLineSerializerOptions);

Microsoft\CSharp\RuntimeBinder\ComInterop\TypeUtils.cs (1)

128if (pis[0].ParameterType != typeFrom)

Microsoft\CSharp\RuntimeBinder\RuntimeBinderExtensions.cs (2)

111return pi1.ParameterType.IsGenericallyEquivalentTo(pi2.ParameterType, method1, method2);

Microsoft\CSharp\RuntimeBinder\Semantics\Tree\MethodInfo.cs (2)

65if (!TypesAreEqual(parameters[i].ParameterType, genericParams[i].AssociatedSystemType)) 132if (!TypesAreEqual(parameters[i].ParameterType, genericInstanceParams[i].AssociatedSystemType))

Microsoft\CSharp\RuntimeBinder\Semantics\Tree\PropertyInfo.cs (1)

61if (!TypesAreEqual(parameters[i].ParameterType, genericInstanceParams[i].AssociatedSystemType))

Microsoft\CSharp\RuntimeBinder\SymbolTable.cs (4)

135AddConversionsForType(param.ParameterType); 1493if ((parameter.Attributes & ParameterAttributes.Optional) != 0 && !parameter.ParameterType.IsByRef) 1528else if ((parameter.Attributes & ParameterAttributes.HasDefault) != 0 && !parameter.ParameterType.IsByRef) 1663Type t = p.ParameterType;

src\runtime\src\libraries\Common\src\System\Runtime\InteropServices\ComEventsMethod.cs (4)

81if (pi.ParameterType.IsByRef 82&& pi.ParameterType.HasElementType 83&& pi.ParameterType.GetElementType()!.IsEnum) 87targetTypes[i] = pi.ParameterType.GetElementType();

DependencyInjectionValidation.cs (3)

145ServiceDescriptor parameterService = services.FirstOrDefault(s => IsMatchingServiceRegistration(s.ServiceType, p.ParameterType)); 159msgBuilder.Append(GetDisplayName(p.ParameterType)); 177msgBuilder.Append(GetDisplayName(p.ParameterType));

Functions\AIFunctionFactory.cs (4)

759if (parameterInfo.ParameterType == typeof(AIFunctionArguments) || 760parameterInfo.ParameterType == typeof(IServiceProvider)) 810Type pType = parameters[i].ParameterType; 918Type parameterType = parameter.ParameterType;

parent\parent\parent\eng\MSBuild\parent\parent\src\LegacySupport\NullabilityInfoContext\NullabilityInfoContext.cs (3)

79NullabilityInfo nullability = GetNullabilityInfo(parameterInfo.Member, parameterInfo.ParameterType, parser); 115CheckGenericParameters(nullability, metaMember, metaParameter.ParameterType, parameter.Member.ReflectedType); 445return property.GetSetMethod(true)!.GetParameters()[0].ParameterType;

Utilities\AIJsonUtilities.Schema.Create.cs (4)

99if (parameter.ParameterType == typeof(CancellationToken)) 123type: parameter.ParameterType, 908Type paramType = parameterInfo.ParameterType; 931Type parameterType = parameterInfo.ParameterType;

Utilities\AIJsonUtilitiesTests.cs (1)

377Type type = parameters[i].ParameterType;

Functions\AIFunctionFactoryTest.cs (3)

568ConfigureParameterBinding = p => p.ParameterType == typeof(IExcludedService) 898if (p.ParameterType == typeof(MyService)) 1400(a.Services as IKeyedServiceProvider)?.GetKeyedService(p.ParameterType, attr.Key) is { } s ? s :

ConfigurationBinder.cs (3)

659if (p.IsOut || p.IsIn || p.ParameterType.IsByRef) 1157parameter.ParameterType, 1170if (!CanBeNull(parameter.ParameterType))

src\runtime\src\libraries\Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs (5)

30bool isNullableParameterType = parameter.ParameterType.IsGenericType && 31parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>); 34if (defaultValue == null && parameter.ParameterType.IsValueType 37defaultValue = CreateValueType(parameter.ParameterType); 52Type? underlyingType = Nullable.GetUnderlyingType(parameter.ParameterType);

ServiceLookup\CallSiteFactory.cs (1)

757Type parameterType = parameter.ParameterType;

ServiceLookup\Expressions\ExpressionResolverBuilder.cs (1)

179parameterExpressions[i] = Convert(VisitCallSite(callSite.ParameterCallSites[i], context), parameters[i].ParameterType);

src\runtime\src\libraries\Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs (5)

30bool isNullableParameterType = parameter.ParameterType.IsGenericType && 31parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>); 34if (defaultValue == null && parameter.ParameterType.IsValueType 37defaultValue = CreateValueType(parameter.ParameterType); 52Type? underlyingType = Nullable.GetUnderlyingType(parameter.ParameterType);

ActivatorUtilities.cs (9)

409Type? parameterType = constructorParameter.ParameterType; 531constructorParameter.ParameterType, 701if (constructorParameters[j].ParameterType.IsAssignableFrom(givenParameter)) 765return serviceProviderIsKeyedService.IsKeyedService(parameterInfo.ParameterType, key); 772return serviceProviderIsService.IsService(parameterInfo.ParameterType); 785return keyedServiceProvider.GetKeyedService(parameterInfo.ParameterType, key); 792return serviceProvider.GetService(parameterInfo.ParameterType); 824_constructor.Parameters[applyIndex].ParameterType.IsAssignableFrom(givenType)) 869throw new InvalidOperationException(SR.Format(SR.UnableToResolveService, _constructor.Parameters[index].ParameterType, _constructor.Info.DeclaringType));

src\runtime\src\libraries\Common\src\Extensions\ParameterDefaultValue\ParameterDefaultValue.cs (5)

30bool isNullableParameterType = parameter.ParameterType.IsGenericType && 31parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>); 34if (defaultValue == null && parameter.ParameterType.IsValueType 37defaultValue = CreateValueType(parameter.ParameterType); 52Type? underlyingType = Nullable.GetUnderlyingType(parameter.ParameterType);

Generated\Basic.CompilerLog.Util\Basic.CompilerLog.Util.Impl.BasicGeneratedFilesAnalyzerReference\BindingExtensions.g.cs (1)

1156Type? temp201 = instance.ParameterType;

Infrastructure\DotNetDispatcher.cs (1)

481parameterTypes[i] = parameters[i].ParameterType;

Handlers\HybridWebView\HybridWebViewHandler.cs (1)

259 var paramType = dotnetParams[i].ParameterType;

BindingExpression.cs (4)

276 if (pi.CanRead && pi.GetMethod.GetParameters()[0].ParameterType == typeof(int)) 289 if (pi.CanRead && pi.GetMethod.GetParameters()[0].ParameterType == typeof(string)) 300 if (pi.CanRead && pi.GetMethod.GetParameters()[0].ParameterType == typeof(object)) 367 object arg = Convert.ChangeType(part.Content, parameter.ParameterType, CultureInfo.InvariantCulture);

TypeConversionHelper.cs (1)

151 && parameters[0].ParameterType.IsAssignableFrom(fromType);

ApplyPropertiesVisitor.cs (5)

174 addMethod.Invoke(source, new[] { value.ConvertTo(addMethod.GetParameters()[0].ParameterType, (Func<TypeConverter>)null, new XamlServiceProvider(node, Context), out xpe) }); 494 if (!parameters[i].ParameterType.IsAssignableFrom(eventInfo.EventHandlerType.GetMethod("Invoke").GetParameters()[i].ParameterType)) 753 addMethod.Invoke(collection, new[] { value.ConvertTo(addMethod.GetParameters()[0].ParameterType, (Func<TypeConverter>)null, serviceProvider, out exception) }); 821 addMethod.Invoke(collection, new[] { value.ConvertTo(addMethod.GetParameters()[0].ParameterType, (Func<TypeConverter>)null, serviceProvider, out exception) });

CreateValuesVisitor.cs (3)

265 if ((p[i].ParameterType.IsAssignableFrom(types[i]))) 268 if (!TypeConversionHelper.TryConvert(arguments[i], p[i].ParameterType, out var convertedValue)) 324 var convertedValue = value.ConvertTo(parameter.ParameterType, () => parameter, serviceProvider, out Exception e);

ComponentModel\ComponentCatalog.cs (3)

358if (parameters[0].ParameterType != typeof(IHostEnvironment)) 359throw Contracts.Except("Method '{0}', 1st parameter is {1}, but must be IHostEnvironment", method.Name, parameters[0].ParameterType); 360InputType = parameters[1].ParameterType;

ComponentModel\LoadableClassAttribute.cs (2)

201types[itypeBase + itype] = parm.ParameterType; 221Contracts.CheckParam(types[itypeBase + itype] == parm.ParameterType, nameof(sigTypes),

Utilities\FuncInstanceMethodInfo1`2.cs (2)

67Contracts.CheckParam(methodCallExpression.Method.GetParameters()[0].ParameterType == typeof(Type), nameof(expression), "Unexpected expression form"); 68Contracts.CheckParam(methodCallExpression.Method.GetParameters()[1].ParameterType == typeof(object), nameof(expression), "Unexpected expression form");

Utilities\FuncInstanceMethodInfo1`3.cs (2)

68Contracts.CheckParam(methodCallExpression.Method.GetParameters()[0].ParameterType == typeof(Type), nameof(expression), "Unexpected expression form"); 69Contracts.CheckParam(methodCallExpression.Method.GetParameters()[1].ParameterType == typeof(object), nameof(expression), "Unexpected expression form");

Utilities\FuncInstanceMethodInfo1`4.cs (2)

69Contracts.CheckParam(methodCallExpression.Method.GetParameters()[0].ParameterType == typeof(Type), nameof(expression), "Unexpected expression form"); 70Contracts.CheckParam(methodCallExpression.Method.GetParameters()[1].ParameterType == typeof(object), nameof(expression), "Unexpected expression form");

Utilities\FuncInstanceMethodInfo2`4.cs (2)

69Contracts.CheckParam(methodCallExpression.Method.GetParameters()[0].ParameterType == typeof(Type), nameof(expression), "Unexpected expression form"); 70Contracts.CheckParam(methodCallExpression.Method.GetParameters()[1].ParameterType == typeof(object), nameof(expression), "Unexpected expression form");

Utilities\FuncInstanceMethodInfo3`3.cs (2)

68Contracts.CheckParam(methodCallExpression.Method.GetParameters()[0].ParameterType == typeof(Type), nameof(expression), "Unexpected expression form"); 69Contracts.CheckParam(methodCallExpression.Method.GetParameters()[1].ParameterType == typeof(object), nameof(expression), "Unexpected expression form");

Utilities\FuncInstanceMethodInfo3`4.cs (2)

69Contracts.CheckParam(methodCallExpression.Method.GetParameters()[0].ParameterType == typeof(Type), nameof(expression), "Unexpected expression form"); 70Contracts.CheckParam(methodCallExpression.Method.GetParameters()[1].ParameterType == typeof(object), nameof(expression), "Unexpected expression form");

Data\SchemaDefinition.cs (1)

236internal Type ReturnType => Generator?.GetMethodInfo().GetParameters().LastOrDefault().ParameterType.GetElementType();

DataView\InternalSchemaDefinition.cs (2)

31public Type ComputedReturnType { get { return ReturnParameterInfo.ParameterType.GetElementType(); } } 112var parameterTypes = (from pInfo in parameterInfos select pInfo.ParameterType).ToArray();

Expression\CodeGen.cs (1)

1251if (Utils.Size(ps) > 0 && (type = ps[ps.Length - 1].ParameterType).IsArray)

Expression\LambdaBinder.cs (2)

1177var type = ps[i].ParameterType; 1444var type = best.Method.GetParameters()[ivMax].ParameterType;

Expression\Node.cs (1)

1054if (Utils.Size(ps) > 0 && ps[ps.Length - 1].ParameterType.IsArray)

MsDeploy\DynamicAssembly.cs (1)

156ParameterExpression[] parameters = eventParams?.Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray() ?? Array.Empty<ParameterExpression>();

ManagedNameUtilities\ManagedNameHelper.Reflection.cs (2)

205AppendTypeString(methodBuilder, p.ParameterType, closedType: true); 318var parameterType = GetTypeString(paramList[i].ParameterType, closedType: true);

Microsoft\VisualBasic\CompilerServices\ConversionResolution.vb (2)

649Dim inputType As System.Type = current.GetParameters(0).ParameterType 788Dim inputType As System.Type = current.GetParameters(0).ParameterType

Microsoft\VisualBasic\CompilerServices\LateBinding.vb (3)

1018If LastParam.ParameterType.IsArray() Then 1056If parameters(i).ParameterType.IsByRef Then 1083args(i) = ObjectType.CTypeHelper(oArg, Parameter.ParameterType)

Microsoft\VisualBasic\CompilerServices\NewLateBinding.vb (1)

1519PassToParameter(lastArgument, lastParameter, lastParameter.ParameterType)

Microsoft\VisualBasic\CompilerServices\ObjectFlowControl.vb (4)

120parameters(0).ParameterType IsNot forLoopArgumentType OrElse 121parameters(1).ParameterType IsNot forLoopArgumentType OrElse 131parameters(0).ParameterType IsNot forLoopArgumentType OrElse 132parameters(1).ParameterType IsNot forLoopArgumentType Then

Microsoft\VisualBasic\CompilerServices\OverloadResolution.vb (23)

Microsoft\VisualBasic\CompilerServices\Symbols.vb (3)

674Return IsArrayType(parameter.ParameterType) AndAlso parameter.IsDefined(GetType(ParamArrayAttribute), False) 692If parameter.ParameterType.IsPointer Then 1430If parameter.ParameterType.IsByRef Then

Microsoft\VisualBasic\CompilerServices\Utils.LateBinder.vb (2)

503Dim parameterType As Type = parameter.ParameterType 658propertyType = setParameters(setParameters.Length - 1).ParameterType

Microsoft\VisualBasic\CompilerServices\Utils.vb (2)

232Return pi1.ParameterType.IsGenericallyEquivalentTo(pi2.ParameterType, method1, method2)

Microsoft\VisualBasic\CompilerServices\VBBinder.vb (33)

286If LastParam.ParameterType.IsArray() Then 379If LastParam.ParameterType.IsArray() Then 552ParamArrayElementType = Parameters(ParamArrayIndex).ParameterType.GetElementType() 587ParmType = Parameters(ParamArrayIndex).ParameterType.GetElementType() 589ParmType = Parameters(ParmIndex).ParameterType 795ParamArrayElementType = Parameters(LastParmIndexToCheck).ParameterType.GetElementType() 803ParmType = Parameters(ParmIndex).ParameterType 1119If parms(ParmIndex).ParameterType.IsByRef Then 1165objs(ParmIndex) = ObjectType.CTypeHelper(args(ParmIndex), parms(ParmIndex).ParameterType) 1171objs(ParmIndex) = ObjectType.CTypeHelper(parms(ParmIndex).DefaultValue, parms(ParmIndex).ParameterType) 1178objs(SetValueIndex) = ObjectType.CTypeHelper(args(args.GetUpperBound(0)), parms(SetValueIndex).ParameterType) 1187ParamArrayElementType = parms(LastParmIndexToCheck).ParameterType.GetElementType() 1191ParmType = parms(LastParmIndexToCheck).ParameterType 1226objs(ArgIndex) = ObjectType.CTypeHelper(args(MappedArgIndex), parms(ArgIndex).ParameterType) 1228objs(ArgIndex) = ObjectType.CTypeHelper(parms(ArgIndex).DefaultValue, parms(ArgIndex).ParameterType) 1233objs(ParmIndex) = ObjectType.CTypeHelper(parms(ParmIndex).DefaultValue, parms(ParmIndex).ParameterType) 1290ParamArrayElementType0 = AmbigParams(ParamArrayIndex0).ParameterType.GetElementType() 1294If (objTmp Is Nothing) OrElse (AmbigParams(LastNonSetValueIndex0).ParameterType.IsInstanceOfType(objTmp)) Then 1303ParamArrayElementType1 = Parameters(ParamArrayIndex1).ParameterType.GetElementType() 1307If (objTmp Is Nothing) OrElse (Parameters(LastNonSetValueIndex1).ParameterType.IsInstanceOfType(objTmp)) Then 1336Type0 = AmbigParams(Index0).ParameterType 1376Type1 = Parameters(Index1).ParameterType 1411Type0 = AmbigParams(AmbigArgIndexes(ParmIndex)).ParameterType 1412Type1 = Parameters(ArgIndexes(ParmIndex)).ParameterType 1491paramType0 = param0(i).ParameterType 1497paramType1 = param1(ParamArrayIndex1).ParameterType 1500paramType1 = param1(i).ParameterType 1532paramType1 = p1(i).ParameterType 1536paramType2 = p2(i).ParameterType 1658Type0 = AmbigParams(Index0).ParameterType 1659Type1 = Parameters(Index1).ParameterType 1804ParmType = Parameters(ParamArrayIndex).ParameterType 1806ParmType = Parameters(ParmIndex).ParameterType

Mono.Cecil\Import.cs (1)

418 new ParameterDefinition (ImportType (parameter.ParameterType, context, parameter.GetRequiredCustomModifiers (), parameter.GetOptionalCustomModifiers ())));

MS\Internal\MarkupCompiler\MarkupCompiler.cs (5)

1836expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null); 1853expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null); 1888Debug.Assert(pis != null && pis.Length == 2 && KnownTypes.Types[(int)KnownElements.DependencyObject].IsAssignableFrom(pis[0].ParameterType)); 1889eventHandlerType = pis[1].ParameterType; 2038CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(pars[i].ParameterType, pars[i].Name);

src\wpf\src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlTypeMapper.cs (3)

1287if (pis == null || pis.Length != 2 || !dependencyObjectType.IsAssignableFrom(pis[0].ParameterType)) 1448if (pis == null || pis.Length != 2 || !dependencyObjectType.IsAssignableFrom(pis[0].ParameterType)) 2058propertyType = parameters.Length == 1 ? methodInfo.ReturnType : parameters[1].ParameterType;

MS\Internal\Data\IndexedEnumerable.cs (1)

494if (indexerParameters[0].ParameterType.IsAssignableFrom(typeof(int)))

MS\Internal\Data\PropertyPathWorker.cs (2)

1351Type paramType = (aryPI != null) ? aryPI[i].ParameterType : typeof(Object); 1424if (isIList && aryPI.Length == 1 && aryPI[0].ParameterType == typeof(int))

MS\Internal\Helper.cs (1)

651memberType = parameterInfos[1].ParameterType;

System\Windows\Markup\BamlRecordReader.cs (10)

System\Windows\Markup\BamlRecords.cs (1)

4668validType = paramInfo[1].ParameterType;

System\Windows\Markup\Primitives\ElementMarkupObject.cs (3)

91yield return new ElementConstructorArgument(value, parameters[i++].ParameterType, this); 262if (parameters[0].ParameterType == typeof(DependencyObject)) 266else if (parameters[0].ParameterType == typeof(XamlWriterMode))

System\Windows\Markup\XamlTypeMapper.cs (3)

1287if (pis == null || pis.Length != 2 || !dependencyObjectType.IsAssignableFrom(pis[0].ParameterType)) 1448if (pis == null || pis.Length != 2 || !dependencyObjectType.IsAssignableFrom(pis[0].ParameterType)) 2058propertyType = parameters.Length == 1 ? methodInfo.ReturnType : parameters[1].ParameterType;

src\roslyn\src\Compilers\Core\Portable\InternalUtilities\ReflectionUtilities.cs (1)

93if (p[i].ParameterType != paramTypes[i])

System\ComponentModel\DataAnnotations\CustomValidationAttribute.cs (3)

260if (parameterInfos.Length == 0 || parameterInfos[0].ParameterType.IsByRef) 272if ((parameterInfos.Length != 2) || (parameterInfos[1].ParameterType != typeof(ValidationContext))) 279_firstParameterType = parameterInfos[0].ParameterType;

System\ComponentModel\Composition\ContractNameServices.cs (1)

93WriteTypeWithNamespace(methodNameStringBuilder, parameters[i].ParameterType, formatGenericName);

System\ComponentModel\Composition\Primitives\ExportedDelegate.cs (1)

54parameterTypes[i] = parameters[i].ParameterType;

System\ComponentModel\Composition\ReflectionModel\ReflectionParameter.cs (1)

36get { return UnderlyingParameter.ParameterType; }

System\ComponentModel\Composition\ReflectionModel\ReflectionParameterImportDefinition.cs (1)

34return new ImportingParameter(this, new ImportType(ImportingLazyParameter.GetNotNullValue("parameter").ParameterType, Cardinality));

System\ComponentModel\Composition\ReflectionModel\ReflectionProperty.cs (1)

107return parameters[parameters.Length - 1].ParameterType;

System\ComponentModel\Composition\Registration\PartBuilder.cs (1)

411importBuilder.BuildAttributes(pi.ParameterType, ref attributes);

System\Composition\Convention\PartConventionBuilder.cs (2)

602importBuilder.BuildAttributes(pi.ParameterType, ref attributes); 616if (mi.ReturnParameter.ParameterType == typeof(void)

System\Composition\Hosting\Providers\Metadata\MetadataViewProvider.cs (1)

31return ci.IsPublic && ps.Length == 1 && ps[0].ParameterType == typeof(IDictionary<string, object>);

System\Composition\TypedParts\Discovery\DiscoveredPart.cs (3)

122var importInfo = ContractHelpers.GetImportInfo(pi.ParameterType, _attributeContext.GetDeclaredAttributes(partTypeAsType, pi), site); 187Expression.Convert(Expression.Call(Expression.Constant(a), s_activatorInvoke, contextParam, operationParm), pi.ParameterType); 191paramActivatorCalls[i] = Expression.Default(pi.ParameterType);

System\Configuration\CallbackValidatorAttribute.cs (1)

30if ((parameters.Length == 1) && (parameters[0].ParameterType == typeof(object)))

System\Diagnostics\TraceUtils.cs (1)

103Type paramtype = ctorparams[0].ParameterType;

System\Dynamic\Utils\DelegateHelpers.cs (8)

115Type parameterType = parameter.ParameterType; 129thunkTypeArgs[i] = parameters[i].ParameterType; 222thunkName.Append(parameters[i].ParameterType.Name); 223paramTypes[i + 1] = parameters[i].ParameterType; 249bool paramIsByReference = parameters[i].ParameterType.IsByRef; 250Type paramType = parameters[i].ParameterType; 290if (parameters[i].ParameterType.IsByRef) 292Type byrefToType = parameters[i].ParameterType.GetElementType()!;

System\Dynamic\Utils\ExpressionUtils.cs (1)

154Type pType = pi.ParameterType;

System\Dynamic\Utils\TypeExtensions.cs (2)

56if (!TypeUtils.AreReferenceAssignable(ps[i].ParameterType, argTypes[i])) 88if (pi.ParameterType.IsByRef)

System\Dynamic\Utils\TypeUtils.cs (1)

728if (pis.Length == 1 && AreEquivalent(pis[0].ParameterType, typeFrom))

System\Linq\Expressions\BinaryExpression.cs (13)

294!TypeUtils.AreEquivalent(method.GetParametersCached()[0].ParameterType.GetNonRefType(), Left.Type); 640ValidateParamsWithOperandsOrThrow(pms[0].ParameterType, left.Type, binaryType, method.Name); 641ValidateParamsWithOperandsOrThrow(pms[1].ParameterType, right.Type, binaryType, method.Name); 688ValidateParamsWithOperandsOrThrow(pis[0].ParameterType, left.Type, binaryType, name); 689ValidateParamsWithOperandsOrThrow(pis[1].ParameterType, right.Type, binaryType, name); 747Type pType = pi.ParameterType; 815if (pms[0].ParameterType != pms[1].ParameterType) 819if (method.ReturnType != pms[0].ParameterType) 860TypeUtils.AreEquivalent(pms[1].ParameterType, right.GetNonNullableType()); 1563if (!TypeUtils.AreEquivalent(pms[0].ParameterType, method.ReturnType)) 2769ValidateParamsWithOperandsOrThrow(pis[0].ParameterType, left.Type, ExpressionType.Power, name); 2770ValidateParamsWithOperandsOrThrow(pis[1].ParameterType, right.Type, ExpressionType.Power, name);

System\Linq\Expressions\Compiler\LambdaCompiler.Expressions.cs (1)

523Type type = parameter.ParameterType;

System\Linq\Expressions\Compiler\LambdaCompiler.Statements.cs (1)

248Type result = node.Comparison.GetParametersCached()[1].ParameterType.GetNonRefType();

System\Linq\Expressions\Compiler\LambdaCompiler.Unary.cs (1)

310Type paramType = pis[0].ParameterType;

System\Linq\Expressions\Compiler\StackSpiller.ChildRewriter.cs (1)

337if (parameters[i].ParameterType.IsByRef)

System\Linq\Expressions\Compiler\StackSpiller.cs (1)

1060if (method != null && method.GetParametersCached().Any(p => p.ParameterType.IsByRef))

System\Linq\Expressions\DynamicExpression.cs (1)

1016if (pi.Length == 0 || pi[0].ParameterType != typeof(CallSite)) throw Error.FirstArgumentMustBeCallSite();

System\Linq\Expressions\ElementInit.cs (1)

120if (pi.ParameterType.IsByRef)

System\Linq\Expressions\IndexExpression.cs (5)

331if (!TypeUtils.AreReferenceAssignable(parms[i].ParameterType, args[i].Type)) 414Type valueType = setParameters[setParameters.Length - 1].ParameterType; 441if (getParameters[i].ParameterType != setParameters[i].ParameterType) 504Type pType = pi.ParameterType;

System\Linq\Expressions\Interpreter\CallInstruction.cs (3)

67if (pi.ParameterType.IsByRef) 187return pi[index].ParameterType; 216types.Add(pi.ParameterType);

System\Linq\Expressions\Interpreter\LightCompiler.cs (3)

1049Type parameterType = parameter.ParameterType; 2181if (parameters[i].ParameterType.IsByRef) 2418if (parameters[i].ParameterType.IsByRef)

System\Linq\Expressions\LambdaExpression.cs (1)

950Type pType = pi.ParameterType;

System\Linq\Expressions\MethodCallExpression.cs (1)

1357Type pType = parms[i].ParameterType;

System\Linq\Expressions\NewExpression.cs (1)

255Type pType = pi.ParameterType;

System\Linq\Expressions\SwitchExpression.cs (4)

75!TypeUtils.AreEquivalent(SwitchValue.Type, Comparison.GetParametersCached()[0].ParameterType.GetNonRefType()); 214throw Error.SwitchValueTypeDoesNotMatchComparisonMethodParameter(switchValue.Type, leftParam.ParameterType); 232throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(rightOperandType, rightParam.ParameterType); 238throw Error.TestValueTypeDoesNotMatchComparisonMethodParameter(rightOperandType, rightParam.ParameterType);

System\Linq\Expressions\UnaryExpression.cs (3)

66return (operandIsNullable && !TypeUtils.AreEquivalent(Method.GetParametersCached()[0].ParameterType, Operand.Type)) || 349ValidateParamsWithOperandsOrThrow(u.Method!.GetParametersCached()[0].ParameterType, operand.Type, unaryType, name); 389ValidateParamsWithOperandsOrThrow(pms[0].ParameterType, operand.Type, unaryType, method.Name);

System\Runtime\CompilerServices\CallSite.cs (4)

337ContractUtils.Requires(pis.Length > 0 && pis[0].ParameterType == typeof(CallSite), nameof(T)); 349args[i - 1] = pi.ParameterType; 368ParameterExpression[] @params = Array.ConvertAll(invoke.GetParametersCached(), p => Expression.Parameter(p.ParameterType, p.Name)); 671ParameterExpression[] @params = Array.ConvertAll(invoke.GetParametersCached(), p => Expression.Parameter(p.ParameterType, p.Name));

System\Runtime\CompilerServices\CallSiteBinder.cs (2)

58if (pis[0].ParameterType != typeof(CallSite)) 66@params[i] = Expression.Parameter(pis[i + 1].ParameterType, "$arg" + i);

System\Linq\EnumerableRewriter.cs (4)

73arg = FixupQuotedExpression(pi.ParameterType, arg); 284Type leftParam = left[i].ParameterType; 285Type rightParam = right[i].ParameterType; 340Type parameterType = mParams[i].ParameterType;

Internal\Reflection\Augments\ReflectionAugments.cs (1)

369parameterTypes[i] = parameters[i].ParameterType;

Internal\Reflection\Extensions\NonPortable\CustomAttributeInstantiator.cs (1)

53Type parameterType = parameters[i].ParameterType;

src\runtime\src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (16)

144if (!par[j].ParameterType.IsArray) 150paramArrayType = par[j].ParameterType.GetElementType(); 160if (!par[lastArgPos].ParameterType.IsArray) 169paramArrayType = par[lastArgPos].ParameterType.GetElementType(); 177if (par[lastArgPos].ParameterType.IsArray 181if (!par[lastArgPos].ParameterType.IsAssignableFrom(argTypes[lastArgPos])) 182paramArrayType = par[lastArgPos].ParameterType.GetElementType(); 196pCls = par[j].ParameterType; 572Type pCls = par[j].ParameterType; 667Type pCls = par[j].ParameterType; 810Type pCls = par[j].ParameterType; 847Type pCls = par[j].ParameterType; 899c1 = p1[paramOrder1[i]].ParameterType; 904c2 = p2[paramOrder2[i]].ParameterType; 1110if (params1[i].ParameterType != params2[i].ParameterType)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipeMetadataGenerator.cs (2)

27EventParameterInfo.GetTypeInfoFromType(parameters[i].ParameterType, out TraceLoggingTypeInfo? paramTypeInfo); 28eventParams[i].SetInfo(parameters[i].Name!, parameters[i].ParameterType, paramTypeInfo);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (1)

29Type parameterType = parameters[i].ParameterType;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (5)

2132Type pType = infos[i].ParameterType; 2584types[i] = parameters[i].ParameterType; 3263manifest.AddEventParameter(args[fieldIdx].ParameterType, args[fieldIdx].Name!); 3473if (args.Length > 0 && args[0].ParameterType == typeof(Guid) && 3552Type dataType = parameter.ParameterType;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventTypes.cs (1)

182result[i] = TraceLoggingTypeInfo.GetInstance(paramInfos[i].ParameterType, recursionCheck);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\EventInfo.cs (1)

52Type c = p[i].ParameterType;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBase.cs (1)

136parameterTypes[i] = paramInfo[i].ParameterType;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\NullabilityInfoContext.cs (3)

76NullabilityInfo nullability = GetNullabilityInfo(parameterInfo.Member, parameterInfo.ParameterType, parser); 112CheckGenericParameters(nullability, metaMember, metaParameter.ParameterType, parameter.Member.ReflectedType); 447return property.GetSetMethod(true)!.GetParametersAsSpan()[0].ParameterType;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\ParameterInfo.cs (1)

105string typeName = ParameterType.FormatTypeName();

src\runtime\src\libraries\System.Private.CoreLib\src\System\Reflection\SignatureTypeExtensions.cs (2)

20return signatureType.MatchesExactly(parameter.ParameterType); 22return pattern == (object)(parameter.ParameterType);

System\Reflection\DynamicInvokeInfo.cs (1)

76Type argumentType = parameters[i].ParameterType;

System\Reflection\Runtime\BindingFlagSupport\MemberPolicies.cs (4)

104Type parameterType1 = p1[i].ParameterType; 105Type parameterType2 = p2[i].ParameterType; 118Type parameterType1 = p1[i].ParameterType; 119Type parameterType2 = p2[i].ParameterType;

System\Reflection\Runtime\BindingFlagSupport\Shared.cs (1)

105if (!lastParameter.ParameterType.IsArray)

System\Reflection\Runtime\MethodInfos\CustomMethodMapper.cs (1)

37parameterTypes[i] = parameterInfos[i].ParameterType;

System\Reflection\Runtime\MethodInfos\RuntimeMethodInfo.cs (7)

227return ReturnParameter.ParameterType; 315Type expectedReturnType = ReturnParameter.ParameterType; 316Type actualReturnType = invokeMethod.ReturnParameter.ParameterType; 351if (target != null && !IsAssignableFrom(targetParameterEnumerator.Current.ParameterType, target.GetType())) 377if (!IsAssignableFrom(firstParameterOfMethodType, delegateParameterEnumerator.Current.ParameterType)) 389if (!IsAssignableFrom(targetParameterEnumerator.Current.ParameterType, delegateParameterEnumerator.Current.ParameterType))

System\Runtime\Serialization\ClassDataContract.cs (2)

1113if (parameters == null || parameters.Length != 1 || parameters[0].ParameterType != Globals.TypeOfExtensionDataObject) 1136if (parameters == null || parameters.Length != 1 || parameters[0].ParameterType != Globals.TypeOfStreamingContext)

System\Runtime\Serialization\CodeGenerator.cs (2)

126paramTypes[i] = parameters[i].ParameterType; 1116ConvertValue(GetVariableType(arg), methodInfo.GetParameters()[oneBasedArgIndex - 1].ParameterType);

System\Runtime\Serialization\CollectionDataContract.cs (1)

1317if (addMethod == null || addMethod.GetParameters()[0].ParameterType != addMethodTypeArray[0])

System\Runtime\Serialization\Json\JsonFormatReaderGenerator.cs (1)

184paramTypes[i] = parameters[i].ParameterType;

System\Runtime\Serialization\Json\JsonFormatWriterGenerator.cs (1)

119paramTypes[i] = parameters[i].ParameterType;

Internal\Reflection\Execution\PayForPlayExperience\MissingMetadataExceptionCreator.cs (1)

52friendlyName.Append(parameter.ParameterType);

TestAccessor.cs (1)

67Type[] types = invokeMethodInfo is null ? [] : [.. invokeMethodInfo.GetParameters().Select(pi => pi.ParameterType)];

System\Xml\Serialization\Compiler.cs (1)

50AddImport(parms[j].ParameterType, types);

System\Xml\Serialization\TypeExtensions.cs (1)

49parameters[0].ParameterType.IsAssignableFrom(sourceType))

System\Xml\Serialization\Types.cs (1)

1422if (parameters.Length == 1 && parameters[0].ParameterType == typeof(int))

System\Xml\Serialization\XmlSerializationReaderILGen.cs (1)

2942Type addParameterType = Add.GetParameters()[0].ParameterType;

System\Xml\Xsl\IlGen\GenerateHelper.cs (1)

827strBldr.Append(paramInfo.ParameterType.Name);

System\Xml\Xsl\Runtime\XmlExtensionFunction.cs (1)

240_argClrTypes[i] = GetClrType(paramInfo[i].ParameterType);

System\Xml\Xsl\XsltOld\XsltCompileContext.cs (3)

166XPathResultType actual = GetXPathType(parameters[par].ParameterType); 976_types[i] = parameters[i].ParameterType; 977argTypes[i] = GetXPathType(parameters[i].ParameterType);

System\Reflection\Context\Delegation\DelegatingParameterInfo.cs (1)

45get { return UnderlyingParameter.ParameterType; }

System\Reflection\Context\Virtual\VirtualParameter.cs (4)

37clonedParameters[i] = new VirtualParameter(member, parameter.ParameterType, parameter.Name, parameter.Position); 49ParameterType == other.ParameterType; 56ParameterType.GetHashCode();

src\runtime\src\libraries\Common\src\System\Reflection\Emit\IgnoreAccessChecksToAttributeBuilder.cs (1)

80c.GetParameters()[0].ParameterType == typeof(AttributeTargets));

System\Reflection\DispatchProxyGenerator.cs (5)

394PropertyBuilder pb = _tb.DefineProperty(pi.Name, pi.Attributes, pi.PropertyType, pi.GetIndexParameters().Select(p => p.ParameterType).ToArray()); 430paramTypes[i] = parameters[i].ParameterType; 479bool isOutRef = parameters[i].IsOut && parameters[i].ParameterType.IsByRef && !parameters[i].IsIn; 485argsArr.EndSet(parameters[i].ParameterType); 538if (parameters[i].ParameterType.IsByRef)

System\Reflection\Emit\CustomAttributeWrapper.cs (1)

56info._ctorArgs[i] = DecodeCustomAttributeValue(pi[i].ParameterType, binaryAttribute, pos, out pos);

System\Reflection\Emit\TypeBuilderImpl.cs (1)

1301parameterTypes[i] = parameterInfos[i].ParameterType;

System\Reflection\DefaultBinder.cs (8)

77Type pCls = par[j].ParameterType; 180Type pCls = par[j].ParameterType; 291Type pCls = par[j].ParameterType; 328Type pCls = par[j].ParameterType; 380c1 = p1[paramOrder1[i]].ParameterType; 385c2 = p2[paramOrder2[i]].ParameterType; 569if (params1[i].ParameterType != params2[i].ParameterType)

System\Reflection\Runtime\BindingFlagSupport\MemberPolicies.cs (4)

97Type parameterType1 = p1[i].ParameterType; 98Type parameterType2 = p2[i].ParameterType; 111Type parameterType1 = p1[i].ParameterType; 112Type parameterType2 = p2[i].ParameterType;

System\Reflection\Runtime\SignatureTypeExtensions.cs (2)

21return pattern.MatchesExactly(parameter.ParameterType); 23return pattern == (object)(parameter.ParameterType);

System\Reflection\TypeLoading\Methods\RoMethod.cs (1)

96public sealed override Type ReturnType => ReturnParameter.ParameterType;

System\Resources\Extensions\BinaryFormat\Deserializer\PendingSerializationInfo.cs (2)

73&& parameters[0].ParameterType == typeof(SerializationInfo) 74&& parameters[1].ParameterType == typeof(StreamingContext))

System\Runtime\InteropServices\Marshalling\ComImportInteropInterfaceDetailsStrategy.cs (1)

94parameterTypes[i] = parameters[i].ParameterType;

System\Runtime\InteropServices\JavaScript\JSHostImplementation.cs (1)

223if (parameterInfos.Length > 0 && parameterInfos[0].ParameterType == typeof(string[]))

System\Runtime\Serialization\ObjectManager.cs (2)

803parameters[0].ParameterType == typeof(SerializationInfo) && 804parameters[1].ParameterType == typeof(StreamingContext))

System\ServiceModel\Description\ServiceReflector.cs (7)

698if (!parameter.ParameterType.IsByRef) 725return paramInfo.ParameterType.IsByRef; 863parameters[parameters.Length - 2].ParameterType != s_asyncCallbackType || 864parameters[parameters.Length - 1].ParameterType != s_objectType || 923parameters[parameters.Length - 1].ParameterType != s_asyncResultType) 983if (IsParameterDisposable(inputInfo.ParameterType)) 991return (!IsParameterDisposable(methodInfo.ReturnParameter.ParameterType));

System\ServiceModel\Description\TypeLoader.cs (13)

587return ((parameterInfo1.ParameterType == parameterInfo2.ParameterType) && 1158if (parameters.Length == 1 && parameters[0].ParameterType.IsDefined(typeof(MessageContractAttribute), false)) 1160messageDescription = CreateTypedMessageDescription(parameters[0].ParameterType, 1576Type parameterType = parameterInfo.ParameterType; 1664if (_syncInputs[i].ParameterType != _asyncInputs[i].ParameterType) 1681if (_syncOutputs[i].ParameterType != _asyncOutputs[i].ParameterType) 1804if (_syncInputs[i].ParameterType != _taskInputs[i].ParameterType) 1922if (_taskInputs[i].ParameterType != _asyncInputs[i].ParameterType)

System\ServiceModel\Dispatcher\InvokerUtil.cs (4)

58if (parameters[i].ParameterType.IsByRef) 128Type variableType = parameters[i].ParameterType.IsByRef 129? parameters[i].ParameterType.GetElementType() 130: parameters[i].ParameterType;

Internal\SrgsCompiler\AppDomainGrammarProxy.cs (2)

210values[j] = ParseValue(paramInfo[j].ParameterType, pair._value); 263sb.Append(pi.ParameterType.Name);

Recognition\Grammar.cs (2)

788values[j] = ParseValue(paramInfo[j].ParameterType, pair._value); 839sb.Append(pi.ParameterType.Name);

src\runtime\src\libraries\System.Text.Json\Common\ReflectionExtensions.cs (1)

290Type parameterType = parameterInfo.ParameterType;

System\Text\Json\Serialization\Converters\Object\ObjectConverterFactory.cs (2)

73Type parameterType = parameter.ParameterType; 102Type parameterType = parameters[i].ParameterType;

System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Helpers.cs (2)

772Type parameterType = reflectionInfo.ParameterType; 974if (!parameterInfo.ParameterType.IsNullableType())

System\Text\Json\Serialization\Metadata\DefaultJsonTypeInfoResolver.Union.cs (3)

309if (!parameter.IsOut || !parameter.ParameterType.IsByRef) 314Type caseType = parameter.ParameterType.GetElementType()!; 512Type parameterType = parameter.ParameterType;

System\Text\Json\Serialization\Metadata\ReflectionEmitMemberAccessor.cs (6)

116Type paramType = parameters[i].ParameterType; 153Type paramType = parameters[i].ParameterType; 195Type parameterType = parameters[0].ParameterType; 268if (parameters[index].ParameterType.IsByRef) 270Type elementType = parameters[index].ParameterType.GetElementType()!; 309if (parameters[index].ParameterType.IsByRef)

System\Windows\Forms\ComponentModel\COM2Interop\COM2IManagedPerPropertyBrowsingHandler.cs (1)

158if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(value.GetType()))

System\ComponentModel\Design\InheritedPropertyDescriptor.cs (3)

53if (name.Equals("AddRange") && parameter.ParameterType.IsArray) 55collectionType = parameter.ParameterType.GetElementType(); 59collectionType = parameter.ParameterType;

System\ComponentModel\Design\Serialization\CodeDomSerializerBase.cs (4)

733paramTypes[idx] = delegateParams[i].ParameterType; 1961newCtx = new ExpressionContext(ctx.Expression, parameters[i].ParameterType, ctx.Owner); 1981if (arg is not null && !parameters[i].ParameterType.IsAssignableFrom(arg.GetType())) 1983exp = new CodeCastExpression(parameters[i].ParameterType, exp);

System\ComponentModel\Design\Serialization\CollectionCodeDomSerializer.cs (4)

247Type type = parameter.ParameterType; 337if (parameters is [{ ParameterType.IsArray: true }] && MethodSupportsSerialization(method)) 357Type elementType = provider.GetRuntimeType(addRangeMethodToUse.GetParameters()[0].ParameterType.GetElementType()!); 366Type elementType = provider.GetRuntimeType(addMethodToUse.GetParameters()[0].ParameterType);

System\ComponentModel\Design\Serialization\DesignerSerializationManager.cs (2)

315if (types[t] is null || parameters[t].ParameterType.IsAssignableFrom(types[t])) 326tempArgs[t] = convertible.ToType(parameters[t].ParameterType, null);

System\Xaml\Runtime\DynamicMethodRuntime.cs (5)

372Type paramType = parameters[i].ParameterType; 427Type targetType = getter.IsStatic ? getter.GetParameters()[0].ParameterType : GetTargetType(getter); 446Type targetType = setter.IsStatic ? parameters[0].ParameterType : GetTargetType(setter); 447Type valueType = setter.IsStatic ? parameters[1].ParameterType : parameters[0].ParameterType;

System\Xaml\Schema\TypeReflector.cs (4)

655if (getterParams[0].ParameterType == setterParams[0].ParameterType && 656curGetter.ReturnType == setterParams[1].ParameterType) 979return (pmi.Length == 2) && typeof(Delegate).IsAssignableFrom(pmi[1].ParameterType);

System\Xaml\XamlMember.cs (2)

687Type result = parameters[0].ParameterType; 1028return parameters[1].ParameterType;

System\Xaml\XamlObjectReader.cs (9)

1283if (parameterInfo.ParameterType.IsValueType) 1285if (!(parameterInfo.ParameterType.IsGenericType && 1286parameterInfo.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>))) 1288throw new XamlObjectReaderException(SR.Format(SR.ObjectReaderInstanceDescriptorIncompatibleArgumentTypes, "null", parameterInfo.ParameterType)); 1292else if (!parameterInfo.ParameterType.IsAssignableFrom(argument.GetType())) 1294throw new XamlObjectReaderException(SR.Format(SR.ObjectReaderInstanceDescriptorIncompatibleArgumentTypes, argument.GetType(), parameterInfo.ParameterType)); 1337XamlType paramXamlType = context.GetXamlType(cstrParams[i++].ParameterType); 1657if ((potentialProperty.Type.UnderlyingType == paraminfo.ParameterType) && 2117property.Type.UnderlyingType == parameter.ParameterType)

System\Xaml\XamlType.cs (4)

984return SchemaContext.GetXamlType(addParams[0].ParameterType); 1004result = addParams[1].ParameterType; 1008result = addParams[0].ParameterType; 1702Type type = param.ParameterType;

System\Xaml\XamlXmlWriter.cs (1)

1933if ((potentialProperty.Type.UnderlyingType == paraminfo.ParameterType) &&