ParameterType

Validation\RuntimeValidatableParameterInfoResolverTests.cs (1)

189public override Type ParameterType => typeof(string);

src\System\Reflection\RuntimeParameterInfo.cs (1)

214public override Type ParameterType

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

43public override Type ParameterType

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

85public override Type ParameterType => _type;

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

30public abstract override Type ParameterType { get; }

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)

.packages\microsoft.extensions.hostfactoryresolver.sources\10.0.0-preview.5.25257.101\contentFiles\cs\netstandard2.0\HostFactoryResolver.cs (1)

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

src\Servers\IIS\IIS\test\testassets\shared\WebSockets\TestStartup.cs (2)

28if (parameters[0].ParameterType == typeof(IApplicationBuilder)) 34else if (parameters[0].ParameterType == typeof(HttpContext))

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

MSBuildTaskBase.cs (1)

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

RouteEmbeddedLanguage\Infrastructure\ExportProviderExtensions.cs (2)

42where method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(string) 52where method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(string)

src\Tools\Shared\TestHelpers\TestConsole.cs (1)

52.Single(c => c.GetParameters().First().ParameterType == typeof(ConsoleSpecialKey));

RenderTree\EventArgsTypeCache.cs (1)

28var declaredType = parameterInfos[0].ParameterType;

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

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

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

291var parameterType = parameters[0].ParameterType;

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\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\Shared\StackTrace\StackFrame\StackTraceHelper.cs (1)

116var parameterType = parameter.ParameterType;

Internal\Binding\JsonTranscodingServiceMethodProvider.cs (1)

67new 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\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\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\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

Validation\RuntimeValidatableParameterInfoResolver.cs (3)

26throw new InvalidOperationException($"Encountered a parameter of type '{parameterInfo.ParameterType}' without a name. Parameters must have a name."); 36if (validationAttributes.Length == 0 && !IsClass(parameterInfo.ParameterType)) 42parameterType: parameterInfo.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 (75)

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\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

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

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

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

src\Shared\ParameterBindingMethodCache.cs (3)

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

src\Shared\PropertyAsParameterInfo.cs (5)

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

ParameterBindingMethodCacheTests.cs (17)

PropertyAsParameterInfoTests.cs (2)

19Assert.Equal(propertyInfo.PropertyType, parameterInfo.ParameterType); 32Assert.Equal(propertyInfo.PropertyType, parameterInfo.ParameterType);

RequestDelegateFactoryTests.cs (10)

RequestDelegateGenerator\SharedTypes.cs (11)

ValidationsGenerator\ValidationsGeneratorTestBase.cs (1)

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

src\Http\Http.Extensions\test\RequestDelegateGenerator\SharedTypes.cs (11)

ModelBinding\Metadata\ModelMetadataIdentity.cs (1)

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

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)

194Type = parameter.ParameterInfo.ParameterType, 209ParameterType = parameter.ParameterType, 217throw new InvalidOperationException($"Encountered a parameter of type '{parameter.ParameterType}' without a name. Parameters must have a name."); 254var parameterType = parameter.ParameterInfo.ParameterType;

src\Shared\PropertyAsParameterInfo.cs (5)

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

DefaultApiDescriptionProviderTest.cs (1)

2366ParameterType = parameter.ParameterType,

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\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\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

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

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

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

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\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

ActionParametersIntegrationTest.cs (3)

767ParameterType = parameterInfo.ParameterType 812ParameterType = parameterInfo.ParameterType, 856ParameterType = parameterInfo.ParameterType,

ValidationIntegrationTests.cs (5)

2031ParameterType = parameterInfo.ParameterType, 2083ParameterType = parameterInfo.ParameterType, 2153ParameterType = parameterInfo.ParameterType, 2477ParameterType = parameterInfo.ParameterType, 2528ParameterType = parameterInfo.ParameterType,

ValidationWithRecordIntegrationTests.cs (4)

1822ParameterType = parameterInfo.ParameterType, 1874ParameterType = parameterInfo.ParameterType, 1944ParameterType = parameterInfo.ParameterType, 2263ParameterType = parameterInfo.ParameterType,

ApplicationModels\CompiledPageActionDescriptorBuilder.cs (1)

