C# 設計形式系列教程-模板辦法形式

C# 設計形式系列教程-模板辦法形式。本站提示廣大學習愛好者：（C# 設計形式系列教程-模板辦法形式）文章只能為提供參考，不一定能成為您想要的結果。以下是C# 設計形式系列教程-模板辦法形式正文

1. 概述

　　界說一個操作中的算法的骨架，而將步調延遲到子類中。模板辦法使得子類可以不轉變一個算法的構造便可重界說算法的某些特定步調。

2. 形式中的腳色

　　2.1 籠統類（AbstractClass）：完成了模板辦法，界說了算法的骨架。

　　2.2 詳細類（ConcreteClass)：完成籠統類中的籠統辦法，已完成完全的算法。

3. 形式解讀

　　3.1 模板辦法類圖

　　3.2 模板辦法形式代碼完成

 /// <summary>
 /// 籠統類
 /// </summary>
 public abstract class AbstractClass
 {
  // 一些籠統行動，放到子類去完成
  public abstract void PrimitiveOperation1();
  public abstract void PrimitiveOperation2();

  /// <summary>
  /// 模板辦法，給出了邏輯的骨架，而邏輯的構成是一些響應的籠統操作，它們推延到子類去完成。
  /// </summary>
  public void TemplateMethod()
  {
   PrimitiveOperation1();
   PrimitiveOperation2();
   Console.WriteLine("Done the method.");
  }
 }

 /// <summary>
 /// 詳細類，完成了籠統類中的特定步調
 /// </summary>
 public class ConcreteClassA : AbstractClass
 {
  /// <summary>
  /// 與ConcreteClassB中的完成邏輯分歧
  /// </summary>
  public override void PrimitiveOperation1()
  {
   Console.WriteLine("Implement operation 1 in Concreate class A.");
  }

  /// <summary>
  /// 與ConcreteClassB中的完成邏輯分歧
  /// </summary>
  public override void PrimitiveOperation2()
  {
   Console.WriteLine("Implement operation 2 in Concreate class A.");
  }
 }

 /// <summary>
 /// 詳細類，完成了籠統類中的特定步調
 /// </summary>
 public class ConcreteClassB : AbstractClass
 {
  /// <summary>
  /// 與ConcreteClassA中的完成邏輯分歧
  /// </summary>
  public override void PrimitiveOperation1()
  {
   Console.WriteLine("Implement operation 1 in Concreate class B.");
  }

  /// <summary>
  /// 與ConcreteClassA中的完成邏輯分歧
  /// </summary>
  public override void PrimitiveOperation2()
  {
   Console.WriteLine("Implement operation 2 in Concreate class B.");
  }
 }

　　3.3 客戶端代碼

 class Program
 {
  static void Main(string[] args)
  {
   // 聲明籠統類
   AbstractClass c;

   // 用ConcreteClassA實例化c
   c = new ConcreteClassA();
   c.TemplateMethod();

   // 用ConcreteClassB實例化c
   c = new ConcreteClassB();
   c.TemplateMethod();

   Console.Read();
  }
 }

　　運轉成果

5. 形式總結

　　5.1 長處

　　　　5.1.1 模板辦法形式經由過程把不變的行動搬移到超類，去除子類中的反復代碼。

　　　　5.1.2 子類完成算法的某些細節，有助於算法的擴大。

　　　　5.1.3 經由過程一個父類挪用子類完成的操作，經由過程子類擴大增長新的行動，相符“開放-關閉准繩”。

　　5.2 缺陷

　　　　5.2.1 每一個分歧的完成都須要界說一個子類，這會招致類的個數的增長，設計加倍籠統。

　　5.3 實用場景

　　　　5.1 在某些類的算法中，用了雷同的辦法，形成代碼的反復。

　　　　5.2 掌握子類擴大，子類必需遵照算律例則。

6. 形式舉例： 用冒泡算法非別對整型數組、浮點數數組、日期數組完成排序。

　　6.1 完成類圖

