Inner class within Interface in C#

Question

The following question shows how to implement an interface that contains a class in java:

inner class within Interface

The code in Java is:

public interface A {
    class B {
    }
}

I was hoping the same thing was possible in C#, though I haven't yet been able to get anything working.

For reference, I have a class which makes lookups of key values, but the keys aren't named in a way that makes them easy to understand. I'd like to have a compile time lookup for keys, so the interface would be something like:

interface Lookup {
    class Keys {
        string SomeKey() => "0"
    }
}

Which means I suppose I have two questions:

1. Is it possible to have an interface containing a class?
2. Is there a better way of having a lookup between two strings (or any other values) that I can reference reliably at compile time?

Answer 1

You cannot have an class within an interface in C#. Interfaces are very simple in C#, and only provide a contract of functionality.

If you want to have a mapping between two strings, a Dictionary<string, string> may be of use to you.

Answer 2

Simply put no you can't have a class inside an interface.

From your comments you are talking about having a restricted list of available strings for the keys so I'm wondering if you are in fact not looking for a string/string lookup but just want a convenient way of referencing a list of fixed strings. So a class with constants is all you need:

public static class Strings 
{
    public const string AString = "A";
    public const string BString = "B";
    public const string CString = "C";
}

Accessed like this:

var s = Strings.AString;

Answer 3

An interface can't itself have any instance data. It's implementation however can have any instance data it requires.

For example, a random example that might give you some insight:

public class SomeClass
{
    public string Key {get; set;}
}

public interface ISomeInterface
{
    string Value { get; set; }
    SomeClass SomeClass { get; set;}
}

public class SomeInterfaceImplementation : ISomeInterface
{
    public SomeInterfaceImplementation()
    {
        SomeClass = new SomeClass()
        {
            Key = "ABC"
        };
    }
    public string Value { get; set; }
    public SomeClass SomeClass { get; set; }
}

public class Program
{

    public static void Main()
    {
        var example = new SomeInterfaceImplementation()
        {
            Value = "A value",
        } as ISomeInterface;
        Console.WriteLine($"{example.SomeClass.Key} has value '{example.Value}'");
    }
}

In the example, the default constructor "generates" a key of ABC. We could implement this any way your logic requires. But you also have a contract that requires "SomeClass" and it's key is present.

Anywhere you want to use the contract, just accept the Interface and not an implementation class.

Additionally, feel free to play with the fiddle:

Answer 4

Most of the answers under this question are no longer true. Since C# 8.0, when default interface methods were added, it is possible for an interface to have member declaration that declare for example nested type. The following code is correct for C# 8.0:

public interface IA
{
    class B
    {
    }
}