111ParameterType = parameterModel.ParameterInfo.ParameterType,

ApplicationModels\PageParameterModel.cs (1)

23: base(parameterInfo.ParameterType, attributes)

Infrastructure\PageActionInvoker.cs (2)

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

ApplicationModels\DefaultPageApplicationModelProviderTest.cs (2)

913Assert.Equal(typeof(string), p.ParameterInfo.ParameterType); 919Assert.Equal(typeof(int), p.ParameterInfo.ParameterType);

Infrastructure\ExecutorFactoryTest.cs (3)

196else if (methodParameter.ParameterType.GetTypeInfo().IsValueType) 198defaultValue = Activator.CreateInstance(methodParameter.ParameterType); 213ParameterType = p.ParameterType,

Infrastructure\PageBinderFactoryTest.cs (1)

773ParameterType = parameterInfo.ParameterType,

.packages\microsoft.extensions.hostfactoryresolver.sources\10.0.0-preview.5.25257.101\contentFiles\cs\netstandard2.0\HostFactoryResolver.cs (1)

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

ViewComponents\DefaultViewComponentHelper.cs (1)

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

Extensions\JsonNodeSchemaExtensions.cs (1)

436if (parameterInfo.ParameterType.IsValueType)

Services\OpenApiGenerator.cs (17)

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

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

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

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

src\Shared\ParameterBindingMethodCache.cs (3)

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

src\Shared\PropertyAsParameterInfo.cs (5)

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

SnapshotTestHelper.cs (1)

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

Services\OpenApiDocumentServiceTestsBase.cs (1)

254ParameterType = parameter.ParameterType,

ParameterPolicyActivator.cs (2)

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

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

291var parameterType = parameters[0].ParameterType;

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

291var parameterType = parameters[0].ParameterType;

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

116var parameterType = parameter.ParameterType;

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\Shared\ObjectMethodExecutor\ObjectMethodExecutor.cs (2)

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

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

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

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\Shared\PropertyHelper\PropertyHelper.cs (1)

291var parameterType = parameters[0].ParameterType;

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

116var parameterType = parameter.ParameterType;

Internal\HubMethodDescriptor.cs (10)

64if (IsStreamResponse && 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(); 241Expression.Convert(parameters[0], methodParameters[0].ParameterType),

Internal\TypedClientBuilder.cs (2)

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

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

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

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

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

.packages\microsoft.extensions.hostfactoryresolver.sources\10.0.0-preview.5.25257.101\contentFiles\cs\netstandard2.0\HostFactoryResolver.cs (1)

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

Evaluation\Expander.cs (6)

3712Type t = method.GetParameters()[i].ParameterType; 4091if (parameters[n].ParameterType == typeof(char[])) 4095else if (parameters[n].ParameterType.GetTypeInfo().IsEnum && args[n] is string v && v.Contains(".")) 4097Type enumType = parameters[n].ParameterType; 4112coercedArguments[n] = Convert.ChangeType(args[n], parameters[n].ParameterType, CultureInfo.InvariantCulture); 4370? Type.GetTypeCode(parameters[0].ParameterType)

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

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

StateFileBase.cs (1)

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

WriteCodeFragment.cs (1)

487.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)

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

InternalUtilities\UICultureUtilities.cs (2)

40if (parameters.Length != 1 || parameters[0].ParameterType != typeof(CultureInfo)) 86if (parameters.Length != 1 || parameters[0].ParameterType != typeof(CultureInfo))

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

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

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

Lightup\LightupHelpers.cs (5)

190if (argType != parameters[0].ParameterType) 192throw new ArgumentException($"Type '{argType}' was expected to match parameter type '{parameters[0].ParameterType}'", nameof(argType)); 373return parameters is [{ ParameterType: var parameterType }] && parameterType == argType; 454return parameters is [{ ParameterType: var parameter0Type }, { ParameterType: var parameter1Type }] && parameter0Type == arg0Type && parameter1Type == arg1Type;

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

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

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

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

SemanticSearch\AbstractSemanticSearchService.cs (2)

312if (!s_queryKindByParameterType.TryGetValue(parameter.ParameterType, out queryKind)) 316parameter.ParameterType,

Protocol\Converters\SumConverter.cs (2)

