Bowen's Tech Blog

Asynchronous method is implemented in C# by using async/await keywords.

Async/Await keywords

That’s the goal of asynchronous: enable code that reads/writes like a sequence of statements, but executes in a much more complicated order based on external resource allocation and when tasks complete.

Without language support, writing asynchronous code required callbacks, completion events, or other means that obscured the original intent of the code. In C#, keywords async and await are used to achieved a asynchronous program. The function return immediately when it meets a await. A code sample is like following.

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

using System;
using System.Threading.Tasks;


namespace TestAsyncIL
{
    class TestAsync
    {
        public async void Method1()
        {
            Console.WriteLine("Start Method 1");
            for (int i = 0; i < 3; i++)
            {
                await Task.Delay(330);
                Console.WriteLine("Method 1: " + i.ToString());
            }
        }

        public async void Method2()
        {
            Console.WriteLine("Start Method 2");
            for (int i = 0; i < 3; i++)
            {
                await Task.Delay(330);
                Console.WriteLine("Method 2: " + i.ToString());
            }
        }

        public void Method3()
        {
            Console.WriteLine("Start Method 3");
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("Method 3: " + i.ToString());
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            TestAsync testAsync = new TestAsync();
            testAsync.Method1();
            testAsync.Method2();
            testAsync.Method3();
            Console.Read();
            /* Output is (replaced '\n' by ',')
            Start Method 1, Start Method 2, Start Method 3
            Method 3: 0, Method 3: 1, Method 3: 2
            Method 1: 0, Method 2: 0, Method 1: 1
            Method 2: 1, Method 1: 2, Method 2: 2
            */
        }
    }
}

How to code executed:

1. Run Method1, code output method1, then encounter await, get back to the main function
2. Run Method2, code output method2, then encounter await, get back to the main function
3. Run Method3, since the running time is less than 330 milliseconds, it will output all the content in Method3
4. After 330 milliseconds from Method1 returning, Method1 output the next str
5. After 330 milliseconds from Method2 returning, Method2 output the next str
6. Repeat 4 and 5 until output all string.

Note. the step 4 and 5 won’t output if we don’t add the ReadKey method in the end because the main thread will ends and those asnyc methods still in the same thread thus end, too.

Analysis of metadata

In IL, we find that the compiler generate 2 classes for Method1 and Method2 called <Method1>d__0 and <Method2>d__1. The two classes are state machines, the implement the interface TStateMachine. The class contains the following elements.

• Fields
  • int state
  • TestAsync this
  • AsyncVoidMethodBuilder builder
  • TaskAwaiter u__1
  • int 5__1 (the local int i in for loop)
• Methods
  • .ctor
  • MoveNext
  • SetStateMachine

There are two important data types. System.Runtime.CompilerServices.AsyncVoidMethodBuilder and System.Runtime.CompilerServices.TaskAwaiter

• AsyncVoidMethodBuilder
  • A struct, value type
  • Represents a builder for asynchronous methods that do not return a value.
  • Its Create method will return a instance of the builder
  • Its Start<TStateMachine> method will begin running the builder with the associated state machine
• TaskAwaiter
  • A struct, value type
  • Provides an object that can check whether current asynchronous task is completed and waits for the completion of an asynchronous task
  • Properties
    • IsCompleted. Gets a value that indicates whether the asynchronous task has completed.
  • Methods
    • GetResult. Ends the wait for the completion of the asynchronous task.
    • OnCompleted(Action). Sets the action to perform when the TaskAwaiter object stops waiting for the asynchronous task to complete.
    • UnsafeOnCompleted(Action). Schedules the continuation action for the asynchronous task that is associated with this awaiter.

IL execution pipeline

For the Method2 itself, the IL code is as follows

Once we call the Method2, it does the following things.

1. Initializes a class called <Method2>d__1.
2. Assign the current instance to <Method2>d__1::this
3. Call AsyncVoidMethodBuilder::Create<<Method2>d__1> to create a async void instance for the state machine
4. Set <Method2>d__1::state to -1
5. Call AsyncVoidMethodBuilder.Start, the passing state machine is the class <Method2>d__1
6. Call the <Method2>d__1::MoveNext, since the state is -1, output the str, and change state to 0
7. Once the state is set to 0, initialize the 5__1 field as 0, then call the Task.Delay method, and get awaiter for this task and set it to u__1 field
8. Check u__1::IsCompleted. If haven’t finish, call AsyncVoidMethodBuilder::AwaitUnsafeOnCompleted<5__1, <Method2>d__1>, which will call <Method2>d__1::MoveNext method when the status of the awaiter is complete
   • Note. I think the AsyncVoidMethodBuilder will set the <Method2>d__1::MoveNext to 5__1::UnsafeOnCompleted(Action)
9. The next time it call the MoveNext method, the code will execute different logic since the state has been changed.

Asynchronous method return types

Async methods can have the following return types

| void | Task | Task<TResult>
—–|——|——|—————
has return statement | No | Yes | Yes
return statement type | - | Task | Task<TResult>
can assign to delegate or event | Yes | Yes | Yes
can assign to Task | No | Yes | Yes
caller can know whether this method has completed (create a awaiter for it) | No | Yes | Yes
its awaiter has return statement | - | No | Yes
its awaiter return type | - | - | TResult

