深度优先

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using System.Windows.Forms;

namespace Example.SqlPreprocessor
{
    class Parser
    {
        enum Symbol
        {
            None,
            LPar,
            RPar,
            Equals,
            Text,
            NumberIf,
            If,
            NumberElse,
            NumberEnd,
            Identifier
        }

        List<string> _input; // Raw SQL with preprocessor directives.
        int _currentLineIndex = 0;

        // Simulates variables used in conditions
        Dictionary<string, string> _variableValues = new Dictionary<string, string> { 
            { "VariableA", "Case1" },
            { "VariableB", "CaseX" }
        };

        Symbol _sy; // Current symbol.
        string _string; // Identifier or text line;
        Queue<string> _textQueue = new Queue<string>(); // Buffered text parts of a single line.
        int _lineNo; // Current line number for error messages.
        string _line; // Current line for error messages.

        /// <summary>
        /// Get the next line from the input.
        /// </summary>
        /// <returns>Input line or null if no more lines are available.</returns>
        string GetLine()
        {
            if (_currentLineIndex >= _input.Count) {
                return null;
            }
            _line = _input[_currentLineIndex++];
            _lineNo = _currentLineIndex;
            return _line;
        }

        /// <summary>
        /// Get the next symbol from the input stream and stores it in _sy.
        /// </summary>
        void GetSy()
        {
            string s;
            if (_textQueue.Count > 0) { // Buffered text parts available, use one from these.
                s = _textQueue.Dequeue();
                switch (s.ToLower()) {
                    case "(":
                        _sy = Symbol.LPar;
                        break;
                    case ")":
                        _sy = Symbol.RPar;
                        break;
                    case "=":
                        _sy = Symbol.Equals;
                        break;
                    case "if":
                        _sy = Symbol.If;
                        break;
                    default:
                        _sy = Symbol.Identifier;
                        _string = s;
                        break;
                }
                return;
            }

            // Get next line from input.
            s = GetLine();
            if (s == null) {
                _sy = Symbol.None;
                return;
            }

            s = s.Trim(' ', '\t');
            if (s[0] == '#') { // We have a preprocessor directive.
                // Split the line in order to be able get its symbols.
                string[] parts = Regex.Split(s, @"\b|[^#_a-zA-Z0-9()=]");
                // parts[0] = #
                // parts[1] = if, else, end
                switch (parts[1].ToLower()) {
                    case "if":
                        _sy = Symbol.NumberIf;
                        break;
                    case "else":
                        _sy = Symbol.NumberElse;
                        break;
                    case "end":
                        _sy = Symbol.NumberEnd;
                        break;
                    default:
                        Error("Invalid symbol #{0}", parts[1]);
                        break;
                }

                // Store the remaining parts for later.
                for (int i = 2; i < parts.Length; i++) {
                    string part = parts[i].Trim(' ', '\t');
                    if (part != "") {
                        _textQueue.Enqueue(part);
                    }
                }
            } else { // We have an ordinary SQL text line.
                _sy = Symbol.Text;
                _string = s;
            }
        }

        void Error(string message, params  object[] args)
        {
            // Make sure parsing stops here
            _sy = Symbol.None;
            _textQueue.Clear();
            _input.Clear();

            message = String.Format(message, args) +
                      String.Format(" in line {0}\r\n\r\n{1}", _lineNo, _line);
            Output("------");
            Output(message);
            MessageBox.Show(message, "Error");
        }

        /// <summary>
        /// Writes the processed line to a (simulated) output stream.
        /// </summary>
        /// <param name="line">Line to be written to output</param>
        void Output(string line)
        {
            Console.WriteLine(line);
        }