136.Select(p => p.ParameterType) 147.Select(p => p.ParameterType)

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\MethodHandlerDetails.cs (1)

170if (!Equals(types[i], parameters[i].ParameterType))

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

Hosting\ObjectFormatter\CommonObjectFormatter.cs (3)

142if (parameter.ParameterType.IsByRef) 146builder.Append(TypeNameFormatter.FormatTypeName(parameter.ParameterType.GetElementType(), options)); 150builder.Append(TypeNameFormatter.FormatTypeName(parameter.ParameterType, options));

Platform\Custom\MetadataSignatureHelper.cs (1)

144AppendType(parameter.ParameterType, sb);

Collections\List\SegmentedList.Generic.Tests.AddRange.cs (2)

69if (firstParameter.ParameterType.GetGenericTypeDefinition() != typeof(SegmentedList<>)) 72if (spanParameter.ParameterType.GetGenericTypeDefinition() != typeof(ReadOnlySpan<>))

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

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

Rpc\RpcServer.cs (2)

120var lastParameterIsCancellationToken = methodParameters.Length > 0 && methodParameters[^1].ParameterType == typeof(CancellationToken); 136arguments[i] = request.Parameters[i].ToObject(methodParameters[i].ParameterType);

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

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

src\Compilers\Core\Portable\InternalUtilities\UICultureUtilities.cs (2)

40if (parameters.Length != 1 || parameters[0].ParameterType != typeof(CultureInfo)) 86if (parameters.Length != 1 || parameters[0].ParameterType != typeof(CultureInfo))

src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (2)

120var lastParameterIsCancellationToken = methodParameters.Length > 0 && methodParameters[^1].ParameterType == typeof(CancellationToken); 136arguments[i] = request.Parameters[i].ToObject(methodParameters[i].ParameterType);

Remote\ServiceDescriptorTests.cs (1)

128foreach (var type in method.GetParameters().Select(p => p.ParameterType))

MethodHandlerDetails.cs (1)

170if (!Equals(types[i], parameters[i].ParameterType))

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;

DependencyInjectionValidation.cs (3)

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

src\Tools\Shared\TestHelpers\TestConsole.cs (1)

52.Single(c => c.GetParameters().First().ParameterType == typeof(ConsoleSpecialKey));

RemoteExecutor.cs (2)

429if (param.ParameterType != typeof(string)) 431throw new ArgumentException($"Invalid parameter type: {param.ParameterType}. Expected string", nameof(method));

HelperFactory.cs (4)

224m.GetParameters()[1].ParameterType.GetGenericTypeDefinition() == typeof(Func<,>)) 256p => p.Type == parameter.ParameterType && p.Name == parameter.Name); 310var parameterType = parameter.ParameterType; 311if (parameter.ParameterType.IsArray && parameter.GetCustomAttribute<ParamArrayAttribute>() != null)

src\Microsoft.DotNet.XUnitExtensions.Shared\XunitParallelTheoryTestCaseRunner.cs (1)

104Type[] parameterTypes = methodToRun.GetParameters().Select(p => p.ParameterType).ToArray();

Functions\AIFunctionFactory.cs (4)

747if (parameterInfo.ParameterType == typeof(AIFunctionArguments) || 748parameterInfo.ParameterType == typeof(IServiceProvider)) 770if (serviceProviderIsService?.IsService(parameterInfo.ParameterType) is true) 874Type parameterType = parameter.ParameterType;

src\Shared\JsonSchemaExporter\JsonSchemaExporter.cs (1)

708Debug.Assert(parameterTypeInfo.Type == parameter.ParameterType, "The typeInfo type must match the ParameterInfo type.");

src\Shared\JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (2)

164dict[new(parameter.Name, parameter.ParameterType)] = parameter; 305Type parameterType = parameterInfo.ParameterType;

src\Shared\JsonSchemaExporter\NullabilityInfoContext\NullabilityInfoContext.cs (3)

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

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

83if (parameter.ParameterType == typeof(CancellationToken)) 100type: parameter.ParameterType, 455Type parameterType = parameterInfo.ParameterType;

Utilities\AIJsonUtilitiesTests.cs (1)

381string numericType = Type.GetTypeCode(parameters[i].ParameterType) is TypeCode.Double or TypeCode.Single or TypeCode.Decimal

