关于业务逻辑层接口问题，大师们救命！！！

[lr5420511]

昨天交上去的作业，被我的导师臭骂了一顿，非常郁闷，昨晚一夜未眠，今天发帖请高手指点！！
就是这个题目：现有业务A和业务B，业务A有查询、添加、删除和修改功能，业务B只有查询和添加功能，要求据此设计一个类似业务逻辑层的东西。
老师上课说过方法的，下来让我们做，我没有按他的方法弄，而是自己发明了一个荒唐的做法！！（所以后来被臭骂了！哎）
老师的方案如下：

  /// <summary>
  /// 业务A的接口
  /// </summary>
    public interface IA
    {
        void SelectA();
        void InsertA();
        void DeleteA();
        void UpdateA();
    }
    /// <summary>
    /// 业务B的接口
    /// </summary>
    public interface IB
    {
        void SelectB();
        void InsertB();
    }
    /// <summary>
    /// 业务A
    /// </summary>
    public class A : IA
    {
        public void SelectA()
        {
            //添加方法
        }
        public void InsertA()
        {
            //添加方法
        }
        public void DeleteA()
        {
            //添加方法
        }
        public void UpdateA()
        {
            //添加方法
        }
    }
    /// <summary>
    /// 业务B
    /// </summary>
    public class B : IB
    {
        public void SelectB()
        {
            //添加方法
        }
        public void InsertB()
        {
            //添加方法
        }
    }
    
    static void Main(string[] args)
        {
            IA Ia = new A();
            Ia.Select();
            Ia.Insert();
            Ia.Delete();
            Ia.Update();
            IB Ib = new B();
            Ib.Select();
            Ib.Insert();
        }
  

我记得他上课说接口和业务最好一对一,但是我觉得这样写蛋疼得很啊，A和B都有类似的业务，要是有3000个业务每个业务都有查询、添加、删除和修改的功能，那也写3000个接口再在这3000个接口里写各写3000个这些功能的方法定义？我觉得好蛋疼的，所以我的荒唐的想法诞生了,哎，最早知道被骂，就不交了！
我的荒唐想法代码如下：

  /// <summary>
    /// 接口
    /// </summary>
    public interface IT
    {
        void Select();
        void Insert();
        void Delete();
        void Update();
    }
    /// <summary>
    /// 第一遍实现
    /// </summary>
    public class ITClass : IT
    {
        public virtual void Select()
        { }
        public virtual void Insert()
        { }
        public virtual void Delete()
        { }
        public virtual void Update()
        { }
    }
    /// <summary>
    /// 业务A--重写第二遍实现
    /// </summary>
    public class A : ITClass
    {
        public override void Select()
        {
            //添加方法
        }
        public override void Insert()
        {
            //添加方法
        }
        public override void Delete()
        {
            //添加方法
        }
        public override void Update()
        {
            //添加方法
        }
    }
    /// <summary>
    /// 业务B--重写第二遍实现
    /// </summary>
    public class B : ITClass
    {
        public override void Select()
        {
            //添加方法
        }
        public override void Insert()
        {
            //添加方法
        }
    }
    
    static void Main(string[] args)
        {
            IT It = new A();
            It.Select();
            It.Insert();
            It.Delete();
            It.Update();
            It = new B();
            It.Select();
            It.Insert();
        }
  

就是这段代码被骂惨了，哎，郁闷！我觉得很多时候查询添加修改删除功能的重复度很高啊！还有就是B业务如果哪一天想增加修改功能了，就可以在B业务里直接重写Update方法就可以了啊！哎，被批评得都不想去上课了！

[叫我三三]

LZ你连题都没看明白，不挨批才怪，题目说的很清楚了
业务B只有查询和添加功能

就算答案写的在好，不是题目所要求的，有毛用？

[ididrrr]

老师要考你接口,你非要写个基类...你不错谁错.

[阿冷]

你这样做，继承基类ITClass。
而基类实现了IT借口，它必须实现接口的所有方法，也就是说你最终的类，都会拥有
IT接口的方法。
而老师的方法，最终类，只会拥有实现接口的方法，这样可以控制新类的对外公开方法。

[lr5420511]

[Quote=引用 1 楼 的回复:]

你这样做，继承基类ITClass。
而基类实现了IT借口，它必须实现接口的所有方法，也就是说你最终的类，都会拥有
IT接口的方法。
而老师的方法，最终类，只会拥有实现接口的方法，这样可以控制新类的对外公开方法。
[/Quote]

嗯 谢谢兄弟，这个我知道的，但是一想到在很多业务的情况下要写很多的接口就好蛋疼啊

[cheng2005]

你的B里面多出了一些根本不需要的public方法，这是问题的关键。

[lr5420511]

[Quote=引用 1 楼 的回复:]

你这样做，继承基类ITClass。
而基类实现了IT借口，它必须实现接口的所有方法，也就是说你最终的类，都会拥有
IT接口的方法。
而老师的方法，最终类，只会拥有实现接口的方法，这样可以控制新类的对外公开方法。
[/Quote]

还有一个就是，对于很多的业务都有添加、修改、查询和删除功能的，这样写貌似问题也不太大呀

[阿冷]

[Quote=引用 2 楼 的回复:]

引用 1 楼 的回复:

你这样做，继承基类ITClass。
而基类实现了IT借口，它必须实现接口的所有方法，也就是说你最终的类，都会拥有
IT接口的方法。
而老师的方法，最终类，只会拥有实现接口的方法，这样可以控制新类的对外公开方法。