Task and Task class

Compared to execute a thread to do actions, the Task class is used to execute asynchronously, and it can track the status of this asynchronous action, including whether it finish and what is the return value. Most commonly, a lambda expression is used to specify the work that the task is to perform.

For operations that return statement, the Task<TResult> class will be used.

Samples

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

using System;
using System.Threading.Tasks;


namespace TestAsyncIL
{
    struct ReturnArgs
    {
        public int Data { get; set; }
        public string Text { get; set; }
    }

    class TestAsyncTask
    {
        public async Task Method1()
        {
            Console.WriteLine("Start Method 1");
            for (int i = 0; i < 3; i++)
            {
                await Task.Delay(330);
                Console.WriteLine("Method 1: " + i.ToString());
            }
        }

        public async Task<ReturnArgs> Method2()
        {
            Console.WriteLine("Start Method 2");
            for (int i = 0; i < 3; i++)
            {
                await Task.Delay(330);
                Console.WriteLine("Method 2: " + i.ToString());
            }
            return new ReturnArgs() { Data = 2, Text = "Task Finished!" };
        }

        public void Method3()
        {
            Console.WriteLine("Start Method 3");
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("Method 3: " + i.ToString());
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // mMain1();
            // mMain2();
            mMain3();
            Console.ReadKey();
        }

        static async void mMain1()
        {
            TestAsyncTask testAsync = new TestAsyncTask();
            testAsync.Method1();
            testAsync.Method2();
            testAsync.Method3();
            /* Output is (replaced '\n' by ',')
            Start Method 1, Start Method 2, Start Method 3
            Method 3: 0, Method 3: 1, Method 3: 2
            Method 1: 0, Method 2: 0, Method 1: 1
            Method 2: 1, Method 1: 2, Method 2: 2
            */
        }

        static async void mMain2()
        {
            TestAsyncTask testAsync = new TestAsyncTask();
            await testAsync.Method1();
            ReturnArgs args = await testAsync.Method2();
            Console.WriteLine(args.Data.ToString() + " " + args.Text);
            testAsync.Method3();
            /* Output is (replaced '\n' by ',')
            Start Method 1, Method 1: 0, Method 1: 1, Method 1: 2
            Start Method 2, Method 2: 0, Method 2: 1, Method 2: 2
            2 Task Finished!
            Start Method 3, Method 3: 0, Method 3: 1, Method 3: 2
            */
        }

        static async void mMain3()
        {
            TestAsyncTask testAsync = new TestAsyncTask();
            Task a = testAsync.Method1();
            Task<ReturnArgs> b = testAsync.Method2();
            Task.WaitAny(a);
            var args = await b;
            Console.WriteLine(args.Data.ToString() + " " + args.Text);
            testAsync.Method3();
            /* Output is (replaced '\n' by ',')
            Start Method 1, Start Method 2
            Method 1: 0, Method 2: 0, 
            Method 1: 1, Method 2: 1,
            Method 1: 2, Method 2: 2,
            2 Task Finished!
            Start Method 3, Method 3: 0, Method 3: 1, Method 3: 2
            */
        }
    }
}

In the mMain1 method, the Method1 and Method2 are still be executed in a synchronously. So the output is the same with the void-returning async method.

In the mMain2 method, we create the awaiter for the Method1 and Method2, so Method2 will be called after Method1, and Method3 will be called after Method2.

In the mMain3 method, we firstly run the Method1 and Method2 synchronously and assign them to Task and Task<TResult> variables. So the two methods will run at the same time. Then we use Task.WaitAny and create a awaiter for Method2, so Method3 will run after Method1 and Method2.

Analysis in IL

Similarly, the complier will generate 2 state machine classes for Method1 and Method2 and 3 state machine for mMain1, mMain2, mMain3.

In the state machine of Method1 and Method2, it is similar to the void-returning async method but it uses AsyncTaskMethodBuilder<TResult> classes to build the async task. In Method2, when it is finished, it uses SetResult(TResult) method to marks the task as successfully completed and also pass the ReturnArgs statement.

In the mMain2 and mMain3 state machines, there will be TaskAwaiter class and TaskAwaiter<TResult> result. After the awaiter’s property IsCompleted is true, they will call TaskAwaiter<TResult>.GetResult to get the return statement from the AsyncTaskMethodBuilder<TResult>.

Cancellation token to terminate async thread

The Async function can be cancelled by passing a CancellationToken parameter created by a CancellationTokenSource.

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

CancellationTokenSource tokenSource;

/// Upload new anchor pipeline
public void UploadNewAnchor()
{
    // Create a new token because token can only by cancelled once
    tokenSource = new CancellationTokenSource();

    // Add the callback methods when the token is cancelled
    tokenSource.Token.Register(() => feedbackBox.text = "Cancel Action!");
    tokenSource.Token.Register(async () =>
    {
        CloudManager.StopSession();
        await cloudManager.ResetSessionAsync();
    });

    // Start the async method
    UploadNewAnchorAsync(tokenSource.Token);
}

/// Upload anchor process, can be canceled anytime
async void UploadNewAnchorAsync(CancellationToken token)
{    
    while (!CloudManager.IsReadyForCreate)
    {
        await Task.Delay(330);
        token.ThrowIfCancellationRequested();
    }

    CloudManager.UploadAnchor();
}

