Есть ли способ использовать «дружественное» имя для этого класса / интерфейса?

Question

По сути, я просто считаю, что имя типа уродливо при передаче его моему проекту.Я знаю, что вы не можете использовать интерфейс, который реализует интерфейс, потому что тогда это новый интерфейс, который просто реализует оригинальный интерфейс, верно?

public class GenericFactory<T, TTypeEnum> : IGenericFactory<T, TTypeEnum>
{
    private readonly IIndex<TTypeEnum, Func<CCompParms, T>> _factory;

    public GenericFactory(IIndex<TTypeEnum, Func<CCompParms, T>> factory)
    {
        _factory = factory;
    }

    public T Create(TTypeEnum serviceType, CCompParms comp)
    {
        return _factory[serviceType](comp);
    }
}

public interface IGenericFactory<T, TTypeEnum>
{
    T Create(TTypeEnum serviceType, CCompParms comp);
}

Я пробовал:

public interface FriendlyName : IGenericFactory<T, TTypeEnum>
{
}

Но когда я пытаюсь выполнить следующее, произойдет сбой, независимо от того, как я его произнесу.

IGenericFactory<T, TTypeEnum> inter = GetTheInterface();
FriendlyName fn = (inter as FriendlyName);

Есть ли способ сделать имя типа дружественным?

Answer 1

Во-первых, любое общее решение для «Дружественного имени» по-прежнему должно быть параметризовано обоими типами, так что я не думаю, что это то, что вы ищете, поскольку оно не спасет вас от набора текста..

Если вы хотите, чтобы у FriendlyName уже были привязаны типы, тогда я думаю, что вы можете получить работоспособное решение, используя Неявные преобразования и шаблон Decorator .

ВНИМАНИЕ !!!Я просто набрал это в браузере (без IDE или компилятора), и мой C # очень ржавый, так что это, вероятно, нужно будет настроить

public interface FooFactory : IGenericFactory<Foo, FooEnum> {

    IGenericFactory<Foo, FooEnum> Wrapped { get; }

    // The "magic" - Note that magic always makes your code harder to understand...

    public static implicit operator FooFactory(IGenericFactory<Foo, FooEnum> wrapped) {
        // I think this can be placed here. If C# won't let you add this
        // implicit operator here, then you can easily implement this factory
        // method as an extension on IGenericFactory<Foo, FooEnum>
        return new FooFactoryWrapper(wrapped);
    }

    public static implicit operator IGenericFactory<Foo, FooEnum>(FooFactory wrapper) {
        return wrapper.Wrapped;
    }

    // I'm pretty sure we can hide this implementation here in the interface,
    // but again, my C# is pretty rusty, so you may have to move this
    // and/or change the visibility
    private class FooFactoryWrapper : FooFactory {

        public IGenericFactory<Foo, FooEnum> Wrapped { get; private set; }

        public FooFactoryWrapper(IGenericFactory<Foo, FooEnum> wrapped) {
            this.wrapped = wrapped;
        }

        // Since the "friendly type" is still an instance of the base type,
        // you'll still have to fully implement that interface. Just delegate
        // all calls to your wrapped type (most useless Decorator ever)

        public Foo Make() { return Wrapped.Make(); } // sample method in IGenericFactory<>
    }
}

Теперь вы должны быть в состоянии использовать это так:

IGenericFactory<Foo, FooEnum> inter = GetTheInterface();
FooFactory fn = inter; // implicit conversion to wrapper type

DoWork(fn); // use the "friendly name" like it were it's wrapped type
            // implicit conversion back to wrapped type

public void DoWork(IGenericFactory<Foo, FooEnum> fooFactory) {
    ...
}

---

Несмотря на это, я бы не стал проходить через это усилие.Всякий раз, когда я делаю типы «Friendly Name», подобные этим, я делаю их частью моей «модели» и воспринимаю их как надлежащие типы, что означает, что я напрямую запрашиваю их в сигнатурах методов и конструкторах.

Примерно так:

public interface BarFactory : IGenericFactory<Bar, BarEnum> { }

// Asking for a BarFactory and not a IGenericFactory<Bar, BarEnum>
public void DoWork(BarFactory barFactory) { ... }

Гораздо меньше печатания и нет необходимости в магии.