/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
return
(new ParameterFinder <Trend>(
lambdaExpression.Body,
new List <string> {
"Type",
"Date",
"ExcludeHashtags"
})
.Parameters);
}
/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
return
(new ParameterFinder <Account>(
lambdaExpression.Body,
new List <string> {
"Type",
"SkipStatus",
"IncludeEntities"
})
.Parameters);
}
/// <summary>
/// Converts a LINQ lambda expression into the Infer.NET equivalent.
/// </summary>
/// <param name="lambdaExpression"></param>
/// <returns></returns>
internal ILambdaExpression ConvertLambda(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
var lambda = new XLambdaExpression
{
Body = Convert(lambdaExpression.Body),
};
foreach (var p in lambdaExpression.Parameters)
{
lambda.Parameters.Add(ConvertParameterToVar(p));
}
return(lambda);
}
public override void BuildSql()
{
if (Property == "IsNotEmpty")
{
if (empty == null)
{
empty = CreateBuilder(this.Statement.SqlContext.Context, this.Sql);
}
}
else if (expression == null)
{
object obj = Statement.SqlContext.Context;
expression = DynamicExpressionParser.ParseLambda(obj.GetType(), typeof(bool), this.Sql);
}
}
internal static DMS DMSInsertIdentity(this DMS dms, IEntity entity)
{
dms.ExcuteType = DMSExcuteType.INSERTIDENTITY;
IDictionary <string, object> ChangedProperties = ((IEntity)entity).ChangedMappingProperties;
if (ChangedProperties == null || ChangedProperties.Count == 0)
{
Log.Debug(ReflectionUtils.GetMethodBaseInfo(System.Reflection.MethodBase.GetCurrentMethod()), "插入字段为空,不能进行添加数据", null);
throw new DMSFrameException("插入字段为空,不能进行添加数据");
}
System.Linq.Expressions.ParameterExpression yExpr = System.Linq.Expressions.Expression.Parameter(entity.GetType(), "x");
System.Linq.Expressions.LambdaExpression lambdaExpr = System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression.Constant(ChangedProperties), yExpr);
dms.ColumnsExpressioin.Append(lambdaExpr);
return(dms);
}
private static MethodInfo GetMethodInfo(System.Linq.Expressions.LambdaExpression expression)
{
if (expression.Body is System.Linq.Expressions.MethodCallExpression method)
{
return(method.Method);
}
if (expression.Body is System.Linq.Expressions.BinaryExpression binary)
{
return(binary.Method);
}
if (expression.Body is System.Linq.Expressions.MemberExpression property)
{
return(((PropertyInfo)property.Member).GetGetMethod());
}
throw new ArgumentException("Invalid Expression. Expression should consist of a Method call only.");
}
} // 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
/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
var paramFinder =
new ParameterFinder <Blocks>(
lambdaExpression.Body,
new List <string> {
"Type",
"ID",
"UserID",
"ScreenName",
"Page"
});
var parameters = paramFinder.Parameters;
return(parameters);
}
/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
var paramFinder =
new ParameterFinder <Search>(
lambdaExpression.Body,
new List <string> {
"Type",
"Query",
"Language",
"PageSize",
"Page",
"SinceID",
"GeoCode",
"ShowUser"
});
return(paramFinder.Parameters);
}
/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
var paramFinder =
new ParameterFinder <Blocks>(
lambdaExpression.Body,
new List <string> {
"Type",
"UserID",
"ScreenName",
"Page",
"PerPage",
"IncludeEntities",
"SkipStatus",
"Cursor"
});
return(paramFinder.Parameters);
}
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);
}
}
protected static MethodInfo GetStatic(LambdaExpression expression, Type expectedReturnType)
{
var unaryExpression = (UnaryExpression)expression.Body;
var methodCallExpression = (MethodCallExpression)unaryExpression.Operand;
var methodCallObject = (ConstantExpression)methodCallExpression.Object !;
var method = (MethodInfo)methodCallObject.Value;
if (method.IsStatic == false)
{
throw new ArgumentException($"Method {method.Name} should be static.");
}
if (method.ReturnType != expectedReturnType)
{
throw new ArgumentException($"Method {method.Name} should return {expectedReturnType.Name}.");
}
return(method);
}
public static string PropertyName <TProperty>(System.Linq.Expressions.Expression <System.Func <TProperty> > property)
{
System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property;
System.Linq.Expressions.MemberExpression memberExpression;
if (lambda.Body is System.Linq.Expressions.UnaryExpression)
{
var unaryExpression = (System.Linq.Expressions.UnaryExpression)lambda.Body;
memberExpression = (System.Linq.Expressions.MemberExpression)unaryExpression.Operand;
}
else
{
memberExpression = (System.Linq.Expressions.MemberExpression)lambda.Body;
}
return(memberExpression.Member.Name);
}
/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
var paramFinder =
new ParameterFinder <Search>(
lambdaExpression.Body,
new List <string> {
"Type",
"Query",
"GeoCode",
"SearchLanguage",
"Locale",
"ResultType",
"Count",
"Until",
"SinceID",
"MaxID",
"IncludeEntities"
});
return(paramFinder.Parameters);
}
private static System.Linq.Expressions.Expression GetSelector_old(
string member,
System.Type entityType
)
{
// Note: entityType = typeof(T);
System.Linq.Expressions.ParameterExpression arg =
System.Linq.Expressions.Expression.Parameter(entityType, "x");
System.Linq.Expressions.Expression expr = arg;
System.Reflection.BindingFlags bf =
System.Reflection.BindingFlags.IgnoreCase
| System.Reflection.BindingFlags.Public
| System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.Instance
| System.Reflection.BindingFlags.Static;
System.Type type = null;
System.Reflection.PropertyInfo pi = entityType.GetProperty(member, bf);
if (pi == null)
{
System.Reflection.FieldInfo fi = entityType.GetField(member, bf);
expr = System.Linq.Expressions.Expression.Field(expr, fi);
type = fi.FieldType;
}
else
{
expr = System.Linq.Expressions.Expression.Property(expr, pi);
type = pi.PropertyType;
}
Type delegateType = typeof(Func <,>).MakeGenericType(entityType, type);
System.Linq.Expressions.LambdaExpression lambda =
System.Linq.Expressions.Expression.Lambda(delegateType, expr, arg);
return(lambda);
}
public static IQueryable GenerateSortExpression(IQueryable source, Type sourceType, string propertyName, string action)
{
System.Linq.Expressions.ParameterExpression paramExpression = System.Linq.Expressions.Expression.Parameter(sourceType, sourceType.Name);
System.Linq.Expressions.MemberExpression memExp = System.Linq.Expressions.Expression.PropertyOrField(paramExpression, propertyName);
System.Linq.Expressions.LambdaExpression lambda = System.Linq.Expressions.Expression.Lambda(memExp, paramExpression);
return(source.Provider.CreateQuery(
System.Linq.Expressions.Expression.Call(
typeof(Queryable),
action,
new Type[] { source.ElementType, lambda.Body.Type },
source.Expression,
lambda)));
}
// 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);
}
}
}
/// <summary>
/// extracts parameters from lambda
/// </summary>
/// <param name="lambdaExpression">lambda expression with where clause</param>
/// <returns>dictionary of parameter name/value pairs</returns>
public Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
var paramFinder =
new ParameterFinder <Search>(
lambdaExpression.Body,
new List <string> {
nameof(Type),
nameof(Query),
nameof(GeoCode),
nameof(SearchLanguage),
nameof(Locale),
nameof(ResultType),
nameof(Count),
nameof(Until),
nameof(SinceID),
nameof(MaxID),
nameof(IncludeEntities),
nameof(TweetMode)
});
return(paramFinder.Parameters);
}
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));
}
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);
}
}
///// <summary>
///// 根据参数名称获取参数表达式
///// </summary>
///// <param name="name">参数名称</param>
///// <returns>参数表达式</returns>
//public ParameterExpression GetParameter(string name)
//{
// if (Parameters != null)
// {
// foreach (ParameterExpression parameter in Parameters)
// {
// if (parameter.Name == name) return parameter;
// }
// }
// return null;
//}
#if DOTNET35
/// <summary>
/// 表达式转换
/// </summary>
/// <param name="expression">表达式</param>
/// <returns>表达式</returns>
internal static LambdaExpression convert(System.Linq.Expressions.LambdaExpression expression)
{
return(new LambdaExpression(Expression.convert(expression.Body)
, expression.Parameters.getArray(value => ParameterExpression.convert(value))));
}
/// <summary>
/// not used
/// </summary>
public virtual Dictionary <string, string> GetParameters(System.Linq.Expressions.LambdaExpression lambdaExpression)
{
throw new NotImplementedException();
}
public MethodGraph SwitchImpl(System.Linq.Expressions.LambdaExpression expression, string newName = null, string oldName = null)
{
return(SwitchImpl(expression.Compile().Method, newName, oldName));
}
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);
}
public Sort(Remote.Linq.Expressions.SortExpression exp)
{
_queryExpression = exp.Operand;
_orderingDirection = exp.SortDirection;
_lambdaExpression = null;
}
public Sort(Remote.Linq.Expressions.LambdaExpression exp, Remote.Linq.Expressions.SortDirection orderingDirection)
{
_queryExpression = exp;
_orderingDirection = orderingDirection;
_lambdaExpression = null;
}
public Filter(Remote.Linq.Expressions.LambdaExpression exp)
{
_queryExpression = exp;
_lambdaExpression = null;
}
private static Remote.Linq.Expressions.LambdaExpression GetOrCreateRemoteExpression(Remote.Linq.Expressions.LambdaExpression remoteExpression, System.Linq.Expressions.LambdaExpression systemExpression)
{
return(remoteExpression ?? ToRemoteExpression(systemExpression));
}
public abstract void MarkSequencePoint(System.Linq.Expressions.LambdaExpression method, int ilOffset, System.Linq.Expressions.DebugInfoExpression sequencePoint);
public Filter(System.Linq.Expressions.LambdaExpression exp)
{
_lambdaExpression = exp;
_queryExpression = null;
}
