pimhwang
/
ILSpy
mirror of https://github.com/icsharpcode/ILSpy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

fix: multi-dimensional arrays sometimes working 

fix: use of tabs in samples C# file

TODO: multi-dimensional arrays not always with overloaded methods - is there a bug in the navigateTo implementation?
pull/697/head
yoyobbi 9 years ago
parent
807143052b
commit
e3a3a7ec33
2 changed files with 407 additions and 416 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 34
      ILSpy.AddIn/CodeElementXmlDocKeyProvider.cs
  2. 789
      ILSpy.AddIn/Samples/ILSpyAddInSamples.cs

34
ILSpy.AddIn/CodeElementXmlDocKeyProvider.cs
Unescape View File

@ -109,7 +109,6 @@ namespace ICSharpCode.ILSpy.AddIn
b.Append(')'); b.Append(')');
} }
if (explicitReturnType != null) { if (explicitReturnType != null) {
// TODO: test explicit return types
b.Append('~'); b.Append('~');
AppendTypeName(b, explicitReturnType.AsFullName, true, false); AppendTypeName(b, explicitReturnType.AsFullName, true, false);
} }
@ -177,12 +176,11 @@ namespace ICSharpCode.ILSpy.AddIn
{ {
EnvDTE80.CodeTypeRef2 parameterTypeRef = (EnvDTE80.CodeTypeRef2)parameter.Type; EnvDTE80.CodeTypeRef2 parameterTypeRef = (EnvDTE80.CodeTypeRef2)parameter.Type;
string parameterTypeString = parameterTypeRef.AsFullName; string parameterTypeString = parameterTypeRef.AsFullName;
if (parameterTypeRef.TypeKind == EnvDTE.vsCMTypeRef.vsCMTypeRefArray) {
parameterTypeString = parameterTypeRef.ElementType.AsFullName;
}
int substringStart = 0; int substringStart = 0;
for (int i = 0; i < parameterTypeString.Length; ++i) { for (int i = 0; i < parameterTypeString.Length; ++i) {
switch (parameterTypeString[i]) { char ch = parameterTypeString[i];
switch (ch) {
case '<': case '<':
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters); AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters);
substringStart = i + 1; substringStart = i + 1;
@ -193,42 +191,30 @@ namespace ICSharpCode.ILSpy.AddIn
substringStart = i + 1; substringStart = i + 1;
b.Append('}'); b.Append('}');
break; break;
case '[':
case ']':
case ',': case ',':
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters); AppendParameterTypeSubstring(b, parameterTypeString, substringStart, i, genericTypeParameters, genericMethodParameters);
substringStart = i + 1; substringStart = i + 1;
// Skip space after comma if present. // Skip space after comma if present.
if (parameterTypeString[substringStart] == ' ') { if ((substringStart < parameterTypeString.Length) && (parameterTypeString[substringStart] == ' ')) {
++substringStart; ++substringStart;
} }
b.Append(','); b.Append(ch);
break; break;
} }
} }
AppendParameterTypeSubstring(b, parameterTypeString, substringStart, parameterTypeString.Length, genericTypeParameters, genericMethodParameters); AppendParameterTypeSubstring(b, parameterTypeString, substringStart, parameterTypeString.Length, genericTypeParameters, genericMethodParameters);
if (parameterTypeRef.TypeKind == EnvDTE.vsCMTypeRef.vsCMTypeRefArray) {
b.Append('[');
for (int i = 0; i < parameterTypeRef.Rank; i++) {
if (i > 0)
b.Append(',');
// TODO: how to get array bounds from EnvDTE code model?
//ArrayDimension ad = arrayType.Dimensions[i];
//if (ad.IsSized) {
// b.Append(ad.LowerBound);
// b.Append(':');
// b.Append(ad.UpperBound);
//}
}
b.Append(']');
}
// Append ref / out indicator if needed. // Append ref / out indicator if needed.
// Note there is no need to append a '*' for pointers, as this is included in the full name of the type.
if ((parameter.ParameterKind == EnvDTE80.vsCMParameterKind.vsCMParameterKindRef) || if ((parameter.ParameterKind == EnvDTE80.vsCMParameterKind.vsCMParameterKindRef) ||
(parameter.ParameterKind == EnvDTE80.vsCMParameterKind.vsCMParameterKindOut)) { (parameter.ParameterKind == EnvDTE80.vsCMParameterKind.vsCMParameterKindOut)) {
b.Append('@'); b.Append('@');
} }
// Note there is no need to append a '*' for pointers, as this is included in the full name of the type.
// Multi-dimensional and nested arrays are also captured in the full name of the type.
} }
private static void AppendParameterTypeSubstring(StringBuilder b, string parameterTypeString, int substringStart, int substringStop, string[] genericTypeParameters, string[] genericMethodParameters) private static void AppendParameterTypeSubstring(StringBuilder b, string parameterTypeString, int substringStart, int substringStop, string[] genericTypeParameters, string[] genericMethodParameters)

