Question

请您提供以下实施建议

我正在尝试实现一种从Class2.Save()调用Class1.Process()方法的通用方法。

class Program
{
    static void Main(string[] args)
    {
        IClass2 c2= new Class2();                         
        Class1 c1 = new Class1(c2);
        c1.Process<Student>(new Student());
    }
}

public interface IClass1 {
    bool Process<T>(T t) where T : new();

}
public class Class1 : IClass1
{

    IClass2 _repo;
    public Class1(IClass2 repo)
    {
        _repo = repo;
    }

    public bool Process<T>(T t) where T :  new()
    {
         _repo.Save (t);
        return true;
    }
}

public interface IClass2 {
    void Save(Student e);
    void Save(Teacher e);
}
public class Class2 : IClass2
{
    public void Save(Student e)
    {
        return;
    }

    public void Save(Teacher e)
    {
        return;
    }
}
public class Student { }

public class Teacher { }

我不喜欢使用反射或投射。任何人都可以帮助解决此问题或建议其他方法。

Answer 1

这样的事情怎么样？

我已将约束更改为类约束，而不是方法约束。并且有两个单独的类，它们都遵循Repository接口。

class Program
{
    static void Main(string[] args)
    {
        StudentRepository studentRepository = new StudentRepository();
        IProcessor<Student> processor = new Processor<Student>(studentRepository);
        processor.Process(new Student());
    }
}

public interface IProcessor<T> where T : new()
{
    bool Process(T t);

}
public class Processor<T> : IProcessor<T> where T : new()
{
    IRepository<T> _repo;
    public Processor(IRepository<T> repo)
    {
        _repo = repo;
    }

    public bool Process(T t)
    {
        _repo.Save(t);
        return true;
    }
}

public interface IRepository<T> where T : new()
{
    void Save(T e);
}

public class StudentRepository : IRepository<Student>
{
    public void Save(Student e)
    {
        return;
    }
}

public class TeacherRepository : IRepository<Teacher>
{

    public void Save(Teacher e)
    {
        return;
    }
}


public class Student { }

public class Teacher { }

Answer 2

考虑到您的约束（虽然我看得更糟，这对我来说似乎有些虚假），您可以通过反射，无需强制转换以及不更改Process方法的通用性质来实现此目标，只需通过反转调用方向，以便知道自己类型的对象可以调用存储库中正确的方法。

首先将您的域对象声明为“可保存”：

public interface ISaveable
{
    void Save(IClass2 repo);
}

public class Student : ISaveable
{ 
    public void Save(IClass2 repo) 
    {
        repo.Save(this);
    }
}

public class Teacher : ISaveable
{ 
    public void Save(IClass2 repo)
    {
        repo.Save(this);
    }
}

现在，每个域对象都知道如何保存自己。您所要做的就是将其交给存储库，您可以使用Process方法进行存储。

public class Class1 : IClass1
{
    IClass2 _repo;

    public Class1(IClass2 repo)
    {
        _repo = repo;
    }

    public bool Process<T>(T t) where T : ISaveable
    {
        t.Save(_repo);
        return true;
    }
}

Full example on DotNetFiddle

什么是实施Manager＆Repository的更好方法

2 个答案: