1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
public interface INode<T>
{
void Hello (T t);
}
public class Stack<T>
{
public T TheData;
public readonly Foo<T> TheFoo;
public Stack (T t)
{
this.TheData = t;
this.TheFoo = new Foo<T> (t);
}
public INode<T> GetNode ()
{
return new Node (this);
}
public Foo<T> GetFoo (T t)
{
return new Foo<T> (t);
}
public Bar<T> GetBar (T t)
{
return new Bar<T> (t);
}
protected class Node : INode<T>
{
public readonly Stack<T> Stack;
public Node (Stack<T> stack)
{
this.Stack = stack;
}
public void Hello (T t)
{
}
}
public class Foo<T>
{
public readonly T Data;
public Bar<T> GetBar ()
{
return new Bar<T> (Data);
}
public Foo (T t)
{
this.Data = t;
}
}
public class Bar<U>
{
public readonly U Data;
public Bar (U u)
{
this.Data = u;
}
public Foo<T> GetFoo (Stack<T> stack)
{
return stack.TheFoo;
}
public class Baz<V>
{
public readonly V Data;
public Foo<T> GetFoo (Stack<T> stack)
{
return new Foo<T> (stack.TheData);
}
public Bar<V> GetBar ()
{
return new Bar<V> (Data);
}
public Baz (V v)
{
this.Data = v;
}
}
}
public void Test ()
{
Stack<T>.Foo<T> foo1 = GetFoo (TheData);
Foo<T> foo2 = GetFoo (TheData);
Stack<long>.Foo<T> foo3 = new Stack<long>.Foo<T> (TheData);
Stack<long>.Foo<float> foo4 = new Stack<long>.Foo<float> (3.14F);
Foo<double> foo5 = new Foo<double> (3.14);
}
}
class A<U>
{
public class Test<T>
{
public static Nested<T> Foo ()
{
return null;
}
public class Nested<X>
{
}
}
}
class X
{
public static int Main ()
{
Stack<int> stack = new Stack<int> (1);
INode<int> node = stack.GetNode ();
Stack<int>.Foo<int> foo = stack.GetFoo (7);
Stack<int>.Bar<int> bar = stack.GetBar (8);
A<bool>.Test<string>.Nested<string> v = A<bool>.Test<string>.Foo ();
return 0;
}
}
|
