добавить в список типичных участников Action <T> - PullRequest
Новая
       32

добавить в список типичных участников Action <T>

12 голосов
/ 23 июля 2010

Можно ли добавить универсальный делегат Action в коллекцию List? Мне нужна какая-то простая система обмена сообщениями для приложения Silverlight.

UPDATE Вот что я действительно хочу 

class SomeClass<T>
{
    public T Data { get; set; }
    // and more ....
}

class App
{
    List<Action<SomeClass<T>>> _actions = new List<Action<SomeClass<T>>>();

    void Add<T>( Action<SomeClass<T>> foo )
    {
        _actions.Add( foo );
    }
}

Компилятор: 

The type or namespace name 'T' could not be found (are you missing a using directive or an assembly reference?)

исходный код снят класс SomeClassBase {} 

class SomeClass<T> : SomeClassBase
{
    public T Data { get; set; }
    // and more ....
}

class App
{
    List<Action<SomeClassBase>> _actions = new List<Action<SomeClassBase>>();

    void Add<T>( Action<SomeClass<T>> foo )
        where T : SomeClassBase
    {
        _actions.Add( foo );
    }
}

Компилятор жалуется - для строки _actions.Add (); 

Argument 1: cannot convert from 'System.Action<test.SomeClass<T>>' to 'System.Action<test.SomeClassBase>'
The best overloaded method match for 'System.Collections.Generic.List<System.Action<test.SomeClassBase>>.Add(System.Action<test.SomeClassBase>)' has some invalid arguments

Со стороны приложения нет необходимости в классе SomeClassBase, однако кажется невозможным определить список из Action<SomeClass<T>> элементов, и подход с базовым классом работает при использовании класса в списке вместо Action

Спасибо, Йохен

Ответы [ 6 ]

17 голосов
/ 23 июля 2010

РЕДАКТИРОВАТЬ: Хорошо, теперь я вижу, что вы пытаетесь сделать. Я оставил старый ответ ниже для потомков:)

К сожалению, вы не можете выразить желаемую взаимосвязь в дженериках C #, но так как вы можете быть уверены, что вы единственный, кто манипулирует коллекцией, вы можете сохранить ее самостоятельно:

Попробуйте это: 

class App
{
     private readonly Dictionary<Type, object> delegateMap;

     void Add<T>(Action<SomeClass<T>> foo)
     {
         object tmp;
         if (!delegateMap.TryGetValue(typeof(T), out tmp))
         {
              tmp = new List<Action<SomeClass<T>>>();
              delegateMap[typeof(t)] = tmp;
         }
         List<Action<SomeClass<T>> list = (List<Action<SomeClass<T>>) tmp;
         list.Add(foo);
     }

     void InvokeActions<T>(SomeClass<T> item)
     {
         object tmp;
         if (delegateMap.TryGetValue(typeof(T), out tmp))
         {
             List<Action<SomeClass<T>> list = (List<Action<SomeClass<T>>) tmp;
             foreach (var action in list)
             {
                 action(item);
             }
         }
     }
}

Обратите внимание, что вы могли бы использовать тот факт, что делегаты являются многоадресными, чтобы просто сохранить Dictionary<Type, Delegate> и объединить их вместе, но я оставлю это в качестве упражнения для читателя:

Старый ответ

Это не удачно по уважительной причине. Давайте избавимся от дженериков (поскольку они здесь неактуальны) и подумаем о более простом случае - фруктах и ​​бананах.

Вы пытаетесь добавить Action<Banana> к List<Action<Fruit>>. Вы не можете сделать это - даже с общей дисперсией C # 4. Почему? Потому что это не безопасно. Учтите это: 

Action<Banana> peeler = banana => banana.Peel();
List<Action<Fruit>> fruitActions = new List<Action<Fruit>>();
fruitActions.Add(peeler); // Nope!
fruitActions[0].Invoke(new Strawberry());

Ик! Теперь у нас есть банановый нож, который пытается очистить клубнику ... какой беспорядок!

Не то, чтобы другие обходные пути были бы приемлемы в C # 4: 

Action<Fruit> eater = fruit => fruit.Eat();
List<Action<Banana>> bananaActions = new List<Action<Banana>>();
fruitActions.Add(eater); // Yes!
fruitActions[0].Invoke(new Banana());

Здесь мы добавляем Action<Fruit> к List<Action<Banana>> - это приемлемо, потому что все, что вы можете сделать с Action<Banana>, также действует для Action<Fruit>.

3 голосов
/ 23 июля 2010

Будет ли это делать то, что вы хотите? 

void Add<T>(Action<SomeClass<T>> foo)
    where T : SomeClassBase
{
    _actions.Add(x => foo((SomeClass<T>) x));
}
1 голос
/ 14 апреля 2011 
using System;
using System.Collections.Generic;

public delegate void MyDelegate<T>( T i );

public class DelegateList<T>
{
    public void Add( MyDelegate<T> del ) {
        imp.Add( del );
    }

    public void CallDelegates( T k ) {
        foreach( MyDelegate<T> del in imp ) {
            del( k );
        }
    }

    private List<MyDelegate<T> > imp = new List<MyDelegate<T> >();
}

public class MainClass
{
    static void Main() {
        DelegateList<int> delegates = new DelegateList<int>();

        delegates.Add( PrintInt );
        delegates.CallDelegates( 42 );
    }

    static void PrintInt( int i ) {
        Console.WriteLine( i );
    }
}
1 голос
/ 23 июля 2010

Не уверен, что это то, что вы хотите. Но попробуйте изменить метод Add для: 

void Add( Action<SomeClassBase> foo )
{
   _actions.Add( foo );
}

Обновление

Это позволит вам сделать что-то вроде этого: 

App app = new App();

Action<SomeClass<int>> action = null; // Initilize it...

app.Add((Action<SomeClassBase>)action);
0 голосов
/ 14 декабря 2012

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

 public static class Extensions
    {
        public static void Action<T>(this IEnumerable<T> list, Action<T> action)
        {
            foreach (T element in list) 
            {
                action.Invoke(element);
            }
        }
    }

Пример вызова с myList типа IEnumerable<string>: 

 myList.Action(element => Console.WriteLine(element));

Возможно, LINQ уже реализует действие в списке, но если это так, я не знаю синтаксис.

0 голосов
/ 23 июля 2010

Если вы посмотрите на строку 

List<Action<SomeClass<T>>> _actions = new List<Action<SomeClass<T>>>();

Класс T, на который вы ссылаетесь, нигде не был объявлен. В SomeClass у вас есть правильное объявление для универсального класса, но в вашем классе App вы не сказали ему, что такое T в данном конкретном случае.

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

Я думаю, что для работы нужно использовать более определенные определения классов, но, как объяснил Джон Скит, это тоже не работает.

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

[0] Дженерики по-разному работают на разных языках, но я думаю, что это хороший грубый принцип для работы ...

...