abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

抽象类具有以下特性：

  • 抽象类不能实例化。

  • 抽象类可以包含抽象方法和抽象访问器。

  • 不能用 sealed（C# 参考）修饰符修改抽象类，这意味着抽象类不能被继承。

  • 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实实现。

在方法或属性声明中使用 abstract 修饰符以指示方法或属性不包含实现。

抽象方法具有以下特性：

  • 抽象方法是隐式的虚方法。

  • 只允许在抽象类中使用抽象方法声明。

  • 因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。例如：

    1. public abstract void MyMethod();

  • 实现由一个重写方法override（C# 参考）提供，此重写方法是非抽象类的一个成员。

  • 在抽象方法声明中使用 static 或 virtual 修饰符是错误的。

除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。

  • 在静态属性上使用 abstract 修饰符是错误的。

  • 在派生类中，通过包括使用 override 修饰符的属性声明，可以重写抽象的继承属性。

抽象类必须为所有接口成员提供实现。

实现接口的抽象类可以将接口方法映射到抽象方法上。例如：

  1. interface I 
  2. {
  3.     void M();
  4. }
  5. abstract class C: I 
  6. {
  7.     public abstract void M();
  8. }

在具体用法如下实例:

新加一个基类:MothedBase.cs

  1.     public abstract class MothedBase
  2.     {
  3.         #region Fields
  4.         public List<string> ErrorList = new List<string>();
  5.         public List<string> MessageList = new List<string>();
  6.         #endregion
  7.  
  8.         #region Properties
  9.  
  10.  
  11.         /// <summary>
  12.         /// 
  13.         /// </summary>
  14.         private string ConnectString
  15.         {
  16.             get
  17.             {
  18.                 return ConfigurationManager.ConnectionStrings["ConnectString"].ConnectionString;
  19.             }
  20.         }
  21.  
  22.  
  23.         #endregion
  24.  
  25.         #region Entrance Method
  26.  
  27.         /// <summary>
  28.         /// 
  29.         /// </summary>
  30.         public void ExcuteMigration()
  31.         {
  32.  
  33.  
  34.         SubmitMigration(this.SqlQueryGetAllAttachment, this.SqlQueryGetAllItems, this.SqlQueryGetFolder, this.SiteUrl);
  35.  
  36.         }
  37.  
  38.  
  39.         protected abstract string SiteUrl
  40.         {
  41.             get;
  42.         }
  43.         /// <summary>
  44.         /// 
  45.         /// </summary>
  46.         protected abstract bool IsMigrateToProductHomePage { get; }
  47.         /// <summary>
  48.         /// 
  49.         /// </summary>
  50.         protected abstract List<string> NeedReplaceColumn { get; }
  51.         /// <summary>
  52.         ///  
  53.         /// </summary>
  54.         protected abstract string SqlQueryGetAllItems { get; }
  55.  
  56.         /// <summary>
  57.         /// 
  58.         /// </summary>
  59.         protected abstract string SqlQueryGetAllAttachment { get; }
  60.  
  61.         protected virtual string SqlQueryGetFolder { get { return null; } }
  62.         /// <summary>
  63.         /// 
  64.         /// </summary>
  65.         /// <param name="dtOriginalData"></param>
  66.         protected abstract void ValidateOriginalData(DataTable dtOriginalData);
  67.  
  68.         /// <summary>
  69.         /// 
  70.         /// </summary>
  71.         /// <param name="dtOriginalData"></param>
  72.         protected abstract DataTable TransferData(DataTable dtOriginalData);
  73.  
  74.         #endregion
  75.  
  76.         #region Protected Methods
  77.  
  78.  
  79.  
  80.  
  81.         /// <summary>
  82.         /// 
  83.         /// </summary>
  84.         /// <param name="sqlQuery"></param>
  85.         /// <returns></returns>
  86.         protected DataTable ExcuteOracleReader(string sqlQuery)
  87.         {
  88.             DataTable dtResult = new DataTable();
  89.             if (!string.IsNullOrEmpty(sqlQuery))
  90.             {
  91.                 OracleCommand command = null;
  92.                 IDataReader dataReader = null;
  93.                 OracleConnection conn = null;
  94.  
  95.                 try
  96.                 {
  97.                     conn = new OracleConnection(this.ConnectString);
  98.                     conn.Open();
  99.                     command = new OracleCommand(sqlQuery);
  100.                     command.Connection = conn;
  101.                     command.CommandType = CommandType.Text;
  102.                     dataReader = command.ExecuteReader();
  103.                     dtResult.Load(dataReader);
  104.                 }
  105.                 catch (Exception ex)
  106.                 {
  107.                     this.ErrorList.Add(ex.Message);
  108.                 }
  109.                 finally
  110.                 {
  111.                     if (conn.State != ConnectionState.Closed)
  112.                     {
  113.                         conn.Close();
  114.                         conn.Dispose();
  115.                     }
  116.  
  117.                     if ((dataReader != null) && (dataReader.IsClosed == false))
  118.                     {
  119.                         dataReader.Close();
  120.                         dataReader.Dispose();
  121.                     }
  122.  
  123.                     if (command != null)
  124.                     {
  125.                         command.Dispose();
  126.                     }
  127.                 }
  128.             }
  129.  
  130.             return dtResult;
  131.         }
  132.  
  133.         #endregion
  134.  
  135.         #region Private Methods
  136.  
  137.  
  138.         /// <summary>
  139.         /// 
  140.         /// </summary>
  141.         /// <param name="GetAllAttachment"></param>
  142.         /// <param name="GetAllItems"></param>
  143.         /// <param name="TheSiteUrl"></param>
  144.         private void SubmitMigration(string GetAllAttachment, string GetAllItems, string GetFolderItem, string TheSiteUrl)
  145.         {
  146.             DataTable dtAttachment = null;
  147.             DataTable dtOriginalData = null;
  148.             //Get data and attachment form oracle database.
  149.             if (!string.IsNullOrEmpty(this.SqlQueryGetAllAttachment))
  150.                 dtAttachment = this.ExcuteOracleReader(GetAllAttachment);
  151.             if (!string.IsNullOrEmpty(this.SqlQueryGetAllItems))
  152.                 dtOriginalData = this.ExcuteOracleReader(GetAllItems);
  153.         }
  154.  
  155.  
  156.  
  157.  
  158.         #endregion
  159.  
  160.     }

