コード例 #1
0
    public static T GetValue <T>(object instance, string propPath)
    {
        Delegate runtimeDelegate;

        System.Linq.Expressions.ParameterExpression instanceParameter =
            System.Linq.Expressions.Expression.Parameter(instance.GetType(), "p");

        string[] properties = propPath.Split('.');

        System.Linq.Expressions.MemberExpression currentExpression =
            System.Linq.Expressions.Expression.PropertyOrField(instanceParameter, properties[0]);

        System.Linq.Expressions.LambdaExpression lambdaExpression =
            System.Linq.Expressions.Expression.Lambda(currentExpression, instanceParameter);

        for (int i = 1; i < properties.Length; i++)
        {
            currentExpression = System.Linq.Expressions.Expression.PropertyOrField(lambdaExpression.Body, properties[i]);
            lambdaExpression  = System.Linq.Expressions.Expression.Lambda(currentExpression, instanceParameter);
        }

        runtimeDelegate = lambdaExpression.Compile();

        return((T)runtimeDelegate.DynamicInvoke(instance));
    }
コード例 #2
0
            /// <summary>
            /// Compile the string expression into a COExpression object.
            /// </summary>
            /// <param name="expression">The expression to compile.</param>
            /// <returns>Compiled COExpression object.</returns>
            public static COExpression <ClassificationObject> Compile <T>(String expression) where T : ClassificationObject
            {
                System.Linq.Expressions.LambdaExpression lambda = DynamicExpression.ParseLambda(typeof(T),
                                                                                                typeof(bool), expression);

                return(ExpressionCasting <T> .ExpressionCast(lambda.Compile()));
            }
コード例 #3
0
        public static System.Func <T, TValue> GetGetter <T, TValue>(string fieldName)
        {
            System.Linq.Expressions.ParameterExpression p    = System.Linq.Expressions.Expression.Parameter(typeof(T));
            System.Linq.Expressions.MemberExpression    prop = System.Linq.Expressions.Expression.PropertyOrField(p, fieldName);
            System.Linq.Expressions.UnaryExpression     con  = System.Linq.Expressions.Expression.Convert(prop, typeof(TValue));
            System.Linq.Expressions.LambdaExpression    exp  = System.Linq.Expressions.Expression.Lambda(con, p);

            System.Func <T, TValue> getter = (System.Func <T, TValue>)exp.Compile();
            return(getter);
        }
コード例 #4
0
ファイル: Dynamic.cs プロジェクト: jinyuttt/SmartXmlSql
        /// <summary>
        /// 条件返回
        /// </summary>
        /// <returns></returns>
        public bool Condtion()
        {
            bool r = false;

            if (empty != null)
            {
                bool tmp = empty.Invoke(Statement.SqlContext.Context);
                r = !tmp;//
            }
            else
            {
                r = (bool)expression.Compile().DynamicInvoke(Statement.SqlContext.Context);
            }
            return(r);
        }
コード例 #5
0
 public static dynamic TryGetProperty(dynamic dynamicObject, String PropertyName, dynamic Default)
 {
     try
     {
         if (!HasProperty(dynamicObject, PropertyName))
         {
             return(Default);
         }
         if (dynamicObject.GetType() == typeof(System.Web.Helpers.DynamicJsonObject))
         {
             // good thing this type of documentation was easy to find
             System.Web.Helpers.DynamicJsonObject obj = (System.Web.Helpers.DynamicJsonObject)dynamicObject;
             Type scope = obj.GetType();
             System.Dynamic.IDynamicMetaObjectProvider provider = obj as System.Dynamic.IDynamicMetaObjectProvider;
             if (provider != null)
             {
                 System.Linq.Expressions.ParameterExpression param = System.Linq.Expressions.Expression.Parameter(typeof(object));
                 System.Dynamic.DynamicMetaObject            mobj  = provider.GetMetaObject(param);
                 System.Dynamic.GetMemberBinder          binder    = (System.Dynamic.GetMemberBinder)Microsoft.CSharp.RuntimeBinder.Binder.GetMember(0, PropertyName, scope, new Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo[] { Microsoft.CSharp.RuntimeBinder.CSharpArgumentInfo.Create(0, null) });
                 System.Dynamic.DynamicMetaObject        ret       = mobj.BindGetMember(binder);
                 System.Linq.Expressions.BlockExpression final     = System.Linq.Expressions.Expression.Block(
                     System.Linq.Expressions.Expression.Label(System.Runtime.CompilerServices.CallSiteBinder.UpdateLabel),
                     ret.Expression
                     );
                 System.Linq.Expressions.LambdaExpression lambda = System.Linq.Expressions.Expression.Lambda(final, param);
                 Delegate del = lambda.Compile();
                 return(del.DynamicInvoke(obj));
             }
             else
             {
                 return(obj.GetType().GetProperty(PropertyName, System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).GetValue(obj, null));
             }
         }
         else if (dynamicObject.GetType() == typeof(System.Collections.IDictionary))
         {
             return((Dictionary <String, object>)dynamicObject[PropertyName]);
         }
         return(Default);
     }
     catch (Exception ex)
     {
         throw new Exception("Could not determine if dynamic object has property.", ex);
     }
 }
コード例 #6
0
ファイル: ArrayHelper.cs プロジェクト: lshift/nhibernate-core
        // NH-specific
        public static void AddAll(IList to, IList from)
        {
            System.Action addNull = null;
            foreach (object obj in from)
            {
                // There is bug in .NET, before version 4, where adding null to a List<Nullable<T>> through the non-generic IList interface throws an exception.
                // TODO: Everything but the to.Add(obj) should be conditionally compiled only for versions of .NET earlier than 4.
                if (obj == null)
                {
                    if (addNull == null)
                    {
                        if (to.GetType().IsGenericType&&
                            to.GetType().GetGenericTypeDefinition() == typeof(List <>) &&
                            to.GetType().GetGenericArguments()[0].IsGenericType &&
                            to.GetType().GetGenericArguments()[0].GetGenericTypeDefinition() == typeof(Nullable <>))
                        {
                            MethodInfo addMethod = to.GetType().GetMethod("Add");
                            System.Linq.Expressions.MethodCallExpression addMethodCall =
                                System.Linq.Expressions.Expression.Call(System.Linq.Expressions.Expression.Constant(to),
                                                                        addMethod,
                                                                        System.Linq.Expressions.Expression.Constant(null, to.GetType().GetGenericArguments()[0]));
                            System.Linq.Expressions.LambdaExpression addLambda =
                                System.Linq.Expressions.Expression.Lambda(addMethodCall);

                            addNull = (System.Action)addLambda.Compile();
                        }
                        else
                        {
                            addNull = () => to.Add(null);
                        }
                    }
                    addNull();
                }
                else
                {
                    to.Add(obj);
                }
            }
        }
コード例 #7
0
    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {
        if (ItemType.IsInstanceOfType(item))
        {
            if (getPropertyValue == null)
            {
                System.Linq.Expressions.ParameterExpression instanceParameter =
                    System.Linq.Expressions.Expression.Parameter(item.GetType(), "p");

                System.Linq.Expressions.MemberExpression currentExpression =
                    System.Linq.Expressions.Expression.PropertyOrField(instanceParameter, PropertyName);

                System.Linq.Expressions.LambdaExpression lambdaExpression =
                    System.Linq.Expressions.Expression.Lambda(currentExpression, instanceParameter);

                getPropertyValue = lambdaExpression.Compile();
            }

            return(SelectTemplateImpl(getPropertyValue.DynamicInvoke(item), container));
        }

        return(base.SelectTemplate(item, container));
    }
