Alternatives to nested interfaces (not possible in C#)

问题

I'm using interfaces in this case mostly as a handle to an immutable instance of an object. The problem is that nested interfaces in C# are not allowed. Here is the code:

public interface ICountry
{
    ICountryInfo Info { get; }

    // Nested interface results in error message:
    // Error    13  'ICountryInfo': interfaces cannot declare types
    public interface ICountryInfo
    {
        int Population { get; }
        string Note { get; }
    }
}


public class Country : ICountry
{
    CountryInfo Info { get; set; }

    public class CountryInfo : ICountry.ICountryInfo
    {
        int Population { get; set; }
        string Note { get; set; }
        .....
    }
    .....
}

I'm looking for an alternative, anybody would have a solution?

回答1:

VB.NET allows this. So, you can create a VB.NET assembly only with the interface definitions that you need:

Public Interface ICountry
  ReadOnly Property Info() As ICountryInfo

  Public Interface ICountryInfo
    ReadOnly Property Population() As Integer
    ReadOnly Property Note() As String
  End Interface
End Interface

As for the implementation, C# does not support covariant return types, so you must declare your class like this:

public class Country : ICountry {
  // this property cannot be declared as CountryInfo
  public ICountry.ICountryInfo Info { get; set; }

  public class CountryInfo : ICountry.ICountryInfo {
    public string Note { get; set; }
    public int Population { get; set; }
  }
}

回答2:

If ICountryInfo has no reason to exist outside ICountry, then why shouldn't you just put the properties of ICountryInfo in ICountry and dismiss the idea of nested interfaces?

An interface that hasn't a meaning of its own without another interface doesn't make sense to me, as an interface on itself is useless if not implemented by a class.

回答3:

If the end goal is to use this with dependency injection, what's wrong with injecting them into each other instead of nesting?

public interface ICountry
{
    ICountryInfo Info { get; }
}

public interface ICountryInfo
{
    int Population { get; set; }
    string Note { get; set; }
}

and implement as:

public class Country : ICountry
{
    private readonly ICountryInfo _countryInfo;

    public Country(ICountryInfo countryInfo)
    {
        _countryInfo = countryInfo;
    }

    public ICountryInfo Info
    {
        get { return _countryInfo; }
    }
}

public class CountryInfo : ICountryInfo
{
    public int Population { get; set; }
    public string Note { get; set;}
}

Then once you set up your bindings for ICountry & ICountryInfo, CountryInfo will inject into Country whenever Country is injected.

You could then restrict the binding, if you wanted, to only inject CountryInfo into Country and nowhere else. Example in Ninject:

Bind<ICountry>().To<Country>();
Bind<ICountryInfo>().To<CountryInfo>().WhenInjectedInto<Country>();

回答4:

You can use namespaces like this:

namespace MyApp
{
    public interface ICountry { }

    namespace Country
    {
        public interface ICountryInfo { }
    }
}

Then in MyApp namespace you can use Country.ICountryInfo which is close to your requirement. Also using alias helps make the code clear.

回答5:

This will work just fine, no need to nest:

public interface ICountry
{
    ICountryInfo Info { get; }
}

public interface ICountryInfo
{
    int Population { get; }
    string Note { get; }
}

来源：https://stackoverflow.com/questions/2287267/alternatives-to-nested-interfaces-not-possible-in-c

标签

interface