然后再加一个UseMothedBase类引用MothedBase基类,代码如下:

  1.  public class UseMothedBase:MothedBase
  2.     {
  3.         protected override string SiteUrl
  4.         {
  5.             get { return ""; }
  6.         }
  7.  
  8.         protected override bool IsMigrateToProductHomePage
  9.         {
  10.             get { return ""; }
  11.         }
  12.  
  13.         protected override List<string> NeedReplaceColumn
  14.         {
  15.             get { throw new NotImplementedException(); }
  16.         }
  17.  
  18.         protected override string SqlQueryGetAllItems
  19.         {
  20.             get { return ""; }
  21.         }
  22.  
  23.         protected override string SqlQueryGetAllAttachment
  24.         {
  25.             get { return ""; }
  26.         }
  27.  
  28.         protected override void ValidateOriginalData(System.Data.DataTable dtOriginalData)
  29.         {
  30.           
  31.         }
  32.  
  33.         protected override System.Data.DataTable TransferData(System.Data.DataTable dtOriginalData)
  34.         {
  35.             return new DataTable();
  36.         }
  37.     }

然后再在main.cs 引用它们,代码如下:

  1.    static void Main()
  2.     {
  3.       MothedBase usemoth = new UseMothedBase();
  4.       usemoth.ExcuteMigration();
  5.     }

就样就是一个Abstract Factory 简单用法了,可以概据各自的需求丰富下,让它使用灵活.

版权声明：本文为springyangwc原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/springyangwc/archive/2011/12/21/1987096.html