コード例 #8
0
        protected virtual ComparisonResult CompareStructural(QueryStructuralValue expected, object actual, string path, bool shouldThrow)
        {
            this.AddToLogBuffer("Verifying structural value. Path: {0}", path);

            if (actual == null)
            {
                if (expected.IsNull)
                {
                    return(ComparisonResult.Success);
                }

                this.ThrowOrLogError(shouldThrow, "Expecting non-null value: {0} in '{1}. Got null instead.", expected, path);

                return(ComparisonResult.Failure);
            }

            if (expected.IsNull)
            {
                // if expected is null but actual is non-null this can be a result of the fact that entity was present in the ObjectStateManager and got attached even though
                // this particular query did not bring it back.
                if (this.LinqResultComparerContextAdapter.IsObjectTrackedByContext(actual))
                {
                    this.AddToLogBuffer("Verifying structural value. Path: {0} SKIPPED (Entity in Object State Manager)", path);

                    return(ComparisonResult.Skipped);
                }
                else
                {
                    this.ThrowOrLogError(shouldThrow, "Expecting null value in '{0}'. Actual: {1}[{2}].", path, actual, actual.GetType());

                    return(ComparisonResult.Failure);
                }
            }

            List <object> visited;

            if (!this.visitedEntities.TryGetValue(expected, out visited))
            {
                visited = new List <object>();
                this.visitedEntities.Add(expected, visited);
            }

            if (visited.Contains(actual))
            {
                this.AddToLogBuffer("Verifying structural value. Path: {0} SKIPPED (Already visited)", path);

                return(ComparisonResult.Skipped);
            }

            visited.Add(actual);

            var expectedType = expected.Type as IQueryClrType;

            if (expectedType != null)
            {
                ExceptionUtilities.Assert(expectedType.ClrType != null, "Expecting non-null CLR type.");

                if (!expectedType.ClrType.IsAssignableFrom(actual.GetType()))
                {
                    this.ThrowOrLogError(shouldThrow, "Types not match in {0}. Expecting: {1}. Actual: {2}.", path, expectedType.ClrType, actual.GetType());

                    return(ComparisonResult.Failure);
                }
            }

            bool comparisonSkippedForAnyProperty = false;
            var  properties = actual.GetType().GetProperties();

            IEnumerable <string> propertyNames = expected.MemberNames;

#if WIN8
            bool isAnonymousType = IsAnonymousType(actual.GetType());
            int  i = 0;
#endif
            foreach (string expectedName in propertyNames)
            {
#if WIN8
                // In WIN8 we are using CSharpGenericTypeBuilder. Properties have fixed names such as Field1, Field2,...
                var actualProperty = isAnonymousType ? properties.ToArray()[i++] : properties.Where(p => p.Name == expectedName).SingleOrDefault();
#else
                var actualProperty = properties.Where(p => p.Name == expectedName).SingleOrDefault();
#endif

                if (actualProperty == null)
                {
                    this.ThrowOrLogError(shouldThrow, "Expected property not found: {0} in '{1}'.", expectedName, path);

                    return(ComparisonResult.Failure);
                }

                object actualValue = null;

 #if SILVERLIGHT
                CoreLinq.Expressions.ParameterExpression param               = CoreLinq.Expressions.Expression.Parameter(typeof(Object), "param");
                CoreLinq.Expressions.Expression          convertedParam      = CoreLinq.Expressions.Expression.Convert(param, actual.GetType());
                CoreLinq.Expressions.LambdaExpression    GetPropertyValueExp = CoreLinq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Property(convertedParam, actualProperty), param);

                Delegate dynamicGetter = GetPropertyValueExp.Compile();

                actualValue = dynamicGetter.DynamicInvoke(actual);
#else
                actualValue = actualProperty.GetValue(actual, null);
#endif
                QueryType expectedPropertyType = expected.Type.Properties.Where(p => p.Name == expectedName).Single().PropertyType;

                string newPath          = path + "." + expectedName;
                var    comparisonResult = this.CompareProperty(expected, expectedName, expectedPropertyType, actualValue, newPath, shouldThrow);
                if (comparisonResult == ComparisonResult.Failure)
                {
                    visited.Remove(actual);
                    return(ComparisonResult.Failure);
                }

                if (comparisonResult == ComparisonResult.Skipped)
                {
                    comparisonSkippedForAnyProperty = true;
                }
            }

            if (comparisonSkippedForAnyProperty)
            {
                this.AddToLogBuffer("Verifying structural value. Path: {0} SKIPPED", path);

                return(ComparisonResult.Skipped);
            }
            else
            {
                this.AddToLogBuffer("Verifying structural value. Path: {0} SUCCESSFUL", path);

                return(ComparisonResult.Success);
            }
        }
