C# IType.IsReferenceType方法代码示例

        /// <summary>
        /// Performs the value analysis.
        /// </summary>
        /// <param name="element">
        /// The element.
        /// </param>
        /// <param name="type">
        /// The type parameter.
        /// </param>
        /// <param name="range">
        /// The range.
        /// </param>
        /// <param name="name">
        /// The variable name.
        /// </param>
        private void PerformValueAnalysis(IElement element, IType type, global::JetBrains.Util.TextRange range, string name)
        {
            if (!type.IsReferenceType())
              {
            return;
              }

              var functionDeclaration = element.GetContainingElement(typeof(IFunctionDeclaration), true) as ICSharpFunctionDeclaration;
              if (functionDeclaration == null)
              {
            return;
              }

              var expression = element.GetContainingElement(typeof(IReferenceExpression), true) as IReferenceExpression;
              if (expression == null)
              {
            return;
              }

              var graf = CSharpControlFlowBuilder.Build(functionDeclaration);

              var inspect = graf.Inspect(ValueAnalysisMode.OPTIMISTIC);

              var state = inspect.GetExpressionNullReferenceState(expression);

              switch (state)
              {
            case CSharpControlFlowNullReferenceState.UNKNOWN:
              this.AddAction("Check if '{0}' is null", "F802DB32-A0B1-4227-BE5C-E7D20670284B", range, name);
              break;
            case CSharpControlFlowNullReferenceState.NOT_NULL:
              break;
            case CSharpControlFlowNullReferenceState.NULL:
              this.AddAction("Check if '{0}' is null", "F802DB32-A0B1-4227-BE5C-E7D20670284B", range, name);
              break;
            case CSharpControlFlowNullReferenceState.MAY_BE_NULL:
              break;
              }
        }

		bool BoxingConversion(IType fromType, IType toType)
		{
			// C# 4.0 spec: §6.1.7
			fromType = NullableType.GetUnderlyingType(fromType);
			return fromType.IsReferenceType(context) == false && toType.IsReferenceType(context) == true && IsSubtypeOf(fromType, toType);
		}

		public static bool IsNonNullableValueType(IType type, ITypeResolveContext context)
		{
			return type.IsReferenceType(context) == false && !IsNullable(type);
		}

		public bool ImplicitReferenceConversion(IType fromType, IType toType)
		{
			// C# 4.0 spec: §6.1.6
			
			// reference conversions are possible only if both types are known to be reference types
			if (!(fromType.IsReferenceType(context) == true && toType.IsReferenceType(context) == true))
				return false;
			
			// conversion from null literal is always possible
			if (fromType == SharedTypes.Null)
				return true;
			
			ArrayType fromArray = fromType as ArrayType;
			if (fromArray != null) {
				ArrayType toArray = toType as ArrayType;
				if (toArray != null) {
					// array covariance (the broken kind)
					return fromArray.Dimensions == toArray.Dimensions
						&& ImplicitReferenceConversion(fromArray.ElementType, toArray.ElementType);
				}
				// conversion from single-dimensional array S[] to IList<T>:
				ParameterizedType toPT = toType as ParameterizedType;
				if (fromArray.Dimensions == 1 && toPT != null && toPT.TypeArguments.Count == 1
				    && toPT.Namespace == "System.Collections.Generic"
				    && (toPT.Name == "IList" || toPT.Name == "ICollection" || toPT.Name == "IEnumerable"))
				{
					// array covariance plays a part here as well (string[] is IList<object>)
					return IdentityConversion(fromArray.ElementType, toPT.TypeArguments[0])
						|| ImplicitReferenceConversion(fromArray.ElementType, toPT.TypeArguments[0]);
				}
				// conversion from any array to System.Array and the interfaces it implements:
				ITypeDefinition systemArray = context.GetTypeDefinition("System", "Array", 0, StringComparer.Ordinal);
				return systemArray != null && (systemArray.Equals(toType) || ImplicitReferenceConversion(systemArray, toType));
			}
			
			// now comes the hard part: traverse the inheritance chain and figure out generics+variance
			return IsSubtypeOf(fromType, toType);
		}