Beispiel #1
0
        private EnumerableFunc FuncAdd(IColumnProcess tool, EnumerableFunc func, bool isexecute)
        {
            try
            {
                tool.SetExecute(isexecute);
                tool.Init(new List <IFreeDocument>());
            }
            catch (Exception ex)
            {
                XLogSys.Print.Error($"位于{tool.Column}列的{tool.TypeName}模块在初始化时出现异常:{ex},请检查任务参数");
                return(func);
            }
            if (!tool.Enabled)
            {
                return(func);
            }
            if (tool is IColumnDataTransformer)
            {
                var ge    = tool as IColumnDataTransformer;
                var func1 = func;
                func = d =>
                {
                    if (ge.IsMultiYield)
                    {
                        return(ge.TransformManyData(func1(d)));
                    }
                    var r = func1(d);
                    return(r.Select(d2 => Transform(ge, d2)));
                };
            }

            if (tool is IColumnGenerator)
            {
                var ge = tool as IColumnGenerator;

                var func1 = func;
                switch (ge.MergeType)
                {
                case MergeType.Append:

                    func = d => func1(d).Concat(ge.Generate());
                    break;

                case MergeType.Cross:
                    func = d => func1(d).Cross(ge.Generate);
                    break;

                case MergeType.Merge:
                    func = d => func1(d).MergeAll(ge.Generate());
                    break;

                case MergeType.Mix:
                    func = d => func1(d).Mix(ge.Generate());
                    break;
                }
            }


            if (tool is IDataExecutor && isexecute)
            {
                var ge    = tool as IDataExecutor;
                var func1 = func;
                func = d => ge.Execute(func1(d));
            }
            else if (tool is IColumnDataFilter)
            {
                var t = tool as IColumnDataFilter;

                if (t.TypeName == "数量范围选择")
                {
                    dynamic range = t;
                    var     func1 = func;
                    func = d => func1(d).Skip((int)range.Skip).Take((int)range.Take);
                }
                else

                {
                    var func1 = func;
                    func = d => func1(d).Where(t.FilteData);
                }
            }
            return(func);
        }
Beispiel #2
0
        public static EnumerableFunc FuncAdd(this IColumnProcess tool, EnumerableFunc func, bool isexecute,
                                             Analyzer analyzer)
        {
            AnalyzeItem analyzeItem = null;

            analyzeItem = analyzer?.Set(tool);
            try
            {
                tool.SetExecute(isexecute);
                if (analyzeItem != null)
                {
                    analyzeItem.HasInit = tool.Init(new List <IFreeDocument>());
                }
            }
            catch (Exception ex)
            {
                if (analyzeItem != null)
                {
                    analyzeItem.HasInit = false;
                }
                XLogSys.Print.Error(string.Format(GlobalHelper.Get("key_209"), tool.Column, tool.TypeName, ex));
                return(func);
            }
            if (!tool.Enabled)
            {
                return(func);
            }
            if (tool is IColumnDataTransformer)
            {
                var ge    = tool as IColumnDataTransformer;
                var func1 = func;
                func = source =>
                {
                    var source2 = func1(source).CountInput(analyzeItem);
                    if (ge.IsMultiYield)
                    {
                        return(ge.TransformManyData(source2, analyzeItem).CountOutput(analyzeItem));
                    }
                    ;
                    return(source2.Select(input =>
                    {
                        var now = DateTime.Now;

                        var result = Transform(ge, input, analyzeItem);
                        if (analyzeItem != null)
                        {
                            analyzeItem.RunningTime = DateTime.Now - now;
                        }
                        return result;
                    }).CountOutput(analyzeItem));
                };
            }

            if (tool is IColumnGenerator)
            {
                var ge = tool as IColumnGenerator;

                var func1 = func;
                switch (ge.MergeType)
                {
                case MergeType.Append:

                    func = source => source.CountInput(analyzeItem).ConcatPlus(func1, ge).CountOutput(analyzeItem);
                    break;

                case MergeType.Cross:
                    func = source =>
                           func1(source.CountInput(analyzeItem)).Cross(ge.Generate).CountOutput(analyzeItem);
                    break;

                case MergeType.Merge:
                    func = source =>
                           func1(source.CountInput(analyzeItem)).MergeAll(ge.Generate()).CountOutput(analyzeItem);
                    break;

                case MergeType.Mix:
                    func = source =>
                           func1(source.CountInput(analyzeItem)).Mix(ge.Generate()).CountOutput(analyzeItem);
                    break;
                }
            }


            if (tool is IDataExecutor && isexecute)
            {
                var ge    = tool as IDataExecutor;
                var func1 = func;
                func = source => ge.Execute(func1(source.CountInput(analyzeItem))).CountOutput(analyzeItem);
            }
            else if (tool is IColumnDataFilter)
            {
                var t = tool as IColumnDataFilter;

                if (t.TypeName == GlobalHelper.Get("key_210"))
                {
                    dynamic range = t;
                    var     func1 = func;
                    func = source => func1(source.CountInput(analyzeItem)).Skip((int)range.Skip).Take((int)range.Take)
                           .CountOutput(analyzeItem);
                }
                else

                {
                    var func1 = func;
                    switch (t.FilterWorkMode)
                    {
                    case FilterWorkMode.PassWhenSuccess:
                        func =
                            source =>
                            func1(source.CountInput(analyzeItem))
                            .SkipWhile(t.FilteData)
                            .CountOutput(analyzeItem);
                        break;

                    case FilterWorkMode.ByItem:
                        func =
                            source =>
                            func1(source.CountInput(analyzeItem)).Where(t.FilteData).CountOutput(analyzeItem);
                        break;

                    case FilterWorkMode.StopWhenFail:
                        func =
                            source =>
                            func1(source.CountInput(analyzeItem))
                            .TakeWhile(t.FilteData)
                            .CountOutput(analyzeItem);
                        break;
                    }
                }
            }
            return(func);
        }
