Условная типизация в универсальном методе - PullRequest
11 голосов
/ 16 февраля 2010

Рассмотрим следующий (сильно упрощенный) код:

public T Function<T>() {
    if (typeof(T) == typeof(string)) {
        return (T) (object) "hello";
    }
    ...
}

Это абсурдно - сначала привести к object, а затем к T. Но компилятор не может знать, что предыдущий тест гарантировал, что T имеет тип string.

Какой самый элегантный идиоматичный способ достижения этого поведения в C # (который включает в себя избавление от глупого typeof(T) == typeof(string), поскольку T is string не может использоваться)?


Приложение: В .net нет дисперсии возвращаемого типа, поэтому вы не можете сделать перегрузку функции для ввода строки (что, кстати, является лишь примером, но одной из причин, почему ассоциация конец переопределения в полиморфизме, например, UML, не может быть сделано в c #). Очевидно, было бы замечательно следующее, но это не работает:

public T Function<T>() {
    ...
}

public string Function<string>() {
    return "hello";
}

Конкретный пример 1: Поскольку было несколько атак на тот факт, что универсальная функция, которая проверяет определенные типы, не является универсальной, я попытаюсь привести более полный пример. Рассмотрим шаблон дизайна Type-Square. Вот следующий фрагмент:

public class Entity {
  Dictionary<PropertyType, object> properties;

  public T GetTypedProperty<T>(PropertyType p) {
    var val = properties[p];

    if (typeof(T) == typeof(string) {
      (T) (object) p.ToString(this);  // magic going here
    }

    return (T) TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(val);
  }
}

Конкретный пример 2: Рассмотрим шаблон проектирования интерпретатора:

public class Expression {
  public virtual object Execute() { }
}

public class StringExpression: Expression {
  public override string Execute() { }    // Error! Type variance not allowed...
}

Теперь давайте используем дженерики в Execute, чтобы позволить вызывающей стороне принудительно возвращать тип:

public class Expression {
  public virtual T Execute<T>() { 
    if(typeof(T) == typeof(string)) {  // what happens when I want a string result from a non-string expression?
       return (T) (object) do_some_magic_and_return_a_string();
    } else if(typeof(T) == typeof(bool)) { // what about bools? any number != 0 should be True. Non-empty lists should be True. Not null should be True
       return (T) (object) do_some_magic_and_return_a_bool();
    }
  }
}

public class StringExpression: Expressiong {
  public override T Execute<T>() where T: string {   
    return (T) string_result;
  }
}

Ответы [ 5 ]

6 голосов
/ 16 февраля 2010

Если вы делаете эти типы проверок в общем методе, я бы переосмыслил ваш дизайн. Этот метод явно не является универсальным - если бы это было так, вам бы не потребовалась специальная проверка типов ...

Ситуации, подобные этой, как правило, могут быть обработаны более аккуратно путем редизайна. Одна альтернатива часто заключается в предоставлении перегрузки соответствующего типа. Существуют и другие варианты дизайна, которые избегают поведения, специфичного для типа, например, предложение Ричарда Берга передать делегата .

3 голосов
/ 16 февраля 2010
using System;
using System.Collections.Generic;
using System.Linq;

namespace SimpleExamples
{
    /// <summary>
    /// Compiled but not run.  Copypasta at your own risk!
    /// </summary>
    public class Tester
    {
        public static void Main(string[] args)
        {
            // Contrived example #1: pushing type-specific functionality up the call stack
            var strResult = Example1.Calculate<string>("hello", s => "Could not calculate " + s);
            var intResult = Example1.Calculate<int>(1234, i => -1);

            // Contrived example #2: overriding default behavior with an alternative that's optimized for a certain type
            var list1 = new List<int> { 1, 2, 3 };
            var list2 = new int[] { 4, 5, 6 };
            Example2<int>.DoSomething(list1, list2);

            var list1H = new HashSet<int> { 1, 2, 3 };
            Example2<int>.DoSomething<HashSet<int>>(list1H, list2, (l1, l2) => l1.UnionWith(l2));
        }
    }

    public static class Example1
    {
        public static TParam Calculate<TParam>(TParam param, Func<TParam, TParam> errorMessage)            
        {
            bool success;
            var result = CalculateInternal<TParam>(param, out success);
            if (success)
                return result;
            else
                return errorMessage(param);
        }

        private static TParam CalculateInternal<TParam>(TParam param, out bool success)
        {
            throw new NotImplementedException();
        }
    }

    public static class Example2<T>
    {
        public static void DoSomething(ICollection<T> list1, IEnumerable<T> list2)
        {
            Action<ICollection<T>, IEnumerable<T>> genericUnion = (l1, l2) =>
            {
                foreach (var item in l2)
                {
                    l1.Add(item);
                }
                l1 = l1.Distinct().ToList();
            };
            DoSomething<ICollection<T>>(list1, list2, genericUnion);
        }

        public static void DoSomething<TList>(TList list1, IEnumerable<T> list2, Action<TList, IEnumerable<T>> specializedUnion)
            where TList : ICollection<T>
        {
            /* stuff happens */

            specializedUnion(list1, list2);

            /* other stuff happens */            
        }
    }
}

/// I confess I don't completely understand what your code was trying to do, here's my best shot
namespace TypeSquarePattern
{
    public enum Property
    {
        A,
        B,
        C,
    }

    public class Entity
    {
        Dictionary<Property, object> properties;
        Dictionary<Property, Type> propertyTypes;

        public T GetTypedProperty<T>(Property p) 
        {
            var val = properties[p];
            var type = propertyTypes[p];

            // invoke the cast operator [including user defined casts] between whatever val was stored as, and the appropriate type as 
            // determined by the domain model [represented here as a simple Dictionary; actual implementation is probably more complex]
            val = Convert.ChangeType(val, type);  

            // now create a strongly-typed object that matches what the caller wanted
            return (T)val;
        }
    }
}

/// Solving this one is a straightforward application of the deferred-execution patterns I demonstrated earlier
namespace InterpreterPattern
{
    public class Expression<TResult>
    {
        protected TResult _value;             
        private Func<TResult, bool> _tester;
        private TResult _fallback;

        protected Expression(Func<TResult, bool> tester, TResult fallback)
        {
            _tester = tester;
            _fallback = fallback;
        }

        public TResult Execute()
        {
            if (_tester(_value))
                return _value;
            else
                return _fallback;
        }
    }

    public class StringExpression : Expression<string>
    {
        public StringExpression()
            : base(s => string.IsNullOrEmpty(s), "something else")
        { }
    }

    public class Tuple3Expression<T> : Expression<IList<T>>
    {
        public Tuple3Expression()
            : base(t => t != null && t.Count == 3, new List<T> { default(T), default(T), default(T) })
        { }
    }
}
1 голос
/ 16 февраля 2010

Я не могу придумать «элегантный» способ сделать это. Как вы говорите, компилятор не может знать, что условный тип гарантирует, что тип T равен string. В результате следует предположить, что, поскольку нет обобщенного способа преобразования из string в T, это ошибка. object до T может успешно, так что компилятор позволяет это.

Я не уверен, что хочу изящный способ выразить это. Хотя я вижу, где в некоторых ситуациях необходимо проводить явные проверки типа, я думаю, я бы хотел, чтобы это было громоздко, потому что это на самом деле немного хак. И я бы хотел, чтобы это выглядело так: «Эй! Я делаю здесь что-то странное!»

1 голос
/ 16 февраля 2010

Можете ли вы использовать as здесь?

T s = "hello" as T;
if(s != null)
    return s;
0 голосов
/ 16 февраля 2010

Хорошо, я пробежался по нему с нескольких разных точек зрения и потерпел неудачу.Я должен был бы заключить, что если ваша текущая реализация выполняет свою работу, вы должны взять победу и двигаться дальше.Если не считать некоторых тайных выбросов, то, что вы получили, это то, что вы получите.

Но компилятор не может знать, что предыдущий тест гарантировал, что T имеет тип string.

Умм .... Если я не ошибаюсь, дженерики - это просто код gen.Компилятор генерирует соответствующий метод для каждого отдельного типа, найденного в вызывающих методах.Таким образом, компилятор знает аргумент типа для вызываемой перегрузки.Снова;Если я не ошибаюсь.

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

только мои 2 песо ...

...