индексируемый оператор переключения, или эквивалентный? .NET, C#

Есть несколько вариантов, которые вы можете попробовать.

Вариант 1. Сделайте так, чтобы объект сохранял значения свойств динамически.

public GetMemberByName(MyObject myobj, string name)  
{  
  return myobj.GetProperty(name);
}

public class MyObject
{
    private Dictionary<string, object> m_Properties = new Dictionary<string, object>();

    public object GetProperty(string name)
    {
        return m_Properties[name];
    }

    public void SetProperty(string name, object value)
    {
        m_Properties[name] = value;
    }

    public object Prop1
    {
        get { return GetProperty("PropOne"); }
        set { SetProperty("PropOne", value); }
    }

    public object Prop2
    {
        get { return GetProperty("PropTwo"); }
        set { SetProperty("PropTwo", value); }
    }
}

Вариант 2: Используйте отражение.

public GetMemberByName(MyObject myobj, string name)  
{  
    return typeof(MyObject).GetProperty(name).GetValue(obj, null);
}

Вариант 3: Оставить как есть.

Это разумный вариант, поскольку операторы switch для строковых типов данных будут преобразованы в поиск Dictionary , как только операторы числового регистра достигнут определенного порога. Для компилятора C # 3.0 этот порог равен 7. Таким образом, поиск будет O (1) независимо от количества операторов case. Он не будет сканировать каждый из них.

Вот быстрый макет того, что может работать для любого класса (с использованием отражения, а не оператора переключения):

public static object GetMemberByName<T>(T obj, string name)
{
    PropertyInfo prop = typeof(T).GetProperty(name);
    if(prop != null)
        return prop.GetValue(obj, null);

    throw new ArgumentException("Named property doesn't exist.");
}

Или версия метода расширения (который по-прежнему будет работать с любым типом объекта) :

public static object GetMemberByName<T>(this T obj, string name)
{
    PropertyInfo prop = typeof(T).GetProperty(name);
    if(prop != null)
        return prop.GetValue(obj, null);

    throw new ArgumentException("Named property doesn't exist.");
}

Очевидно, вы могли бы захотеть провести дополнительную проверку ошибок, но это было бы началом.

Я также не зря возвратил объект типа из методов. Это позволяет вызывающей стороне обрабатывать приведение значения, как они считают нужным (если им вообще нужно приведение).

Вы можете использовать отражение для динамического получения свойства во время выполнения. Вот отрывок из небольшой утилиты отражения, которую я написал. Это написано как метод расширения, который легко позволит вам получить свойство из экземпляра вашего класса

myInstance.GetProperty<string>("Title"); // Replace 'string' with the proper return value.

Код:

public static class ReflectionExtensions
{
    private const BindingFlags DefaultFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;

    public static T GetProperty<T>(this object instance, string propertyName)
    {
        PropertyInfo property = GetPropertyInfo(instance, propertyName);
        if (property == null)
        {
            var message = string.Format("The Type, '{0}' does not implement a '{1}' property", instance.GetType().AssemblyQualifiedName, propertyName);
            throw new NotImplementedException(message);
        }

        return (T)property.GetValue(instance, null);
    }

    private static PropertyInfo GetPropertyInfo(object instance, string propertyName)
    {
        Type type = instance.GetType();
        return type.GetProperty(propertyName, DefaultFlags);
    }
}

Ну, если предположить, что Name соответствует реальному имени свойства (в отличие от вашего примера), это, вероятно, лучше всего будет обработать через отражение.

Вы не можете сделать это с помощью индекса, но вы можете использовать отражение.

Вы можете попробовать использовать что-то вроде этого.

private static readonly Dictionary<Type, Dictionary<string, PropertyInfo>> _cache = new Dictionary<Type,Dictionary<string,PropertyInfo>>();
public static T GetProperty<T>(object obj, string name)
{
    if (obj == null)
    {
        throw new ArgumentNullException("obj");
    }
    else if (name == null)
    {
        throw new ArgumentNullException("name");
    }

    lock (_cache)
    {
        var type = obj.GetType();
        var props = default(Dictionary<string, PropertyInfo>);
        if (!_cache.TryGetValue(type, out props))
        {
            props = new Dictionary<string, PropertyInfo>();
            _cache.Add(type, props);
        }
        var prop = default(PropertyInfo);
        if (!props.TryGetValue(name, out prop))
        {
            prop = type.GetProperty(name);
            if (prop == null)
            {
                throw new MissingMemberException(name);
            }
            props.Add(name, prop);
        }
        return (T)prop.GetValue(obj, null);
    }
}