コード例 #9
0
ファイル: CryptoHelper.cs プロジェクト: wpenbert/CoreWCF
        internal static object GetAlgorithmFromConfig(string algorithm)
        {
            if (string.IsNullOrEmpty(algorithm))
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(algorithm)));
            }

            object algorithmObject = null;
            object defaultObject   = null;

            if (!s_algorithmDelegateDictionary.TryGetValue(algorithm, out Func <object> delegateFunction))
            {
                lock (s_algorithmDictionaryLock)
                {
                    if (!s_algorithmDelegateDictionary.ContainsKey(algorithm))
                    {
                        try
                        {
                            algorithmObject = CryptoConfig.CreateFromName(algorithm);
                        }
                        catch (TargetInvocationException)
                        {
                            s_algorithmDelegateDictionary[algorithm] = null;
                        }

                        if (algorithmObject == null)
                        {
                            s_algorithmDelegateDictionary[algorithm] = null;
                        }
                        else
                        {
                            defaultObject = GetDefaultAlgorithm(algorithm);
                            if (defaultObject != null && defaultObject.GetType() == algorithmObject.GetType())
                            {
                                s_algorithmDelegateDictionary[algorithm] = null;
                            }
                            else
                            {
                                // Create a factory delegate which returns new instances of the algorithm type for later calls.
                                Type algorithmType = algorithmObject.GetType();
                                System.Linq.Expressions.NewExpression algorithmCreationExpression = Linq.Expressions.Expression.New(algorithmType);
                                Linq.Expressions.LambdaExpression     creationFunction            = Linq.Expressions.Expression.Lambda <Func <object> >(algorithmCreationExpression);
                                delegateFunction = creationFunction.Compile() as Func <object>;

                                if (delegateFunction != null)
                                {
                                    s_algorithmDelegateDictionary[algorithm] = delegateFunction;
                                }
                                return(algorithmObject);
                            }
                        }
                    }
                }
            }
            else
            {
                if (delegateFunction != null)
                {
                    return(delegateFunction.Invoke());
                }
            }

            //
            // This is a fallback in case CryptoConfig fails to return a valid
            // algorithm object. CrytoConfig does not understand all the uri's and
            // can return a null in that case, in which case it is our responsibility
            // to fallback and create the right algorithm if it is a uri we understand
            //
            switch (algorithm)
            {
            case SHA256String:
            case SecurityAlgorithms.Sha256Digest:
                return(SHA256.Create());

            case SecurityAlgorithms.Sha1Digest:
                return(SHA1.Create());

            case SecurityAlgorithms.HmacSha1Signature:
                return(new HMACSHA1());

            default:
                break;
            }

            return(null);
        }
コード例 #10
0
ファイル: MethodGraph.cs プロジェクト: Azarem/RogueLauncher
 public MethodGraph SwitchImpl(System.Linq.Expressions.LambdaExpression expression, string newName = null, string oldName = null)
 {
     return(SwitchImpl(expression.Compile().Method, newName, oldName));
 }
コード例 #11
0
ファイル: MethodGraph.cs プロジェクト: Azarem/RogueLauncher
 public MethodGraph(System.Linq.Expressions.LambdaExpression expression, TypeGraph parentGraph = null) : this(expression.Compile().Method, parentGraph)
 {
 }
コード例 #12
0
ファイル: XmlSerialization.cs プロジェクト: bixiu/BlueMine
            } // End Function GetNamespaces

            static AccessorCache()
            {
                try
                {
                    s_GetNamespaces = null;
                    System.Linq.Expressions.ParameterExpression p    = System.Linq.Expressions.Expression.Parameter(typeof(T));
                    System.Linq.Expressions.MemberExpression    prop = System.Linq.Expressions.Expression.Property(p, "Namespaces");
                    System.Linq.Expressions.UnaryExpression     con  = System.Linq.Expressions.Expression.Convert(prop, typeof(System.Xml.Serialization.XmlSerializerNamespaces));
                    System.Linq.Expressions.LambdaExpression    exp  = System.Linq.Expressions.Expression.Lambda(con, p);
                    s_GetNamespaces = (System.Func <T, System.Xml.Serialization.XmlSerializerNamespaces>)exp.Compile();
                }
                catch (System.Exception ex)
                {
                    System.Console.WriteLine(ex.Message);
                    System.Console.WriteLine(ex.StackTrace);
                }
            } // End Static constructor
