Delegados a operaciones genéricas donde el tipo genérico es desconocido. ¿Cómo crear algo así?
Supongamos que tengo el siguiente código.
static class Store<T> {
public static T A;
public static T B;
public static T C;
}
public static class Store {
public static Value A = new Value(<T>(v) => Store<T>.A = v); //just an example of what I want
public static Value B = new Value(<T>(v) => Store<T>.B = v); //just an example of what I want
public static Value C = new Value(SetC<T>); //just an example of what I want
public static void SetA<T>(T value) { Store<T>.A = value; }
public static void SetB<T>(T value) { Store<T>.B = value; }
public static void SetC<T>(T value) { Store<T>.C = value; }
}
public class Value {
Action<T><T> _valueChanger; //just an example of what I want
public Value(Action<T><T> valueChanger) { //just an example of what I want
_valueChanger = valueChanger;
}
public void SetValue<T> (T value) {
_valueChanger<T>(value); //just an example of what I want
}
}
Quiero escribirStore.A.SetValue(42)
para que el valor se guarde enStore<int>.A
. ¿Qué puedo escribir en lugar de las líneas marcadas con "solo un ejemplo de lo que quiero" para que eso suceda? (Quiero explorar una solución que no implique diccionarios o algo similar)
Replanteando la pregunta: Quiero modificar la claseValue
(defina algunos campos, escriba un constructor y escriba el método Value.SetValue (valor T)), luego construya tres variables diferentes de tipo Valor (A, B, C) de tal manera que cuando llameStore.A.SetValue(42)
el valorStore<int>.A
se cambia a 42.
Otra variación de las clases:
static class Holder<T> {
T Value { get; set; }
}
static class Store2<T> {
public static Holder<T> A = new Holder<T>();
public static Holder<T> B = new Holder<T>();
public static Holder<T> C = new Holder<T>();
}
public static class Store2 {
public static Value A = new Value2(Store2<>.A); //just an example of what I want
public static Value B = new Value2(Store2<>.B); //passing non-specific generic expression
public static Value C = new Value3({TFree}() => Store2<TFree>.C); //just an example of what I want
}
public class Value2 { //Non-generic class!
Holder{TFree}<TFree> _holder; //just an example of what I want
public Value(Holder{TFree}<TFree> holder) { //just an example of what I want
_holder = holder;
}
public void SetValue<T> (T value) {
_holder{T}.Value = value; //just an example of what I want
}
}
public class Value3 { //Non-generic class! (Another variation)
Func{TFree}<Holder<TFree>> _holderFactory; //just an example of what I want
public Value(Func{TFree}<Holder<TFree>> holderFactory) { //just an example of what I want
_holderFactory = holderFactory;
}
public void SetValue<T> (T value) {
Holder<T> holder = _holderFactory{T}(); //just an example of what I want
holder.Value = value;
}
}
Solución: Se encontró una solución fácil de reflexión libre y de colección utilizando las respuestas a otra pregunta (Emulación de delegados con parámetros de tipo genérico libres en C # yEmulación de delegados con parámetros de tipo genérico libres en C #). La solucion esDelegados a operaciones genéricas donde el tipo genérico es desconocido. ¿Cómo crear algo así?.