Beispiel #3
0
        public static EnumerableFunc FuncAdd(this IColumnProcess tool, EnumerableFunc func, bool isexecute, Analyzer analyzer)
        {
            AnalyzeItem analyzeItem = null;

            analyzeItem = analyzer?.Set(tool);
            try
            {
                tool.SetExecute(isexecute);
                if (analyzeItem != null)
                {
                    analyzeItem.HasInit = tool.Init(new List <IFreeDocument>());
                }
            }
            catch (Exception ex)
            {
                if (analyzeItem != null)
                {
                    analyzeItem.HasInit = false;
                }
                XLogSys.Print.Error($"位于{tool.Column}列的{tool.TypeName}模块在初始化时出现异常:{ex},请检查任务参数");
                return(func);
            }
            if (!tool.Enabled)
            {
                return(func);
            }
            if (tool is IColumnDataTransformer)
            {
                var ge    = tool as IColumnDataTransformer;
                var func1 = func;
                func = source =>
                {
                    var source2 = func1(source).CountInput(analyzeItem);
                    if (ge.IsMultiYield)
                    {
                        return(ge.TransformManyData(source2).CountOutput(analyzeItem));
                    }
                    ;
                    return(source2.Select(input => Transform(ge, input, analyzeItem)).CountOutput(analyzeItem));
                };
            }

            if (tool is IColumnGenerator)
            {
                var ge = tool as IColumnGenerator;

                var func1 = func;
                switch (ge.MergeType)
                {
                case MergeType.Append:

                    func = source => source.CountInput(analyzeItem).ConcatPlus(func1, ge).CountOutput(analyzeItem);
                    break;

                case MergeType.Cross:
                    func = source => func1(source.CountInput(analyzeItem)).Cross(ge.Generate).CountOutput(analyzeItem);
                    break;

                case MergeType.Merge:
                    func = source => func1(source.CountInput(analyzeItem)).MergeAll(ge.Generate()).CountOutput(analyzeItem);
                    break;

                case MergeType.Mix:
                    func = source => func1(source.CountInput(analyzeItem)).Mix(ge.Generate()).CountOutput(analyzeItem);
                    break;
                }
            }


            if (tool is IDataExecutor && isexecute)
            {
                var ge    = tool as IDataExecutor;
                var func1 = func;
                func = source => ge.Execute(func1(source.CountInput(analyzeItem))).CountOutput(analyzeItem);
            }
            else if (tool is IColumnDataFilter)
            {
                var t = tool as IColumnDataFilter;

                if (t.TypeName == "数量范围选择")
                {
                    dynamic range = t;
                    var     func1 = func;
                    func = source => func1(source.CountInput(analyzeItem)).Skip((int)range.Skip).Take((int)range.Take).CountOutput(analyzeItem);
                }
                else

                {
                    var func1 = func;
                    func = source => func1(source.CountInput(analyzeItem)).Where(t.FilteData).CountOutput(analyzeItem);
                }
            }
            return(func);
        }
Beispiel #4
0
        private EnumerableFunc FuncAdd(IColumnProcess tool, EnumerableFunc func, bool isexecute)
        {
            try
            {
                tool.SetExecute(isexecute);
                tool.Init(new List<IFreeDocument>());
            }
            catch (Exception ex)
            {
                XLogSys.Print.Error($"位于{tool.Column}列的{tool.TypeName}模块在初始化时出现异常:{ex},请检查任务参数");
                return func;
            }
            if (!tool.Enabled)
                return func;
            if (tool is IColumnDataTransformer)
            {
                var ge = tool as IColumnDataTransformer;
                var func1 = func;
                func = d =>
                {
                    if (ge.IsMultiYield)
                    {
                        return ge.TransformManyData(func1(d));
                    }
                    var r = func1(d);
                    return r.Select(d2 => Transform(ge, d2));
                };
            }

            if (tool is IColumnGenerator)
            {
                var ge = tool as IColumnGenerator;

                var func1 = func;
                switch (ge.MergeType)
                {
                    case MergeType.Append:

                        func = d => func1(d).Concat(ge.Generate());
                        break;
                    case MergeType.Cross:
                        func = d => func1(d).Cross(ge.Generate);
                        break;

                    case MergeType.Merge:
                        func = d => func1(d).MergeAll(ge.Generate());
                        break;
                    case MergeType.Mix:
                        func = d => func1(d).Mix(ge.Generate());
                        break;
                }
            }

            if (tool is IDataExecutor && isexecute)
            {
                var ge = tool as IDataExecutor;
                var func1 = func;
                func = d => ge.Execute(func1(d));
            }
            else if (tool is IColumnDataFilter)
            {
                var t = tool as IColumnDataFilter;

                if (t.TypeName == "数量范围选择")
                {
                    dynamic range = t;
                    var func1 = func;
                    func = d => func1(d).Skip((int) range.Skip).Take((int) range.Take);
                }
                else

                {
                    var func1 = func;
                    func = d => func1(d).Where(t.FilteData);
                }
            }
            return func;
        }