        /// <summary>
        /// Starts the parsing process.
        /// </summary>
        public void Parse()
        {
            // Simulate an input stream.
            _input = new List<string> {
                "select column1",
                "from",
                "#if(VariableA = Case1)",
                "    #if(VariableB = Case3)",
                "        table3",
                "    #else",
                "        table4",
                "    #end",
                "#else if(VariableA = Case2)",
                "    table2",
                "#else",
                "    defaultTable",
                "#end"
            };

            // Clear previous parsing
            _textQueue.Clear();
            _currentLineIndex = 0;

            // Get first symbol and start parsing
            GetSy();
            if (LineSequence(true)) { // Finished parsing successfully.
                //TODO: Do something with the generated SQL
            } else { // Error encountered.
                Output("*** ABORTED ***");
            }
        }

        // The following methods parse according the the EBNF syntax.

        bool LineSequence(bool writeOutput)
        {   
            // EBNF:  LineSequence = { TextLine | IfStatement }.
            while (_sy == Symbol.Text || _sy == Symbol.NumberIf) {
                if (_sy == Symbol.Text) {
                    if (!TextLine(writeOutput)) {
                        return false;
                    }
                } else { // _sy == Symbol.NumberIf
                    if (!IfStatement(writeOutput)) {
                        return false;
                    }
                }
            }
            return true;
        }

        bool TextLine(bool writeOutput)
        {
            // EBNF:  TextLine = <string>.
            if (writeOutput) {
                Output(_string);
            }
            GetSy();
            return true;
        }

        bool IfStatement(bool writeOutput)
        {
            // EBNF:  IfStatement = IfLine LineSequence { ElseIfLine LineSequence } [ ElseLine LineSequence ] EndLine.
            bool result;
            if (IfLine(out result) && LineSequence(writeOutput && result)) {
                writeOutput &= !result; // Only one section can produce an output.
                while (_sy == Symbol.NumberElse) {
                    GetSy();
                    if (_sy == Symbol.If) { // We have an #else if
                        if (!ElseIfLine(out result)) {
                            return false;
                        }
                        if (!LineSequence(writeOutput && result)) {
                            return false;
                        }
                        writeOutput &= !result; // Only one section can produce an output.
                    } else { // We have a simple #else
                        if (!LineSequence(writeOutput)) {
                            return false;
                        }
                        break; // We can have only one #else statement.
                    }
                }
                if (_sy != Symbol.NumberEnd) {
                    Error("'#end' expected");
                    return false;
                }
                GetSy();
                return true;
            }
            return false;
        }

        bool IfLine(out bool result)
        {
            // EBNF:  IfLine = "#if" "(" Condition ")".
            result = false;
            GetSy();
            if (_sy != Symbol.LPar) {
                Error("'(' expected");
                return false;
            }
            GetSy();
            if (!Condition(out result)) {
                return false;
            }
            if (_sy != Symbol.RPar) {
                Error("')' expected");
                return false;
            }
            GetSy();
            return true;
        }

        private bool Condition(out bool result)
        {
            // EBNF:  Condition = Identifier "=" Identifier.
            string variable;
            string expectedValue;
            string variableValue;

            result = false;
            // Identifier "=" Identifier
            if (_sy != Symbol.Identifier) {
                Error("Identifier expected");
                return false;
            }
            variable = _string; // The first identifier is a variable.
            GetSy();
            if (_sy != Symbol.Equals) {
                Error("'=' expected");
                return false;
            }
            GetSy();
            if (_sy != Symbol.Identifier) {
                Error("Value expected");
                return false;
            }
            expectedValue = _string;  // The second identifier is a value.

            // Search the variable
            if (_variableValues.TryGetValue(variable, out variableValue)) {
                result = variableValue == expectedValue; // Perform the comparison.
            } else {
                Error("Variable '{0}' not found", variable);
                return false;
            }

            GetSy();
            return true;
        }

        bool ElseIfLine(out bool result)
        {
            // EBNF:  ElseIfLine = "#else" "if" "(" Condition ")".
            result = false;
            GetSy(); // "#else" already processed here, we are only called if the symbol is "if"
            if (_sy != Symbol.LPar) {
                Error("'(' expected");
                return false;
            }
            GetSy();
            if (!Condition(out result)) {
                return false;
            }
            if (_sy != Symbol.RPar) {
                Error("')' expected");
                return false;
            }
            GetSy();
            return true;
        }
    }
}

