CSharp笔记

 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

using System;
namespace EnumTest
{
    internal class Program
    {
        enum Hello
        {
            A=0xfff0,
            B= 0xfff1,
        }

        static void Main(string[] args)
        {
            int n = 0xfff0;
            int m = 0xfff2;
            // int强转enum和enum正常赋值是一样的开销 不做越界处理
            Hello h1=(Hello)n;
            int b1 = m;
            

            Console.WriteLine(h1);
            Console.WriteLine(b1);
            Console.ReadKey();
        }
    }
}

 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

//Debug模式
.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       43 (0x2b)
  .maxstack  1
  .locals init ([0] int32 n,
           [1] int32 m,
           [2] valuetype EnumTest.Program/Hello h1,
           [3] int32 b1) //局部变量索引
  IL_0000:  nop
  IL_0001:  ldc.i4     0xfff0  //入栈
  IL_0006:  stloc.0 // n赋值 栈顶出栈
  IL_0007:  ldc.i4     0xfff2  //入栈
  IL_000c:  stloc.1 // m赋值  栈顶出栈
  IL_000d:  ldloc.0 //加载 入栈 n
  IL_000e:  stloc.2 // h1=n  栈顶出栈
  IL_000f:  ldloc.1 // 加载 入栈 m
  IL_0010:  stloc.3 // b1=m 栈顶出栈
  IL_0011:  ldloc.2 //加载 入栈 h1
  IL_0012:  box        EnumTest.Program/Hello //栈顶h1出栈 装箱结果入栈
  IL_0017:  call       void [mscorlib]System.Console::WriteLine(object)  //使用一个参数，使用后栈顶出栈
  IL_001c:  nop
  IL_001d:  ldloc.3 //加载 入栈 b1 
  IL_001e:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_0023:  nop
  IL_0024:  call       valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey()
  IL_0029:  pop
  IL_002a:  ret
} // end of method Program::Main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

//Relase模式
.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       36 (0x24)
  .maxstack  2
  .locals init ([0] int32 m,
           [1] int32 b1)
  IL_0000:  ldc.i4     0xfff0
  IL_0005:  ldc.i4     0xfff2
  IL_000a:  stloc.0 // m=0xfff2 
  IL_000b:  ldloc.0 
  IL_000c:  stloc.1 // b1=0xfff0
  IL_000d:  box        EnumTest.Program/Hello
  IL_0012:  call       void [mscorlib]System.Console::WriteLine(object)
  IL_0017:  ldloc.1 //加载b1
  IL_0018:  call       void [mscorlib]System.Console::WriteLine(int32)
  IL_001d:  call       valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey()
  IL_0022:  pop
  IL_0023:  ret
} // end of method Program::Main

 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

using System;
namespace EnumTest
{
    internal class Program
    {
        enum Hello
        {
            A=0xfff0,
            B= 0xfff1,
        }

        static void Main(string[] args)
        {
            int n = 0xfff0;
            int m = 0xfff2;

            Hello h1=(Hello)n;
            int b1 = m;

            Console.WriteLine(h1.ToString());
            h1 = (Hello)100;
            //int强转成enum越界时赋值会成功，但是输出是int的值
            Console.WriteLine(h1.ToString());
            Console.WriteLine(b1);
            Console.ReadKey();
        }
    }
}

1
2
3

A
100
65522

 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

+--------------------------------------------------+------+----------------------------------------------+
|                      Struct                      |      |                      Class                    |
+--------------------------------------------------+------+----------------------------------------------+
| - 1 per Thread.                                  |      | - 1 per application.                         |
|                                                  |      |                                              |
| - Holds value types.                             |      | - Holds reference types.                     |
|                                                  |      |                                              |
| - Types in the stack are positioned              |      | - No type ordering (data is fragmented).     |
|   using the LIFO principle.                      |      |                                              |
|                                                  |      |                                              |
| - Can't have a default constructor and/or        |      | - Can have a default constructor             |
|   finalizer(destructor).                         |      |   and/or finalizer.                          |
|                                                  |      |                                              |
| - Can be created with or without a new operator. |      | - Can be created only with a new operator.   |
|                                                  |      |                                              |
| - Can't derive from the class or struct          |  VS  | - Can have only one base class and/or        |
|   but can derive from the multiple interfaces.   |      |   derive from multiple interfaces.           |
|                                                  |      |                                              |
| - The data members can't be protected.           |      | - Data members can be protected.             |
|                                                  |      |                                              |
| - Function members can't be                      |      | - Function members can be                    |
|   virtual or abstract.                           |      |   virtual or abstract.                       |
|                                                  |      |                                              |
| - Can't have a null value.                       |      | - Can have a null value.                     |
|                                                  |      |                                              |
| - During an assignment, the contents are         |      | - Assignment is happening                    |
|   copied from one variable to another.           |      |   by reference.                              |
+--------------------------------------------------+------+----------------------------------------------+

