//c#
class MyGeneric<T>
{
 T data[100];
}
//c++
template<int N>
int get(int x)
{
    return N*x;
}

MyGeneric!<int> foo;
int a = get!<10>(20);

int a = get!< ((9>8)<<2)  >(20);

class MyGeneric&My_first_very_readable_symbol_1;T&My_second_very_readable_symbol2;

7.6.4.2 Grammar ambiguities
The productions for simple-name (§7.6.2) and member-access (§7.6.4) can give rise to ambiguities in the grammar for expressions. For example, the statement:

F(G<A,B>(7));

could be interpreted as a call to F with two arguments, G < A and B > (7). Alternatively, it could be interpreted as a call to F with one argument, which is a call to a generic method G with two type arguments and one regular argument.
If a sequence of tokens can be parsed (in context) as a simple-name (§7.6.2), member-access (§7.6.4), or pointer-member-access (§18.5.2) ending with a type-argument-list (§4.4.1), the token immediately following the closing > token is examined. If it is one of

(  )  ]  }  :  ;  ,  .  ?  ==  !=  |  ^

then the type-argument-list is retained as part of the simple-name, member-access or pointer-member-access and any other possible parse of the sequence of tokens is discarded. Otherwise, the type-argument-list is not considered to be part of the simple-name, member-access or pointer-member-access, even if there is no other possible parse of the sequence of tokens. Note that these rules are not applied when parsing a type-argument-list in a namespace-or-type-name (§3.8). The statement

F(G<A,B>(7));

will, according to this rule, be interpreted as a call to F with one argument, which is a call to a generic method G with two type arguments and one regular argument. The statements

F(G < A, B > 7);
F(G < A, B >> 7);

will each be interpreted as a call to F with two arguments. The statement

x = F < A > +y;

will be interpreted as a less than operator, greater than operator, and unary plus operator, as if the statement had been written x = (F < A) > (+y), instead of as a simple-name with a type-argument-list followed by a binary plus operator. In the statement

x = y is C<T> + z;

the tokens C<T> are interpreted as a namespace-or-type-name with a type-argument-list.

T Square(T)(T t) {
  return t * t;
}

// объявление
public T GetValue<T>(string key)
{
  ...
}
// вызов
int x = GetValue<int>("x");

// объявление
public T GetValue(Type T, string key)
{
  ...
}
// вызов
int x = GetValue(int, "x");

// объявление
public class MyClass<T, K>
{
  ...
}
// создание
MyClass<int, string> c = new MyClass<int, string>();

// объявление
public class MyClass(Type T, Type K)
{
  ...
}
// создание
MyClass(int, string) y = new MyClass(int, string);

S>>// объявление
S>>public T GetValue(Type T, string key)
S>>{
S>>}
S>>// вызов
S>>int x = GetValue(int, "x");
S>>

// что-то близкое к С++, здесь угловые скобки терпимы,
// но в целом в С++ они не приятны
int some_func(int arg, MyType<int, string> data)

// через квадратные скобки - в большинстве случаев они приятнее,
// правда здесь не очень показательно
int some_func(int arg, MyType[int, string] data)

// через круглые - имеем вложенные скобки на пустом месте
// в объявлении функции, возможны гараздо хуже ситуации,
// когда подряд будут )))...
int some_func(int arg, MyType(int, string) data)

//вот вообще без скобок в около-сишном Go
func some_func(arg int, data chan int) res int