ReturnType

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

767public override Type ReturnType { get { return m_dynMethod.ReturnType; } } 976public override Type ReturnType

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

624public override Type ReturnType

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

102public override Type ReturnType

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

131public override Type ReturnType

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

103public override Type ReturnType { get { return m_method.ReturnType; } }

system\reflection\methodinfo.cs (1)

804public override Type ReturnType

net\System\Net\_AutoWebProxyScriptHelper.cs (1)

48public override Type ReturnType {

System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (1)

1974public override Type ReturnType { get { return _info.ReturnType; } }

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (1)

1974public override Type ReturnType { get { return _info.ReturnType; } }

Rules\RuleValidation.cs (3)

282public override Type ReturnType 394public override Type ReturnType 783public override Type ReturnType

AuthoringOM\Compiler\TypeSystem\MethodInfo.cs (1)

174public override Type ReturnType

AuthoringOM\Compiler\TypeSystem\PropertyInfo.cs (1)

286public override Type ReturnType

AuthoringOM\Compiler\TypeSystem\RTTypeWrapper.cs (1)

1090public override Type ReturnType

System\Workflow\Activities\ContractMethodInfo.cs (1)

140public override Type ReturnType

ComplusTypeValidator.cs (6)

148if (!IsValidParameter(method.ReturnType, method.ReturnTypeCustomAttributes, allowReferences, out typeMismatchDetails)) 151ToolConsole.WriteError(SR.GetString(SR.InvalidWebServiceReturnValue, method.ReturnType.Name, method.Name, Tool.Options.ShowGuids ? interfaceInfo.Iid.ToString("B") : interfaceInfo.Name, typeMismatchDetails), ""); 153ToolConsole.WriteNonVerboseWarning(SR.GetString(SR.InvalidWebServiceReturnValue, method.ReturnType.Name, method.Name, Tool.Options.ShowGuids ? interfaceInfo.Iid.ToString("B") : interfaceInfo.Name, typeMismatchDetails)); 274if (!IsValidParameter(method.ReturnType, method.ReturnTypeCustomAttributes, allowReferences, out typeMismatchDetails)) 277ToolConsole.WriteError(SR.GetString(SR.InvalidWebServiceReturnValue, method.ReturnType.Name, method.Name, Tool.Options.ShowGuids ? interfaceInfo.Iid.ToString("B") : interfaceInfo.Name, typeMismatchDetails), ""); 279ToolConsole.WriteWarning(SR.GetString(SR.InvalidWebServiceReturnValue, method.ReturnType.Name, method.Name, Tool.Options.ShowGuids ? interfaceInfo.Iid.ToString("B") : interfaceInfo.Name, typeMismatchDetails));

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

3399if (method.ReturnType != typeof(void))

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

29var retType = property.getterInfo.ReturnType;

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

128&& meth.ReturnType != typeof(void)) 337if (methodInfo.ReturnType != typeof(void))

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

624if (methodInfo.ReturnType != typeof(void))

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

364return mi.ReturnType;

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

106return m_method.ReturnType;

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

1881return GetArrayMethodToken(declaringType, method.Name, method.CallingConvention, method.ReturnType, tt); 1912this, method.CallingConvention, method.ReturnType, 1919sigHelp = SignatureHelper.GetMethodSigHelper(this, method.ReturnType, parameterTypes);

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

103public override Type ReturnType { get { return m_method.ReturnType; } }

system\reflection\eventinfo.cs (2)

126if (addMethod.ReturnType == typeof(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken)) 130Contract.Assert(addMethod.ReturnType == typeof(void));

system\rttype.cs (2)

5644if (Object.ReferenceEquals(meth.ReturnType, typeof(void))) 5676Type retType = meth.ReturnType;

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