　　6.2 完成代碼

 /// <summary>
 /// 籠統類，界說冒泡排序的骨架
 /// </summary>
 public abstract class BubbleSorter
 {
  private int operations = 0;
  protected int length = 0;

  /// <summary>
  /// 冒泡排序算法
  /// </summary>
  /// <returns></returns>
  protected int DoSort()
  {
   operations = 0;
   if (length <= 1)
   {
    return operations;
   }

   for (int nextToLast = length - 2; nextToLast >= 0; nextToLast--)
   {
    for (int index = 0; index <= nextToLast; index++)
    {
     if (OutOfOrder(index))
     {
      Swap(index);
     }

     operations++;
    }
   }

   return operations;
  }

  /// <summary>
  /// 留給子類完成的交流地位辦法
  /// </summary>
  /// <param name="index"></param>
  protected abstract void Swap(int index);
  /// <summary>
  /// 留給子類完成的比擬辦法
  /// </summary>
  /// <param name="index"></param>
  /// <returns></returns>
  protected abstract bool OutOfOrder(int index);
 }

 /// <summary>
 /// 整型類型的冒泡算法完成
 /// </summary>
 public class IntBubbleSorter:BubbleSorter
 {
  private int[] array = null;

  /// <summary>
  /// 用冒泡算法排序
  /// </summary>
  /// <param name="theArray"></param>
  /// <returns></returns>
  public int Sort(int[] theArray)
  {
   array = theArray;
   length = array.Length;
   // 挪用冒泡算法
   return DoSort();
  }

  /// <summary>
  /// 完成冒泡算法中的交流操作
  /// </summary>
  /// <param name="index"></param>
  protected override void Swap(int index)
  {
   int temp = array[index];
   array[index] = array[index + 1];
   array[index + 1] = temp;
  }

  /// <summary>
  /// 完成冒泡算法中的比擬操作
  /// </summary>
  /// <param name="index"></param>
  /// <returns></returns>
  protected override bool OutOfOrder(int index)
  {
   return (array[index] > array[index + 1]);
  }
 }

 /// <summary>
 /// 浮點數類型的冒泡算法
 /// </summary>
 public class FloatBubbleSorter:BubbleSorter
 {
  private float[] array = null;

  /// <summary>
  /// 用冒泡算法排序
  /// </summary>
  /// <param name="theArray"></param>
  /// <returns></returns>
  public int Sort(float[] theArray)
  {
   array = theArray;
   length = array.Length;
   // 挪用冒泡算法
   return DoSort();
  }

  /// <summary>
  /// 完成冒泡算法中的交流操作
  /// </summary>
  /// <param name="index"></param>
  protected override void Swap(int index)
  {
   float temp = array[index];
   array[index] = array[index + 1];
   array[index + 1] = temp;
  }

  /// <summary>
  /// 完成冒泡算法中的比擬操作
  /// </summary>
  /// <param name="index"></param>
  /// <returns></returns>
  protected override bool OutOfOrder(int index)
  {
   return (array[index] > array[index + 1]);
  }
 }

　　6.3 客戶端挪用

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

   // 對整型數組排序
   int[] intArray = new int[]{5, 3, 12, 8, 10};
   BubbleSorter.IntBubbleSorter sorter = new BubbleSorter.IntBubbleSorter();
   sorter.Sort(intArray);
   foreach (int item in intArray)
   {
    Console.Write(item+" ");
   }

   Console.WriteLine("");

   // 對浮點數排序
   float[] floatArray = new float[] { 5.0f, 3.0f, 12.0f, 8.0f, 10.0f };
   BubbleSorter.FloatBubbleSorter floatSorter = new BubbleSorter.FloatBubbleSorter();
   floatSorter.Sort(floatArray);
   foreach (float item in floatArray)
   {
    Console.Write(item + " ");
   }

   Console.Read();
  }
 }

　　運轉成果

以上就是本文的全體內容，願望能給年夜家一個參考，也願望年夜家多多支撐。