¿Cuál es el mejor diseño que puedo usar para definir métodos con el mismo nombre?

Question

Hay un problema de diseño como este.

Supongamos que tiene un conjunto de clases que implementa métodos similares pero no idénticos.

Ejemplo: La ClassA tiene métodos como este.

void Add(string str); 
void Delete(string str); 
List<string> GetInfo(string name); 

Otra clase, ClassB tiene los siguientes métodos.

void Add(Dictionary Info); 
void Delete(string str); 
Dictionary GetInfo(string name); 

Así que la naturaleza de los métodos son similares, pero los tipos de retorno/parámetros de entrada son diferentes. Si desarrollo una interfaz para mantener la coherencia, solo puedo definir la operación Eliminar allí. Alternativamente, puedo pensar en un conjunto de clases independientes sin ninguna relación entre sí (por supuesto, no hay implementaciones de interfaz), pero no creo que sea un buen diseño.

1. ¿Cuál es el enfoque que puede utilizar para implementar esta?
2. Soy nuevo en interfaces genéricas. ¿Ayuda en este caso? Si es así, voy a aprender e implementar su uso.

Answer 1

Usted puede utilizar el interfaz genérica aquí. Un ejemplo:

interface IModifiable<T> 
{ 
    void Add(T Info); 
    void Delete(T item); 
    T GetInfo(string name); 
} 
public class MyClass : IModifiable<List<string>> 
{ 
    public void Add(List<string> list) 
    { 
     //do something 
    } 

    public void Delete(List<string> item) { } 
    public List<string> GetInfo(string name) { } 
} 

Answer 2

No veo ningún problema con esas interfaces. Pero SI veo un problema si implementa ambas interfaces en la misma clase. Romperás el Principio de Responsabilidad Individual al hacerlo.

leer más aquí: http://www.objectmentor.com/resources/articles/srp.pdf

También puede leer este excelente libro sobre algunos principios de diseño: http://cdn.cloudfiles.mosso.com/c82752/pablos_solid_ebook.pdf

Answer 3

public interface IInt<T> { 
    void Add(T val); 
    void Delete(string str); 
    T GetInfo(string name); 
} 

Answer 4

Genéricos le ayudaría si se puede cambiar ligeramente el diseño:

interface IFoo<TKey, TValue> 
{ 
    void Add(TKey name, TValue value); 
    void Delete(TKey name); 
    IEnumerable<TValue> GetInfo(TKey name); 
} 

Esto no encaja sus ejemplos, pero muy cerca. Si no puede hacer este cambio, diría que sus clases no son lo suficientemente similares como para que tenga una interfaz común.

También debe tener en cuenta que este diseño es muy similar a la interfaz IDictonary o ILookup. Quizás puedas usar interfaces existentes en lugar de crear una nueva.

Answer 5

El problema se define bastante vaugely pero por lo que entiendo Tiene varias posibilidades utilizar primero la definición Método Genérico

public void Detele<T>(T toDelete); //optional : where T 

y definirlo en el interfaz general (o clase abstracta si it'syour caso)

De lo contrario, una técnica muy antigua pero sólida es la sobrecarga de métodos. Puede definir múltiples métodos con el mismo nombre pero tomando diferentes argumentos. .Net usa este patrón principalmente en clases como StreamReader, ToString, etc.

A partir de las firmas que ha proporcionado, parece que puede encontrar un uso para eso.

La tercera opción (aunque es más difícil de codificar) es usar las expresiones lambda.

Add<T,P>(Action<T,P> addingAction, T source, P param) (addingAction(source,param);); 
//this is naive p.Add(q) it can be arbitralily more complicated 
aObject.Add((p,q) => p.Add(q), myObj, myParam); 

De esta manera usted define una acción genérica de adición que luego puede ser encapsulada en Sus objetos. La firma que proporcioné puede ser fácilmente cambios. Además, es posible que no desee ejecutar la acción de inmediato, programarla para la ejecución diferida o ejecutarla de forma asíncrona. Las posibilidades con expresiones lambda son infinitas.

También proporcioné una implementación que usa el delegado de Acción. Puede convertir fácilmente este código para usar la clase Expresión, mediante la cual puede construir sus propios delegados durante la ejecución del código (y almacenarlos en caché después de la inicialización, ya que es un proceso bastante lento, es decir, reflexión y demás). Recomiendo abusar de delegados y expresiones cuando sea posible.

Tener cuidado Łukasz