/// Stop the uploading process by the cancellation token
public void StopAction()
{
    if (tokenSource != null)
    {
        tokenSource.Cancel();
        tokenSource.Dispose();
    }
}

Reference

1. AsyncVoidMethodBuilder Struct
2. AsyncTaskMethodBuilder Struct
3. AsyncTaskMethodBuilder Struct
4. TaskAwaiter Struct
5. TaskAwaiter.GetResult Method
6. Task.GetAwaiter Method
7. Task.Delay Method

Inheritance is a very important feature in C#. It can allow you to achieve the polymorphisn, which is very very important feature which could help you to write the code in a good design (easy to extend).

Category

• Inherit a class
  • Inherit a abstract class
    • Must implement the abstract methods in the abstract class
    • Can override/new the virtual methods in the abstract class
  • Inherit a normal class
    • Can override/new the virtual methods in the abstract class
• Inherit an interface
  • Must implement all members (properties, methods, events) in the interface.

The different field

When class Student inherits class Person publicly. Those functions and members which are public and protected in class Person can be used in class Student. Functions and members which are private in class Person cannot be used in class Student.

However, if there is a public/protected function in class Person, which uses the private members of class Person. When class Student call that functions, those private members in class Person could also be used via this function.

Base function

Use base.function() in the class Student can call the functions implemented in class Person (the functions should be public/protected). This is often used when class Student rewrite the methods of class Person but still need to call the method of class Person.

About override/new keyword

Polymorphisn often happens when you declare a class Person reference, but you point it to an object instantiated from class Student.

When there is a abstract/virtual method in class Person, class Student could use override/new to rewrite that method. At this moment, call the which are rewrote can lead to charming results.

Since the abstract class can’t be instantiated, we just talked about those virtual - override/new relationship.

• If the reference type and the object type is the same. Call those functions are calling the function in their own field.
• If the reference type is the base class and the object type is the subclass.
  • If the method is declared override in subclass. Call this method from the reference is executing the method in subclass.
  • If the method is declared new in subclass. Call this method from the reference is executing the method in base class.

If the method is declared abstract in base class. You cannot call it except the subclass override this method.

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

using System;

namespace testInherit
{
    class Person
    {
        protected int age = 10;
        protected int id = 0;
        public Person()
        {
            Console.WriteLine("Person Created!");
        }
        public void ShowBaseInfo()
        {
            Console.WriteLine(age.ToString() + ","+ id.ToString());
        }

        public virtual void ShowType()
        {
            Console.WriteLine("This is a person");
        }

        public virtual void ShowName()
        {
            Console.WriteLine("Person name");
        }
    }

    class Student : Person
    {
        new int age = 20;
        public Student()
        {
            Console.WriteLine("Student Created!");
        }
        public void ShowInfo()
        {
            Console.WriteLine(age.ToString() + ","+ id.ToString());
        }

        public override void ShowType()
        {
            Console.WriteLine("This is a student");
        }

        public new void ShowName()
        {
            Console.WriteLine("Person name");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student();
            
            Console.WriteLine("--------------------");
            student.ShowBaseInfo();
            student.ShowInfo();
            Console.WriteLine("--------------------");
            student.ShowType();
            Console.WriteLine("--------------------");
            Console.WriteLine("--------------------");

            Person person = new Person();
            Person person_student = student;
            Console.WriteLine("--------------------");
            person.ShowType();
            person_student.ShowType();
            student.ShowType();
            Console.WriteLine("--------------------");
            person.ShowName();
            person_student.ShowName();
            student.ShowName();
        }
    }
}

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

using System;

namespace TestCSharp
{
    public class Father
    {
        public static void DoStaticWork()
        {
            Console.WriteLine("Father.DoStaticWork");
        }

        public void DoWork()
        {
            Console.WriteLine("Father.DoWork");
        }

        public virtual void DoVirtualWork()
        {
            Console.WriteLine("Father.DoVirtualWork");
        }

        public virtual void DoVirtualWork2()
        {
            Console.WriteLine("Father.DoVirtualWork2");
        }

        public virtual void DoVirtualWorkAll()
        {
            Console.WriteLine("Father.DoVirtualWorkAll");
        }
    }

    public class Son : Father
    {
        public static void DoStaticWork()
        {
            Console.WriteLine("Son.DoStaticWork");
        }
        public void DoWork()
        {
            Console.WriteLine("Son.DoWork");
        }

        public new virtual void DoVirtualWork()
        {
            Console.WriteLine("Son.DoVirtualWork");
        }

        public override void DoVirtualWork2()
        {
            Console.WriteLine("Son.DoVirtualWork2");
        }
        public override void DoVirtualWorkAll()
        {
            base.DoVirtualWorkAll();
            Console.WriteLine("Son.DoVirtualWorkAll");
        }
    }

    public class Grandson : Son
    {
        public override void DoVirtualWork()
        {
            Console.WriteLine("GrandSon.DoVirtualWork");
        }

