C# 如何在C中将泛型类型的类转换为对象类型为泛型类型的类#

您好，我正在使用VisualStudio2005（因为我需要compact框架支持），我的问题是泛型

我创建了一个名为AbstractDAO的抽象类，它是我的基础

基于此，我创建了其他类，如DocumentDAO、HeaderDAO等，它们表示数据库中的不同表

我希望做的是检索一定数量的上述DAO类，但作为一个抽象DAO（抽象类有许多我希望使用的具体实现）

我试过的是

AbstractDAO<object> dao = new DocumentDAO();
AbstractDAO<object> dao = (AbstractDAO<object>)new DocumentDAO();
AbstractDAO<T> dao = new DocumentDAO();

AbstractDAO=newdocumentdao（）；
AbstractDAO=（AbstractDAO）新文档dao（）；
AbstractDAO=新文档dao（）；

我需要上面的内容，因为我创建了一个函数，可以将数据从一个表传输到另一个数据库中的类似表，所以它（如果有效的话）应该是这样的

AbstractDAO<object> dao_local = new DocumentDAO(local_database);
AbstractDAO<object> dao_remote = new DocumentDAO(remote_database);      
do_transfer(dao_local,dao_remote)

void do_transfer(AbstractDAO<object> from, AbstractDAO<object> to) {
     List<object> items = from.get_all();
     to.insert(items);
}

AbstractDAO\u local=新文档dao（本地数据库）；
AbstractDAO\u remote=新文档dao（远程数据库）；
do_传输（dao_本地，dao_远程）
void do_传输（AbstractDAO from，AbstractDAO to）{
List items=from.get_all（）；
至.插入（项目）；
}

---

有什么方法可以做到以上几点吗？

只有在你的班级结构是这样的情况下才有效：

class DocumentDAO : AbstractDAO<object> {
    //...
}

class DocumentDAO : AbstractDAO<SomeType> {
    public override SomeType Foo() {
        //...
        return someValue;
    }
    //...
}
class AbstractDAO<T> {
    public abstract T Foo();
    //...
}

void do_transfer(AbstractDAO<FirstType> from, AbstractDAO<SecondType> to) 
{
    Mapper.Initialize(cfg=>cfg.CreateMap<FirstType, SecondType>);

    List<FirstType> fromItems = from.get_all();
    List<SecondType> itemsToInsert = 
        Mapper.Map<List<FirstType>, List<SecondType>>(fromItems);
    to.insert(itemsToInsert);
}

类DocumentDAO:AbstractDAO{
//...
}

根据您的评论，您似乎拥有如下类型层次结构：

class DocumentDAO : AbstractDAO<object> {
    //...
}

class DocumentDAO : AbstractDAO<SomeType> {
    public override SomeType Foo() {
        //...
        return someValue;
    }
    //...
}
class AbstractDAO<T> {
    public abstract T Foo();
    //...
}

void do_transfer(AbstractDAO<FirstType> from, AbstractDAO<SecondType> to) 
{
    Mapper.Initialize(cfg=>cfg.CreateMap<FirstType, SecondType>);

    List<FirstType> fromItems = from.get_all();
    List<SecondType> itemsToInsert = 
        Mapper.Map<List<FirstType>, List<SecondType>>(fromItems);
    to.insert(itemsToInsert);
}

类DocumentDAO:AbstractDAO{
公共重写SomeType Foo（）{
//...
返回一些值；
}
//...
}
类抽象DAO{
公开摘要T Foo（）；
//...
}

您可能希望重构AbstractDAO以实现像IAbstractDAO这样的非泛型接口：

class IAbstractDAO {
    object Foo();
    //...
}

class AbstractDAO<T> {
    public object Foo() {
        return Foo();
    }
    public abstract T Foo();
    //...
}

类IAbstractDAO{
对象Foo（）；
//...
}
类抽象DAO{
公共对象Foo（）{
返回Foo（）；
}
公开摘要T Foo（）；
//...
}

您可以尝试使用以下方式传输对象：

class DocumentDAO : AbstractDAO<object> {
    //...
}

class DocumentDAO : AbstractDAO<SomeType> {
    public override SomeType Foo() {
        //...
        return someValue;
    }
    //...
}
class AbstractDAO<T> {
    public abstract T Foo();
    //...
}

