Bowen's Tech Blog

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部分，王涛著

Summary for some exercise.

Data structure of string.

Captures some features of Microsoft HoloLens.

Git is a powerful version management system. This posts captures the common used commands.

Microsoft Azure Remote Rendering is a service that can render high-quality, interactive 3D content, and stream it to your devices in real time.

Regular Expression, short as Regex, is an expression method for string.

VS Code is an amazing code editor, which contains various extensions and support multi-languages.

Basic Skills

• Use Ctrl+Shift+P to open the VSCode command center to input command
• Use command center and type Open settings(JSON) to edit the VS Code settings
• Some useful keyboard shortcuts

C#

In order to use VS Code for the C# programming, we need to install

• .NET Core
• C# Extension in VS Code

Then open a folder with VS Code, and use the terminal to type dotnet new console to establish a new console project.

Then the VS Code will automatically generate some files and new a Program.cs script.

Go to Dubug-Start without Debuging, VS Code will add the required assets to the project(or press ctrl+shift+p and type .net: Generate Assets for Build and Debug), and open a launch.json file for user to configure some settings of the C# project. Make sure the version of netcore is right. Then cick the Start without Debuging again, the program will run.

Python

For Python, we need to install

• Python interpreter
• Python Extension in VS Code

Open a folder and add a python file. Then press ctrl+shift+p to open the command and type Python: select interpreter to choose the python interpreter. Then go to Debug-Start without Debuging to run the code.

LaTex

In order to use Latex, we need to install

• Tex Environment, like Tex Live
• Latex Workshop Extension for VS Code

Environment and Packages Management

For environment, you can use virtualenv to create a virtual python environment to seperate this to the original environment.

1

virtualenv XX

Note. the virtual env folder will be located to your current folder of the bash locates. When you change the path of the env folder, it will cause problem for some direct running module. Like pip, jupyter

For packages, you can use the following command to export installed packages in env1 and install those packages in env2

1
2

(env1) $ pip freeze > requirement.txt
(env2) $ pip install -r requirement.text