        public override void DoVirtualWork2()
        {
            Console.WriteLine("GrandSon.DoVirtualWork2");
        }
        public override void DoVirtualWorkAll()
        {
            base.DoVirtualWorkAll();
            Console.WriteLine("GrandSon.DoVirtualWorkAll");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Father son = new Son();
            Son.DoStaticWork();
        
            son.DoWork();
            son.DoVirtualWork();
            son.DoVirtualWork2();
            son.DoVirtualWorkAll();

            Console.WriteLine("--------------------");

            Father gson = new Grandson();

            gson.DoWork();
            gson.DoVirtualWork();
            gson.DoVirtualWork2();
            gson.DoVirtualWorkAll();

            Console.WriteLine("--------------------");

            Father father = new Father();

            father.DoWork();
            father.DoVirtualWork();
            father.DoVirtualWork2();
            father.DoVirtualWorkAll();

            Console.WriteLine("--------------------");

            Son realSon = new Son();

            realSon.DoWork();
            realSon.DoVirtualWork();
            realSon.DoVirtualWork2();
            realSon.DoVirtualWorkAll();

            Console.WriteLine("--------------------");

            Son realgSon = new Grandson();

            realgSon.DoWork();
            realgSon.DoVirtualWork();
            realgSon.DoVirtualWork2();
            realgSon.DoVirtualWorkAll();
        }
    }
}

Reference

This post is some ROS command from ROS tutorial.

This post talks about different level of Windows application development, including APIs, Application category, and hardware platform.

本文将简述.NET（包括.NET Framework, .NET Core等）和编程语言C#之间的关系。

Basic Information of .NET

Features of .NET

.NET的命名就是因为.net是互联网中比较通用的一个域名后缀，因此.NET本身也是和通用相关的。