1
2
3

_NT_SYMBOL_PATH=C:\Symbols;srv*C:\Symbols*http://msdl.microsoft.com/download/symbols;

_NT_ALT_SYMBOL_PATH=cache*C:\Symbols

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#step1
dotnet tool install -g dotnet-sos
#step2 
dotnet-sos install

#安装成功后有SOS install succeeded的提示，并且返回有安装路径。
PS E:\Project> dotnet-sos install
Installing SOS to C:\Users\coding\.dotnet\sos
Installing over existing installation...
Creating installation directory...
Copying files from C:\Users\coding\.dotnet\tools\.store\dotnet-sos\6.0.328102\dotnet-sos\6.0.328102\tools\netcoreapp3.1\any\win-x64
Copying files from C:\Users\coding\.dotnet\tools\.store\dotnet-sos\6.0.328102\dotnet-sos\6.0.328102\tools\netcoreapp3.1\any\lib
Execute '.load C:\Users\coding\.dotnet\sos\sos.dll' to load SOS in your Windows debugger.
Cleaning up...
SOS install succeeded

1
2
3
4

.loadby sos clr 
如果失败需要 （sos.dll和clr.dll一般情况下在同一个目录）
.load 绝对路径的sos.dll
.load 绝对路径的clr.dll

1
2
3
4

    sxe ld clr
    sxe ld mscorwks
    sxe ld coreclr
    g

1
2
3
4

# mydotNetApp.exe是进程名字
procdump -ma mydotNetApp.exe d:\myapp.dmp
# TestCase.exe是进程名字
.\procdump.exe -ma TestCase.exe e:\test.dmp

1
2
3
4
5
6
7
8

Windbg(x86)

C:\Users\coding\AppData\Local\Microsoft\WindowsApps\WinDbgX.exe
C:\Program Files (x86)\Windows Kits\10\Debuggers\x86\windbg.exe

 -srcpath $(ProjectDir) $(TargetPath)

 $(TargetDir)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

C:\Symbols
srv*C:\Symbols*http://msdl.microsoft.com/download/symbols

cache*C:\Symbols

 !DumpHeap -stat

0:000> !clrstack
No export clrstack found
0:000> !dumpstackobjects
No export dumpstackobjects found
0:000> sxe ld clr
0:000> sxe ld mscorwks
0:000> sxe ld coreclr

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

    sxe ld clr # 添加中断 （加载指定名称的dll时，调试器中断） 
    # sxe ld mscorwks  # 添加中断 （加载指定名称的dll时，调试器中断） 
    # sxe ld coreclr  # 添加中断 （加载指定名称的dll时，调试器中断） 
    # sxe ld clrjit  # 添加中断 （加载指定名称的dll时，调试器中断） 
    g # 运行，当遇到中断或者断点时 中断
    # 让应用程序运行到.NET可用（clr等核心初始化后，这时候.net环境初始化完成）
    .loadby sos clr  ## 加载sos模块 (宿主程序必须加载clr后执行，否则会找不到clr)
    
    !bpmd DotnetTest DotnetTest.Program.Main  ## Main函數添加断点
    !bpmd -md 005e4d90 #在指定的MethodDesc地址处添加断点
    g # 运行，当遇到中断或者断点时 中断
    !name2ee DotnetTest DotnetTest.Program.Main

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

.cordll -ve -u -l
lmv mclr #（适用于 CLR 4.0 版）

lmv mscorwks  #（适用于 CLR 的 1.0 或 2.0 版）

!sos.help
!sos.Threads
!sos.DumpDomain

k
kv
kb
x *! 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

.load DLLName
!DLLName.load
.loadby DLLName ModuleName

参数
DLLName
指定要加载的调试器扩展DLL。如果使用.load命令，DLLName应包含完整路径。如果使用.loadby命令，DLLName应仅包含文件名。

ModuleName
指定与DLLName指定的扩展DLL位于同一目录中的模块的模块名。

1
2
3
4
5
6
7

0:000> !name2ee DotnetTest DotnetTest.Program.Main
Module:      00c44044
Assembly:    DotnetTest.exe
Token:       06000009
MethodDesc:  00c44d90
Name:        DotnetTest.Program.Main(System.String[])
Not JITTED yet. Use !bpmd -md 00c44d90 to break on run.

1
2
3

# 添加断点
!bpmd DotnetTest DotnetTest.Program.Main  #[<module name> <method name>]
!bpmd DotnetTest DotnetTest.HeapStack.New