Functions\AIFunctionFactoryTest.cs (1)

554if (p.ParameterType == typeof(MyService))

src\Tools\Shared\TestHelpers\TestConsole.cs (1)

52.Single(c => c.GetParameters().First().ParameterType == typeof(ConsoleSpecialKey));

ConfigurationBinder.cs (2)

610if (p.IsOut || p.IsIn || p.ParameterType.IsByRef) 1092parameter.ParameterType,

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 (3)

629bestConstructorParameterTypes.Add(p.ParameterType); 635if (!bestConstructorParameterTypes.Contains(p.ParameterType)) 680Type parameterType = parameters[index].ParameterType;

ServiceLookup\Expressions\ExpressionResolverBuilder.cs (1)

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

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)

404Type? parameterType = constructorParameter.ParameterType; 526constructorParameter.ParameterType, 696if (constructorParameters[j].ParameterType.IsAssignableFrom(givenParameter)) 760return serviceProviderIsKeyedService.IsKeyedService(parameterInfo.ParameterType, key); 767return serviceProviderIsService.IsService(parameterInfo.ParameterType); 780return keyedServiceProvider.GetKeyedService(parameterInfo.ParameterType, key); 787return serviceProvider.GetService(parameterInfo.ParameterType); 819_constructor.Parameters[applyIndex].ParameterType.IsAssignableFrom(givenType)) 864throw new InvalidOperationException(SR.Format(SR.UnableToResolveService, _constructor.Parameters[index].ParameterType, _constructor.Info.DeclaringType));

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);

src\Tools\Shared\TestHelpers\TestConsole.cs (1)

52.Single(c => c.GetParameters().First().ParameterType == typeof(ConsoleSpecialKey));

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)

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

ErrorReporting\VisualStudioErrorReportingService.ExceptionFormatting.cs (1)

172=> stringBuilder.Append(string.Join(",", method?.GetParameters().Select(t => (t.ParameterType?.Name ?? "<UnknownType>") + " " + t.Name) ?? []));

StartupForEndpointFilters.cs (1)

43if (context.MethodInfo.GetParameters().Length >= 1 && context.MethodInfo.GetParameters()[0].ParameterType == typeof(string))

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

1849expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null); 1866expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null); 1901Debug.Assert(pis != null && pis.Length == 2 && KnownTypes.Types[(int)KnownElements.DependencyObject].IsAssignableFrom(pis[0].ParameterType)); 1902eventHandlerType = pis[1].ParameterType; 2051CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(pars[i].ParameterType, pars[i].Name);

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\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

JsonSchemaExporter\JsonSchemaExporter.cs (1)

708Debug.Assert(parameterTypeInfo.Type == parameter.ParameterType, "The typeInfo type must match the ParameterInfo type.");

JsonSchemaExporter\JsonSchemaExporter.ReflectionHelpers.cs (2)

164dict[new(parameter.Name, parameter.ParameterType)] = parameter; 305Type parameterType = parameterInfo.ParameterType;

JsonSchemaExporter\NullabilityInfoContext\NullabilityInfoContext.cs (3)

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

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)

101WriteTypeWithNamespace(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)

144Type parameterType = parameter.ParameterType; 158thunkTypeArgs[i] = parameters[i].ParameterType; 249thunkName.Append(parameters[i].ParameterType.Name); 250paramTypes[i + 1] = parameters[i].ParameterType; 276bool paramIsByReference = parameters[i].ParameterType.IsByRef; 277Type paramType = parameters[i].ParameterType; 317if (parameters[i].ParameterType.IsByRef) 319Type byrefToType = parameters[i].ParameterType.GetElementType()!;

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

157Type 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)

