C# 打开文件：抽象类继承、父类继承的联系：多个类型文件的打开操作

打开文件，根据用户输入的类型打开

//纯粹是为了练习，单纯打开文件不需要判断类型，进一步操作需要考虑。

1、打开固定类型文件

 //  使用进程打开一个文件
   

      // 提示用户输入路径，然后进行打开文件操作
           {
                Console.WriteLine("请输入要打开的磁盘");
                string filepath = Console.ReadLine ();
                Console.WriteLine("请输入要打开的文件");
                filepath += Console.ReadLine();
                OpenFile(filepath);
            }
            private static void OpenFile(string filepath)
            {
            
                ProcessStartInfo psi = new ProcessStartInfo(filepath);
                Process pr = new Process();
                pr.StartInfo = psi;// 表示要打开一个文件
                pr.Start();
            }

2、打开多个类型的文件，利用抽象类；

由于不知道用户会输入什么类型的文件，所有给用户返回一个父类，但是父类中装的肯定是子类的对象

注意：每个子类都要用到文件的全路径，应该写成属性的形式，放到父类中

namespace review
{
    class Program
    {
        static void Main(string[] args)
        {

            // 只是打开一个文件类型的话，比较简单！但是应用中应该考虑多个 类型

                Console.WriteLine("请输入要打开的磁盘");
                string filepath = Console.ReadLine ();
                Console.WriteLine("请输入要打开的文件名");
                string filename= Console.ReadLine();

                FatherFile fa= WhichFile(filename,filepath+filename);
                fa.OpenFile();
                Console.ReadKey ();   
        }

        // 这里根据文件的扩展名决定利用哪个子类
        public static FatherFile WhichFile(string path,string fp)
        {
            string extension=Path.GetExtension(path); // 利用Path获得文件的扩展名
            FatherFile ff=null;
            switch (extension)
             {
                case ".txt":
                    ff=new texFile(fp) ;        
                    break;
                case ".png":
                    ff=new pngFile (fp) ;
                    break;
                case ".avi":
                     ff=new aviFile (fp);
                    break;
                default:
                    break;
            }
            return ff;
        }

        // 不知道用户会输入什么类型的文件，所以给用户返回一个父类，但是父类中装的肯定是子类的对象
        //利用抽象类：抽象类的东西父类自己不能用，纯粹是为了给子类继承用的
        public abstract class FatherFile
        {
            // 每个类型中都需要全路径，写成属性的形式，放到在父类中，        属性为了记录全路径
            //这里用到文件的全路径，用属性
            public string FullPath
            {
                get;
                set;
            }
            public FatherFile(string fullPath)  // 写一个构造函数，构造函数没有返回类型
            { 
                this.FullPath=fullPath;
            }
             // 以上两个函数是给子类属性继承用的
            public abstract void OpenFile();// 抽象的函数不应该有函数体            
        }

        public class texFile:FatherFile
        {
            public texFile(string fullpath)
                :base(fullpath)
            {  }
            public override void OpenFile()
            {
                ProcessStartInfo psi=new ProcessStartInfo (this.FullPath );
                Process pr=new Process();
                pr.StartInfo =psi;
                pr.Start ();
            }
        }
         
        public class aviFile:FatherFile
        {
            public aviFile (string fullpath)
                :base(fullpath){}
            public override void OpenFile()
            {
                ProcessStartInfo ps=new  ProcessStartInfo(this.FullPath);// 属性,共享
                Process pp=new Process ();
                pp.StartInfo =ps;
                pp.Start ();
            }
        }

        public class pngFile:FatherFile
       {
            public pngFile (string fullpath)
                :base(fullpath){}
            public override void OpenFile()
            {
                ProcessStartInfo  ps=new ProcessStartInfo (this.FullPath );
                Process pps=new Process ();
                pps.StartInfo =ps;
                pps.Start ();
            }
        }
    }
}

3、由于使用了抽象类，子类中每次去打开文件都采用了相同的方法，OpenFile()重写了三遍，所有，把这个方法写到父类中，让子类继承；但是父类就不能是abstract类。

namespace review
{
    class Program
    {
        static void Main(string[] args)
        {
                 // 只是打开一个文件类型的话，比较简单！但是应用中应该考虑多个 类型
                Console.WriteLine("请输入要打开的磁盘");
                string filepath = Console.ReadLine ();
                Console.WriteLine("请输入要打开的文件名");
                string filename= Console.ReadLine();

                FatherFile fa= WhichFile(filename,filepath+filename);
                fa.OpenFile();
                Console.ReadKey ();  
        }

        // 这里根据文件的扩展名决定利用哪个子类
        public static FatherFile WhichFile(string path,string fp)
        {
            string extension=Path.GetExtension(path); // 利用path获得文件的扩展名
            FatherFile ff=null;
            switch (extension){
                case ".txt":
                    ff=new texFile(fp) ;        
                    break;
                case ".png":
                    ff=new pngFile (fp) ;
                    break;
                case ".avi":
                     ff=new aviFile (fp);
                    break;
                default:
                    break;
            }
            return ff;
        }

        // 不知道用户会输入什么类型的文件，所有给用户返回一个父类，但是父类中装的肯定是子类的对象
        //利用抽象类
        public  class FatherFile
        {
            // 每个类型中都需要全路径，写成属性的形式，放到在父类中
            //这里用到文件的全路径，用属性
            public string FullPath
            {
                get;
                set;
            }
            public FatherFile(string fullPath) // 写一个构造函数，构造函数没有返回类型
            {
                this.FullPath=fullPath;
            }
            public void OpenFile()   // 将打开函数写入到父类中，子类不需要重写，大大减少了代码量
            {
                ProcessStartInfo psi = new ProcessStartInfo(this.FullPath);
                Process pr = new Process();
                pr.StartInfo = psi;
                pr.Start();
            }             
        }

        public class texFile:FatherFile
        {
            public texFile(string fullpath)
                :base(fullpath)
            {  }
        }
         
        public class aviFile:FatherFile
        {
            public aviFile (string fullpath)
                :base(fullpath)
            {  }
        }

        public class pngFile:FatherFile {
            public pngFile (string fullpath)
                :base(fullpath)
           {  }
        }
    }
}

感觉这个没有特别大意义，纯粹是为了处理多个不同类型的文件做的小铺垫。因为不区分类型照样打开所有的文件