正确的程序结构(Correct program structure)

 我的应用程序用于与电子设备通信。 它会读取一些识别数据（如设备固件版本），一些配置数据以及来自传感器的周期性数据。 计划分为三层： 
 
 
 
 数据层 - 描述数据如何存储在设备存储器中的简单结构。 
 
 
 业务层 - 用于与设备通信的类。 它们包含来自数据层的结构，并在读取和写入设备时使用它们来存储数据。 
 
 
 表示层 - 用户界面（WinForms）; 使用businnes图层类。 
 
 
 假使，假设： 
 
 数据结构如下： 
 
public struct Configuration
{
 public int Option1;
 public int Option2;
}

public struct Visualization
{
 public int Temperature;
 public int Pressure;
}
 
 业务层类包装这些结构并包含通信逻辑： 
 
public abstract class BaseEntity<DataStructureType>
{
 protected DataStructureType dataStructure;
 public BaseEntity()
 {
  this.dataStructure = new DataStructureType();
 }
 /*
  device communication logic
 */
 public abstract bool GetAllData();
}

public class ConfigurationEntity : BaseEntity<Configuration>
{
 public override bool GetAllData()
 {
  //getting configuration data from device
 }
 public int Option1
 {
  get { return this.dataStructure.Option1; }
  set { this.dataStructure.Option1 = value; }
 }
 public int Option2;
 {
  get { return this.dataStructure.Option2 * 100; }
  set { this.dataStructure.Option1 = value / 100; }
 }
}

public class VisualizationEntity : BaseEntity<Visualization>
{
 public override bool GetAllData()
 {
  //getting visualization data from device
 }
 public int Temperature
 {
  get { return this.dataStructure.temperature; }
 }
 public float Pressure;
 {
  get { return Conversions.IntToPressure(this.dataStructure.pressure); }
 }
}
 
 和Conversions类用于转换二进制数据： 
 
public static class Conversions
{
 public static float IntToPressure(int parameter)
 {
  return PressureAlgorithmA(parameter);
 }
 private static float PressureAlgorithmA(int parameter)
 {
  //some algorithm (called A) to convert binary pressure to pressure in bars
 }
}
 
 问题是新的固件版本，因为应用程序应该处理两个设备版本（旧版本和更新版本）。 新版本已更新，包括几个新结构，新转换算法，新配置选项。 看起来像： 
 
public struct Configuration
{
 /*
  old options are here
 */
 //and updated goes here:
 public int Option3;
 public int Option4;
}

public class ConfigurationEntity : BaseEntity<Configuration>
{
 /*
  old code is here
 */
 //and updated goes here
 public int Option3
 {
  get { return this.dataStructure.Option3; }
  set { this.dataStructure.Option3 = value; }
 }
 public int Option4;
 {
  get { return this.dataStructure.Option4 * 20; }
  set { this.dataStructure.Option4 = value / 20; }
 }
}
 
 转换也改变了： 
 
public static class Conversions
{
 public static float IntToPressure(int parameter)
 {
  return PressureAlgorithmB(parameter);
 }
 private static float PressureAlgorithmB(int parameter)
 {
  //some algorithm (called B) to convert binary pressure to pressure in bars
 }
}
 
 现在我每次需要使用新功能时都要检查设备版本（当从Configuration更改Option3或Option4时，或者当我需要使用新数据etities或在向用户显示压力时使用哪种算法）。 
 
 我的问题是如何使用OOP实践来做到这一点？ 在C＃中执行此操作的正确方法是什么？ 
 
 我在考虑工厂模式，但配置中的新选项或新数据实体是什么？ 

My application is used for communication with electronic device. It reads some identification data (like device firmware version), some configuration data, and periodically data from sensors. Program is divided into three layers:
 
 
 
Data layer - simple structures describing how data are stored in device memory.
 
 
Business layer - classes used for communication with device. They contains structures from data layer and using them to store data when reading from and writing to device.
 
 
Presentation layer - user interface (WinForms); using businnes layer classes.
 
 
Assume that:
 
Data structures looks like:
 
public struct Configuration
{
 public int Option1;
 public int Option2;
}

public struct Visualization
{
 public int Temperature;
 public int Pressure;
}
 
Business layer classes wraps these structures and contains logic for communication:
 
public abstract class BaseEntity<DataStructureType>
{
 protected DataStructureType dataStructure;
 public BaseEntity()
 {
  this.dataStructure = new DataStructureType();
 }
 /*
  device communication logic
 */
 public abstract bool GetAllData();
}

public class ConfigurationEntity : BaseEntity<Configuration>
{
 public override bool GetAllData()
 {
  //getting configuration data from device
 }
 public int Option1
 {
  get { return this.dataStructure.Option1; }
  set { this.dataStructure.Option1 = value; }
 }
 public int Option2;
 {
  get { return this.dataStructure.Option2 * 100; }
  set { this.dataStructure.Option1 = value / 100; }
 }
}

public class VisualizationEntity : BaseEntity<Visualization>
{
 public override bool GetAllData()
 {
  //getting visualization data from device
 }
 public int Temperature
 {
  get { return this.dataStructure.temperature; }
 }
 public float Pressure;
 {
  get { return Conversions.IntToPressure(this.dataStructure.pressure); }
 }
}
 
And Conversions class used to convert binary data:
 
public static class Conversions
{
 public static float IntToPressure(int parameter)
 {
  return PressureAlgorithmA(parameter);
 }
 private static float PressureAlgorithmA(int parameter)
 {
  //some algorithm (called A) to convert binary pressure to pressure in bars
 }
}
 
Problem is new firmware version, because application should handle both device versions(older and newer). New version has been updated with couple of new structures to read, new conversion algorithms, new configuration options. It looks like:
 
public struct Configuration
{
 /*
  old options are here
 */
 //and updated goes here:
 public int Option3;
 public int Option4;
}

public class ConfigurationEntity : BaseEntity<Configuration>
{
 /*
  old code is here
 */
 //and updated goes here
 public int Option3
 {
  get { return this.dataStructure.Option3; }
  set { this.dataStructure.Option3 = value; }
 }
 public int Option4;
 {
  get { return this.dataStructure.Option4 * 20; }
  set { this.dataStructure.Option4 = value / 20; }
 }
}
 
Also Conversions has beem changed:
 
public static class Conversions
{
 public static float IntToPressure(int parameter)
 {
  return PressureAlgorithmB(parameter);
 }
 private static float PressureAlgorithmB(int parameter)
 {
  //some algorithm (called B) to convert binary pressure to pressure in bars
 }
}
 
Now I have to check for device version every time I need to use new funcionality (when changing Option3 or Option4 from Configuration or when I need to use new data etities or which algorithm use when showing pressure to user).
 
My question is how can I do that with OOP practicies? What is correct way to do this in C#?
 
I was thinking about factory pattern, but what with new options in Configuration, or with new data entities?

原文：https://stackoverflow.com/questions/10190781