1072if (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; 2162if (parameters[i].ParameterType.IsByRef) 2399if (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)

60if (pis[0].ParameterType != typeof(CallSite)) 68@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;

src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (2)

665Type pCls = par[j].ParameterType; 845Type pCls = par[j].ParameterType;

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

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

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

29Type parameterType = parameters[i].ParameterType;

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

2117Type pType = infos[i].ParameterType; 2566types[i] = parameters[i].ParameterType; 3355manifest.AddEventParameter(args[fieldIdx].ParameterType, args[fieldIdx].Name!); 3451if (args.Length > 0 && args[0].ParameterType == typeof(Guid) && 3538Type dataType = parameter.ParameterType;

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

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

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

76NullabilityInfo nullability = GetNullabilityInfo(parameterInfo.Member, parameterInfo.ParameterType, parser); 112CheckGenericParameters(nullability, metaMember, metaParameter.ParameterType, parameter.Member.ReflectedType);

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

105string typeName = ParameterType.FormatTypeName();

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

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

src\System\Attribute.CoreCLR.cs (1)

389indexParamTypes[i] = indexParams[i].ParameterType;

src\System\Reflection\Emit\RuntimeModuleBuilder.cs (4)

269parameterTypes[i] = parameters[i].ParameterType; 472SignatureHelper sigHelp = SignatureHelper.GetMethodSigHelper(this, method.CallingConvention, cGenericParameters, returnParameter?.ParameterType, returnParameter?.GetRequiredCustomModifiers(), returnParameter?.GetOptionalCustomModifiers(), parameterTypes, requiredCustomModifiers, optionalCustomModifiers); 1006tt[i] = paramInfo[i].ParameterType; 1027parameterTypes[i] = parameters[i].ParameterType;

src\System\RuntimeType.CoreCLR.cs (1)

2339if (!lastParameter.ParameterType.IsArray)

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

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

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

127paramTypes[i] = parameters[i].ParameterType; 1117ConvertValue(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;

System\Private\Windows\BinaryFormat\Deserializer\PendingSerializationInfo.cs (2)

71&& parameters[0].ParameterType == typeof(SerializationInfo) 72&& parameters[1].ParameterType == typeof(StreamingContext))

TestAccessor.cs (1)

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

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)

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

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

2826Type 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\libraries\Common\src\System\Reflection\Emit\IgnoreAccessChecksToAttributeBuilder.cs (1)

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

System\Reflection\DispatchProxyGenerator.cs (5)

383PropertyBuilder pb = _tb.DefineProperty(pi.Name, pi.Attributes, pi.PropertyType, pi.GetIndexParameters().Select(p => p.ParameterType).ToArray()); 419paramTypes[i] = parameters[i].ParameterType; 468bool isOutRef = parameters[i].IsOut && parameters[i].ParameterType.IsByRef && !parameters[i].IsIn; 474argsArr.EndSet(parameters[i].ParameterType); 527if (parameters[i].ParameterType.IsByRef)

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

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

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

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

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

51WriteParametersSignature(module, Array.ConvertAll(parameters, p => p.ParameterType), parameterEncoder);

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

1312parameterTypes[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)

98public 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\Serialization\ObjectManager.cs (2)

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

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

290Type parameterType = parameterInfo.ParameterType;

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

65JsonTypeInfo.ValidateType(parameter.ParameterType); 78typeArguments[i + 1] = parameters[i].ParameterType;

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

307ParameterType = reflectionInfo.ParameterType, 496if (!parameterInfo.ParameterType.IsNullableType())

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

96Type paramType = parameters[i].ParameterType;

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) &&

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

217Assert.Equal(new Type[] { typeof(string) }, Assert.IsAssignableFrom<ConstructorInfo>(descriptor.MemberInfo).GetParameters().Select(p => p.ParameterType));

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

178Assert.Equal(new Type[] { typeof(Type) }, Assert.IsAssignableFrom<ConstructorInfo>(descriptor.MemberInfo).GetParameters().Select(p => p.ParameterType));

System\Xaml\Replacements\DateTimeOffsetConverter2Tests.cs (1)

91Assert.Equal(new Type[] { typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(int), typeof(TimeSpan) }, parameters.Select(p => p.ParameterType));

System\Xaml\Replacements\TypeUriConverterTests.cs (1)

152Assert.Equal(new Type[] { typeof(string), typeof(UriKind) }, parameters.Select(p => p.ParameterType));

CodeMetricsTestsBase.cs (1)

129if (parameterInfos.Length < 1 || typeof(OutputKind) != parameterInfos[0].ParameterType)

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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

src\RoslynAnalyzers\Utilities\Compiler\Lightup\LightupHelpers.cs (1)

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