C#:复杂条件判断类型(练习)

/// <summary>
    /// 文件类型
    /// </summary>
    public enum FileType
    {
        Courseware,         //"课件"
        Document,           //"文档"
        Picture,            //"图片"
        Audio,              //"音频"
        Video,              //"视频"
        Cartoon,            //"动画"
        Other               //"其他"
    }

    /// <summary>
    ///  资源类型
    /// </summary>
    public enum ContentType
    {
        MaterialInterpretation,     //"教材解读",
        Writing,                    //"写作",
        ExpandData,                 //"拓展资料",
        CoursewareIllustrated,      //"课件配图",
        ReadText,                   //"课文朗读",
        LearnCase,                  //"学案",
        AudioVideo,                 //"音视频",
        TeachingPlan,               //"教案",
        Courseware,                 //"课件",
        TestQuestions,              //"试题",
        Other,                      //"其他"
    }

    /// <summary>
    /// 判断资源类型 (shenc 2016-7-11)
    /// </summary>
    public class JudgeContentType
    {
        LogService _logger = new LogService();

        #region 文件格式类型

        public List<string> _fileTypeName = new List<string>{"课件","文档","图片","音频","视频","动画","其他"};
        public List<string> _coursewareFormatType = new List<string> { "ppt", "pptx"};
        public List<string> _documentFormatType = new List<string> { "doc", "docx", "xls", "xlsx", "pdf", "vsd", "rtf", "txt", "xml", "xpt", "pps", "ppsx", "pdfx" };
        public List<string> _pictureFormatType = new List<string> { "jpg", "jpeg", "gif", "bmp", "png", "tif" };
        public List<string> _audioFormatType = new List<string> { "mp3", "mid", "wma", "wav", "flac", "m4a", "voc" };
        public List<string> _videoFormatType = new List<string> { "flv", "avi", "mkv", "wmv", "mp4", "f4v", "mpg", "asf", "webm", "mov", "rmvb", "rm" };
        public List<string> _cartoonFormatType = new List<string> { "swf" };
        public List<string> _otherFormatType = new List<string> { "exe", "dbb" };
        public Dictionary<FileType, List<string>> _dicFileType_Formats = new Dictionary<FileType, List<string>>();
        //public Dictionary<string, List<string>> _dicFileTypeName_Formats = new Dictionary<string, List<string>>();
        public Dictionary<FileType, string> _dicFileType_Name = new Dictionary<FileType, string>();
        #endregion

        #region 资源格式

        public List<string> _contentTypeName = new List<string> { "教材解读", "写作", "拓展资料", "课件配图", "课文朗读", "学案", "音视频", "教案", "课件", "试题", "其他" };
        public Dictionary<ContentType, string> _dicContentType_Name = new Dictionary<ContentType, string>();
        public List<string> _materialInterpretationFlags = new List<string> { "教材解读" };
        public List<string> _writingFlags = new List<string> { "写作" };
        public List<string> _expandDataFlags = new List<string> { "拓展资料", "专题资源"};
        public List<string> _coursewareIllustratedFlags = new List<string> {  };
        public List<string> _readTextFlags = new List<string> { "课文朗读" };
        public List<string> _learnCaseFlags = new List<string> { "学案" };
        public List<string> _audioVideoFlags = new List<string> {  };
        public List<string> _teachingPlanFlags = new List<string> { "教案", "教学设计", "教学案例", "说课", "教学反思", "教学案", "课程设计", "教学方案" };  //教案、教学设计、教学案例、说课、教学反思,教学案,课程设计,教学方案
        public List<string> _coursewareFlags = new List<string> {  };
        public List<string> _testQuestionsFlags = new List<string> { "试题", "习题", "练习" }; //试题、习题、练习
        public List<string> _otherFlags = new List<string> { };    //以上不包含的文件,资源格式均列入“其他”

        #endregion

        public JudgeContentType()
        {
            InitFileType_Name();
            InitFileTypeFormats();
            //InitFileTypeNameFormats();
            InitContentType_Name();
        }

        private void InitFileType_Name()
        {
            _dicFileType_Name.Clear();
            int i = 0;
            FileType type = FileType.Other;
            foreach (string typeName in _contentTypeName)
            {
                type = (FileType)i++;
                _dicFileType_Name.Add(type, typeName);
            }
        }
        /*
        private void InitFileTypeNameFormats()
        {
            _dicFileTypeName_Formats.Add("课件", _coursewareFormatType);
            _dicFileTypeName_Formats.Add("文档", _documentFormatType);
            _dicFileTypeName_Formats.Add("图片", _pictureFormatType);
            _dicFileTypeName_Formats.Add("音频", _audioFormatType);
            _dicFileTypeName_Formats.Add("视频", _videoFormatType);
            _dicFileTypeName_Formats.Add("动画", _cartoonFormatType);
            _dicFileTypeName_Formats.Add("其他", _otherFormatType);
        }
        */
        private void InitFileTypeFormats()
        {
            _dicFileType_Formats.Clear();
            _dicFileType_Formats.Add(FileType.Courseware, _coursewareFormatType);
            _dicFileType_Formats.Add(FileType.Document, _documentFormatType);
            _dicFileType_Formats.Add(FileType.Picture, _pictureFormatType);
            _dicFileType_Formats.Add(FileType.Audio, _audioFormatType);
            _dicFileType_Formats.Add(FileType.Video, _videoFormatType);
            _dicFileType_Formats.Add(FileType.Cartoon, _cartoonFormatType);
            _dicFileType_Formats.Add(FileType.Other, _otherFormatType);
        }
        private void InitContentType_Name()
        {
            _dicContentType_Name.Clear();
            int i = 0;
            ContentType contentType = ContentType.Other;
            foreach (string typeName in _contentTypeName)
            {
                contentType = (ContentType) i++;
                _dicContentType_Name.Add(contentType,typeName);
            }
        }

        #region 获取内容类型、名称

        public string GetContentTypeName(string fileName)
        {
            string contentName = string.Empty;
            ContentType contentType = GetContentType(fileName);
            contentName = _dicContentType_Name[contentType];
            return contentName;
        }

        public ContentType GetContentType(string fileName)
        {
            ContentType contentType = ContentType.Other;
            try
            {
                if (IsMaterialInterpretationType(fileName))
                {
                    contentType = ContentType.MaterialInterpretation;
                }
                else if (IsWritingType(fileName))
                {
                    contentType = ContentType.Writing;
                }
                else if (IsExpandDataType(fileName))
                {
                    contentType = ContentType.ExpandData;
                }
                else if (IsCoursewareIllustratedType(fileName))
                {
                    contentType = ContentType.CoursewareIllustrated;
                }
                else if (IsReadTextType(fileName))
                {
                    contentType = ContentType.ReadText;
                }
                else if (IsLearnCaseType(fileName))
                {
                    contentType = ContentType.LearnCase;
                }
                else if (IsAudioVideoType(fileName))
                {
                    contentType = ContentType.AudioVideo;
                }
                else if (IsTeachingPlanType(fileName))
                {
                    contentType = ContentType.TeachingPlan;
                }
                else if (IsCoursewareType(fileName))
                {
                    contentType = ContentType.Courseware;
                }
                else if (IsTestQuestionsType(fileName))
                {
                    contentType = ContentType.TestQuestions;
                }
                else
                {
                    contentType = ContentType.Other;
                }
            }
            catch(Exception ex)
            {
                contentType = ContentType.Other;
                _logger.Error("获取教材解读内容类型出错:" + ex.Message);
            }
            return contentType;
        }

        public bool IsMaterialInterpretationType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _materialInterpretationFlags) && _documentFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsWritingType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName,_writingFlags) && _documentFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取写作内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsExpandDataType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _expandDataFlags) && _documentFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取拓展资料内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsCoursewareIllustratedType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _coursewareIllustratedFlags) && _pictureFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取课件配图内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsReadTextType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _readTextFlags) && _audioFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取课文朗读内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsLearnCaseType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _learnCaseFlags) && _documentFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取学案内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsAudioVideoType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (!IsReadTextType(fileName) && isFileNameContainsFlags(fileName, _audioVideoFlags) && (_audioFormatType.Contains(ext) || _videoFormatType.Contains(ext) || _cartoonFormatType.Contains(ext)))
                {
                    isRight = true;
                }
            }
            catch(Exception ex)
            {
                isRight = false;
                _logger.Error("获取音视频内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsTeachingPlanType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _teachingPlanFlags) && _documentFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch(Exception ex)
            {
                isRight = false;
                _logger.Error("获取教案内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsCoursewareType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _coursewareFlags) && _coursewareFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch(Exception ex)
            {
                isRight = false;
                _logger.Error("获取课件内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsTestQuestionsType(string fileName)
        {
            bool isRight = false;
            try
            {
                string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                if (isFileNameContainsFlags(fileName, _teachingPlanFlags) && _documentFormatType.Contains(ext))
                {
                    isRight = true;
                }
            }
            catch(Exception ex)
            {
                isRight = false;
                _logger.Error("获取试题内容类型出错:" + ex.Message);
            }
            return isRight;
        }
        public bool IsOtherType(string fileName)
        {
            bool isRight = false;
            try
            {
                //string ext = Path.GetExtension(fileName.Trim()).Replace(".",string.Empty);
                //if (isFileNameContainsFlags(fileName, _otherFlags) && _otherFormatType.Contains(ext))
                //{
                //    isRight = true;
                //}
                //else
                if (!IsAudioVideoType(fileName) && !IsCoursewareIllustratedType(fileName) && !IsCoursewareType(fileName) && !IsExpandDataType(fileName) && IsLearnCaseType(fileName) && !IsMaterialInterpretationType(fileName) && !IsReadTextType(fileName) && !IsTeachingPlanType(fileName) && !IsTestQuestionsType(fileName) && !IsWritingType(fileName))
                {
                    isRight = true;
                }
            }
            catch (Exception ex)
            {
                isRight = false;
                _logger.Error("获取其他内容类型出错:" + ex.Message);
            }
            return isRight;
        }

        public bool isFileNameContainsFlags(string fileName,List<string> contentFlags)
        {
            bool isContain = false;
            if (contentFlags == null || contentFlags.Count == 0)
            {
                isContain = true;
            }
            else
            {
                foreach (string flag in contentFlags)
                {
                    if (fileName.Contains(flag.Trim()))
                    {
                        isContain = true;
                        break;
                    }
                }
            }
            return isContain;
        }
        #endregion
    }

时间: 2024-10-05 08:35:29

C#:复杂条件判断类型(练习)的相关文章

bash 脚本编程之二 条件判断

bash中如何实现条件判断 条件判断类型: 整数判断(双目判断): -eq:等于 .equal,测试两个整数之间是否相等,比如$A -eq $B -gt:大于.greater than -lt:小于.lesser than -ne:不等于.no  equal 这里也可以用另外一种写法,比如[ 2 -ne 3 ]可以写作[ ! 2 -eq 3 ] -le:小于或等于.lesser or equal -ge:大于等于.greater or equal ... 字符判断: 文件判断:单目判断 -e:e

MYSQL数据类型和where条件判断

MySQL中常见的数据类型 一.字符型 ① CHAR(N):固定N个字符长度的字符串,如果长度不够自动空格补齐; N的范围 0~255 ② VARCHAR(N): 存储可变长度的字符串,最常用 ③ TEXT: 存储可变长度的字符串,(常用于发布文章等大段内容) ④ TINYTEXT:0~2^8-1 *10 ⑤ MEDIUMTEXT: 0~2^24-1 *10^3; ⑥ LONGTEXT: 0~2^32-1 * 10^4;二.整形: ① TINYINT: 无符号0~2^8-1 有符号 -2^7 ~

Sass学习笔记 -- 初步了解函数、运算、条件判断及循环

函数 sass定义了很多函数可供使用,当然你也可以自己定义函数,以@fuction开始.sass的官方函数链接为:sass fuction,实际项目中我们使用最多的应该是颜色函数,而颜色函数中又以lighten减淡和darken加深为最,其调用方法为lighten($color,$amount)和darken($color,$amount),它们的第一个参数都是颜色值,第二个参数都是百分比. //scss $baseFontSize:      10px !default; $gray:    

条件判断之if、case语句和文件查找命令

一.脚本编程 1.if语句怎样用 人生面临许多选择,在编程世界里同样也有许多选择.同其他编程语言一样,当我们想写一个功能健壮的脚本时,通过条件判断来选择适合的操作尤为重要.在我们执行某些重要的操作之前,判断当前环境是否适合执行这一操作是非常重要的.我们可以用&&和||来做简单的判断,不过shell有更用的语句.shell有两种常见的条件选择语句if和case.我们先来看一下if该怎样用吧. if语句的单分支语法: if 条件判断 ;then;执行命令:fi [[email protecte

bash脚本编程之条件判断、条件测试

脚本编程: 编程面向过程有如下几种执行方式 顺序执行 选择执行:  如 if, case 循环执行:  如 for, while, until bash的变量类型: 本地变量 set VAR_NAME=value 设置变量赋值 如: set User=Centos unset VAR_NAME 撤消变量赋值 如: unset User=Centos ${VAR_NAME} 作用范围:当前shell进程: 局部变量 local VAR_NAME=value 设置变量赋值 unset VAR_NAM

条件判断

按照文件类型进行判断: -b 文件 判断该文件是否存在,并且是否为块设备(是块设备文件为真) -c 文件 判断该文件是否存在,并且是否为字符设备文件 -d 文件 判断该文件是否存在,并且是否为目录文件 -e 文件 判断该文件是否存在 -f 文件 判断该文件是否存在,并且是否为普通文件 -L 文件 判断该文件是否存在,并且是否为符号链接文件 -p 文件 判断该文件是否存在,并且是否为管道文件 -s 文件 判断该文件是否存在,并且是否为非空 -S 文件 判断该文件是否存在,并且是否为套接字文件 按照

条件判断语句比较

条件判断语句比较 流程控制进行条件语句判断的时候,经常用到各种数据类型的变量与零值比较的问题,这里进行一个总结加深对数据类型的认识,不规范的与零比较语句容易让人对参与比较的数据类型产生误解. §1. 布尔变量与零值比较 C++有bool类型,C99标准才有布尔类型_Bool,用整型代替布尔类型,非0表示真,0表示假,如果你的编译器不支持布尔类型,可以自定义类型enum_BOOL{FALSE = 0,TRUE = !FALSE}. 不可将布尔变量直接与TRUE.FALSE或者1.0进行比较,假设布

Bourne Shell中的条件判断

条件判断是一个程序获得智能的基础,而Bourne Shell脚本则通过命令 [ 来模拟大多数编程语言中的条件表达式. shell中支持的控制结构有: (1) if then else fi (2) for in do done (3) while do done 第二种主要用于遍历,可能不需要条件判断,其它两种则免不了和 [ 命令共同使用了.下面讲解这个命令如何模拟条件表达式. 文件/目录判断[ -b FILE ] 如果 FILE 存在且是一个块特殊文件则为真.[ -c FILE ] 如果 FI

Shell学习笔记 - 条件判断式

1. 判断格式 1) test 参数 文件 例: test -e /root/install.log 2) [ 参数 文件 ]  -- 推荐使用 例: [ -e /root/install.log ] 注意:中括号后面和前面需要有空格 2. 判断文件类型参数 1)-d 文件:判断该文件是否存在,并且是否为目录文件 2)-e 文件:判断文件是否存在 3)-f 文件:判断文件是否存在,并且是否为普通文件 4)-s 文件:判断文件是否存在,并且是否为非空 5)其他文件类型判断: -b 块设备文件:-c