コード例 #1
0
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            Type       contracts  = typeof(IRpcRequestService);
            MethodInfo methodInfo = contracts.GetMethod("ExecuteRpc");
            Type       t          = typeof(T);
            Type       u          = binder.ReturnType;
            ICriterion c          = new Criterion();

            c.AddItem(XFConstants.Application.ActionResultModelType, u.AssemblyQualifiedName);
            c.AddItem(XFConstants.Application.ActionExecuteMethodName, binder.Name);
            c.AddItem(XFConstants.Application.ActionExecuteStrategy, XFConstants.Application.ActionExecuteStrategyDynamic);

            int i = 1;

            foreach (var arg in args)
            {
                string s = String.Format("", XFConstants.Application.StrategyKey, i.ToString());
                c.AddItem(s, arg);
                i++;
            }

            MethodInfo constructed = methodInfo.MakeGenericMethod(t, u);

            object[] methodArgs = { null, c };

            result = constructed.Invoke(_Service, methodArgs);
            return((result != null) ? true : false);
        }
コード例 #2
0
        public static void SetStrategyKeyValue(this ICriterion item, string strategyKey, string strategyValue)
        {
            Criterion criteria = item as Criterion;

            if (criteria != null)
            {
                criteria.AddItem(XFConstants.Application.StrategyKey, strategyKey);
                criteria.AddItem(strategyKey, strategyValue);
            }
        }
コード例 #3
0
ファイル: Criterion.cs プロジェクト: eXtensoft/xf-2.0
        public static ICriterion GenerateStrategy(string switchKey)
        {
            Criterion criteria = new Criterion();

            if (criteria != null)
            {
                criteria.AddItem(XFConstants.Application.StrategyKey, switchKey);
            }
            return(criteria as ICriterion);
        }
コード例 #4
0
        public virtual ICriterion Delete(ICriterion criterion, IContext context)
        {
            Criterion item = new Criterion();

            if (criterion != null)
            {
                if (DbConnection != null)
                {
                    IRequestContext ctx = context as IRequestContext;
                    //ISqlCommandContext<T> resolver = (ISqlCommandContext<T>)this;
                    SqlCommand cmd = null;
                    int        i   = 0;
                    using (SqlConnection cn = DbConnection)
                    {
                        try
                        {
                            cn.Open();
                            cmd = DeleteSqlCommand(cn, criterion, context);

                            if (cmd != null)
                            {
                                if (eXtensibleConfig.CaptureMetrics)
                                {
                                    ctx.SetMetric(cmd.CommandType.ToString(), XFConstants.Metrics.Database.Command, cmd.CommandText);
                                    ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.Scope.Command.Begin, DateTime.Now);
                                }
                                i = cmd.ExecuteNonQuery();
                                bool b = (i == 1) ? true : false;
                                item.AddItem("Success", b);
                                if (eXtensibleConfig.CaptureMetrics)
                                {
                                    ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.Scope.Command.End, DateTime.Now);
                                    ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.Count, i);
                                }
                            }
                            else
                            {
                                var message = Exceptions.ComposeNullSqlCommand <T>(ModelActionOption.Delete, null, criterion, context, this.GetType().FullName);
                                context.SetError(500, message.ToPublish());
                                EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
                            }
                        }
                        catch (Exception ex)
                        {
                            if (eXtensibleConfig.CaptureMetrics)
                            {
                                ctx.SetMetric(XFConstants.Metrics.Scope.DataStore, XFConstants.Metrics.Scope.Command.End, DateTime.Now);
                            }
                            string database = String.Format("server:{0};database:{1}", cn.DataSource, cn.Database);
                            var    message  = Exceptions.ComposeSqlException <T>(ModelActionOption.Delete, ex, null, criterion, context, this.GetType().FullName, database);
                            context.SetError(500, message.ToPublish());
                            context.SetStacktrace(ex.StackTrace);
                            EventWriter.WriteError(message.ToLog(), SeverityType.Error, XFConstants.Category.DataAccess, context.ToDictionary(message.Id));
                        }
                    }
                }
            }
            else if (eXtensibleConfig.Inform)
            {
                EventWriter.Inform(String.Format("No criterion was provided for {0}.Delete method in {1}", GetModelType().FullName, this.GetType().FullName));
            }

            return(item);
        }