Примеры использования Generics в .Net (C # / VB.NET) [закрыто]

The most common reasons and use cases for generics are described in the MSDN documentation mentioned before. One benefit of generics I'd like to add is that they can enhance the tool support in the development process. Refactoring tools like those integrated in Visual Studio or ReSharper rely on static type analysis for providing assistance while coding. As generics usually add more type information to your object model, there is more information for such tools to analyse and to help you coding.

On a conceptual level, generics help you solving "cross-cutting" concerns independently from your application domain. Regardless whether you are developing a financial application or a book store, you will sooner or later need to maintain collections of things, be it accounts, books or whatever. The implementation of such collections usually needs to know little to nothing about the things to be maintained in those collections. Hence, the generic collections shipped with the .NET framework are a primary example for a generics use case.

Просто, Вы объявляете, что тип или метод с дополнительными тегами указывают на универсальные биты:

class Foo<T> {
    public Foo(T value) {
        Value = value;
    }
    public T Value {get;private set;}
}

Вышеупомянутое определяет универсальный тип Foo " T", где T обеспечивается вызывающей стороной. Условно, общие аргументы типа запускаются с T. Если существует только один, T прекрасен - иначе называют их всех полезно: TSource, TValue, TListType и т.д.

В отличие от шаблонов C++, дженерики.NET обеспечиваются временем выполнения (не приемы компилятора). Например:

Foo<int> foo = new Foo<int>(27);

Все Ts были заменены int в вышеупомянутом. При необходимости можно ограничить универсальные споры с ограничениями:

class Foo<T> where T : struct {}

Теперь Foo<string> откажется компилировать - как string не структура (тип значения). Допустимые ограничения:

T : class // reference-type (class/interface/delegate)
T : struct // value-type except Nullable<T>
T : new() // has a public parameterless constructor
T : SomeClass // is SomeClass or inherited from SomeClass
T : ISomeInterface // implements ISomeInterface

Ограничения могут также включить другие общие аргументы типа, например:

T : IComparable<T> // or another type argument

У Вас может быть столько универсальных аргументов, сколько Вам нужно:

public struct KeyValuePair<TKey,TValue> {...}

Другие вещи отметить:

• статические участники и т.д. определяются на универсальную комбинацию типа - так статическое поле на Foo<int> является отдельным к этому на Foo<float>.
• методы могут быть общими также - стараются не использовать те же имена, как класс использует, поскольку Вы не сможете снять неоднозначность
• вложенные типы наследовали универсальные типы от своих родителей

например:

class Foo<T> {
    class Bar<TInner> {} // is effectively Bar<T,TInner>, for the outer T
}

Пример 1: Вы хотите создать тройной класс

Class Triple<T1, T2, T3>
{
   T1 _first;
   T2 _second;
   T3 _Third;
}

Пример 2: класс помощника, который проанализирует любое перечисление значений для типа определенных данных

static public class EnumHelper<T>
{
   static public T Parse(string value)
   {
       return (T)Enum.Parse(typeof(T), value);
   }
}

Один из распространенных и чрезвычайно полезных способов использования обобщений - это строго типизированные классы коллекций. Традиционно всем классам коллекции нужно было передавать объекты и возвращать объекты при запросе. Вам приходилось самостоятельно обрабатывать все преобразования типов. С дженериками этого делать не нужно. У вас может быть List (Of Integer), и когда вы запрашиваете из него значения, вы получаете целые числа. Вы не получите объекты, которые затем нужно будет преобразовать в целые числа.

    private void button1_Click_1(object sender, RoutedEventArgs e)
    {
        TextValue<string, int> foo = new TextValue<string, int>("",0);
        foo.Text = "Hi there";
        foo.Value = 3995;
        MessageBox.Show(foo.Text);
    }

    class TextValue<TText, TValue>
    {
        public TextValue(TText text, TValue value)
        {
            Text = text;
            Value = value;
        }
        public TText Text { get; set; }
        public TValue Value { get; set; }
    }

    private void button1_Click_1(object sender, RoutedEventArgs e)
    {
        TextValue<string, int> foo;
        List<TextValue<string, int>> listTextValue = new List<TextValue<string, int>>();
        for (int k = 0; k < 5; ++k)
        {
            foo = new TextValue<string, int>("",0);
            foo.Text = k.ToString();
            foo.Value = k;
            listTextValue.Add(foo);
            otherList.
            MessageBox.Show(foo.Text);
        }

    }

    class TextValue<TText, TValue>
    {
        public TextValue(TText text, TValue value){Text = text; Value = value;}
        public TText Text { get; set; }
        public TValue Value { get; set; }
    }