Question

所以我有一个非常大的通用类1500多行并且正在增长，有很多方法。它有CrazyMethods和GoodMethods，我想把不同类型的方法放在他们自己的类中，但仍然可以使用我的泛型，就好像它们在泛型类中一样。

public class MyGeneric<T> : IMyGeneric<T> where T : IEntity
{
    public MyGeneric(string stuff)
    {
        moreStuff(stuff);
    }
    // Region Good
    public void MyGoodMethod1(T entity)
    {
      //does good stuff with the generic..
    }
    public T MyGoodMethod2()
    {
      //does other good stuff with the generic..
    }

    //Region Crazy
    public void MyCrazyMethod1(T entity)
    {
      //does crazy stuff with the generic..
    }
    public T MyCrazyMethod2()
    {
      //does other crazy stuff with the generic..
    }
}

现在在我使用此泛型的其他项目中，它看起来像这样

...
SomeObject _myObject =  new MyGeneric<SomeObject>("ladida");

_myObject.MyGoodMethod1();
//..Other stuff
_myObject.MyCrazyMethod2();¨
...

如何将MyGeneric类中的方法分离为单独的类（MyGenericGoodMethods.cs，MyGenericCrazyMethods.cs），但仍能按照我上面展示的方式使用它们？

如果我可以使用泛型的扩展方法，那将是完美的解决方案。

public static class MyGenericGoodMethods<T> where T : IEntity
{
    public static T Method2(this MyGeneric<T> generic)
    {
        //does other good stuff with the generic..
    }
}

但

扩展方法只能在非泛型，非嵌套的静态类
中声明

Answer 1

您可以在普通静态类中声明扩展方法，并将其与泛型一起使用。

public static class MyGenericGoodMethodsExtensions
{
    public static T Method2(this MyGeneric<T> generic)
    {
        //does other good stuff with the generic..
    }
}

var myGeneric = new MyGeneric<string>();
myGeneric.Method2()

但是你总是可以在很多独立的泛型类中拆分你的巨型类，并在你的main-generic类中使用它们。

拆分你的界面

public interface IMyGeneric<T>
{
    void MyGeneric(string stuff);
}

public interface IMyGoodGeneric<T>
{
    void MyGoodMethod1(T entity);
    void MyGoodMethod2(T entity);
}

public interface IMyCrazyGeneric<T>
{
    void MyCrazyMethod1(T entity);
    void MyCrazyMethod2(T entity);
}

介绍单独的实现

public class MyGeneric<T> : IMyGeneric<T> where T : IEntity
{
    public void MyGeneric(string stuff)
    {
        // implementation
    }
}

public class MyGoodGeneric<T> : IMyGoodGeneric<T> where T : IEntity
{
    public void MyGoodMethod1(T entity) {}
    public void MyGoodMethod2(T entity) {}
}

public class MyCrazyGeneric<T> : IMyCrazyGeneric<T> where T : IEntity
{
    public void MyCrazyMethod1(T entity) {}
    public void MyCrazyMethod2(T entity) {}
}

然后你可以创建你的＆＃34;巨人＆＃34;组合类，它将实现所有接口并使用已存在的实现

public class MyGiantGeneric<T> : IMyGeneric<T>,
                                 IMyGoodGeneric<T>,
                                 IMyCrazyGeneric<T> where T : IEntity
{
    private readonly IMyGeneric<T> _myGeneric;
    private readonly IMyGoodGeneric<T> _myGoodGeneric;
    private readonly IMyCrazyGeneric<T> _myCrazyGeneric;

    public MyGiantGeneric(IMyGeneric<T> myGeneric,
                          IMyGoodGeneric<T> myGoodGeneric,
                          IMyGCrazyGeneric<T> myCrazyGeneric)
    {
        _myGeneric = myGeneric;
        _myGoodGeneric = myGoodGeneric;
        _myCrazyGeneric = myCrazyGeneric;
    }

    public void MyGeneric(string stuff)
    {
        _myGeneric.MyGeneric(stuff);
    }

    public void MyGoodMethod1(T entity) 
    {
        _myGoodGeneric.MyGoodMethod1(entity);
    }

    // and so on...
}

通过这种方法，您的逻辑将保留在逻辑上分离的类中如果您需要MyGoodGeneric方法的某个地方，您不需要提供整个巨型课程，并且只提供所需的部分。

如果您想在某些地方引入仅针对MyCrazy方法的其他实现，则不会强制您实施MyGood方法，在这种情况下您不需要这些方法。

Answer 2

所以部分课程正是我想要的。感谢@BradleyDotNET和@AliAbdelfattah

public partial class MyGeneric<T> where T : IEntity
{
    public void MyGoodMethod1(T entity)
    {
      //does good stuff with the generic..
    }
    public T MyGoodMethod2()
    {
      //does other good stuff with the generic..
    }
}

在MyGenericGood.cs中

SELECT table1.uid, table1.email, table1.name, table1.password, 
table2.vocation, table2.groups FROM table1 INNER JOIN table2 ON
table1.uid = table2.uid
WHERE table2.groups LIKE '%3%' AND email<>'me@meme.com'

Answer 3

扩展方法可以是通用的，而不是它的容器类：

public static class Extensions
{
    public static T Method2<T>(this MyGeneric<T> generic)
    {
    }
}

如何将方法与我的巨型泛型类分开

3 个答案: