/// <summary>
        /// recursive  call by self
        /// </summary>
        /// <returns></returns>
        public override T RunSubThread(ICloneable thparam)
        {
            //judage if threading is cancelled.
            this.IsTaskCanceled();
            TraverseParameter param;

            if (thparam != null)
            {
                param = (TraverseParameter)thparam;
            }
            else
            {
                return(default(T));
            }
            DirectoryInfo originalFold = new DirectoryInfo(param.OriginalRootPath);

            FileInfo[] OriginalFileList = originalFold.GetFiles();
            foreach (var file in OriginalFileList)
            {
                string originalFileName = file.Name;

                successamount++;
                SuccessRecorder.Record(FormatHistory(successamount, file.DirectoryName, file.Name, file.Extension));
            }

            //recursive Sub Directory
            foreach (DirectoryInfo dir in originalFold.GetDirectories())
            {
                TraverseParameter paramSub = (TraverseParameter)param.Clone();
                paramSub.SetOriginalRootPath(dir.FullName);
                RunSubThread(paramSub);
            }

            return(default(T));
        }
        public void Start()
        {
            while (true)
            {
                var input = AskForInput();

                if (!IsInputValid(input))
                {
                    Console.WriteLine("The input was not valid, check that you entered a single word.");
                    Console.WriteLine();
                    continue;
                }

                Console.WriteLine("Fetching definition...");

                _historyRecorder.Record(input);

                List <string> definitions;
                try
                {
                    definitions = this._definer.GetDefinitions(input).ToList();
                }
                catch (AggregateException ae)
                {
                    ae.Handle(e =>
                    {
                        LogException(e);
                        return(true);
                    });

                    continue;
                }

                if (definitions.Any())
                {
                    PrintEnumerable(definitions);
                    Console.WriteLine();
                }
                else
                {
                    Console.WriteLine("Couldn't find a definition for that word.");
                    Console.WriteLine();
                }
            }
        }
示例#3
0
        /// <summary>
        /// recursive  call by self
        /// </summary>
        /// <returns></returns>
        public override T RunSubThread(ICloneable thparam)
        {
            //judage if threading is cancelled.
            this.IsTaskCanceled();
            bool IsNameChanged = true;
            ChangeFileNameParameter param;

            if (thparam != null)
            {
                param = (ChangeFileNameParameter)thparam;
            }
            else
            {
                return(default(T));
            }
            //Directory Change
            DirectoryInfo outputFold    = new DirectoryInfo(param.OutputRootPath);
            string        newOutputPath = ConvertToValidName(outputFold.Name);

            IsNameChanged = !(newOutputPath == outputFold.Name);
            if (IsNameChanged)
            {
                outputFold = new DirectoryInfo(param.OutputRootPath.Substring(0, param.OutputRootPath.Length - outputFold.Name.Length) + newOutputPath);
            }
            //outputFold.
            if (!System.IO.Directory.Exists(outputFold.FullName))
            {
                try { outputFold.Create(); }
                catch
                {
                    LoggerHelper.Warn("Program cann't create fold:" + outputFold.FullName + "\r\n");
                    return(default(T));
                }
                if (!System.IO.Directory.Exists(outputFold.FullName))
                {
                    LoggerHelper.Warn("Program cann't create fold:" + outputFold.FullName + "\r\n");
                    return(default(T));
                }
            }
            //if (IsValidName(outputFold.Name))
            //{
            //    successamount++;
            //    SuccessRecorder.Record(FormatHistory(successamount,EventSet.DirectoryEvent, IsNameChanged, param.OriginalRootPath, outputFold.FullName, "directory event"));

            //}
            //else
            //{
            //    failamount++;
            //    FailRecorder.Record(FormatHistory(failamount, EventSet.DirectoryEvent, IsNameChanged, param.OriginalRootPath, outputFold.FullName, "directory event"));
            //}
            successamount++;
            SuccessRecorder.Record(FormatHistory(successamount, EventSet.DirectoryEvent, IsNameChanged, param.OriginalRootPath, outputFold.FullName, "directory event"));
            PrintProcess(failamount, successamount);



            //File Name Change
            DirectoryInfo originalFold = new DirectoryInfo(param.OriginalRootPath);

            FileInfo[] OriginalFileList = originalFold.GetFiles();
            foreach (var file in OriginalFileList)
            {
                string originalFileName = file.Name;
                string newFileName      = ConvertToValidName(originalFileName);
                IsNameChanged = !(originalFileName == newFileName);
                //rename file
                if (!System.IO.File.Exists(outputFold.FullName + "\\" + newFileName))
                {
                    try
                    {
                        System.IO.File.Copy(file.FullName, outputFold.FullName + "\\" + newFileName, true);
                    }
                    catch (UnauthorizedAccessException ex)
                    {
                        LoggerHelper.Warn("File[" + file.FullName + "] cann't be renamed\r\n");
                        //System.IO.File.Copy(file.FullName, outputFold.FullName + "\\" + newFileName, true);
                    }
                }
                else
                {
                    //
                    FileInfo f = new FileInfo(outputFold.FullName + "\\" + newFileName);

                    if (f.Length != file.Length)
                    {
                        //It's not the same file
                        if (f.IsReadOnly)
                        {
                            f.IsReadOnly = false;
                        }
                        try
                        {
                            System.IO.File.Copy(file.FullName, outputFold.FullName + "\\" + newFileName, true);
                        }
                        catch (UnauthorizedAccessException ex)
                        {
                            LoggerHelper.Warn("File[" + file.FullName + "] cann't be renamed\r\n");
                            //System.IO.File.Copy(file.FullName, outputFold.FullName + "\\" + newFileName, true);
                        }
                    }
                }

                //if (IsValidName(newFileName))
                //{

                //}
                //else
                //{
                //    failamount++;
                //    FailRecorder.Record(FormatHistory(failamount, EventSet.FileEvent, IsNameChanged, file.FullName, outputFold.FullName + "\\" + newFileName, file.DirectoryName));
                //}
                successamount++;
                SuccessRecorder.Record(FormatHistory(successamount, EventSet.FileEvent, IsNameChanged, file.FullName, outputFold.FullName + "\\" + newFileName, file.DirectoryName));
                PrintProcess(failamount, successamount);
            }

            //recursive Sub Directory
            foreach (DirectoryInfo dir in originalFold.GetDirectories())
            {
                ChangeFileNameParameter paramSub = (ChangeFileNameParameter)param.Clone();
                paramSub.SetOriginalRootPath(dir.FullName);
                paramSub.SetOutputRootPath(outputFold.FullName + "\\" + dir.Name);
                RunSubThread(paramSub);
            }

            return(default(T));
        }
        /// <summary>
        /// recursive  call by self
        /// </summary>
        /// <returns></returns>
        public override bool RunSubThread(ICloneable thparam)
        {
            //judage if threading is cancelled.
            this.IsTaskCanceled();
            CheckNameParameter param;
            List <string>      invalidInfo;
            string             Info = "";

            if (thparam != null)
            {
                param = (CheckNameParameter)thparam;
            }
            else
            {
                return(false);
            }
            //Check Directory
            DirectoryInfo outputFold = new DirectoryInfo(param.OriginalRootPath);

            invalidInfo = CheckFileName(outputFold.Name);
            Info        = "";
            if (invalidInfo != null)
            {
                if (invalidInfo.Count > 0)
                {
                    foreach (string s in invalidInfo)
                    {
                        Info += s + "\r\n";
                    }
                    failamount++;
                    FailRecorder.Record(FormatHistory(failamount, EventSet.DirectoryEvent, Info, outputFold.FullName));
                    PrintProcess(failamount);
                }
            }



            //Check File Name

            FileInfo[] OriginalFileList = outputFold.GetFiles();
            foreach (var file in OriginalFileList)
            {
                string originalFileName = file.Name;
                invalidInfo = CheckFileName(originalFileName);
                Info        = "";
                if (invalidInfo != null)
                {
                    if (invalidInfo.Count > 0)
                    {
                        foreach (string s in invalidInfo)
                        {
                            Info += s + "\r\n";
                        }
                        failamount++;
                        FailRecorder.Record(FormatHistory(failamount, EventSet.FileEvent, Info, file.FullName));
                        PrintProcess(failamount);
                    }
                }
            }

            //recursive Sub Directory
            foreach (DirectoryInfo dir in outputFold.GetDirectories())
            {
                CheckNameParameter paramSub = (CheckNameParameter)param.Clone();
                paramSub.SetOriginalRootPath(dir.FullName);
                RunSubThread(paramSub);
            }

            return(false);
        }