嗯 谢谢兄弟，这个我知道的，但是一想到在很多业务的情况下要写很多的接口就好蛋疼啊
[/Quote]

如果你说的接口，不会被很多类似的类同时实现，也就是说，你的接口复用率比较低的话，你没必要定义这么多接口啊，失去了它的意义了啊。呵呵

[lr5420511]

[Quote=引用 3 楼 的回复:]

你的B里面多出了一些根本不需要的public方法，这是问题的关键。
[/Quote]

把功能重复度高的继承一下这种借口貌似问题也不太大呀

[E次奥]

一句话，不利于维护！老师的方法，体现了低耦合！你的方法是高耦合！

[lr5420511]

[Quote=引用 6 楼 的回复:]

引用 2 楼 的回复:

引用 1 楼 的回复:

你这样做，继承基类ITClass。
而基类实现了IT借口，它必须实现接口的所有方法，也就是说你最终的类，都会拥有
IT接口的方法。
而老师的方法，最终类，只会拥有实现接口的方法，这样可以控制新类的对外公开方法。


嗯 谢谢兄弟，这个我知道的，但是一想到在很多业务的情况下要写很多的接口就好蛋疼啊


如果你说的接口……
[/Quote]

但是不用接口的话，还是会被骂啊！

[阿冷]

其实我感觉，你想要的意思，可以这么实现。
写四个接口，分别是，插入，更改，删除，选择。
然后，A类实现，4个接口，B类，实现2个，也就是说，你只实现想要的接口。

[lr5420511]

[Quote=引用 7 楼 的回复:]

一句话，不利于维护！老师的方法，体现了低耦合！你的方法是高耦合！
[/Quote]

果真这样吗？55555

[lr5420511]

[Quote=引用 9 楼 的回复:]

其实我感觉，你想要的意思，可以这么实现。
写四个接口，分别是，插入，更改，删除，选择。
然后，A类实现，4个接口，B类，实现2个，也就是说，你只实现想要的接口。
[/Quote]

着这个意思吗？

/// <summary>
    /// 接口s
    /// </summary>
    public interface ITS
    {
        void Select();
    }
    /// <summary>
    /// 接口i
    /// </summary>
    public interface ITI
    {
        void Insert();
    }
    /// <summary>
    /// 接口d
    /// </summary>
    public interface ITD
    {
        void Delete();
    }
    /// <summary>
    /// 接口u
    /// </summary>
    public interface ITU
    {
        void Update();
    }
    /// <summary>
    /// 业务A--
    /// </summary>
    public class A : ITS,ITI,ITU,ITD
    {
        public void Select()
        {
            //添加方法
        }
        public void Insert()
        {
            //添加方法
        }
        public void Delete()
        {
            //添加方法
        }
        public void Update()
        {
            //添加方法
        }
    }
    /// <summary>
    /// 业务B--
    /// </summary>
    public class B : ITS,ITI
    {
        public void Select()
        {
            //添加方法
        }
        public void Insert()
        {
            //添加方法
        }
    }

    static void Main(string[] args)
        {
            ITS Its = new A();
            Its.Select();
            ITI Iti = new A();
            Iti.Insert();
            ITD Itd = new A();
            Itd.Delete();
            ITU Itu = new A();
            Itu.Update();
            ITS ITs = new B();
            ITs.Select();
            ITI ITi = new B();
            Iti.Insert();
        }

[阿冷]

[Quote=引用 11 楼 的回复:]

引用 9 楼 的回复:

其实我感觉，你想要的意思，可以这么实现。
写四个接口，分别是，插入，更改，删除，选择。
然后，A类实现，4个接口，B类，实现2个，也就是说，你只实现想要的接口。


着这个意思吗？
C# code

/// <summary>
/// 接口s
/// </summary>
public interface ITS
{
……
[/Quote]

就是这么个意思，接口不用再增加了。呵呵

[cheng2005]

[Quote=引用 12 楼 的回复:]

引用 11 楼 的回复:

引用 9 楼 的回复:

其实我感觉，你想要的意思，可以这么实现。
写四个接口，分别是，插入，更改，删除，选择。
然后，A类实现，4个接口，B类，实现2个，也就是说，你只实现想要的接口。


着这个意思吗？
C# code

/// <summary>
/// 接口s
/// </summary>
public interface I……
[/Quote]

接口不增加是不可能的，你这写的只是作业。
你现在定义的Select，Update，Insert，Delete都是没有参数没有返回值的。
而现实中两个业务的入参和返回值非常可能是不一样的，你不可能只定义几个增删改查的接口就把业务抽象出来，这太理想化了。
接口不是不能增加，而是公用接口最好不要随着业务增加。当你有独特的业务的时候，接口怎么可能不增加。

[阿冷]

[Quote=引用 13 楼 的回复:]

引用 12 楼 的回复:

引用 11 楼 的回复:

引用 9 楼 的回复:

其实我感觉，你想要的意思，可以这么实现。
写四个接口，分别是，插入，更改，删除，选择。
然后，A类实现，4个接口，B类，实现2个，也就是说，你只实现想要的接口。


着这个意思吗？
C# code

/// <summary>
/// 接口s
/// </summary>
p……
[/Quote]

再细说的话，其实楼主一开始定义的接口初衷就不是太理想，一般来说，一类事物的共有动作性，单一动作性比较好用接口。也就说，楼主一开始的动作，不是单一的，而是一连串的，如果来实现的话，继承，个人感觉更合理一些。

[popo0762]

为什么很多程序和客户需求渐行渐远......