多个access数据库合并工具 如何合并多个access数据库

我们看SQLConnection和OleDbConnection的父类的时候都看到了他继承了DdConnection这个类

1.public sealed class OleDbConnection : DbConnection, ICloneable, IDbConnection, IDisposable

2.public sealed class SqlConnection : DbConnection, ICloneable

再看 DbConnection,实现了IDbConnection的接口。
3.public abstract class DbConnection : Component, IDbConnection, IDisposable

所以我们就可以用接口来指向我们的子类

 

string connstr= ConfigurationManager.ConnectionStrings["connstr"].ConnectionString;
            string proName=ConfigurationManager.ConnectionStrings["connstr"].ProviderName;
            IDbConnection conn;
            if (proName == "Access")
            {
                conn = new OleDbConnection(connstr);
            }
            else if (proName == "Sql")
            {
                conn = new SqlConnection(connstr);
            }
            else
            {
                throw new Exception("没有选择对应的数据库吧");
            }
            conn.Open();
            using (IDbCommand cmd = conn.CreateCommand())//体现接口，调用的是OleDbCommadn或者SqlCommand
            {
                cmd.CommandText = "insert into T_Person(Name,Age) values('李艳',22)";
                cmd.ExecuteNonQuery();
                MessageBox.Show("成功");
            }

接口只是指向具体的对象，调用的方法还是SQlconnection,sqlCommand.的.
只要修改配置文件，就能实现多个数据库的链接是不是很方便呢.?

 

接口和抽象类不能到底有什么区别呢？

2.override实现多态

真正的多态使用override来实现的。回过去看前面的例1，在基类Animal中将方法Eat()用virtual标记为虚拟方法，再在派生类Cat和Dog中用override对Eat()修饰，进行重写，很简单就实现了多态。需要注意的是，要对一个类中一个方法用override修饰，该类必须从父类中继承了一个对应的用virtual修饰的虚拟方法，否则编译器将报错。

 

好像讲得差不多了，还有一个问题，不知道你想没有。就是多层继承中又是怎样实现多态的。比如类A是基类，有一个虚拟方法method()（virtual修饰），类B继承自类A，并对method()进行重写（override修饰），现在类C又继承自类B，是不是可以继续对method()进行重写，并实现多态呢？看下面的例子。

 

例3:

 

代码

public class Animal 
   
     {    
         public virtual void Eat()    
         {    
             Console.WriteLine("Animal eat");    
         }    
     }    

     public class Dog : Animal    
     {    
         public override void Eat()    
         {    
             Console.WriteLine("Dog eat");    
         }    
     }    

     public class WolfDog : Dog    
     {    
         public override void Eat()    
         {    
             Console.WriteLine("WolfDog eat");    
         }    
     }    

     class Tester    
     {    
         static void Main(string[] args)    
         {    
             Animal[] animals = new Animal[3];    

             animals[0] = new Animal();    
             animals[1] = new Dog();    
             animals[2] = new WolfDog();    

             for (int i = 0; i < 3; i++)    
             {    
                 animals[i].Eat();    
             }    
         }    
 }      
   复制代码  
 
 
     运行结果为： 
Animal eat...
Dog eat...
WolfDog eat... 
在上面的例子中类Dog继承自类Animal，对方法Eat()进行了重写，类WolfDog又继承自Dog，再一次对Eat()方法进行了重写，并很好地实现了多态。不管继承了多少层，都可以在子类中对父类中已经重写的方法继续进行重写，即如果父类方法用override修饰，如果子类继承了该方法，也可以用override修饰，多层继承中的多态就是这样实现的。要想终止这种重写，只需重写方法时用sealed关键字进行修饰即可。
 
 
3. abstract-override实现多态
先在我们在来讨论一下用abstract修饰的抽象方法。抽象方法只是对方法进行了定义，而没有实现，如果一个类包含了抽象方法，那么该类也必须用abstract声明为抽象类，一个抽象类是不能被实例化的。对于类中的抽象方法，可以再其派生类中用override进行重写，如果不重写，其派生类也要被声明为抽象类。看下面的例子。
例4：
 
 
 
  
代码  

        public abstract class Animal 
   
     {      

    　　　   public abstract void Eat(); 
   
     }    

     public class Cat : Animal    
     {    
         public override void Eat()    
         {    
             Console.WriteLine("Cat eat");    
         }    
     }    

     public class Dog : Animal    
     {    
         public override void Eat()    
         {    
             Console.WriteLine("Dog eat");    
         }    
     }    

     public class WolfDog : Dog    
     {    
         public override void Eat()    
         {    
             Console.WriteLine("Wolfdog eat");    
         }    
     }    

     class Tester    
     {    
         static void Main(string[] args)    
         {    
             Animal[] animals = new Animal[3];    

             animals[0] = new Cat();    
             animals[1] = new Dog();    
             animals[2] = new WolfDog();    

             for (int i = 0; i < animals.Length; i++)    
             {    
                 animals[i].Eat();    
             }    
         }    
     }     
   复制代码  
 
 
 
运行结果为： 
Cat eat...
Dog eat...
Wolfdog eat...
从上面可以看出，通过使用abstract

-override可以和virtual-override一样地实现多态，包括多层继承也是一样的。不同之处在于，包含虚拟方法的类可以被实例化，而包含抽象方法的类不能被实例化。