DataAction类，设置数据库连接的类

using System;
using System.IO;
using System.Collections;
//using System.Runtime.Serialization;
//using System.Data;
using System.Data.SqlClient;
using Microsoft.Win32;

namespace DataAction{
          public class DBCS{
                  private static RegistryKey regcreate=Registry.LocalMachine.CreateSubKey("SOFTWARE\\Baf Group");
                  private static RegistryKey regopen=Registry.LocalMachine.OpenSubKey("SOFTWARE\\Baf Group");
                  private static string connectionString;
                  private static SqlConnection cn;
                  public static string IP{
                          get{
                                 return ConnectionText.IP;
                           }
                          set{
                                 ConnectionText.IP = value;
                           }
                  }
                  public static string Port{
                          get{
                                 return ConnectionText.Port;
                           }
                          set{
                                 ConnectionText.Port = value;
                           }
                  }
                  public static string Database{
                          get{
                                 return ConnectionText.Database;
                           }
                          set{
                                 ConnectionText.Database = value;
                           }
                  }
                  public static string User{
                          get{
                                 return ConnectionText.User;
                           }
                          set{
                                 ConnectionText.User = value;
                           }
                  }
                  public static string Password{
                          get{
                                  return ConnectionText.Password;
                           }
                          set{
                                 ConnectionText.Password = value;
                           }
                  }
//Test the SqlConnection.
                  public static void Connect(){
                          try{
                                 Validate();
                           }
                          catch{
                                 throw;
                           }
                          try{
                                WriteFile();
                           }
                                 catch{}
                   }

  //Return a opened SqlConnection.
                  public static SqlConnection GetConnection(){
                          try{
                                 ReadFile();
                                 Validate();
                                 cn = new SqlConnection(connectionString);
                                 cn.Open();
                                 return cn;
                           }
                          catch{
                                 throw;
                          }
                   }

  //Validate the SqlConnection.
                  private static void Validate(){
                         connectionString = "Data Source=" + ConnectionText.IP + ","
                           + ConnectionText.Port + ";"
                           + "Network Library=dbmssocn;"
                           + "Initial Catalog=" + ConnectionText.Database + ";"
                           + "User ID=" + ConnectionText.User + ";"
                           + "Password=" + ConnectionText.Password + ";";
                           cn = new SqlConnection(connectionString);
                           try{
                                 cn.Open();
                                 cn.Close();
                           }
                          catch{
                                 throw;
                           }
                  }
//Read connectionString from file "path".
                    private static void ReadFile(){
/*                      if (File.Exists(path)){
                                 try{
                                    // Open the file to read from "path".
                                        fs = new FileStream(path, FileMode.Open, FileAccess.Read);
                                    // Read data from "path".
                                        text = (Hashtable) new BinaryFormatter().Deserialize(fs);
                                        fs.Close();
                                 }
                                 catch
    {
     throw;
    }

                                 foreach (DictionaryEntry de in text)
    {
                                 switch (de.Key.ToString())
     {
                                 case "ip":
                                 ConnectionText.IP = de.Value.ToString();
                                 break;
                                 case "port":
                                 ConnectionText.Port = de.Value.ToString();
                                 break;
                                 case "database":
                                 ConnectionText.Database = de.Value.ToString();
                                 break;
                                 case "user":
                                 ConnectionText.User = de.Value.ToString();
                                 break;
                                 case "password":
                                 ConnectionText.Password = de.Value.ToString();
                                 break;
     }
    }
    else
   {
    throw new Exception("the file inexistence.");
   }
*/
   try
   {
    ConnectionText.IP=regopen.GetValue("ip").ToString();
    ConnectionText.Port=regopen.GetValue("port").ToString();
    ConnectionText.Database=regopen.GetValue("database").ToString();
    ConnectionText.User=regopen.GetValue("user").ToString();
    ConnectionText.Password=regopen.GetValue("password").ToString();
   }
   catch{
    throw;
    }
  }

  //Write connectionString to file "path".
  private static void WriteFile()
  {
   try
   {
/*    if (File.Exists(path))
    {
     //Delete this file.
     File.Delete(path);
    }

    text = new Hashtable();
    text.Add("ip", ConnectionText.IP);
    text.Add("port", ConnectionText.Port);
    text.Add("database", ConnectionText.Database);
    text.Add("user", ConnectionText.User);
    text.Add("password", ConnectionText.Password);

    fs = new FileStream(path, FileMode.Create, FileAccess.Write);
    
    try
    {
     // Write data to "path".
     new BinaryFormatter().Serialize(fs, text);
    }
    catch (SerializationException)
    {
     throw;
    }

    fs.Close();
*/
    regcreate.SetValue("ip",ConnectionText.IP);
    regcreate.SetValue("port",ConnectionText.Port);
    regcreate.SetValue("database",ConnectionText.Database);
    regcreate.SetValue("user",ConnectionText.User);
    regcreate.SetValue("password",ConnectionText.Password);
   }
   catch
   {
    throw;
   }
  }
 }

 public class ConnectionText
 {
  private static string ip;
  private static string port;
  private static string database;
  private static string user;
  private static string password;

  public static string IP
  {
   get
   {
    return ip;
   }
   
   set
   {
    ip = value;
   }
  }

  public static string Port
  {
   get
   {
    return port;
   }
   
   set
   {
    port = value;
   }
  }

  public static string Database
  {
   get
   {
    return database;
   }
   
   set
   {
    database = value;
   }
  }

  public static string User
  {
   get
   {
    return user;
   }
   
   set
   {
    user = value;
   }
  }

  public static string Password
  {
   get
   {
    return password;
   }
   
   set
   {
    password = value;
   }
  }
 }
}

这段代码是我们用来设置数据库连接的类，开始的时候我们打算让它通过验证一系列数据库链接字符串参数，然后把有效的数据库连接信息保存到一个文件中。然后需要用到数据库链接时，我们可以随时用这个类的某个方法来取得有效的连接。后来我们把它改成了使用注册表来保存数据库连接字符串。我们不认为这么做很好，只是我们在向已存在文件重新写入信息时发生了错误，而到现在也没有找到错误在哪里。无奈之下只好暂时做缓兵之计－使用注册表。

这个类的整体结构是这样的
一个类{}
这个类在开始有间接操作下一个类变量的函数，这样做可能很多余。
然后，connect是一个连接数据库动作的方法，方法首先验证字符串的有效性，然后使用写方法。
跟着，GetConnection是可以取得有效数据库连接的方法。方法先使用取方法，然后验证有效性并打开连接。

接着，Validate是一个用来验证数据库连接字符创是否有效的方法。
然后，ReadFile是一个从文件或者注册表读取数据库连接字符串的方法。没有调用任何其他方法。单纯方法

最后，WriteFile是一个向文件或者注册表写入数据库连接字符串的方法。没有调用任何其他方法。单纯方法


另一个类{}这个类用若干变量来保存数据库连接所必须的字符串，仅此而已；单纯类。

后记：注意throw的越界抛出操作，如果当前级别没有可以接收异常的代码，它将把异常返回给调用异常函数的函数。

由此代码产生的思考：

面向对象的思维方式不是体现在编码的局部上，是宏观的，整体的设计上，才能体现面向对象设计方式的优势，有时候，在局部编码中强迫使用面向对象的方法思考会得到混乱繁琐的反现象。尤其刻意的把代码变为类似面向对象模式模式化的代码。

 

无论怎样，整体的设计以及一大块局部功能的设计，在最开始就需要大量使用面向对象的设计思路，否则就会造成代码混乱不成章法，看上去很不论不类的后果。