using NLog;
using Renci.SshNet;
using Renci.SshNet.Sftp;
using ShellProgressBar;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;

namespace PiSftpClient
{
    public class SFtpHelper
    {
        private SftpClient sftp;

        private static readonly Logger logger = LogManager.GetLogger("SFtpHelper");

        /// <summary>
        /// 连接状态
        /// </summary>
        public bool Connected
        {
            get
            {
                return this.sftp.IsConnected;
            }
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="host">sftp的IP</param>
        /// <param name="port">sftp的端口</param>
        /// <param name="username">sftp的帐户</param>
        /// <param name="password">sftp的密码</param>
        public SFtpHelper(string host, int port, string username, string password)
        {
            this.sftp = new SftpClient(host, port, username, password);
        }

        /// <summary>
        /// 连接sftp服务器
        /// </summary>
        /// <returns>连接状态</returns>
        public bool Connect()
        {
            bool result;
            try
            {
                bool flag = !this.Connected;
                if (flag)
                {
                    this.sftp.Connect();
                }
                result = true;
            }
            catch (Exception ex)
            {
                result = false;
                logger.Error(string.Format("连接SFTP失败，原因：{0}", ex.Message));
            }
            return result;
        }

        /// <summary>
        /// 断开连接
        /// </summary>
        public void Disconnect()
        {
            try
            {
                bool flag = this.sftp != null && this.Connected;
                if (flag)
                {
                    this.sftp.Disconnect();
                }
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("断开SFTP失败，原因：{0}", ex.Message));
            }
        }

        /// <summary>
        /// 上传文件
        /// </summary>
        /// <param name="localPath">本地文件路径</param>
        /// <param name="remotePath">服务器端文件路径</param>
        public void Put(string localPath, string remotePath)
        {
            try
            {
                using (FileStream fileStream = File.OpenRead(localPath))
                {
                    this.sftp.UploadFile(fileStream, remotePath, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("SFTP文件上传失败，原因：{0}", ex.Message));
            }
        }

        /// <summary>
        /// 上传文字字节数据
        /// </summary>
        /// <param name="fileByteArr">文件内容字节</param>
        /// <param name="remotePath">上传到服务器的路径</param>
        public void Put(byte[] fileByteArr, string remotePath)
        {
            try
            {
                Stream input = new MemoryStream(fileByteArr);
                this.sftp.UploadFile(input, remotePath, null);
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("SFTP文件上传失败，原因：{0}", ex.Message));
            }
        }

        /// <summary>
        /// 将sftp服务器的文件下载本地
        /// </summary>
        /// <param name="remotePath">服务器上的路径</param>
        /// <param name="localPath">本地的路径</param>
        public void DownloadFile(string remotePath, string localPath)
        {
            try
            {
                this.Connect();
                MemoryStream stream = new MemoryStream();
                this.sftp.DownloadFile(remotePath, stream, UpdateProgress);
                File.WriteAllBytes(localPath, stream.ToArray());
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("SFTP文件获取失败，原因：{0}", ex.Message));
            }
        }

        private void UpdateProgress(ulong obj)
        {
        }