789
ILSpy.AddIn/Samples/ILSpyAddInSamples.cs
Unescape View File

@ -14,402 +14,407 @@ using System.Collections.Generic;
// N:ILSpy.AddIn.Tests // N:ILSpy.AddIn.Tests
namespace ILSpy.AddIn.Tests namespace ILSpy.AddIn.Tests
{ {
// T:ILSpy.AddIn.Tests.SomeClass // T:ILSpy.AddIn.Tests.SomeClass
public class SomeClass public class SomeClass
{ {
// E:ILSpy.AddIn.Tests.SomeClass.OnEvent // E:ILSpy.AddIn.Tests.SomeClass.OnEvent
public event Action OnEvent; public event Action OnEvent;
// F:ILSpy.AddIn.Tests.SomeClass.mField // F:ILSpy.AddIn.Tests.SomeClass.mField
private int mField; private int mField;
// P:ILSpy.AddIn.Tests.SomeClass.Property // P:ILSpy.AddIn.Tests.SomeClass.Property
private int Property private int Property
{ {
get get
{ {
return mField; return mField;
} }
set set
{ {
mField = value; mField = value;
} }
} }
// P:ILSpy.AddIn.Tests.SomeClass.Item(System.Int32,System.Int32) // P:ILSpy.AddIn.Tests.SomeClass.Item(System.Int32,System.Int32)
public int this[int x, int y] public int this[int x, int y]
{ {
get { return x + y + mField; } get { return x + y + mField; }
} }
// M:ILSpy.AddIn.Tests.SomeClass.#ctor // M:ILSpy.AddIn.Tests.SomeClass.#ctor
public SomeClass() public SomeClass()
{ {
mField = 0; mField = 0;
} }
// M:ILSpy.AddIn.Tests.SomeClass.#ctor(System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.#ctor(System.Int32)
public SomeClass(int x) public SomeClass(int x)
{ {
mField = x; mField = x;
} }
// M:ILSpy.AddIn.Tests.SomeClass.#ctor(System.Int32,System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.#ctor(System.Int32,System.Int32)
public SomeClass(int x, int y) public SomeClass(int x, int y)
{ {
mField = x + y; mField = x + y;
} }
// M:ILSpy.AddIn.Tests.SomeClass.Method // M:ILSpy.AddIn.Tests.SomeClass.Method
public int Method() public int Method()
{ {
return mField; return mField;
} }
// M:ILSpy.AddIn.Tests.SomeClass.MethodWithGenericParameter(System.IEquatable{System.String}) // M:ILSpy.AddIn.Tests.SomeClass.MethodWithGenericParameter(System.IEquatable{System.String})
public void MethodWithGenericParameter(IEquatable<string> x) public void MethodWithGenericParameter(IEquatable<string> x)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeClass.MethodWithGenericParameter(System.IEquatable{System.String},System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.MethodWithGenericParameter(System.IEquatable{System.String},System.Int32)
public void MethodWithGenericParameter(IEquatable<string> x, int y) public void MethodWithGenericParameter(IEquatable<string> x, int y)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeClass.GenericMethod``1(``0) // M:ILSpy.AddIn.Tests.SomeClass.GenericMethod``1(``0)
public int GenericMethod<T>(T x) public int GenericMethod<T>(T x)
{ {
return mField + x.GetHashCode(); return mField + x.GetHashCode();
} }
// M:ILSpy.AddIn.Tests.SomeClass.GenericOverloadedMethod``1(System.Int32,``0) // M:ILSpy.AddIn.Tests.SomeClass.GenericOverloadedMethod``1(System.Int32,``0)
public int GenericOverloadedMethod<T1>(int x, T1 y) public int GenericOverloadedMethod<T1>(int x, T1 y)
{ {
return mField + x + y.GetHashCode(); return mField + x + y.GetHashCode();
} }
// M:ILSpy.AddIn.Tests.SomeClass.GenericOverloadedMethod``2(System.Int32,``0,``1) // M:ILSpy.AddIn.Tests.SomeClass.GenericOverloadedMethod``2(System.Int32,``0,``1)
public int GenericOverloadedMethod<T1, T2>(int x, T1 y, T2 z) public int GenericOverloadedMethod<T1, T2>(int x, T1 y, T2 z)
{ {
return mField + x + y.GetHashCode() + z.GetHashCode(); return mField + x + y.GetHashCode() + z.GetHashCode();
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedMethod // M:ILSpy.AddIn.Tests.SomeClass.OverloadedMethod
public int OverloadedMethod() public int OverloadedMethod()
{ {
return mField * mField; return mField * mField;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedMethod(System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedMethod(System.Int32)
public int OverloadedMethod(int m) public int OverloadedMethod(int m)
{ {
return mField * m; return mField * m;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedMethod(System.Int32,System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedMethod(System.Int32,System.Int32)
public int OverloadedMethod(int m1, int m2) public int OverloadedMethod(int m1, int m2)
{ {
return mField * m1 * m2; return mField * m1 * m2;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1 // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1
public int OverloadedGenericMethod<T>() public int OverloadedGenericMethod<T>()
{ {
return mField * mField; return mField * mField;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32)
public int OverloadedGenericMethod<T>(int m) public int OverloadedGenericMethod<T>(int m)
{ {
return mField * m; return mField * m;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32)
public int OverloadedGenericMethod<T>(int m1, int m2) public int OverloadedGenericMethod<T>(int m1, int m2)
{ {
return mField * m1 * m2; return mField * m1 * m2;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32,System.Collections.IEnumerable) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32,System.Collections.IEnumerable)
public int OverloadedGenericMethod<T>(int m1, int m2, IEnumerable m3) public int OverloadedGenericMethod<T>(int m1, int m2, IEnumerable m3)
{ {
return mField * m1 * m2; return mField * m1 * m2;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32,System.Collections.Generic.IEnumerable{``0}) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32,System.Collections.Generic.IEnumerable{``0})
public int OverloadedGenericMethod<T>(int m1, int m2, IEnumerable<T> m3) public int OverloadedGenericMethod<T>(int m1, int m2, IEnumerable<T> m3)
{ {
return mField * m1 * m2; return mField * m1 * m2;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32,System.Collections.Generic.IEnumerable{System.String}) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Int32,System.Int32,System.Collections.Generic.IEnumerable{System.String})
public int OverloadedGenericMethod<T>(int m1, int m2, IEnumerable<string> m3) public int OverloadedGenericMethod<T>(int m1, int m2, IEnumerable<string> m3)
{ {
return mField * m1 * m2; return mField * m1 * m2;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Collections.Generic.IEnumerable{System.Collections.Generic.IEnumerable{ILSpy.AddIn.Tests.SomeGenericClass{System.String,``0}}}) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(System.Collections.Generic.IEnumerable{System.Collections.Generic.IEnumerable{ILSpy.AddIn.Tests.SomeGenericClass{System.String,``0}}})
public int OverloadedGenericMethod<T>(IEnumerable<IEnumerable<SomeGenericClass<string, T>>> m3) public int OverloadedGenericMethod<T>(IEnumerable<IEnumerable<SomeGenericClass<string, T>>> m3)
{ {
return mField; return mField;
} }
// M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(ILSpy.AddIn.Tests.SomeGenericClass{``0,ILSpy.AddIn.Tests.SomeGenericClass{``0,``0}}.NestedGeneric{System.String,``0}) // M:ILSpy.AddIn.Tests.SomeClass.OverloadedGenericMethod``1(ILSpy.AddIn.Tests.SomeGenericClass{``0,ILSpy.AddIn.Tests.SomeGenericClass{``0,``0}}.NestedGeneric{System.String,``0})
public void OverloadedGenericMethod<T>(SomeGenericClass<T, SomeGenericClass<T, T>>.NestedGeneric<string, T> wow) public void OverloadedGenericMethod<T>(SomeGenericClass<T, SomeGenericClass<T, T>>.NestedGeneric<string, T> wow)
{ {
} }
// T:ILSpy.AddIn.Tests.SomeClass.NestedEnum // T:ILSpy.AddIn.Tests.SomeClass.NestedEnum
public enum NestedEnum public enum NestedEnum
{ {
// F:ILSpy.AddIn.Tests.SomeClass.NestedEnum.First // F:ILSpy.AddIn.Tests.SomeClass.NestedEnum.First
First = 1, First = 1,
Second = 2, Second = 2,
Third = 3 Third = 3
} }
// T:ILSpy.AddIn.Tests.SomeClass.NestedInterface // T:ILSpy.AddIn.Tests.SomeClass.NestedInterface
public interface NestedInterface public interface NestedInterface
{ {
// P:ILSpy.AddIn.Tests.SomeClass.NestedInterface.SomeProperty // P:ILSpy.AddIn.Tests.SomeClass.NestedInterface.SomeProperty
int SomeProperty { get; } int SomeProperty { get; }
// M:ILSpy.AddIn.Tests.SomeClass.NestedInterface.SomeMethod // M:ILSpy.AddIn.Tests.SomeClass.NestedInterface.SomeMethod
int SomeMethod(); int SomeMethod();
} }
// T:ILSpy.AddIn.Tests.SomeClass.NestedClass // T:ILSpy.AddIn.Tests.SomeClass.NestedClass
public class NestedClass : NestedInterface public class NestedClass : NestedInterface
{ {
// F:ILSpy.AddIn.Tests.SomeClass.NestedClass.mX // F:ILSpy.AddIn.Tests.SomeClass.NestedClass.mX
private int mX; private int mX;
// M:ILSpy.AddIn.Tests.SomeClass.NestedClass.#ctor(System.Int32) // M:ILSpy.AddIn.Tests.SomeClass.NestedClass.#ctor(System.Int32)
public NestedClass(int x) public NestedClass(int x)
{ {
mX = x; mX = x;
} }
// M:ILSpy.AddIn.Tests.SomeClass.NestedClass.#ctor(ILSpy.AddIn.Tests.SomeClass.NestedEnum) // M:ILSpy.AddIn.Tests.SomeClass.NestedClass.#ctor(ILSpy.AddIn.Tests.SomeClass.NestedEnum)
public NestedClass(NestedEnum x) public NestedClass(NestedEnum x)
{ {
mX = (int)x; mX = (int)x;
} }
// P:ILSpy.AddIn.Tests.SomeClass.NestedClass.SomeProperty // P:ILSpy.AddIn.Tests.SomeClass.NestedClass.SomeProperty
public int SomeProperty public int SomeProperty
{ {
get { return mX; } get { return mX; }
} }
// M:ILSpy.AddIn.Tests.SomeClass.NestedClass.SomeMethod // M:ILSpy.AddIn.Tests.SomeClass.NestedClass.SomeMethod
public int SomeMethod() public int SomeMethod()
{ {
return mX * mX; return mX * mX;
} }
} }
// T:ILSpy.AddIn.Tests.SomeClass.NestedStruct // T:ILSpy.AddIn.Tests.SomeClass.NestedStruct
public struct NestedStruct : NestedInterface public struct NestedStruct : NestedInterface
{ {
// F:ILSpy.AddIn.Tests.SomeClass.NestedStruct.X // F:ILSpy.AddIn.Tests.SomeClass.NestedStruct.X
public int X; public int X;
// F:ILSpy.AddIn.Tests.SomeClass.NestedStruct.Y // F:ILSpy.AddIn.Tests.SomeClass.NestedStruct.Y
public int Y; public int Y;
// P:ILSpy.AddIn.Tests.SomeClass.NestedStruct.SomeProperty // P:ILSpy.AddIn.Tests.SomeClass.NestedStruct.SomeProperty
public int SomeProperty public int SomeProperty
{ {
get { return X + Y; } get { return X + Y; }
} }
// M:ILSpy.AddIn.Tests.SomeClass.NestedStruct.SomeMethod // M:ILSpy.AddIn.Tests.SomeClass.NestedStruct.SomeMethod
public int SomeMethod() public int SomeMethod()
{ {
return X * Y; return X * Y;
} }
} }
} }
// T:ILSpy.AddIn.Tests.SomeGenericClass`2 // T:ILSpy.AddIn.Tests.SomeGenericClass`2
public class SomeGenericClass<T1, T2> public class SomeGenericClass<T1, T2>
{ {
// F:ILSpy.AddIn.Tests.SomeGenericClass`2.mField1 // F:ILSpy.AddIn.Tests.SomeGenericClass`2.mField1
T1 mField1; T1 mField1;
// F:ILSpy.AddIn.Tests.SomeGenericClass`2.mField2 // F:ILSpy.AddIn.Tests.SomeGenericClass`2.mField2
T2 mField2; T2 mField2;
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.#ctor(`0,`1) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.#ctor(`0,`1)
public SomeGenericClass(T1 a, T2 b) public SomeGenericClass(T1 a, T2 b)
{ {
mField1 = a; mField1 = a;
mField2 = b; mField2 = b;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.#ctor(`0) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.#ctor(`0)
public SomeGenericClass(T1 a) public SomeGenericClass(T1 a)
{ {
mField1 = a; mField1 = a;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.#ctor // M:ILSpy.AddIn.Tests.SomeGenericClass`2.#ctor
public SomeGenericClass() public SomeGenericClass()
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.Finalize // M:ILSpy.AddIn.Tests.SomeGenericClass`2.Finalize
~SomeGenericClass() ~SomeGenericClass()
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(`0,`1) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(`0,`1)
public void GenericClassMethod(T1 a, T2 b) public void GenericClassMethod(T1 a, T2 b)
{ {
mField1 = a; mField1 = a;
mField2 = b; mField2 = b;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(System.Int32*) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(System.Int32*)
unsafe public void GenericClassMethod(int* x) unsafe public void GenericClassMethod(int* x)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(System.Int32*[]) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(System.Int32*[])
unsafe public void GenericClassMethod(int*[] x) unsafe public void GenericClassMethod(int*[] x)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(`0[]@) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(`0[]@)
unsafe public void GenericClassMethod(out T1[] x) unsafe public void GenericClassMethod(out T1[] x)
{ {
x = null; x = null;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(System.Int32@) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassMethod(System.Int32@)
public void GenericClassMethod(ref int a) public void GenericClassMethod(ref int a)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``1(``0@) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``1(``0@)
public T3 GenericClassGenericMethod<T3>(ref T3 x) public T3 GenericClassGenericMethod<T3>(ref T3 x)
{ {
return x; return x;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``1 // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``1
public T3 GenericClassGenericMethod<T3>() public T3 GenericClassGenericMethod<T3>()
{ {
return default(T3); return default(T3);
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``1(System.Int32) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``1(System.Int32)
public void GenericClassGenericMethod<T3>(int x) public void GenericClassGenericMethod<T3>(int x)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``1,System.Int32,`1@) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``1,System.Int32,`1@)
public T4 GenericClassGenericMethod<T3, T4>(T1 x, T4 y, int z, out T2 result) public T4 GenericClassGenericMethod<T3, T4>(T1 x, T4 y, int z, out T2 result)
{ {
mField1 = x; mField1 = x;
string foo = y.ToString() + z.ToString(); string foo = y.ToString() + z.ToString();
result = mField2; result = mField2;
return y; return y;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``0,System.Int32[]) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``0,System.Int32[])
public T3 GenericClassGenericMethod<T3, T4>(T1 x, T3 y, int[] z) public T3 GenericClassGenericMethod<T3, T4>(T1 x, T3 y, int[] z)
{ {
mField1 = x; mField1 = x;
string foo = y.ToString() + z.ToString(); string foo = y.ToString() + z.ToString();
return y; return y;
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod(`0[],System.Int32[]) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod(`0[],System.Int32[])
public void ArrayMethod(T1[] x, int[] y) public void ArrayMethod(T1[] x, int[] y)
{ {
} }
// NOT? M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod(`0[,],System.Int32[,]) // NOT? M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod(`0[,],System.Int32[,])
public void ArrayMethod(T1[,] x, int[,] y) public void ArrayMethod(T1[,] x, int[,] y)
{ {
} }
// NOT! M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod([],[]) // NOT? M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod(System.Int32[,],System.Int32[,])
public void ArrayMethod(T1[][] x, int[][] y) public void ArrayMethod(int[,] x, int[,] y)
{ {
} }
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``0,ILSpy.AddIn.Tests.SomeClass) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.ArrayMethod(`0[][],System.Int32[][])
public T3 GenericClassGenericMethod<T3, T4>(T1 x, T3 y, SomeClass z) public void ArrayMethod(T1[][] x, int[][] y)
{ {
mField1 = x; }
string foo = y.ToString() + z.ToString();
return y; // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``0,ILSpy.AddIn.Tests.SomeClass)
} public T3 GenericClassGenericMethod<T3, T4>(T1 x, T3 y, SomeClass z)
{
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``0,ILSpy.AddIn.Tests.SomeClass[]@) mField1 = x;
public T3 GenericClassGenericMethod<T3, T4>(T1 x, T3 y, out SomeClass[] z) string foo = y.ToString() + z.ToString();
{ return y;
mField1 = x; }
z = null;
string foo = y.ToString() + z.ToString(); // M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(`0,``0,ILSpy.AddIn.Tests.SomeClass[]@)
return y; public T3 GenericClassGenericMethod<T3, T4>(T1 x, T3 y, out SomeClass[] z)
} {
mField1 = x;
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(System.Int32[],ILSpy.AddIn.Tests.SomeGenericClass{``0,``1}) z = null;
public void GenericClassGenericMethod<T3, T4>(int[] x, SomeGenericClass<T3, T4> y) string foo = y.ToString() + z.ToString();
{ return y;
string foo = x.ToString() + y.ToString(); }
}
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.GenericClassGenericMethod``2(System.Int32[],ILSpy.AddIn.Tests.SomeGenericClass{``0,``1})
public void GenericClassGenericMethod<T3, T4>(int[] x, SomeGenericClass<T3, T4> y)
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.op_Addition(ILSpy.AddIn.Tests.SomeGenericClass{`0,`1},ILSpy.AddIn.Tests.SomeGenericClass{`0,`1}) {
public static SomeGenericClass<T1, T2> operator +(SomeGenericClass<T1, T2> a, SomeGenericClass<T1, T2> b) string foo = x.ToString() + y.ToString();
{ }
return new SomeGenericClass<T1, T2>();
}
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.op_Addition(ILSpy.AddIn.Tests.SomeGenericClass{`0,`1},ILSpy.AddIn.Tests.SomeGenericClass{`0,`1})
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.op_Explicit(ILSpy.AddIn.Tests.SomeGenericClass{`0,`1})~ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2 public static SomeGenericClass<T1, T2> operator +(SomeGenericClass<T1, T2> a, SomeGenericClass<T1, T2> b)
public static explicit operator NestedGeneric<T1, T2>(SomeGenericClass<T1, T2> sgc) {
{ return new SomeGenericClass<T1, T2>();
return new NestedGeneric<T1, T2>(); }
}
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.op_Explicit(ILSpy.AddIn.Tests.SomeGenericClass{`0,`1})~ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.op_Implicit(ILSpy.AddIn.Tests.SomeGenericClass{`0,`1})~ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2 public static explicit operator NestedGeneric<T1, T2>(SomeGenericClass<T1, T2> sgc)
public static implicit operator NestedGeneric<T2, T1>(SomeGenericClass<T1, T2> sgc) {
{ return new NestedGeneric<T1, T2>();
return new NestedGeneric<T2, T1>(); }
}
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.op_Implicit(ILSpy.AddIn.Tests.SomeGenericClass{`0,`1})~ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2
// T:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2 public static implicit operator NestedGeneric<T2, T1>(SomeGenericClass<T1, T2> sgc)
public class NestedGeneric<T3, T4> {
{ return new NestedGeneric<T2, T1>();
// T:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2.NestedDelegate }
public delegate int NestedDelegate(T3 x, IEnumerable<T4> y);
// T:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2.NestedGenericMethod``1(`0,``0) public class NestedGeneric<T3, T4>
public void NestedGenericMethod<T5>(T1 x, T5 y) {
{ // T:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2.NestedDelegate
} public delegate int NestedDelegate(T3 x, IEnumerable<T4> y);
// M:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2.NestedGenericMethod``3(`0,`3,``0[],System.Collections.Generic.IEnumerable{``2}) // M:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2.NestedGenericMethod``1(`0,``0)
public void NestedGenericMethod<T5, T6, T7>(T1 x, T4 y, T5[] z, IEnumerable<T7> w) public void NestedGenericMethod<T5>(T1 x, T5 y)
{ {
} }
}
} // M:ILSpy.AddIn.Tests.SomeGenericClass`2.NestedGeneric`2.NestedGenericMethod``3(`0,`3,``0[],System.Collections.Generic.IEnumerable{``2})
public void NestedGenericMethod<T5, T6, T7>(T1 x, T4 y, T5[] z, IEnumerable<T7> w)
{
}
}
}
} }
// T:SpaceFreeClass // T:SpaceFreeClass
class SpaceFreeClass class SpaceFreeClass
{ {
// F:SpaceFreeClass.mField // F:SpaceFreeClass.mField
int mField; int mField;
// M:SpaceFreeClass.Method // M:SpaceFreeClass.Method
private void Method() private void Method()
{ {
} }
} }

Write Preview
Loading…
Cancel
Save