void do_transfer(AbstractDAO<FirstType> from, AbstractDAO<SecondType> to) 
{
    Mapper.Initialize(cfg=>cfg.CreateMap<FirstType, SecondType>);

    List<FirstType> fromItems = from.get_all();
    List<SecondType> itemsToInsert = 
        Mapper.Map<List<FirstType>, List<SecondType>>(fromItems);
    to.insert(itemsToInsert);
}

void do_transfer（AbstractDAO from，AbstractDAO to）
{
初始化（cfg=>cfg.CreateMap）；
List fromItems=from.get_all（）；
列表项插入=
Mapper.Map（fromItems）；
至。插入（项目至插入）；
}

---

默认情况下，automapper将映射具有相同名称的字段。您可以创建复杂类型映射。

任何

AbstractDAO

的实现都被编译为一个单独的对象类型，其中T被替换为类型。有关如何发生此情况的更多信息，请参阅“”。简而言之，不要让

欺骗你

这意味着您不能将

DocumentDAO

分配给

AbstractDAO

，就像您不能将字符串分配给它一样。此外，泛型类型与继承不同，这似乎是您试图实现的目标

如前所述，无论哪种情况，都有两种标准解决方案

第一个是。您为公共属性创建了一个接口，并具有

AbstractDAO

或从此继承的任何其他属性。大多数情况下，您只需对接口进行操作。具体的组织方式取决于你自己

---

第二个是对对象执行一个操作。这意味着将值和引用从一个对象复制到另一个对象。为此，通常使用对象映射器，如。应该让您开始了。

所以我最终找到了我要做的事情的答案，而不是将abstractDAO分配给某个东西，而是创建了一个工厂，根据泛型的类型检索所需的abstractDAO，并使用了这个函数

private bool transfer<T>(){
    AbstractDAO<T> local = DAOFactory.get<T>(local_database);
    AbstractDAO<T> remote = DAOFactory.get<T>(remote_database);
    List<T> items = local.get_all();
    foreach (T item in items) {
        remote.insert(item);
    } 
}

private bool transfer（）{
AbstractDAO local=DAOFactory.get（本地_数据库）；
AbstractDAO remote=DAOFactory.get（远程_数据库）；
List items=local.get_all（）；
foreach（项目中的T项目）{
远程。插入（项目）；
} 
}

这样我可以像这样调用此函数： 转移（）； 传输

（）

等等，做一个完整的转移

编辑：为了完整，这是我创建的工厂

    public static AbstractDAO<T> get<T>(Database database) {
        Type t = typeof(T);
        if (t == typeof(Document)) {
            return new DocumentDAO(database) as AbstractDAO<T>;
        } else if (t == typeof(Header)) {
            return new HeaderDAO(database) as AbstractDAO<T>;
        } etc.
    }

公共静态抽象DAO get（数据库）{ 类型t=类型（t）； if（t==类型（文件））{ 将新文档DAO（数据库）作为AbstractDAO返回； }else if（t==类型（标题））{ 将新的HeaderDAO（数据库）作为AbstractDAO返回； }等等。 }

---

Dude-如何将类型B的值赋给类型a的变量（至少第一行是这样做的。）这就像c#basics:AbstractDOA doa=new DocumentDOA（）；或者，只有当您的类层次结构如下时，这才有效：因为B是A的一个实现/子类。使用AbstractDOA doa=new DocumentDOA（）会引发一个异常，表示使用泛型类型“AbstractDAO”需要“1”类型参数，顺便说一句，您所说的在Java中确实有效，但它似乎在c#中不起作用。我的层次结构与您上一次发布的层次结构（没有接口）

class AbstractDAO{}class DocumentDAO:AbstractDAO{}

，但添加了以下内容：`public List get_objects（）{List items=get_all（）；return items as List；}public int insert_object（object obj）{return insert（（T）obj）；}`在抽象dao中似乎不会抛出错误，所以我想我可以使用它，这并不完全是我想要的（即能够将子类转换为超类）但是我可以这样做，谢谢，我的问题不是我不能将from的类型转换为to，我的问题是如果可能的话，我想将泛型作为该函数的参数，即

do\u transfer（AbstractDAO from，AbstractDAO to）

或

do\u transfer（AbstractDAO from，AbstractDAO to）

问题是，我似乎无法将AbstractDAO转换为AbstractDAO，即使在理论上object是所有对象的超类。您是否尝试像这样声明传输

DoTransfer（Dao源，Dao目标）

？感谢您的帮助，我采用了另一种解决方案，我将