• 跨语言：即只要是面向.NET平台的编程语言((C#、Visual Basic.NET、C++/CLI、Eiffel、F#、IronPython、IronRuby、PowerBuilder、Visual COBOL 以及 Windows PowerShell))，用其中一种语言编写的类型可以无缝地用在另一种语言编写的应用程序中的互操作性。
• 跨平台：一次编译，不需要任何代码修改，应用程序就可以运行在任意有.NET框架实现的平台上，即代码不依赖于操作系统，也不依赖硬件环境。

.NET Technical Framework System

.NET是一个微软搭造的开发者平台，它主要包括：

1. 支持(面向)该平台的编程语言(如C#、Visual, Basic、C++/CLI、F#、IronPython、IronRuby…)
2. 用于该平台下开发人员的技术框架体系(.NET Framework、.NET Core、Mono等)，
   1. 定义了通用类型系统，庞大的CTS体系
   2. 用于支撑.NET下的语言运行时的环境：CLR
   3. NET体系技术的框架库FCL
3. 用于支持开发人员开发的软件工具(即SDK，如VS2017、VS Code等)

Common Type System (CTS)

在.NET的三部分内容中，编程语言和软件工具我们都比较清楚，那么技术框架体系中的具体内容都是什么呢？

• CLS: (Common Language Specification) 公共语言规范, 在面向.NET开发中，语言互操作的标准规范
• CTS: (Common Type System) 公共类型系统, 包含：
  • 建立用于跨语言执行的框架。
  • 提供面向对象的模型，支持在 .NET 实现上实现各种语言。
  • 定义处理类型时所有语言都必须遵守的一组规则(CLS)。
  • 提供包含应用程序开发中使用的基本基元数据类型（如 Boolean、Byte、Char 等）的库。
  • 支持CTS，那么我们就称它为面向.NET平台的语言
    CLI（Common Language Infrastructure），是微软将CTS等内容提交给国际组织计算机制造联合会ECMA的一个工业标准。

Common Language Runtime (CLR)

• CLR：.NET虚拟机
  • CLR是.NET类型系统的基础，所有的.NET技术都是建立在此之上
  • 在我们执行托管代码之前，总会先运行这些运行库代码，通过运行库的代码调用，从而构成了一个用来支持托管程序的运行环境，进而完成诸如不需要开发人员手动管理内存，一套代码即可在各大平台跑的这样的操作。
  • 这套环境及体系之完善，以至于就像一个小型的系统一样，所以通常形象的称CLR为”.NET虚拟机”。那么，如果以进程为最低端，进程的上面就是.NET虚拟机(CLR)，而虚拟机的上面才是我们的托管代码。换句话说，托管程序实际上是寄宿于.NET虚拟机中
  • C# 编写的程序如果想运行就必须要依靠.NET提供的CLR环境来支持
• CLR宿主进程：容纳.NET虚拟机的进程，该程序称之为运行时主机

下图是代码编译和运行的流程

Framework Class Library (FCL)

框架库是一些用于描述数据类型的基础类型。比如Object不仅是C#语言的类型根、还是VB等所有面向.NET的语言的类型根，它是整个FCL的类型根。同时.NET的框架库有单继承的特点。

• BCL(Base Class Library)基础类库
  • 通过.NET语言下编写的一些类库
  • 多都包含在System命名空间下。
  • 包含：基本数据类型，文件操作，集合，自定义属性，格式设置，安全属性，I/O流，字符串操作，事件日志等的类型
• FCL(Framework Class Library)框架类库
  • FCL中大部分类都是微软通过C#来编写的。
  • 用于网站开发技术的 ASP.NET类库，该子类包含webform/webpage/mvc，
  • 用于桌面开发的 WPF类库、WinForm类库
  • 用于通信交互的WCF、asp.net web api、Web Service类库等等

.NET Implementations

• .NET Framework
  • A .NET implement coupled with Windows System
  • Only support different version of Windows
• .NET Core
  • A open source .NET implementation for several desktop OS including Windows, macOS, and Linux, but NOT support mobile OS like Android or iOS.
  • Include a cross-platform CoreCLR
  • Implement subset of the .NET Framework library (decouple with Windows), and add new features (for common usage of different OS)
    • e.g. Not include WPF which coupled with Windows
    • UWP: Specific for Windows System
      • Cross Devices but only runs in Windows.
  • Better in the functions than Mono
• Xamarin
  • A open source .NET implementation by for several OS including Android、IOS and macOS
  • It is based on Mono BCL. Unity3d adopts this framework. It will compile the C# code to IL, and compile to naive code according to the target platform
  • Higher efficiency than .NET Core
• .NET Standard
  • A set of fundamental APIs that all.NET implementations should implement
  • Cannot build the real program, but serve as the library for .NET implementations above

C# and .NET

C# is the programming language targeted to .NET. The version of C# is updated with the update of .NET implementations.

Reference

[1] https://www.cnblogs.com/1996V/p/9037603.html
[2] https://blog.csdn.net/MePlusPlus/article/details/76242330
[3] .NET Standard

Description

Delegate and event are good ways to “subscribe” some actions to other particular actions carried out by the user or the code. It sounds like function 1 is executed firstly, then function 2, 3, and etc are executed following. Those functions may not in the same class.

For example, they are in class A, class B, class C. If we use the traditional ways to achieve this relationship, we need to call function 2 and 3 in the class A when the function 1 is executed. In this way we will increase the degree of coupling between these classes, that is class A cannot work normally without class B and C.

Therefore, we proposed the ideas of delegate and event. Class B and C could “subscribe” the action publisher in class A with their function 2 and 3. When the action 1 is executed, the class A will call the action publisher, then the class B and C will receive the information that action 1 is executed, so they will execute the action 2 and 3.

Comparison between delegate and event

• Commons
  • They are like the pointer of methods.
  • A method can be used += and -= to be assigned or unassigned to a delegate, and subscribe or unsubscribe the event
  • They both accept anonymous methods (delegate declared, or lambda expression)
  • Event is a specific kind of delegate which will be safer

• Differences

Generic delegate

1
2
3
4
5
6

event EventHandler<bool> OnEvent1;

delegate void MyHandler<T>(int a, T t);
event MyHandler<bool> OnEvent2;        // Generic variable must be set to a fixed type

Func<float, bool> myFuc; 

Delegate declaring anonymous methods

Delegate can be used to declare an anonymous method.

1
2
3
4
5
6
7

event MyHandler<EventArgs> OnTrigger;

OnTrigger += delegate(object sender, EventArgs e)
{
    Console.WriteLine(sender);
    Console.WriteLine(e);
}

See more about anonymous method from here

Execution

The delegate and event can both be used two methods to executed.

• Use myDelegateInstance(paras) or myEvent(paras)
• Use myDelegateInstance.Invoke(paras) or myEvent.Invoke(paras)

They are the same in compiler but the second method could add ? to handle the null conditions.

myDelegateInstance?.Invoke(paras) or myEvent?.Invoke(paras)

This post summarizes the common data structure and algorithm knowledge and questions.

Basic Skills

• Usually set the values of private values in the Start() function.
• Only gameObject has the function of GetComponent
• Transform
  • Only transform has the function of Find(string name)
  • The function of Find(string name) for a transform can only find the direct children of a transform

Physics Engine

Collider

Wheel Collider

Wheel collider is a collider rather than the mesh of the wheel. You can add force or torque to the collider to make the collider rotate like a wheel.

Rigidbody

Rigidbody has a element named velocity, which can set the speed(Vector3) of the gameobject.

Detect collision or collision position between objects

• Use OnCollisionEnter or OnTriggerEnter
  • Required object to have collider and rigidbody
• Use Physics.OverlapSphere(point) to detect whether the point collides with other colliders.
• Use Collider.Raycast to get the accurate collision position. It will ignore other colliders but this collider.

Scripting

Find Objects

• Use transform.root.gameObject can find the root object
• Use gameObject.GetComponentInChild() can find the script attached to the child objects.
• Use transform.Find() can find the children objects, but this is only used to find the direct children objects.

Attributes

Attributes of C# can add metadata (information about the types defined in a program) to the program. In Unity, it can be used to show information in Unity editor’s inspector.

The attributes work by placing the name of the attribute enclosed in square brackets ([]) above the declaration of the entity to which it applies. There are several different attributes in Unity

Asynchronous

Unity can use async/await keywords of C# to achieve asynchronous methods, which can be found here.

However, some Unity library functions cannot be executed correctly in the asynchronous thread. Instead, Unity has its own asynchronous keyword, which is IEnumerator/yield return.

yield return keyword has many kinds of return type, which shows following

In Unity scripts, sometimes we need to do some actions after changing the properties of the GameObject, e.g. position, rotation. Unity will finish the changing action in the end of current frame. So we need to wait for a while before doing other actions.

Note. the event of delegate trigger is also finished in the current frame.

Also in Unity, we need to use yield return null or allow the code return to the main thread to do some changes in the scene.

Note. don’t use yield return 0 because it is the same with yield return null but it will lead to boxing action.

Compile

Conditional Compile

Unity has many targeted platforms, so the codes can be conditional complied according to this link

Compile Pipeline

• Unity will compile C# scripts to IL with C# compiler firstly
• Unity will also combines all the other assemblies like the UnityEngine.dll and mscorlib.dll
• Unity will use Mono or IL2CPP to build the IL scripts to naive code

Overview

There are several advanced features of C# which are very powerful.

Assembly

An assembly is a collection of types and resources that are built to work together and form a logical unit of functionality. Assemblies are the building blocks of .NET applications. Assemblies has the code that the common language runtime executes.

Assemblies take the 2 forms

• executable (.exe)
  • <compiler command> <module name>
    • csc test.cs
• dynamic link library (.dll) files
  • <compiler command> -t:library <module name>
    • csc -t:library test.cs
  • is similar to a class library that contains types that will be referenced by other assemblies
  • has no entry point to begin execution

Note. Each assembly have only one entry point: DllMain, WinMain, or Main.

• Static assemblies
  • stored on disk in portable executable (PE) files
  • include interfaces, classes, and resources like bitmaps, JPEG files, and other resource files
• Dynamic assemblies
  • run directly from memory and aren’t saved to disk before execution
  • can save dynamic assemblies to disk after they have executed.

To use an assembly in an application, you must add a reference to it. To add a reference to a assembly. Use the following methods

• static Load method of the System.Reflection.Assembly
• GetType method of the Type class can load assemblies
• Load method of the System.AppDomain class
• …

Once an assembly is referenced, all the accessible types, properties, methods, and other members of its namespaces are available to your application as if their code were part of your source file.

Attributes

Attributes can add metadata (information about the types defined in a program) to the program. An attribute is actually an object that is associated with any of these elements: Assembly, Class, Method, Delegate, Enum, Event, Field, Interface, Property and Struct.

The attributes work by placing the name of the attribute enclosed in square brackets ([]) above the declaration of the entity to which it applies. It can contain parameters and the users can customize the attributes.

See here for more info.

In Unity, a public element with the attribute HideInInspector won’t appear in the inspector of Unity Editor. See here for Unity attribute.

A sample of serialization attribute is in the Serialization and Deserialization below.

Exceptions

See here for more info.

Generics

Generics makes it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client code.

A Generics class can also be inherited by other class. The derived class can specify the type of the class or it can inherit without specify the class. Generics class can also add Constrains to give some restrictions of the type.

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

using System;
using System.Collections.Generic;

namespace testCSharp
{
    class MyGenericClass<type>
    {
        public type element1;
        public MyGenericClass(type value = default(type))
        {
            element1 = value;
        }
        
        public type function1(type input)
        {
            Console.WriteLine(input);
            return element1;
        }
    }

    class MyDerivedClass1: MyGenericClass<string>
    {
        public MyDerivedClass1(string value)
        {
            element1 = value;
        }
    }
   
    class MyDerivedClass2<type>: MyGenericClass<type> where type: class
    {
        public MyDerivedClass2(type value)
        {
            element1 = value;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyGenericClass<int> test1 = new MyGenericClass<int>(10);

            int value1 = test1.function1(20);   // 20
            Console.WriteLine(value1);  // 10

            MyGenericClass<string> test2 = new MyGenericClass<string>("abc");

            string value2 = test2.function1("jkl"); //"jkl"
            Console.WriteLine(value2);  //"abc"

            MyDerivedClass1 test3 = new MyDerivedClass1("abc");     
            string value3 = test3.function1("jkl"); //"jkl"
            Console.WriteLine(value3);  //"abc"

            MyDerivedClass2<int> test4 = new MyDerivedClass2<int>("abc");   //complie error, the 'type' must be a reference type
        }
    }
}

See here for more about generic.

Interface

Just define the return type and type of parameters, the specific implementation needs to be finish in derived class, which looks like the header file in C++, that only decare but not implement.

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

interface IMyInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

See here for more info.

Lambda expression

Lambda expression can be used for anonymous method. The operator => is used.

1
2
3
4
5
6
7
8
9

Func<string> greet = () => "Hello, World!";
Console.WriteLine(greet());

event Handler OnTrigger;
OnTrigger += (sender, e) =>
{
    Console.WriteLine(sender);
    Console.WriteLine(e);
}

Properties

A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field (Member variables or methods in a class or structures). Properties can be used as if they are public data members, but they are actually special methods called accessors. This enables data to be accessed easily and still helps promote the safety and flexibility of methods.

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

class Myclass
{
    float seconds;

    // Declare a Code property of type string:
    public float Hours
    {
        get
        {
            return seconds / 3600.0f;
        }
        set
        {
            if (value < 0 || value > 24)
                throw new ArgumentOutOfRangeException(
                      $"{nameof(value)} must be between 0 and 24.");

            seconds = value * 3600;
        }
    }
}

In some cases, property get and set only return a value or assign a value, so the properties can be used auto-implemented to write. Note the code below only has the properties but no actual private field set. The required field of class of this kind of code will be set automatically during the compile.

1
2
3
4
5
6

public class SaleItem
{
   public string Name { get; set; }

   public int Price { get; set; }
}

The properties can also use body expression to simplify. Here we need to use the operator of =>. It could link a member with an expression. Here we don’t need to write the keywords of return but still require an private field.

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

public class SaleItem
{
    string _name;
    decimal _cost;

    public string Name
    {
        get => _name;
        set => _name = value;
    }

    public decimal Price
    {
        get => _cost;
        set
        {
            if (value >= 0)
            {
                _cost = value;
            }
        }

    }
}

The abstract class may have an abstract property, which can be implemented in the derived class

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

public abstract class Person {
    public abstract string Name {
        get;
        set;
    }
}

class Student : Person {
    private string name = "N.A";
    private int age = 0;

    // Declare a Name property of type string:
    public override string Name {
        get {
            return name;
        }
        set {
            name = value;
        }
    }
}

Serialization and Deserialization

It is the process of converting an object into a stream of bytes to store the object or transmit it to memory. The stream of bytes can be deserialized to the object.

To serialize an object, the object should be have a SerializableAttribute attribute. Fields within a class that don’t need to be serialized should include a NonSerializedAttribute attribute.

Users can use binary or XML serialization to serialize an object. Below is a sample to use basic serialization to serialize a class.

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

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

namespace testCSharp
{

    [Serializable]
    class TestSerialize
    {
        public int ID = 13;
        public string content = "test";

        [NonSerialized]
        public string content2 = "Costum";

        public int function()
        {
            return 0;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            TestSerialize test1 = new TestSerialize();
            test1.ID = 1234;
            test1.content = "Hello World";
            test1.content2 = "Hello World 2";
            IFormatter formatter = new BinaryFormatter();
            Stream fs = new FileStream("data.txt", FileMode.Create, FileAccess.Write);

            formatter.Serialize(fs, test1);
            fs.Close();

            fs = new FileStream("data.txt", FileMode.Open, FileAccess.Read);
            TestSerialize test2 = (TestSerialize)formatter.Deserialize(fs);

            Console.WriteLine(test2.ID);    // 1234
            Console.WriteLine(test2.content);   // Hello World
            Console.WriteLine(test2.content2); // None
        }
    }
}

Thread

One thread if one execution flow for the code. For some parallel work in the same program, we can use multi-thread to save the total execution time.

See here for more information.

LINQ (Language Integrated Query)

Query expression is like the SQL language, it can search elements with some relationship. It starts with from and ends with select or group.

LINQ is the data object language that integrated into C#. It can be used for search, order, compare and summarize action.

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

List<User> users = new List<User>
{
    new User{Name = "a", Age = 27},
    new User{Name = "b", Age = 32},
    new User{Name = "c", Age = 15}
}
Enumerable<Uesr> selectUsers = from user in users
            where user.Age < 30
            orderby user.Age descending
            select user;

// Below is also work
var selectUsers = users.Where(user => user.Age < 30)
    .OrderByDescending(user => user.Age).Select(user => user);

LINQ can be used in following scenarios.

• Objects: object’s in code. e.g. class, collectiosn
• XML: XML file
• SQL: SQL database
• Entities
• Datasets

Elements of OO

3 elements of object oriented: Inheritance, encapsulation, and polymorphisn. Interface is another important element of the OOP.

Inheritance

Categories

Inherit is way to describe the relationship between between classes. If class A IS-A class B, we call class A Subclass or Derived class, call class B as Parent class or Base Class or Super Class.

Subclass could inherit the properties and methods from parent class, and subclass could also add or modify new properties and methods.

In .NET, it cloud be divided into 2 categories:

• Inherit a class
  • Can only inherit one class at one time
  • The top parent class for any class in .NET is System.Object
  • System.Object has 4 functions: ToString, Equals, GetHashCode, Finalize.
• Inherit an interface
  • Can inherit several interfaces at one time
  • Can divide the objects (class) and actions (interface) during the inherit

Modify existing classes - Adapter Design Patterns

Adapter pattern is a way to modify the existing classes to meet the new requirements. It has two categories:

• Adapter pattern of class
  • Design a new subclass which inherits previous classes and the new interface
• Adapter pattern of object
  • Design a new subclass which inherits the new interface and get the parameter of previous base class

Additional Knowledge - Abstract Class

• Abstract class
  • The class can only be inherited but cannot be instantiated.
  • All abstract methods in the abstract class need to be override in subclass.
• Abstract function v.s. Virtual functions
  • Abstract function doesn’t have the function body, and it requires to be override in the subclass.
  • Virtual function could have the function body, and it could be override or not in the subclass.

Encapsulation

It is for class to hide some private field or methods but leave public interface for other classes. The rules include

• Field
  • Declare field (variables of class) as private
• Property
  • Declare property as public
  • supporting get and/or set
  • Use property instead of field directly
  • Property is transferred to function during the compile
• Functions
  • Functions that other classes need to call can be declared as public; other functions of classes should be declared as private

Polymorphisn

This allows users to set a base class reference points to different subclass. When call the methods in base class, the same method acts differently according to the implement in subclass. The specific relationship between reference and real methods will be determined after the compile.

We can declare a base class variable / interface but still points to the subclass object. Assume the base class is A, and the subclass is B. When we call a method in A, the compiler will check whether this method was declared virtual.

• If it is not declared virtual, call this method directly.
• If it is declared virtual, then will check whether subclass B has override this method
  • If there is a override method, call this method
  • If there is not override method, recursively check the parent class whether override this method

Interface

• Interface usually ends with able, which shows a kind of ability of the class, also described a can-do.
• Interface is like a class containing abstract methods. The methods inside interface are declared public abstract automatically.
• Methods in interface need to be implemented in the subclass, but no need to use abstract, virtual, override keywords.
• Interface only contains the single category of functions.
• When create a new object, we can declare the pointer as the interface but points to object inherited from the interface.

See here for more info.

Design Principles of OO

The final design principles of OO is Abstract-oriented, loosely coupled.

Single Responsibility Principle

One class only do one thing, and only change due to one reason.

For example, an interface defines the basic actions and class A inherit the interface and implement those actions. Class B adds some judging methods and it also inherits the interface and include a field inheriting from the interface (an object of class A), so class B just call A’s functions instead of implement them.

Open Closed Principle

Open for extension, closed for modifying. Program for abstract instead of specific.

For example, if there will be much similar methods, we can put them into different classes but inherits a same interface. Then we use another manager class to create an interface reference for different classes. When a new method adds into the system, we can just implement the new class inheriting from the interface.

Dependency Inversion Principle

Depends on abstract. Classes should depend on interface rather than other classes.

Some principle:

• Less inheritance, more aggregate
• One-way dependency (Low coupling, high cohesion)
• Encapsulation abstraction
• Dependence should ends on abstract class or interface

For example, use interface pointer to call method. Since different object implement different methods, the method will automatically link to the right method according to the type of created object. When new kinds of methods add, just implement new classes inherited from the interface and previous code don’t need to change.

In other words, we solve the problem of deciding what versions of the similar method to use by the Polymorphisn(different methods have a same interface) rather than write judging code.

Interface Segregation Principle

Use many small interface instead of a big interface.

Class could inherit several interfaces that are useful to the class.

Liskov Substitution Principle

Subclass must be able to replace base class.

Subclass must have all the methods of base class. The base class should declare the method virtual and subclass override that method. This can reduce the unnecessary judging code.

Composite/Aggregate Reuse Principle

Reduce coupling between classes by aggregating existing classes/interface instead of inheriting objects.

One example is the adapter pattern, which is a way to modify the existing classes to meet the new requirements. It has two categories:

• Adapter pattern of class
  • Design a new subclass which inherits previous classes and the new interface
  • Requires to inherit a class, will increasing the coupling between classes
• Adapter pattern of object
  • Design a new subclass which inherits the new interface and contains a field which is the base class of classes that need to be extended
  • Use aggregate (combine class and interface together), reduce coupling

Design Pattern of OO

Dependency / coupling

Kinds of coupling

• Non-coupling: two classes are independent
• Concrete coupling: one class have the reference of another class
• Abstract coupling: one class have the reference of another abstract class, which can achieve the Polymorphisn

Reasons causing the coupling

• Inheritance
• Aggregation
• Interface
• Call methods or reference
• Call services

Design principle to reduce the coupling

• Dependency Inversion Principle (DIP)
  • Add a middle class
  • Let class use the reference of the interface which another class inherits from, instead of use the reference of another class
• Inversion of Control (IoC)
  • Let the system control the code
• Dependency Injection (DI)
  • Interface Injection (Use the parameters of methods of method)
  • Constructor Injection (Use constructor method)
  • Setter Injection (Properties)

Design Pattern to reduce the coupling happening in when need to create(new) an object

• Factory Mode
  • Use interface and generic
• Dependency Injection
  • Use Unity container to create new object
  • Use the resolve method of Unity container to dynamically create different objects inherited from the same abstract class or interface

Design Pattern

| Category | Name | Function |
| — | — |
| Creation Pattern | Factory Method Pattern | A dynamic way to deal with the process when create a new object, especially for creating different objects but those objects have same base class or interface |
| | Singleton Pattern | One class only have one instance |
| Structural model | Bridge Pattern | Divide the implement with the logic |
| | Proxy Pattern | Encapsulation the complex logic, use proxy to control the the create and call the original object |
| | Adapter Pattern | Don’t change previous classes, add new interfaces |
| | Composite Pattern | Use the same method to process all objects in a composite |
| | Decorator Pattern | Dynamically add or remove status or actions |
| | Facade Pattern | Divide the logic layer and the presentation layer |
| Behavioral model | Template Method Pattern | Define the template in base class and implement them in subclass |
| | Iterator Pattern | Provide a method to get every element in a container but not exposure to outside |
| | Chain of Responsibility Pattern | Form the methods a linked list,traverse the linked list and get the right method |
| | Command Pattern | Encapsulation the request as a class, divide the execution of order and duty |
| | Observer Pattern | one v.s. many. One object’s status changes, other objects will get the event, then they will change. e.g. the delegate and event in C# |
| | Strategy Pattern | Encapsulation the part changing a lot as interface |

Object-Oriented & Object-Based

Object-Based: Handle the object with field and method, but the object doesn’t inherit any class, thus no Polymorphisn.

.NET Closure

Closure is the body formed by methods and environment attached to the method. It can allow several methods operate the same element.

Good Code

• Good Name
  • Pascal Casing for namespace, class, interface, method, event, enum
  • Camel Casing for paramenters, private members
  • Attribute, delegate, exception as the suffix
• Security of thread

Reference

1. 《你必须知道的.NET（第二版）》，第1部分，王涛著