3

我正在尝试实现各种相关类组，有点像这样：

  • MySQL数据库
  • MySQLTable（引用一个 MySQLDatabase）
  • MySQLRecord（引用 MySQLTable）
  • PostGre 数据库
  • PostGreTable（引用 PostGreDatabase）
  • PostGreRecord（引用 PostGreTable）
  • 甲骨文数据库
  • ...

由于相关类（MySQLTable、PostGreTable 等）有很多共享代码，我已经使用抽象父类和泛型实现了这一点，如下所示：

class Database {}

class Table<DatabaseType> where DatabaseType : Database 
{
  public DatabaseType FDatabase; //this is what I mean by "references"
}

class Record<TableType, DatabaseType> where 
  DatabaseType : Database
  TableType : Table<DatabaseType> 
{
  public TableType FTable;
}

class MySQLDatabase : Database {}

class MySQLTable : Table<MySQLDatabase> 
{
  public string FCharset;
}

MySQLRecord : Record<MySQLTable, MySQLDatabase> {}

...

我需要这种架构能够：

  • 防止错误的引用。

例如：MySQLTable 不能引用 PostGreDatabase 或 OracleDatabase，只能引用 MySQLDatabase。

  • 使程序员无需强制转换即可访问对象的特定属性。

例子：

SomeMySQLRecord.FTable.FCharset = 'UTF-8';

代替

((MySQLTable)SomeMySQLRecord.FTable).Charset = 'UTF-8';

我正在寻找一种更优雅的方式（或模式）来做到这一点，因为真正的类组有 3 个以上的类，而泛型真的让代码变得很糟糕。例子：

MyType : Type1<GType1, GType2, GType3, GType4> where
  GType1 : Type2,
  GType2 : Type3<GType1>,
  GType3 : Type4<GType1, GType2>,
  GType4 : Type5<GType2, GType1, Type2, GType3>
4

2 回答 2

0

我会采取稍微不同的路线，尽管我不完全确定这是否适用于您的特定情况：

     public class Provider { }

    public class Oracle : Provider { }

    public class AbstractDatabase<T> where T : Provider
    {
        // Your base code here
    }

    public class AbstractTable<T> where T : Provider
    {
        public AbstractDatabase<T> FDatabase { get; set; }
        // Your base code here
    }

    public class AbstractRecord<T> where T : Provider
    {
        public AbstractTable<T> FTable { get; set; }
    }

    public class OracleDatabase : AbstractDatabase<Oracle> { }

    public class OracleTable : AbstractTable<Oracle>
    {
        public new OracleDatabase FDatabase { get; set; }

        // Your strongly typed code
        public OracleTable(OracleDatabase parent) { }
    }
于 2013-01-04T03:58:33.483 回答
0

泛型对我来说在这里没有意义。使用您自己的代码：

Table<DatabaseType : Database>
MySQLTable : Table<MySQLDatabase>

有人会假设 MySQLTable 也使用泛型定义，因为您将其定义为 Table 的子项：

MySQLTable<Something> : Table<MySQLDatabase>

你会如何在这里定义Something？这没有意义。

如果您使用泛型来实现这一点：

例如：MySQLTable 不能引用 PostGreDatabase 或 OracleDatabase，只能引用 MySQLDatabase。

我认为这不是使用泛型的充要条件。

于 2013-01-02T07:20:41.843 回答