1031if (CurrentMethod.ReturnType != typeof(void) ||

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

109Method.ReturnType, 114AddReturn(Method.ReturnType, il, Meth); 126Type ReturnType = Method.ReturnType;

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

4259retType = mi.ReturnType; 4426Type retType = mi.ReturnType;

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

494Type returnType = mi.ReturnType;

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

2061Type endReturnType = method.ReturnType; 2095(mi.ReturnType == beginReturnType) && 2103(mi.ReturnType == endReturnType) &&

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

301Type retType = ((MethodInfo)mb).ReturnType;

Framework\System\Windows\Markup\XamlTypeMapper.cs (1)

2154propertyType = parameters.Length == 1 ? methodInfo.ReturnType : parameters[1].ParameterType;

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

503if ((mi != null) && (mi.ReturnType == typeof(int)))

src\Framework\System\Windows\Markup\BamlRecordReader.cs (1)

5919return this.AttachedPropertyGetter.ReturnType;

src\Framework\System\Windows\Markup\Primitives\ElementMarkupObject.cs (2)

243if (shouldSerializeMethod != null && shouldSerializeMethod.ReturnType != typeof(bool)) 266if (shouldSerializeMethod != null && shouldSerializeMethod.ReturnType != typeof(bool))

src\Framework\System\Windows\Markup\XamlTypeMapper.cs (1)

2154propertyType = parameters.Length == 1 ? methodInfo.ReturnType : parameters[1].ParameterType;

compmod\system\componentmodel\MemberDescriptor.cs (1)

440if (result != null && !result.ReturnType.IsEquivalentTo(returnType)) {

compmod\system\componentmodel\ReflectTypeDescriptionProvider.cs (2)

1154MethodInfo setMethod = providerType.GetMethod("Set" + provideAttr.PropertyName, new Type[] {receiverType, getMethod.ReturnType}); 1161extendedList.Add(new ReflectPropertyDescriptor(providerType, provideAttr.PropertyName, getMethod.ReturnType, receiverType, getMethod, setMethod, null));

System\Activities\Debugger\XamlMemberExtensions.cs (1)

41if (attachablePropertyMethod.ReturnType == typeof(void))

System\Activities\Expressions\MethodCallExpressionHelper.cs (1)

201Expression block = ComposeLinqExpression(methodInfo, targetInstance, objectArray, methodInfo.ReturnType, valueTypeReference);

System\Activities\ExpressionUtilities.cs (1)

512setItemParameterTypes[getItemParameters.Length] = this.getItemMethod.ReturnType;

System\Activities\Statements\MethodResolver.cs (5)

254if (this.beginMethod != null && !this.beginMethod.ReturnType.Equals(typeof(IAsyncResult))) 260if (this.endMethod != null && resultType != null && !TypeHelper.AreTypesCompatible(this.endMethod.ReturnType, resultType)) 262metadata.AddValidationError(SR.ReturnTypeIncompatible(this.endMethod.ReturnType.Name, MethodName, targetType.Name, this.Parent.DisplayName, resultType.Name)); 301else if (resultType != null && !TypeHelper.AreTypesCompatible(result.ReturnType, resultType)) 304SR.ReturnTypeIncompatible(result.ReturnType.Name, MethodName,

System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (1)

1974public override Type ReturnType { get { return _info.ReturnType; } }

DataAnnotations\CustomValidationAttribute.cs (1)

230if (methodInfo.ReturnType != typeof(ValidationResult)) {

Microsoft\Scripting\Actions\CallSite.cs (4)

270if (invoke.ReturnType == typeof(void)) { 318Type[] args = new Type[invoke.ReturnType != typeof(void) ? pis.Length : pis.Length - 1]; 328if (invoke.ReturnType != typeof(void)) { 329args[args.Length - 1] = invoke.ReturnType;

Microsoft\Scripting\Ast\BinaryExpression.cs (27)

370TypeUtils.AreEquivalent(method.ReturnType, TypeUtils.GetNonNullableType(left)); 595return new MethodBinaryExpression(binaryType, left, right, method.ReturnType, method); 602if (method != null && method.ReturnType.IsValueType && !TypeUtils.IsNullableType(method.ReturnType)) { 603if (method.ReturnType != typeof(bool) || liftToNull) { 604return new MethodBinaryExpression(binaryType, left, right, TypeUtils.GetNullableType(method.ReturnType), method); 623return new MethodBinaryExpression(binaryType, left, right, method.ReturnType, method); 630method.ReturnType.IsValueType && !TypeUtils.IsNullableType(method.ReturnType)) { 631if (method.ReturnType != typeof(bool) || liftToNull) { 632return new MethodBinaryExpression(binaryType, left, right, TypeUtils.GetNullableType(method.ReturnType), method); 730if (method.ReturnType == typeof(void)) 785if (method.ReturnType != pms[0].ParameterType) { 794if (opTrue == null || opTrue.ReturnType != typeof(bool) || 795opFalse == null || opFalse.ReturnType != typeof(bool)) { 1245returnType = (TypeUtils.IsNullableType(left.Type) && TypeUtils.AreEquivalent(method.ReturnType, TypeUtils.GetNonNullableType(left.Type))) ? left.Type : method.ReturnType; 1251returnType = (TypeUtils.IsNullableType(left.Type) && TypeUtils.AreEquivalent(method.ReturnType, TypeUtils.GetNonNullableType(left.Type))) ? left.Type : method.ReturnType; 1291returnType = (TypeUtils.IsNullableType(left.Type) && method.ReturnType == TypeUtils.GetNonNullableType(left.Type)) ? left.Type : method.ReturnType; 1297returnType = (TypeUtils.IsNullableType(left.Type) && method.ReturnType == TypeUtils.GetNonNullableType(left.Type)) ? left.Type : method.ReturnType; 1341if (method.ReturnType == typeof(void)) { 1353if (!TypeUtils.AreEquivalent(method.ReturnType, right.Type)) { 1483if (!TypeUtils.AreEquivalent(mi.ReturnType, left.Type)) { 1488if (!TypeUtils.AreEquivalent(pms[0].ParameterType, method.ReturnType)) {

Microsoft\Scripting\Ast\IndexExpression.cs (1)

380if (setter.ReturnType != typeof(void)) throw Error.SetterMustBeVoid();

Microsoft\Scripting\Ast\InvocationExpression.cs (1)

185return new InvocationExpression(expression, args, mi.ReturnType);

Microsoft\Scripting\Ast\LambdaExpression.cs (5)

113get { return Type.GetMethod("Invoke").ReturnType; } 567if (mi.ReturnType != typeof(void) && !TypeUtils.AreReferenceAssignable(mi.ReturnType, body.Type)) { 568if (!TryQuote(mi.ReturnType, ref body)) { 569throw Error.ExpressionTypeDoesNotMatchReturn(body.Type, mi.ReturnType);

Microsoft\Scripting\Ast\MethodCallExpression.cs (1)

64get { return _method.ReturnType; }

Microsoft\Scripting\Ast\SwitchExpression.cs (1)

278if (comparison != null && comparison.ReturnType != typeof(bool)) {

Microsoft\Scripting\Ast\TypeUtils.cs (1)

474if (!TypeUtils.AreEquivalent(mi.ReturnType, typeTo)) {

Microsoft\Scripting\Ast\UnaryExpression.cs (12)

96(resultIsNullable && !TypeUtils.AreEquivalent(_method.ReturnType, this.Type)); 380return new UnaryExpression(unaryType, operand, method.ReturnType, method); 386if (method != null && method.ReturnType.IsValueType && !TypeUtils.IsNullableType(method.ReturnType)) { 387return new UnaryExpression(unaryType, operand, TypeUtils.GetNullableType(method.ReturnType), method); 401return new UnaryExpression(unaryType, operand, method.ReturnType, method); 406method.ReturnType.IsValueType && !TypeUtils.IsNullableType(method.ReturnType)) { 407return new UnaryExpression(unaryType, operand, TypeUtils.GetNullableType(method.ReturnType), method); 437if (ParameterIsAssignable(pms[0], operand.Type) && TypeUtils.AreEquivalent(method.ReturnType, convertToType)) { 438return new UnaryExpression(unaryType, operand, method.ReturnType, method); 443TypeUtils.AreEquivalent(method.ReturnType, TypeUtils.GetNonNullableType(convertToType))) {

Microsoft\Scripting\Compiler\LambdaCompiler.Expressions.cs (1)

903if (initializers[i].AddMethod.ReturnType != typeof(void)) {

Microsoft\Scripting\Utils\TypeExtensions.cs (1)

41return (mi.IsConstructor) ? mi.DeclaringType : ((MethodInfo)mi).ReturnType;

cdf\src\NetFx40\Tools\System.Activities.Presentation\System\Activities\Presentation\Base\Core\Metadata\MetadataStore.cs (1)

1974public override Type ReturnType { get { return _info.ReturnType; } }

System\Data\Metadata\Edm\LightweightCodeGenerator.cs (2)

210Type realType = mi.ReturnType; 418realType = setterMethodInfo.ReturnType;

System\Data\Objects\ELinq\LinqExpressionNormalizer.cs (2)

247if (m.Method.Name == "Compare" && m.Arguments.Count > 1 && m.Method.ReturnType == typeof(int)) 272if (m.Method.Name == "CompareTo" && m.Arguments.Count == 1 && m.Method.ReturnType == typeof(int))

System\Data\Objects\ELinq\MethodCallTranslator.cs (1)

73if (linq.Method.GetParameters().Count() == 1 && linq.Method.ReturnType.Equals(typeof(bool)))

System\Data\Objects\ELinq\ReflectionUtil.cs (2)

456if (null != method.ReturnType) 459AppendCanonicalTypeDescription(method.ReturnType, genericArgumentOrdinals, description);

System\Data\SqlClient\SqlTypesAssembly.cs (1)

174this.SqlCharsType = asTextMethod.ReturnType;

DataContext.cs (1)

801if (!typeof(IQueryable<TResult>).IsAssignableFrom(methodInfo.ReturnType)) {

DataServices.cs (1)

353if (typeof(T).IsAssignableFrom(this.member.LoadMethod.ReturnType)) {

Mapping\AttributedMetaModel.cs (8)

882if (attrs.Length == 0 && mi.ReturnType == typeof(IMultipleResults)) { 885else if (attrs.Length > 1 && mi.ReturnType != typeof(IMultipleResults)) { 888else if (attrs.Length <= 1 && mi.ReturnType.IsGenericType && 889(mi.ReturnType.GetGenericTypeDefinition() == typeof(IEnumerable<>) || 890mi.ReturnType.GetGenericTypeDefinition() == typeof(ISingleResult<>) || 891mi.ReturnType.GetGenericTypeDefinition() == typeof(IQueryable<>))) { 892Type elementType = TypeSystem.GetElementType(mi.ReturnType); 967get { return this.methodInfo.ReturnType == typeof(IMultipleResults); }

Mapping\MappedMetaModel.cs (5)

1346if (map.Types.Count == 0 && this.method.ReturnType == typeof(IMultipleResults)) { 1349else if (map.Types.Count > 1 && this.method.ReturnType != typeof(IMultipleResults)) { 1352else if (map.Types.Count == 1 && this.method.ReturnType != typeof(IMultipleResults)) { 1353Type elementType = TypeSystem.GetElementType(method.ReturnType); 1426get { return this.method.ReturnType == typeof(IMultipleResults); }

SqlClient\Common\SqlFactory.cs (2)

522return new SqlMethodCall(method.ReturnType, this.Default(method.ReturnType), method, obj, args, sourceExpression);

SqlClient\Query\MethodCallConverter.cs (2)

47return !call.Method.IsStatic && call.Method.Name == "CompareTo" && call.Arguments.Count == 1 && call.Method.ReturnType == typeof(int); 51return call.Method.IsStatic && call.Method.Name == "Compare" && call.Arguments.Count > 1 && call.Method.ReturnType == typeof(int);

SqlClient\Query\QueryConverter.cs (4)

1163SqlTableValuedFunctionCall functionCall = sql.TableValuedFunctionCall(function.ResultRowTypes[0].InheritanceRoot, mce.Method.ReturnType, function.MappedName, sqlParams, mce); 1188Type returnType = mce.Method.ReturnType; 2006: this.typeProvider.From(mc.Method.ReturnType); 2008return sql.FunctionCall(mc.Method.ReturnType, sqlType, function.MappedName, sqlParams, mc);

SqlClient\Query\SqlMethodCallConverter.cs (7)

178if (mc.Method.IsStatic && mc.Method.Name == "Compare" && mc.Method.ReturnType == typeof(int)) { 912else if (mc.Method.Name == "Compare" && mc.Arguments.Count == 2 && mc.Method.ReturnType == typeof(int)) { 1408return sql.FunctionCall(mc.Method.ReturnType, "ROUND", mc.Arguments, mc.SourceExpression); 1418return sql.FunctionCall(mc.Method.ReturnType, "ROUND", 1427return sql.FunctionCall(mc.Method.ReturnType, "ROUND", 2060return new SqlSearchedCase(mc.Method.ReturnType, new SqlWhen[] { new SqlWhen(aLower, b) }, a, source); 2155return sql.FunctionCall(mc.Method.ReturnType, "ROUND", new SqlExpression[] { x, sql.ValueFromObject(0, false, source), sql.ValueFromObject(1, false, source) }, source);

SqlClient\Reader\ObjectReaderCompiler.cs (5)

822return d.Method.ReturnType; 922return mc.Method.ReturnType; 1356return miCreateGroup.ReturnType; 1872this.GenerateConvertToType(rType, cType, readerMethod.ReturnType); 1894this.GenerateConvertToType(rType, cType, bufferMethod.ReturnType);

SqlClient\SqlProvider.cs (1)

1376else if (mce.Method.DeclaringType == typeof(DataManipulation) && mce.Method.ReturnType == typeof(int)) {

System\Data\Services\DataServiceConfiguration.cs (3)

908Type returnType = method.ReturnType; 957if (method != null && method.ReturnType == typeof(void)) 1077Type returnType = method.ReturnType;

System\Data\Services\Providers\BaseServiceProvider.cs (7)

730if (method.ReturnType == typeof(void)) 741if (WebUtil.IsPrimitiveType(method.ReturnType)) 744resultType = method.ReturnType; 749Type queryableElement = GetGenericInterfaceElementType(method.ReturnType, IQueryableTypeFilter); 759Type enumerableElement = GetIEnumerableElement(method.ReturnType); 767resultType = method.ReturnType; 783throw new InvalidOperationException(Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));

System\Data\Services\Client\ALinq\ExpressionNormalizer.cs (2)

362if (!visited.Method.IsStatic && visited.Method.Name == "CompareTo" && visited.Arguments.Count == 1 && visited.Method.ReturnType == typeof(int)) 371if (visited.Method.IsStatic && visited.Method.Name == "Compare" && visited.Arguments.Count > 1 && visited.Method.ReturnType == typeof(int))

System\Data\Services\Client\ALinq\ReflectionUtil.cs (2)

468if (null != method.ReturnType) 471AppendCanonicalTypeDescription(method.ReturnType, genericArgumentOrdinals, description);

System\Data\Services\Client\ALinq\ResourceBinder.cs (6)

268AddSequenceQueryOption(input, new FilterQueryOptionExpression(mce.Method.ReturnType, newFilter)); 527ResourceExpression resultSelectorSource = CreateResourceSetExpression(mce.Method.ReturnType, source, collectorReference, TypeSystem.GetElementType(collectorReference.Type)); 617return RemoveTransparentScope(mce.Method.ReturnType, (ResourceSetExpression)input); 624return CreateNavigationPropertySingletonExpression(mce.Method.ReturnType, navSource, boundProjection); 680rse = CreateResourceSetExpression(mce.Method.ReturnType, input, navPropRef, resourceType); 819return re.CreateCloneWithNewType(mce.Method.ReturnType);

System\Data\Services\Client\ProjectionPlanCompiler.cs (2)

976Type returnElementType = call.Method.ReturnType.GetGenericArguments()[0]; 1065Type returnElementType = call.Method.ReturnType.GetGenericArguments()[0];

System\Xml\Xsl\IlGen\IteratorDescriptor.cs (3)

106Debug.Assert(locIter.LocalType.GetMethod("get_Current").ReturnType == itemStorageType, 120Debug.Assert(methGlobal.ReturnType == itemStorageType || 121typeof(IList<>).MakeGenericType(itemStorageType).IsAssignableFrom(methGlobal.ReturnType),

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

218this.retClrType = GetClrType(this.meth.ReturnType);

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

796XPathResultType returnType = GetXPathType(method.ReturnType);

metadata\wsdlparser.cs (2)

4521sb.Append(CSharpTypeString(method.ReturnType.FullName)); 4575String valueString = URTMethod.ValueString(CSharpTypeString(method.ReturnType.FullName));

metadata\wsdlwriter.cs (2)

372AddType(method.ReturnType, methodXNS); 1621Type returnType = method.ReturnType;

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

1145if (method.ReturnType != Globals.TypeOfVoid) 1166if (method.ReturnType != Globals.TypeOfVoid)

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

207BeginMethod(signature.ReturnType, methodName, paramTypes, allowPrivateMemberAccess); 771memberType = method.ReturnType;

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

1208if (getEnumeratorMethod == null || !Globals.TypeOfIEnumerator.IsAssignableFrom(getEnumeratorMethod.ReturnType))

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

1235if (method != null && method.ReturnType == UnderlyingType) 2105if (!Globals.TypeOfTypeEnumerable.IsAssignableFrom(method.ReturnType))

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

162ilg.ConvertValue(Globals.TypeOfDateTimeOffset, ilg.CurrentMethod.ReturnType); 166ilg.ConvertValue(objectLocal.LocalType, ilg.CurrentMethod.ReturnType); 177ilg.ConvertValue(objectLocal.LocalType, ilg.CurrentMethod.ReturnType); 232DynamicMethod dynamicMethod = new DynamicMethod(methodName, signature.ReturnType, paramTypes, typeof(JsonFormatReaderGenerator).Module, allowPrivateMemberAccess); 338ilg.ConvertValue(Globals.TypeOfObject, ilg.CurrentMethod.ReturnType); 1039if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid) 1047if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid)

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

160DynamicMethod dynamicMethod = new DynamicMethod(methodName, signature.ReturnType, paramTypes, typeof(JsonFormatWriterGenerator).Module, allowPrivateMemberAccess); 420enumeratorType = collectionContract.GetEnumeratorMethod.ReturnType; 457Type elementType = getCurrentMethod.ReturnType; 465ilg.ConvertValue(collectionContract.GetEnumeratorMethod.ReturnType, Globals.TypeOfIDictionaryEnumerator); 472ilg.ConvertValue(collectionContract.GetEnumeratorMethod.ReturnType, ctorParam);

System\Runtime\Serialization\SchemaExporter.cs (3)

638if (!(Globals.TypeOfXmlQualifiedName.IsAssignableFrom(getMethod.ReturnType)) && !(Globals.TypeOfXmlSchemaType.IsAssignableFrom(getMethod.ReturnType))) 639throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.GetString(SR.InvalidReturnTypeOnGetSchemaMethod, DataContract.GetClrTypeFullName(clrType), methodName, DataContract.GetClrTypeFullName(getMethod.ReturnType), DataContract.GetClrTypeFullName(Globals.TypeOfXmlQualifiedName), typeof(XmlSchemaType))));

System\Runtime\Serialization\XmlFormatReaderGenerator.cs (6)

173ilg.ConvertValue(Globals.TypeOfDateTimeOffset, ilg.CurrentMethod.ReturnType); 177ilg.ConvertValue(objectLocal.LocalType, ilg.CurrentMethod.ReturnType); 188ilg.ConvertValue(objectLocal.LocalType, ilg.CurrentMethod.ReturnType); 331ilg.ConvertValue(Globals.TypeOfObject, ilg.CurrentMethod.ReturnType); 886if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid) 892if (collectionContract.AddMethod.ReturnType != Globals.TypeOfVoid)

System\Runtime\Serialization\XmlFormatWriterGenerator.cs (4)

456enumeratorType = collectionContract.GetEnumeratorMethod.ReturnType; 493Type elementType = getCurrentMethod.ReturnType; 500ilg.ConvertValue(collectionContract.GetEnumeratorMethod.ReturnType, Globals.TypeOfIDictionaryEnumerator); 507ilg.ConvertValue(collectionContract.GetEnumeratorMethod.ReturnType, ctorParam);

System\ServiceModel\Administration\ContractInstanceProvider.cs (2)

88if (null != operationDescription.SyncMethod.ReturnType) 90operation.SetProperty(AdministrationStrings.ReturnType, operationDescription.SyncMethod.ReturnType.Name);

System\ServiceModel\ComIntegration\ComPlusTypeLoader.cs (1)

277methodInfo.ReturnType,

System\ServiceModel\ComIntegration\EmitterCache.cs (1)

92mInfo.ReturnType, GetParameterTypes(mInfo));

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

879method.ReturnType != asyncResultType) 902if (method.ReturnType == taskType) 906if (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == taskTResultType) 916Type methodReturnType = method.ReturnType;

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

393if (!typeof(IEnumerable<Type>).IsAssignableFrom(method.ReturnType)) 1006if ((!isTask && outputMethod.ReturnType != ServiceReflector.VoidType) || (isTask && taskTResult != ServiceReflector.VoidType) || 1109Type responseType = isTask ? taskTResult : methodInfo.ReturnType; 1602if (this.syncOperation.SyncMethod.ReturnType != this.syncOperation.EndMethod.ReturnType) 1725if (this.syncOperation.SyncMethod.ReturnType != this.syncOperation.TaskTResult) 1845if (this.taskOperation.TaskTResult != this.asyncOperation.EndMethod.ReturnType)

System\ServiceModel\Dispatcher\CodeGenerator.cs (1)

126BeginMethod(signature.ReturnType, methodName, paramTypes, allowPrivateMemberAccess);

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

114ilg.ConvertValue(type, ilg.CurrentMethod.ReturnType); 149LocalBuilder returnLocal = ilg.DeclareLocal(ilg.CurrentMethod.ReturnType, "returnParam"); 195LocalBuilder returnLocal = ilg.DeclareLocal(ilg.CurrentMethod.ReturnType, "returnParam"); 241LocalBuilder returnLocal = ilg.DeclareLocal(ilg.CurrentMethod.ReturnType, "returnParam"); 331if (method.ReturnType == typeof(void)) 334ilg.ConvertValue(method.ReturnType, ilg.CurrentMethod.ReturnType);

System\ServiceModel\Dispatcher\TaskMethodInvoker.cs (1)

41this.taskTResultGetMethod = ((PropertyInfo)taskMethod.ReturnType.GetMember(ResultMethodName)[0]).GetGetMethod();

System\ServiceModel\ServiceHost.cs (1)

1864if (configure != null && configure.ReturnType == typeof(void))

HttpApplicationFactory.cs (1)

246if (m.ReturnType != typeof(void))

UI\WebControls\ModelDataSourceView.cs (2)

337bool returnTypeIsTask = typeof(Task).IsAssignableFrom(methodInfo.ReturnType); 379Type selectMethodReturnType = method.MethodInfo.ReturnType;

UI\WebParts\WebPartManager.cs (2)

1787if (method.IsPublic && method.ReturnType == typeof(void) && parameterType != null) { 1816Type returnType = method.ReturnType;

Util\FactoryGenerator.cs (1)

81if (_methodToOverride.ReturnType != _returnedType) {

Script\Services\WebServiceMethodData.cs (1)

118return (_methodInfo == null) ? null : _methodInfo.ReturnType;

UI\AsyncPostBackTrigger.cs (1)

109if (!handlerMethod.ReturnType.Equals(typeof(void)) ||

UI\WebControls\Dynamic.cs (1)

1194if (method.ReturnType == typeof(void))

UI\MobileControls\DeviceSpecificChoice.cs (1)

344if (methodInfo == null || methodInfo.ReturnType != typeof(bool))

UI\MobileControls\FactoryGenerator.cs (1)

92if (_methodToOverride.ReturnType != _returnedType ||

System\Web\Services\Protocols\LogicalMethodInfo.cs (3)

79retType = methodDefinition.ReturnType; 115retType = endMethodInfo.ReturnType; 467return typeof(IAsyncResult).IsAssignableFrom(methodInfo.ReturnType) &&

Common\DelegateTypeInfo.cs (1)

112this.returnType = new CodeTypeReference(method.ReturnType);

CorrelationValidator.cs (2)

436if (methodInfo.ReturnType != typeof(void) && (memberInfo is EventInfo)) 882if (mInfo.ReturnType != typeof(void))

EventSinkActivity.cs (1)

471if (!(method.ReturnType == typeof(void)))

Executors\InvokeBase.cs (1)

24if (methodBase.ReturnType != typeof(void))

Executors\WorkflowWebService.cs (1)

47bool responseRequired = (mInfo.ReturnType != typeof(void));

InvokeMethodActivity.cs (1)

269if (!(method.ReturnType == typeof(void)))

InvokeWebService.cs (2)

396if (!(method.ReturnType == typeof(void))) 462if (methodInfo.ReturnType != typeof(void))

Rules\Design\Dialogs\IntellisenseTextBox.cs (1)

525toolTipText.Append(RuleDecompiler.DecompileType(methodInfo.ReturnType));

Rules\Executor.cs (2)

721Type tx = conversion.ReturnType; 768Type tx = conversion.ReturnType;

Rules\Expressions.cs (1)

1405if (mi.ReturnType == null)

Rules\Literal.cs (3)

918if (mi.ReturnType == typeof(bool) && 926if (mi.ReturnType == typeof(bool) && 934if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) &&

Rules\RuleValidation.cs (23)

45: base(mi.ReturnType) 79: base(mi.ReturnType) 284get { return actualMethod.ReturnType; } 325resultType = method.ReturnType; 430resultType = typeof(Nullable<>).MakeGenericType(method.ReturnType); 447return Executor.AdjustType(actualMethod.ReturnType, result, resultType); 465resultType = typeof(Nullable<>).MakeGenericType(method.ReturnType); 479return Executor.AdjustType(actualMethod.ReturnType, result, resultType); 488Debug.Assert(method.ReturnType == typeof(bool), "not a bool result"); 519Debug.Assert(method.ReturnType == typeof(bool), "not a bool result"); 1257if (ConditionHelper.IsNonNullableValueType(mi.ReturnType) && ConditionHelper.IsNonNullableValueType(parameters[0].ParameterType)) 1293Type tx = candidates[0].ReturnType; 1298Type testType = candidates[i].ReturnType; 1315if ((candidates[i].ReturnType == tx) && 1337if ((candidates[i].ReturnType == tx) && 1513Type testType = candidates[i].ReturnType; 1526Type testType = candidates[i].ReturnType; 1541Type testType = candidates[i].ReturnType; 1557if ((candidates[i].ReturnType == tx) && 1579if ((candidates[i].ReturnType == tx) && 2225Type targetType = mi.ReturnType; 2248Type targetType = mi.ReturnType; 3232IsAuthorized(theMethod.ReturnType);

WebServiceReceive.cs (7)

319if (mInfo.ReturnType != typeof(void) || responseRequired) 627if ((outParameters.Count > 0 || methodInfo.ReturnType != typeof(void)) && !foundMatchingResponse) 789webMethod.ReturnType = new CodeTypeReference(methodInfo.ReturnType); 838int iStartIndex = (methodInfo.ReturnType == typeof(void)) ? 0 : 1; 857if (methodInfo.ReturnType != typeof(void)) 866CodeMethodReturnStatement methodReturnStatement = new CodeMethodReturnStatement(new CodeCastExpression(methodInfo.ReturnType, new CodeIndexerExpression(returnTargetExpression, new CodePrimitiveExpression(0)))); 869else if (outRefParams.Count == 0 && methodInfo.ReturnType == typeof(void))

WebServiceResponse.cs (3)

158if (mInfo.ReturnType == typeof(void)) 678if (methodInfo.ReturnType != typeof(void)) 697if (methodInfo.ReturnType != typeof(void) && methodInfo.ReturnParameter.ParameterType == null)

AuthoringOM\Bind.cs (3)

1251return getter.ReturnType; 1553newPropertyType = arrayPropertyInfo.GetGetMethod().ReturnType; 1628return this.getMethod.ReturnType;

AuthoringOM\Compiler\TypeSystem\DesignTimeType.cs (1)

1223this.returnType = ((MethodInfo)memberInfo).ReturnType;

AuthoringOM\Compiler\TypeSystem\RTTypeWrapper.cs (1)

1094return this.rtTypeWrapper.ResolveTypeFromTypeSystem(this.methodInfo.ReturnType);

AuthoringOM\Compiler\Validation\BindValidator.cs (3)

554else if (!invokeMethod.ReturnType.Equals(methodInfo.ReturnType)) 556message = SR.GetString(SR.Error_MethodReturnTypeMismatch, GetFullPropertyName(manager), invokeMethod.ReturnType.FullName);

AuthoringOM\Compiler\Validation\DependencyObjectValidator.cs (2)

209if (methodInfo != null && TypeProvider.IsAssignable(invokeMethod.ReturnType, methodInfo.ReturnType))

AuthoringOM\Design\Dialogs\ActivityBindForm.cs (1)

514paths.Add(new PathInfo(currentPath + indexString, info, info.ReturnType));

Shared\DelegateTypeInfo.cs (1)

111this.returnType = new CodeTypeReference(method.ReturnType);

System\Workflow\Activities\ContractType.cs (1)

730this.returnType = ((MethodInfo)memberInfo).ReturnType;

System\Workflow\Activities\ReceiveActivity.cs (8)

791if (!(methodInfo.ReturnType == typeof(void))) 1394if (methodInfo.ReturnType != null && methodInfo.ReturnType != typeof(void)) 1397this.returnTypeName = methodInfo.ReturnType.FullName; 1399!((methodInfo.ReturnType.IsPrimitive || methodInfo.ReturnType.IsEnum || methodInfo.ReturnType.IsValueType) && !ServiceOperationHelpers.IsNullableType(methodInfo.ReturnType));

System\Workflow\Activities\SendActivity.cs (3)

470if (!(methodInfo.ReturnType == typeof(void))) 612if (methodInfo.ReturnType != null && methodInfo.ReturnType != typeof(void))

System\Workflow\Activities\ValidationHelper.cs (2)

785if (isOneWay && methodInfo.ReturnType != typeof(void)) 1111if (methodInfo.ReturnParameter != null && methodInfo.ReturnType != typeof(void))

System\Xml\Serialization\Mappings.cs (4)

982if (needSchema && typeof(XmlSchemaType).IsAssignableFrom(getSchemaMethod.ReturnType)) 1054if (typeof(XmlSchemaType).IsAssignableFrom(getSchemaMethod.ReturnType)) 1136if (typeof(XmlSchemaType).IsAssignableFrom(getSchemaMethod.ReturnType)) { 1141else if (typeof(XmlQualifiedName).IsAssignableFrom(getSchemaMethod.ReturnType)) {

System\Xml\Serialization\SourceInfo.cs (2)

107Type eType = get_Item.ReturnType; 203ILG.ConvertValue(Nullable_get_Value.ReturnType, targetType);

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

36method.ReturnType != null && 37targetType.IsAssignableFrom(method.ReturnType)) {

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

1115if (enumerator == null || !typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType)) { 1120if (enumerator != null && typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType)) { 1135if (enumerator == null || !typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType)) { 1141PropertyInfo p = enumerator.ReturnType.GetProperty("Current");

System\Xml\Serialization\XmlReflectionImporter.cs (2)

438if (!(typeof(XmlQualifiedName).IsAssignableFrom(getMethod.ReturnType)) && !(typeof(XmlSchemaType).IsAssignableFrom(getMethod.ReturnType)))

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

2037ilg.ConvertValue(XmlDocument_ReadNode.ReturnType, localAttr.LocalType); 2683ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, typeDesc.Type); 2697ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, member.Mapping.ChoiceIdentifier.Mapping.TypeDesc.Type.MakeArrayType()); 2846if (Add.ReturnType != typeof(void))

System\Xml\Serialization\XmlSerializationWriterILGen.cs (6)

152returnType = XmlConvert_ToString.ReturnType; 170returnType = FromXXX.ReturnType; 1239if (method.ReturnType != typeof(void)) 1449if (getEnumeratorMethod != null && typeof(IEnumerator).IsAssignableFrom(getEnumeratorMethod.ReturnType)) 1469ilg.ConvertValue(getEnumeratorMethod.ReturnType, typeof(IEnumerator)); 2365ilg.ConvertValue(Activator_CreateInstance.ReturnType, cast);

Base\MS\Internal\ComponentModel\DependencyObjectPropertyDescriptor.cs (1)

163if (method != null && method.ReturnType == BoolType)