        /// <summary>
        ///  删除ftp服务器上的文件
        /// </summary>
        /// <param name="remoteFile">服务器上的路径</param>
        public void Delete(string remoteFile)
        {
            try
            {
                this.sftp.Delete(remoteFile);
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("SFTP文件删除失败，原因：{0}", ex.Message));
            }
        }

        /// <summary>
        /// 获取ftp服务器上指定路径上的指定前缀的文件名列表
        /// </summary>
        /// <param name="remotePath">服务器上的路径</param>
        /// <param name="fileSuffix">文件名后缀</param>
        /// <returns></returns>
        public List<string> GetFileList(string remotePath, string fileSuffix)
        {
            List<string> result;
            try
            {
                IEnumerable<SftpFile> enumerable = this.sftp.ListDirectory(remotePath, null);
                result = new List<string>();
                foreach (SftpFile current in enumerable)
                {
                    if (current.Name.EndsWith(fileSuffix))
                    {
                        result.Add(current.Name);
                    }
                }
            }
            catch (Exception ex)
            {
                result = new List<string>();
                logger.Error(string.Format("SFTP文件列表获取失败，原因：{0}", ex.Message));
            }
            return result;
        }

        /// <summary>
        /// ftp服务器端文件移动
        /// </summary>
        /// <param name="oldRemotePath">原来服务器上路径</param>
        /// <param name="newRemotePath">移动后服务器上新路径</param>
        public void Move(string oldRemotePath, string newRemotePath)
        {
            try
            {
                this.sftp.RenameFile(oldRemotePath, newRemotePath);
            }
            catch (Exception ex)
            {
                logger.Error(string.Format("SFTP文件移动失败，原因：{0}", ex.Message));
            }
        }
    }
}

using NLog;
using PiSftpClient.Mail;
using ShellProgressBar;
using System;
using System.IO;
using System.Linq;

namespace PiSftpClient
{
    internal class Program
    {
        private static readonly Logger logger = LogManager.GetLogger("PiSftpClient");

        private static void Main(string[] args)
        {
            var servicePath = "/opt/docker/camera/pictures/";
            var localhostPath = @"F:\pi\pictures\";

            var dateStr = DateTime.Now.AddDays(-1).ToString("yyyy-MM-dd");
            logger.Info($"开始下载 {dateStr} 的照片文件！");

            SFtpHelper ftp = new SFtpHelper("192.168.8.100", 22, "root", "123456");

            ftp.Connect();
            var servicePathDate = $"{servicePath}/{dateStr}/";
            var localhostPathDate = $"{localhostPath}/{dateStr}";

            if (!Directory.Exists(localhostPathDate))
            {
                Directory.CreateDirectory(localhostPathDate);
            }

            var childOptions = new ProgressBarOptions
            {
                ProgressCharacter = '#',
                ForegroundColor = ConsoleColor.Yellow,
                ForegroundColorDone = ConsoleColor.DarkGreen,
                BackgroundColor = ConsoleColor.DarkGray,
                ProgressBarOnBottom = true,
            };

            var imageFiles = ftp.GetFileList(servicePathDate, ".jpg").OrderBy(p => p).ToList();
            logger.Info($"服务器上总共 {imageFiles.Count} 个文件！");
            using var pbar = new ProgressBar(imageFiles.Count, "download", childOptions);

            for (int i = 0; i < imageFiles.Count; i++)
            {
                var newName = $"{imageFiles[i].Replace("-", "").Replace(".jpg", "")}{i.ToString().PadLeft(4, '0')}.jpg";

                ftp.DownloadFile($"{servicePathDate}/{imageFiles[i]}", $"{localhostPathDate}/{newName}");
                pbar.Message = $"[{DateTime.Now:HH:mm:ss}] ({i}/{imageFiles.Count}) downloading {imageFiles[i]}";
                pbar.Tick();

                logger.Info($"下载成功 ({i}/{imageFiles.Count}) downloading {imageFiles[i]} ");
            }

            ftp.Disconnect();
            logger.Info($"下载完成！");

            SendMail();
        }

        private static void SendMail()
        {
            string filePath = $"./logs/{DateTime.Now:yyyy-MM-dd}.log";
            MailHelper mail = new MailHelper();
            MailObject mailObject = new MailObject()
            {
                toMails = "bfsdfs@yeah.net",
                ccMails = "1439084907@qq.com",
                Subject = "【树莓派】消息通知",
                MailBody = "ok...日志信息见附件！",
                FilePaths = filePath
            };
            var result = mail.Send(mailObject);
        }
    }
}