C# IValue.GetType方法代码示例

        // Public Methods 

        public static IValue Visit(IValue src)
        {


            if (src.GetType() == typeof(StaticMemberAccessExpression))
            {
                var xx = src as StaticMemberAccessExpression;
                var fieldInfo = xx.Expression.DotnetType.GetField(xx.MemberName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                if (fieldInfo != null)
                {
                    throw new NotSupportedException();
                    // return Visit(new ClassFieldAccessExpression(fieldInfo));
                }
                var propertyInfo = xx.Expression.DotnetType.GetProperty(xx.MemberName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
                if (propertyInfo != null)
                    return Visit(new CsharpInstancePropertyAccessExpression(propertyInfo, null));
                return src;
            }
            if (src.GetType() == typeof(InstanceMemberAccessExpression))
            {
                var xx = src as InstanceMemberAccessExpression;
                var t = xx.Expression.ValueType;
                var fieldInfo = t.GetField(xx.MemberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                if (fieldInfo != null)
                    return Visit(new InstanceFieldAccessExpression(fieldInfo, xx.Expression));

                var propertyInfo = t.GetProperty(xx.MemberName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                if (propertyInfo != null)
                    return Visit(new CsharpInstancePropertyAccessExpression(propertyInfo, xx.Expression));
                return src;
            }

            if (src.GetType() == typeof(MemberAccessExpression))
            {
                var xx = src as MemberAccessExpression;
                if (xx.Expression is TypeValue)
                {
                    var yy = xx.Expression as TypeValue;
                    var tmp = new StaticMemberAccessExpression(xx.MemberName, new LangType(yy.DotnetType));
                    return Visit(tmp);

                }
                /*
                if (xx.Expression is LangType)
                {
                    var yy = xx.Expression as LangType;
                    var tmp = new StaticMemberAccessExpression(xx.MemberName, yy);
                    return Visit(tmp);
                } */
            }
            if (src is UnknownIdentifierValue)
            {

            }
            return src;
            throw new NotSupportedException();
        }

        private void AddCustomValue(XmlElement parent, PropertyAuditingData propertyAuditingData,
            IValue value, ISimpleMapperBuilder mapper, bool insertable, bool key)
        {
            if (parent != null) {
                XmlElement prop_mapping = MetadataTools.AddProperty(parent, propertyAuditingData.Name,
                        null, insertable, key);

                //CustomType propertyType = (CustomType) value.getType();

                XmlElement type_mapping = parent.OwnerDocument.CreateElement("type");
                prop_mapping.AppendChild(type_mapping);
                type_mapping.SetAttribute("name", value.GetType().Name);

                if (value is SimpleValue) {
                    IDictionary<string, string> typeParameters = ((SimpleValue)value).TypeParameters;
                    if (typeParameters != null) {
                        foreach (KeyValuePair<string,string> paramKeyValue in typeParameters) {
                            XmlElement type_param = parent.OwnerDocument.CreateElement("param");
                            type_param.SetAttribute("name", (String) paramKeyValue.Key);
                            type_param["name"].Value =  paramKeyValue.Value;
                        }
                    }
                }

                MetadataTools.AddColumns(prop_mapping, (IEnumerator<ISelectable>)value.ColumnIterator);
            }

            if (mapper != null) {
                mapper.Add(propertyAuditingData.getPropertyData());
            }
        }

 // left in right
 public virtual bool Contains(IValue right, IValue left)
 {
     throw new TypeInconsistancyException("Variable of type " + GetType() + " cannot contain a variable of type " +
                                          left.GetType());
 }

//.........这里部分代码省略.........
				return EvalNot(value);
			}
			if (expression is NPathParameter)
			{
				NPathParameter value = (NPathParameter)expression;
				return EvalParameter(value);
			}
			if (expression is NPathNullValue)
			{
				return EvalNullValue();
			}
			if (expression is NPathBooleanValue)
			{
				NPathBooleanValue value = (NPathBooleanValue)expression;
				return EvalBooleanValue(value);
			}
			if (expression is NPathDecimalValue)
			{
				NPathDecimalValue value = (NPathDecimalValue)expression;
				return EvalDecimalValue(value);
			}
			if (expression is NPathDateTimeValue)
			{
				NPathDateTimeValue value = (NPathDateTimeValue)expression;
				return EvalDateTimeValue(value);
			}
			if (expression is NPathGuidValue)
			{
				NPathGuidValue value = (NPathGuidValue)expression;
				return EvalGuidValue(value);
			}
			if (expression is NPathStringValue)
			{
				NPathStringValue value = (NPathStringValue)expression;
				return EvalStringValue(value);
			}
			if (expression is NPathIdentifier)
			{
				NPathIdentifier propertyPath = (NPathIdentifier) expression;
				return EvalIdentifier(propertyPath);
			}
			//			if (expression is PropertyFilter)
			//			{
			//				PropertyFilter propertyFilter = (PropertyFilter) expression;
			//				return EvalPropertyFilter(propertyFilter);
			//			}
			if (expression is NPathParenthesisGroup) // SearchCondition
			{
				NPathParenthesisGroup parenthesisGroup = (NPathParenthesisGroup) expression;
				return EvalParenthesisGroup(parenthesisGroup);
			}
			//			if (expression is MathExpression)
			//			{
			//				MathExpression mathExpression = (MathExpression) expression;
			//				return EvalMathExpression(mathExpression);
			//			}
			if (expression is NPathBooleanExpression)  // SearchCondition
			{
				NPathBooleanExpression boolExpression = (NPathBooleanExpression) expression;
				return EvalBooleanExpression(boolExpression);
			}

			if (expression is NPathFunction) // Function
			{
				NPathFunction value = (NPathFunction)expression;
				return EvalFunction(value);
			}
			if (expression is NPathCompareExpression) // ComparePredicate
			{
				NPathCompareExpression compareExpression = (NPathCompareExpression) expression;
				return EvalCompareExpression(compareExpression);
			}
			if (expression is NPathBetweenExpression) // BetweenPredicate
			{
				NPathBetweenExpression value = (NPathBetweenExpression)expression;
				return EvalBetween(value);
			}
			if (expression is NPathInExpression) // InPredicate
			{
				NPathInExpression value = (NPathInExpression)expression;
				return EvalIn(value);
			}
			if (expression is NPathMathExpression) // InPredicate
			{
				NPathMathExpression value = (NPathMathExpression)expression;
				return EvalMath(value);
			}
			if (expression is NPathSelectQuery)
			{
				NPathSelectQuery query = (NPathSelectQuery)expression;
				return EvalSubQuery(query);
			}

			//			if (expression is SearchFunction) //FreeTextPredicate
			//			{
			//				SearchFunction value = (SearchFunction)expression;
			//				return EvalSearchFunction(value);
			//			}
			throw new IAmOpenSourcePleaseImplementMeException(string.Format("Expressions of type '{0}' is not yet implemented",expression.GetType().Name) ) ;
		}

 /// <summary>
 /// Initializes the specified key.
 /// </summary>
 /// <param name="key">The key.</param>
 /// <param name="initialValue">The initial value.</param>
 /// <param name="direction">The direction (Input / Output).</param>
 /// <param name="comment">The comment.</param>
 /// <returns>This.</returns>
 public IParameter Initialize(string key, IValue initialValue, EnumParameterDirection direction = EnumParameterDirection.Input, string comment = "")
 {
     this.Key = key;
     this.Comment = comment;
     this.ParameterDirection = direction;
     this.ParameterType = initialValue.GetType() == typeof (DigitalValue) ? EnumParameterType.Digital : EnumParameterType.Analog;
     this.IsUptoDate = false;
     this.value = initialValue;
     return this;
 }