How do I require all objects that implement an interface to have a certain field

Question

In short, I want all of my objects that implement an interface to have a common field. I have an interface called IMovable and I want every object that implements it to have a public field called hasMoved. In other words, I want all objects to have a field as if they inherited it from a class, but I want to implement multiple different interfaces and I don't want to have a class hierarchy. What would be the best way to solve this? Should I use properties? It's my first time using interfaces and I am not sure if they are the right solution to something like this.

Answer 1

I want every object that implements it to have a private field called _hasMoved

private field can't be made since interfaces will have all as public as it's a contract. You can't even go by an abstract class since private members are not inherited.

What if you make it a public field and have that contract in your interface

public interface IMovable
{
  bool HasMoved { get; set; }
}

Answer 2

For the record: interfaces don't define fields at all, regardless of public/private/protected, so your expectation is simply not possible.

I've also considered using a property, but that seems unreasonable, as I don't want any extra functionality.

The issue isn't in the distinction between a field and a property, but rather because you're trying to use an interface to define a private.

Interfaces only define public properties (and methods), because interfaces effectively define the public inferface that is known to an external caller.

When I say public class Foo : IFoo, I am saying that external callers can observe an object of the Foo class as if it were an IFoo (they don't actually need to know it's a Foo or a DifferentFoo). This inherently forces me to then ensure that Foo fulfills the necessary IFoo contract.

In short, I want all of my objects that implement an interface to have a common field.

It makes no sense for interfaces to define private (or protected) fields because an external caller would not have access to them anyway.
Furthermore, since it's a private field, this would only be usable inside of the class itself. There is no way to define/reference this field in any other class (including the interface definition or any other implementation of the interface).

You call them a "common" field, but how would they every be common? No one would be able to use them, other than the class whose field it is. No one (not even the interface implementations themselves) will ever have access to more than one of these fields, there is no possible commonality (or benefit from it).

---

If the language were to accommodate what you want, there would be absolutely no functional benefit to it whatsoever. None. If you (or anyone else) can list any functional benefit, I'm interested in hearing it.

The only arguable benefit is that you could copy/paste code from one class to the next, because you would be able to guarantee that the referenced field (in the pasted code) has the same name.
But if you're copy/pasting, you're doing something wrong. Every time you copy/paste code, you should evaluate if you're not trying to work around a necessary abstraction. And in most cases, that is exactly what you're doing, which is bad practice.

---

If this is simply a matter of not wanting to type the same field declaration over and over, and you've already established that you're not trying to sweep a necessary abstraction under the rug, you can look into code generation tools that can generate the initial class definition for you.

However, if this is only for a handful of fields in a handful of classes, the effort is not worth the gains. You'll spend more time setting up the generation rules than you will copy/pasting the field declarations.

Answer 3

https://csharp.2000things.com/2011/10/28/443-an-interface-cannot-contain-fields/

Unfortunately interfaces cannot contain fields so your next best move would to define an abstract class with abstract methods and declare your fields within that class.

That way, anything that inherits the class will have to define the inherited methods similar to an interface with the additional fields from the base class

Answer 4

If you want a field that is to be used only inside a base and all its derived classes, then declare it as protected in an abstract base class, as private would instead hide it to all the inheriting classes as well. If its value should be common for every class, you can still make it const or readonly and initialize it in the base class, so the derived classes cannot modify it (refer to this question to choose between the two modifiers).
As others have already explained, interfaces only allow public properties to be declared. Either you accept that, or you use an abstract class.

EDIT: Based on the new information provided by the OP, I suggest the use of a property in the base interface. That's the closest you can get to a commonly-shared public field without using an asbtract class.