コード例 #13
0
        protected virtual ComparisonResult CompareStructural(QueryStructuralValue expected, object actual, string path, bool shouldThrow)
        {
            this.AddToLogBuffer("Verifying structural value. Path: {0}", path);

            if (actual == null)
            {
                if (expected.IsNull)
                {
                    return(ComparisonResult.Success);
                }

                this.ThrowOrLogError(shouldThrow, "Expecting non-null value: {0} in '{1}. Got null instead.", expected, path);

                return(ComparisonResult.Failure);
            }

            if (expected.IsNull)
            {
                this.ThrowOrLogError(shouldThrow, "Expecting null value in '{0}'. Actual: {1}[{2}].", path, actual, actual.GetType());

                return(ComparisonResult.Failure);
            }

            if (expected.Type is QueryEntityType)
            {
                if (this.visitedEntities.ContainsKey(expected))
                {
                    if (object.ReferenceEquals(this.visitedEntities[expected], actual))
                    {
                        this.AddToLogBuffer("Comparing structural value. Path: {0}. Result - EQUAL (ALREADY VISITED)", path);

                        return(ComparisonResult.Success);
                    }
                    else
                    {
                        this.ThrowOrLogError(shouldThrow, "Expecting different object in '{0}'. Expected: {1}. Actual: {2}.", path, this.visitedEntities[expected], actual);

                        return(ComparisonResult.Failure);
                    }
                }
                else
                {
                    this.visitedEntities.Add(expected, actual);
                }
            }

            var expectedType = expected.Type as IQueryClrType;

            if (expectedType != null)
            {
                ExceptionUtilities.Assert(expectedType.ClrType != null, "Expecting non-null CLR type.");

                if (!expectedType.ClrType.IsAssignableFrom(actual.GetType()))
                {
                    this.visitedEntities.Remove(expected);
                    this.ThrowOrLogError(shouldThrow, "Types not match in {0}. Expecting: {1}. Actual: {2}.", path, expectedType.ClrType, actual.GetType());

                    return(ComparisonResult.Failure);
                }
            }

            var properties = actual.GetType().GetProperties();
            IEnumerable <string> propertyNames = expected.MemberNames;

            foreach (string expectedName in propertyNames)
            {
                var actualProperty = properties.Where(p => p.Name == expectedName).SingleOrDefault();

                if (actualProperty == null)
                {
                    this.visitedEntities.Remove(expected);
                    this.ThrowOrLogError(shouldThrow, "Expected property not found: {0} in '{1}'.", expectedName, path);

                    return(ComparisonResult.Failure);
                }

                object actualValue = null;

#if SILVERLIGHT
                CoreLinq.Expressions.ParameterExpression param               = CoreLinq.Expressions.Expression.Parameter(typeof(Object), "param");
                CoreLinq.Expressions.Expression          convertedParam      = CoreLinq.Expressions.Expression.Convert(param, actual.GetType());
                CoreLinq.Expressions.LambdaExpression    GetPropertyValueExp = CoreLinq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Property(convertedParam, actualProperty), param);

                Delegate dynamicGetter = GetPropertyValueExp.Compile();

                actualValue = dynamicGetter.DynamicInvoke(actual);
#else
                actualValue = actualProperty.GetValue(actual, null);
#endif
                QueryType expectedPropertyType = expected.Type.Properties.Where(p => p.Name == expectedName).Single().PropertyType;

                string newPath = path + "." + expectedName;
                var    propertyComparisonResult = this.CompareProperty(expected, expectedName, expectedPropertyType, actualValue, newPath, shouldThrow);
                if (propertyComparisonResult == ComparisonResult.Failure)
                {
                    this.visitedEntities.Remove(expected);

                    return(ComparisonResult.Failure);
                }
            }

            this.AddToLogBuffer("Verifying structural value. Path: {0} SUCCESSFUL", path);

            return(ComparisonResult.Success);
        }
コード例 #14
0
ファイル: ProviderExtensions.cs プロジェクト: bixiu/BlueMine
 static ProviderExtensions()
 {
     System.Linq.Expressions.ParameterExpression p    = System.Linq.Expressions.Expression.Parameter(typeof(System.Data.Common.DbConnection));
     System.Linq.Expressions.MemberExpression    prop = System.Linq.Expressions.Expression.Property(p, "DbProviderFactory");
     System.Linq.Expressions.UnaryExpression     con  = System.Linq.Expressions.Expression.Convert(prop, typeof(System.Data.Common.DbProviderFactory));
     System.Linq.Expressions.LambdaExpression    exp  = System.Linq.Expressions.Expression.Lambda(con, p);
     s_func = (Func <System.Data.Common.DbConnection, System.Data.Common.DbProviderFactory>)exp.Compile();
 } // End Static Constructor