property - C#: getters/setters de herencia de interfaz

property c# get set

Question

Tengo un conjunto de interfaces que se utilizan en estrecha relación con un objeto mutable particular.

Muchos usuarios del objeto solo necesitan la capacidad de leer valores del objeto y, a continuación, solo unas pocas propiedades. Para evitar la contaminación del espacio de nombres (intellisense más fácil) y para conocer el propósito del uso, me gustaría tener una pequeña interfaz base que solo exhiba unas pocas propiedades de "clave" en forma de solo lectura.

Sin embargo, casi todas las implementaciones admitirán la interfaz completa, que incluye modificabilidad.

Lamentablemente, me encontré con un obstáculo que expresa ese concepto en C #:

interface IBasicProps {
public int Priority { get; }
public string Name {get;}
//... whatever
}
interface IBasicPropsWriteable:IBasicProps {
public int Priority { set; } //warning CS0108: [...] hides inherited member [...]
public string Name { set; }
//... whatever
}

Ciertamente no tenía la intención de ocultar ningún miembro, ¡así que no es bueno!

Por supuesto, puedo resolver esto usando métodos bien, pero ¿cuál es la elección correcta ? Me gustaría mantener la interfaz "central" lo más pequeña posible, incluso si la división de las interfaces no tiene otro propósito que comunicar la intención. Con las interfaces divididas, es realmente obvio qué métodos no van a hacer ninguna actualización, y hace que la escritura del código sea un poco más clara (sin mencionar también permite simples y únicos stubs únicos estáticos que son suficientes para bastantes casos simples) .

Me gustaría evitar cualquier clase abstracta y similares; hacen que la reimplementación o calzas de un solo propósito sean más complejas y difíciles de asimilar.

Entonces, ¿ideas?

Answer 1

El método de ocultarse en una interfaz no es tan sucio; Yo iría con algo como:

interface IBasicProps {
int Priority { get; }
string Name {get;}
//... whatever
}
interface IBasicPropsWriteable:IBasicProps {
new int Priority { get; set; }
new string Name { get; set; }
//... whatever
}
class Foo : IBasicPropsWriteable {
public int Priority {get;set;}
public string Name {get;set;}
/* optional
int IBasicProps.Priority {get {return Priority;}}
string IBasicProps.Name {get {return Name;}}
*/
}

Answer 2

Puede dejar las interfaces no relacionadas y simplemente hacer que su clase implemente ambas interfaces. Después de todo, las interfaces simplemente definen el contrato y los contratos no necesitan estar relacionados. Parece que es solo una optimización para usted cuando codifica para que la escriturable se derive de la otra, por lo que solo debe especificar una interfaz.

public interface IBasicProps
{
int Priority { get; }
string Name {get;}
//... whatever
}
public interface IBasicPropsWriteable
{
int Priority { get; set; }
string Name { get; set; }
//... whatever
}
public class Foo : IBasicProps, IBasicPropsWriteable
{
public int Priority { get; set; }
public string Name { get; set; }
// whatever
}

Si realmente necesitabas la optimización, podrías crear otra interfaz que derive de ambos y hacer que tus clases lo implementen.

public interface IBasicPropsAll : IBasicProps, IBasicPropsWriteable { }
public class Foo : IBasicPropsAll
{
public int Priority { get; set; }
public string Name { get; set; }
// whatever
}

Answer 3

Si su objetivo es aclararlo cuando se permite la lectura o la escritura, entonces usaría métodos getter y setter separados en lugar de propiedades.

interface IBasicProps {
int GetPriority();
string GetName();
//... whatever
}
interface IBasicPropsWriteable:IBasicProps {
void SetPriority(int priority);
void SetName(string name);
//... whatever
}

Answer 4

Una forma podría ser simplemente omitir la herencia de las interfaces. Cree una interfaz de solo lectura y una de solo escritura, e impleméntela según sea necesario:

interface IBasicPropsReadable {
int Priority { get; }
string Name { get; }
}
interface IBasicPropsWriteable {
int Priority { set; }
string Name { set; }
}
class SomeClassReadWrite : IBasicPropsReadable, IBasicPropsWriteable {
int Priority { get; set; }
string Name { get; set; }
}
class SomeClassReadOnly : IBasicPropsReadable {
int Priority { get; }
string Name { get; }
}