Как избежать реализации метода с бесполезными параметрами для удовлетворения условий интерфейса?

Question

У меня есть интерфейс IFoo с методом Bar, принимающим строковый аргумент.Этот интерфейс получил реализацию, которая возвращает постоянное значение без использования аргумента вообще.Другой использует параметры.

Как можно избежать этого бесполезного параметра?Вот фиктивная реализация

  public interface IFoo
    {
        string Bar(string parameter);
    }

    public class Foo : IFoo
    {
        public string Bar(string parameter)
        {
            return string.Format("{0}Fooooooo", parameter);
        }
    }

    public class ConstantFoo : IFoo
    {
        public string Bar(string parameter)
        {
            return "Baaaaaaar";
        }
    }

    public class Caller
    {
        private readonly IFoo _foo;
        private readonly IFoo _constFoo;
        public Caller()
        {
            _foo = new Foo();
            _constFoo = new ConstantFoo();
        }
        public void DummyUsage()
        {
            string arg = "Wololo";
            Console.WriteLine(_foo.Bar(arg));
            Console.WriteLine(_constFoo.Bar(arg));

        }
    }

Answer 1

Сигнатура функции или свойства, которую реализует класс, всегда должна быть идентична соответствующему интерфейсу. Если вы сами управляете интерфейсом, можете изменить сигнатуру как в интерфейсе, так и в классе реализации.

public interface IFoo
{
    string Bar();
}

public class Foo : IFoo
{
    public string Bar()
    {
        return "Fooooooo";
    }
}

Если это не то, что вы хотите, это может означать, что ваша модель наследования не очень хорошо определена.

Answer 2

Ваш пример считается с одним фактом. Вы как производитель класса знаете о деталях реализации, которые вы точно знаете, какой тип экземпляра IFoo

public class Caller
    {
        private readonly IFoo _foo;
        private readonly IFoo _constFoo;
        public Caller()
        {
            _foo = new Foo();   // => here is exact instance type
            _constFoo = new ConstantFoo(); // => here is exact instance type
        }
        public void DummyUsage()
        {
            string arg = "Wololo";
            Console.WriteLine(_foo.Bar(arg)); // -> here you know that you need parameterarg
            Console.WriteLine(_constFoo.Bar(arg)); // -> here you know that you do not need parameter arg

        }

Теперь подумайте об этом:

public class Caller
    {
        private readonly IEnumerable<IFoo> _fooServices;

        public Caller(IEnumerable<IFoo> fooServices)
        {
            _fooServices = fooServices;
        }
        public void DummyUsage()
        {
            string arg = "Wololo";

           foreach(IFoo fooService in _fooServices)
          {
               Console.WriteLine(fooService.Bar(arg)); //==> you do not know what type of foo it is if it require internally argument or not .. But you have to pass it to satisfy contract defined by IFoo interface
          }

        }

---

Теперь еще один

Представьте, что у вас есть 2 интерфейса:

interface IFoo 
{
    void Bar();
}

interface IParametrizedFoo
{
    void Bar(string parameter);
}

, тогда вы можете иметь реализацию

public class Foo : IParametrizedFoo
    {
        public string Bar(string parameter)
        {
            return string.Format("{0}Fooooooo", parameter);
        }
    }

    public class ConstantFoo : IFoo, IParametrizedFoo
    {
        public string Bar()
        {
            return "Baaaaaaar";
        }

      string  IParametrizedFoo.Bar(string parameter)
{
Bar();
}
    }

, затем использование

public class Caller
    {
        private readonly IParametrizedFoo _parametrizedFoo;
        private readonly IFoo _foo;
        public Caller(IParametrizedFoo parametrizedFoo, IFoo foo)
        {
            _parametrizedFoo= parametrizedFoo;
            _foo= foo;
        }
        public void DummyUsage()
        {
            string arg = "Wololo";
            Console.WriteLine(parametrizedFoo.Bar(arg));
            Console.WriteLine(_foo.Bar());

        }

Но все же я не думаю, что это лучший дизайн

Answer 3

Объявите дополнительный метод Bar () без каких-либо параметров в интерфейсе IFoo

public interface IFoo
{
    string Bar(string parameter);

    string Bar();
}

public class Foo : IFoo
{
    public string Bar(string parameter)
    {
        return string.Format("{0}Fooooooo", parameter);
    }

    public string Bar()
    {
        return string.Empty;
    }
}

public class ConstantFoo : IFoo
{
    public string Bar(string parameter)
    {
        return string.Empty;
    }

    public string Bar()
    {
        return "Baaaaaaar";
    }
}

public class Caller
{
    private readonly IFoo _foo;
    private readonly IFoo _constFoo;
    public Caller()
    {
        _foo = new Foo();
        _constFoo = new ConstantFoo();
    }
    public void DummyUsage()
    {
        string arg = "Wololo";
        Console.WriteLine(_foo.Bar(arg));
        Console.WriteLine(_constFoo.Bar());

    }
}