English FAQ

简体中文常见问题解答

C#Like

v1.1 Update time 2023-02-27

C#Like is an Unity hot update script solution. You can hot update your C# script if you want to hotfix your project.
It support so much C# syntax, So you can easy to make your project into can be hot update.
You can debug code, you can interactive prefab data, you can using coroutine, you can inherit LikeBehaviour as inherit MonoBehaviour.
You don't need to register the type in not hot update script before use it in hot update script.

PLEASE NOTE that C#LikeFree can be downloaded from anywhere, is a FREE asset.
If you do not meet the conditions of Unity's personal license, you cannot use it for commercial purposes.
C#LikeFree is the lite version of the C#Like, it missing some features from full version.
For the user who owned the Unity's personal license, can use it easy to build a hot update project using C#.
For other user, can try to find out C#Like whether worth buying by on trial the C#LikeFree.
The file tree and usage guide of the C#LikeFree is same with C#Like, so the upgrade is very convenient.

Thanks to open source C#Light

As below are the samples which export to WebGL platform (Welcome export the C#LikeFree sample yourself to verify how to hot update script):
C#LikeFree Demo C#Like Demo

Main Features

features	C#Light	C#LikeFree	C#Like
delegate	support	support	support
lambda	support	support	support
object-oriented	interface inherit	adds support partial	adds support constructor(support this/base);destructor;class inherit;virtual function
math expression	+ - * / % += -= *= /= %= > >= < <= != == && \|\| ! ++ --(support i++ but not support ++i) ?: is as	adds full support '++ --'	adds bit operation '& \| ~ ^ &= \|= ^= << >> <<= >>='
keyword	this	this typeof	this base sizeof typeof unsafe $ @ #pragma #warning #error
namespace using	Not support namespace.You must register the type in not hot update script before use it in hot update script.	Support namespace,Don't need to register the type in not hot update script before use it in hot update script,and 'using alias/command/static'.	adds 'using sentence'
exception	throw	same with C#Light	adds try-catch-finally
type	var void bool float double char string byte sbyte int uint short ushort long ulong null	same with C#Light	Adds support Nullable type and Nullable math expression and coalescing operator '?.' and '??'.
get/set Accessor	Only support automatic implement get/set accessor	same with C#Light	Adds custom implement get set accessor
loop	for foreach continue break if-else return while do-while	same with C#Light	Adds switch-case-default
debug	Can print error sentence	In debug mode, you can use breakpoint and step-in to debug your code by VisualStudio. In hot update mode,you can get the stack information (include file name,class name, function name,which line) while got error.	same with C#LikeFree, but greatly reduces the difference between debug mode and hot update mode because support more C# features
compile script	It may take several seconds or even more than ten seconds to compile at runtime, depending on the amount of your code, even if it has been Precompiled into token.	All compilation processes are completed in the editor and saved as binary file. The loading time at runtime is almost negligible. Although the compilation time is basically the same (it even takes more time to build cached data), The loading time gives user an excellent experience.	same with C#LikeFree
MonoBehaviour	not support	You can write your hot update script just same with in normal script. You can regard LikeBehaviour as MonoBehaviour in hot update script.	adds support the coroutine.
multi-threading	not support	support	adds lock syntax
code annotation	//	same with C#Light	// and /**/
macro and region	not support	same with C#Light	#if #elif #else #endif #region #endregion
enum	not support	same with C#Light	support
parameter modifier	not support	same with C#Light	support 'ref out in params'
function overloading	not support	same with C#Light	support
default parameters	not support	same with C#Light	support
CSV	not support	KissCSV	same with C#LikeFree
JSON	not support	KissJSON	same with C#LikeFree
Socket/WebSocket	not support	KissServerFramework is easy use in hot update script, corresponding C# server. This is a most simple and stupid IOCP server framework component include WebSocket/Socket/HTTP/MySQL. All your logic work in A single main thread, you don't need to worry about multi-threading problem. All the heavy work process by framework in background threads. Easy to use database even never hear about SQL. You won't use the SQL knowledge, just need define the struct of database table, and then can use that data and it will automatically synchronize data with client and database.	same with C#LikeFree

C#Like Quick Guide

normal Unity code

C#Like hot update code

We define a simple class, inherit MonoBehaviour, call some Unity periodic functions which most commonly used

using UnityEngine;
                        using System;
                        using System.Collections;
                        
                        namespace CSharpLike
                        {
                            /// <summary>
                            /// Sample for HelloWorld.
                            /// Show the most simple usage of the Unity periodic functions.
                            /// (support all MonoBehaviour event,but we just show the some of them.)
                            /// And the usage of coroutine
                            /// </summary>
                            public class SampleHelloWorld : MonoBehaviour
                            {
                                void Awake()
                                {
                                    gameObject.name = "I'm MonoBehaviour";
                                    Debug.Log("Awake");
                                }
                                void OnEnable()
                                {
                                    Debug.Log("OnEnable");
                                }
                                IEnumerator Start()
                                {
                                    Debug.Log("Start:return type is IEnumerator mean coroutine mode");
                                    Debug.Log("Start:before WaitForSeconds:" + DateTime.Now);
                                    yield return new WaitForSeconds(2f);
                                    Debug.Log("Start:after WaitForSeconds:" + DateTime.Now);
                                /*'StartCoroutine(string methodName, object obj)' only support ONE param,
                                so we have to use 'StartCoroutine(IEnumerator routine)' because have 3 params.
                                We call a sub coroutine with 3 params for example.*/
                                    yield return StartCoroutine(SubCoroutine("test string", 123, -1f));
                                    Debug.Log("Start:after SubCoroutine:" + DateTime.Now);
                                    //usage of stop coroutine:same with MonoBehaviour
                                    ////StopCoroutine("SubCoroutine");
                                    //StopAllCoroutines();
                                }
                                //the coroutine call by Start() 
                                IEnumerator SubCoroutine(string strValue, int iValue, float fValue)
                                {
                                    Debug.Log("SubCoroutine(" + strValue + "," + iValue + "," + fValue + ")");
                                    yield return new WaitForSeconds(2f);
                                    if (fValue > 0f)
                                        yield break;
                                    else
                                    {
                                        //test Nullable type '?' coalescing operator '?.' and '??'
                                        System.Random r = null;//new System.Random();
                                        int? i = r?.Next(1000);
                                        Debug.Log("SubCoroutine:i=" + (i ?? iValue));
                                    }
                                    yield return new WaitForEndOfFrame();
                                    Debug.Log("SubCoroutine:end:" + DateTime.Now);
                                }
                                void FixedUpdate()
                                {
                                    Debug.Log("FixedUpdate");
                                }
                                float angle = 0f;
                                void Update()
                                {
                                    //Debug.Log("Update");
                                    angle += Time.deltaTime * 50f;
                                    transform.localEulerAngles = new Vector3(0f, angle, 0f);
                                }
                                void LateUpdate()
                                {
                                    Debug.Log("LateUpdate");
                                }
                                void OnGUI()
                                {
                                    Debug.Log("OnGUI");
                                }
                                void OnDisable()
                                {
                                    Debug.Log("OnDisable");
                                }
                                void OnDestroy()
                                {
                                    Debug.Log("OnDestroy");
                                }
                            }
                        }

Here are the same with the left side normal code, but using the hot update script.You can check it out the difference.

using UnityEngine;
                        using System;
                        using System.Collections;
                        
                        namespace CSharpLike
                        {
                            /// <summary>
                            /// Sample for HelloWorld.
                            /// Show the most simple usage of the Unity periodic functions.
                            /// (support all MonoBehaviour event,but we just show the some of them.)
                            /// And the usage of coroutine
                            /// </summary>
                            public class SampleHelloWorld : LikeBehaviour
                            {
                                void Awake()
                                {
                                    //same with the gameObject of MonoBehaviour
                                    gameObject.name = "I'm LikeBehaviour";
                                    Debug.Log("Awake:same with MonoBehaviour");
                                }
                                void OnEnable()
                                {
                                    Debug.Log("OnEnable:same with MonoBehaviour");
                                }
                                IEnumerator Start()
                                {
                                    Debug.Log("Start:return type is IEnumerator mean coroutine mode");
                                    Debug.Log("Start:before WaitForSeconds:" + DateTime.Now);
                                    yield return new WaitForSeconds(2f);
                                    Debug.Log("Start:after WaitForSeconds:" + DateTime.Now);
                                /*support 'Coroutine StartCoroutine(string methodName, params object[] vars)'.
                                not support 'Coroutine StartCoroutine(IEnumerator routine)'.
                                We call a sub coroutine with 3 params for example.*/
                                    yield return StartCoroutine("SubCoroutine", "test string", 123, -1f);
                                    Debug.Log("Start:after SubCoroutine:" + DateTime.Now);
                                    ////usage of stop coroutine:same with MonoBehaviour
                                    //StopCoroutine("SubCoroutine");
                                    //StopAllCoroutines();
                                }
                                //the coroutine call by Start() 
                                IEnumerator SubCoroutine(string strValue, int iValue, float fValue)
                                {
                                    Debug.Log("SubCoroutine(" + strValue + "," + iValue + "," + fValue + ")");
                                    yield return new WaitForSeconds(2f);
                                    if (fValue > 0f)
                                        yield break;
                                    else
                                    {
                                        //test Nullable type '?' coalescing operator '?.' and '??'
                                        System.Random r = null;//new System.Random();
                                        int? i = r?.Next(1000);
                                        Debug.Log("SubCoroutine:i=" + (i ?? iValue));
                                    }
                                    yield return new WaitForEndOfFrame();
                                    Debug.Log("SubCoroutine:end:" + DateTime.Now.ToString());
                                }
                                void FixedUpdate()
                                {
                                    Debug.Log("FixedUpdate:same with MonoBehaviour");
                                }
                                float angle = 0f;
                                void Update()
                                {
                                    //Debug.Log("Update:same with MonoBehaviour");
                                    angle += Time.deltaTime * 50f;
                                    //same with the transform of MonoBehaviour
                                    transform.localEulerAngles = new Vector3(0f, angle, 0f);
                                }
                                void LateUpdate()
                                {
                                    Debug.Log("LateUpdate:same with MonoBehaviour");
                                }
                                void OnGUI()
                                {
                                    Debug.Log("OnGUI:same with MonoBehaviour");
                                }
                                void OnDisable()
                                {
                                    Debug.Log("OnDisable:same with MonoBehaviour");
                                }
                                void OnDestroy()
                                {
                                    Debug.Log("OnDestroy:same with MonoBehaviour");
                                }
                            }
                        }

C#Like how to interactive data with Unity prefab

setting prefab in unity editor

interactiv in hot update script

As shown below, show how to get/set value and component which binding in prefab. BindHotUpdateClassFullName is the full name of the class with Namespace.

As shown below, it's the binding hot update script.

using System;
                        using UnityEngine;
                        using UnityEngine.UI;
                        
                        namespace CSharpLike
                        {
                            /// <summary>
                            /// Sample for interactive prefab data
                            /// </summary>
                            public class SampleInteractivePrefabData : LikeBehaviour
                            {
                                void Start()
                                {
                                    //the instance of the HotUpdateBehaviour which inherit the MonoBehaviour.
                                    Debug.Log("HotUpdateBehaviour=" + behaviour);
                                    //same with the gameObject of MonoBehaviour
                                    Debug.Log("gameObject.name=" + gameObject.name);
                                    //same with the transform of MonoBehaviour
                                    Debug.Log("transform.localPosition=" + transform.localPosition);
                        
                                    //We can get/set value(int/bool/float/double/string) which binding in prefab(key by string).
                                    //Here are the example for the integer value.
                                    //Get the integer value which binding in prefab.
                                    //For example,we blinding the key 'iValueA' with value 123 in prefab.
                                    //GetBoolean/GetDouble/GetFloat/GetString
                                    Debug.Log("integer value set in prefab:iValue=" + GetInt("iValueA"));
                                    //Modify the integer value, It will refresh the value in editor.
                                    //You also can modify it in editor when running.
                                    SetInt("iValueA", 321);//SetBoolean/SetDouble/SetFloat/SetString
                                    //Verify the integer value after modify
                                    Debug.Log("integer value after modify:iValue=" + GetInt("iValueA"));

//We can accept the Unity Component(GameObject/TextAsset/Material/Texture/AudioClip)
                                    //which binding in prefab(key by string)
                                    //Here are the example for get the 'GameObject' which bind at the gameObjects in HotUpdateBehaviour 
                                    GameObject goStart = GetGameObject("ButtonStart");
                                    goStart.SetActive(true);

//Here are the example for get the UnityEngine.UI.Text in prefab.
                                    //You can get 'runtime' component which bind at the gameObjects in HotUpdateBehaviour.
                                    //You also can get any type which can get by GameObject.GetComponent<T>() in MonoBehaviour.
                                    //such as Image/Button/Slider/MeshRenderer/...
                                    Text text = GetComponent<Text>("TextMsg");

//Here are the example for get TextAsset 'resource' which bind in prefab.
                                    //Such as we bind some TextAsset resource to prefab, that can't drag into GameObject at editor.
                                    TextAsset ta = GetTextAsset("LoadTextAsset");//GetMaterial/GetTexture/GetAudioClip
                                    Debug.Log("Load TextAsset:" + ta.text);
                                    text.text = ta.text;
                                }
                                void OnClick()//response of 'ButtonStart' button
                                {
                                    SetInt("iValueA", GetInt("iValueA") + 1);
                                    GetComponent<Text>("TextMsg").text = DateTime.Now.ToString();
                                }
                                void OnClickBack()//response of 'back' button
                                {
                                    SampleCSharpLike.instance.gameObject.SetActive(true);//back to SampleCSharpLike
                                    HotUpdateManager.Hide("Sample/SampleInteractivePrefabData");//close self
                                }
                            }
                        }

C#Like no need register before use

C#Light

C#Like

You must register the type in not hot update script before use it in hot update script.

Just direct use in hot update script,no need register

IL2CPP Stripping

Type Stripping

Generic type

IL2CPP will strip the engine code if they are not be use. Unfortunately, our hot update script happens to be the strip one. You must set 'Managed Stripping Level' to 'Low' or 'Medium' (can't set to 'High'). Check which *.dll that you'll be use in the future in the folder '{Unity install folder}\Editor\Data\Managed\UnityEngine\'. And then the modify 'Assets\C#Like\link.xml', make sure your type wont be stripping by IL2CPP.

Because you can't JIT the generic type in IL2CPP,and must AOT. All the generic type must be used once in not hot update script before use in hot update script. We will automatic generate 'Assets\C#Like\Runtime\AheadOfTime\AheadOfTime.cs' while compile script. Theoretically all your generic types almost be generated when you finally release your product. Here is the file automatic generate in sample. Don't modify this file manually.

C#Like usage guide

File tree framework

C#Like
    |
    |--Documentation
    |    |-C#LikeManual.pdf        //Manual of C#Like
    |
    |--Editor                      //C#LikeEditor, you can ignore it
    |
    |--HotUpdateScripts            //Default folder for hot update script. You can delete it while you final 
    |    |                         //build your project to user, but remember backup it.
    |    |--Sample                 //Sample of the hot update script,you can delete this folder at any time.
    |        |--SampleChatRoom.cs                          //Chat room connet with a KissFramework server
    |        |--SampleInteractivePrefabData.cs             //Sample for interactive prefab data 
    |        |--SampleHelloWorld.cs                        //Sample for HelloWorld and the usage of coroutine
    |        |--SampleC#                                   //Sample for C# function in hot update script
    |        |--AircraftBattle                             //An aircraft battle game sample make with hot update script
    |        |--NetObjects                                 //Transfer object between client and game server
    |        |--SampleSocket.cs                            //Sample for how to use KissFramework by Socket/WebSocket 
    |
    |--Resources
    |    |--Sample                 //The resources of the Sample, you can delete this folder at any time.
    |
    |--Runtime
    |    |--AheadOfTime            //Automatic generation by CSharpLikeEditor for IL2CPP, don't modify it
    |    |--Interaction            //Interaction with user.
    |    |    |--CLS_Environment.cs               //The compare with C#Light/C#LikeFree/C#Like, and statement of the 'C#Light' author
    |    |    |--CSL_Utils.cs                     //custom Encrypt/Decrypt the final binary file
    |    |    |--HotUpdateBehaviour.cs            //Hot update script behaviour Which interactive with Unity prefab,
    |    |    |                                   //include 'Awake/OnEnable/Start/OnDisable/OnDestroy' behaviour only.
    |    |    |--HotUpdateManager.cs              //Hot update script manager
    |    |    |--LikeBehaviour.cs                 //Hot update script base class 'MonoBehaviour'. If you want to interactive with Unity prefab,
    |    |    |                                   //your class must Inherit from LikeBehaviour.You can think of it as MonoBehaviour in hot update script.
    |    |    |--MyCustomConfig.cs                //Custom configuration
    |    |    |--MyHotUpdateManager.cs            //Custom hot update script manager
    |    |    |--HotUpdateBehaviourCustom         //You should custom your HotUpdateBehaviour base on HotUpdateBehaviour,
    |    |        |                               //so you can include more behaviours except 'Awake/OnEnable/Start/OnDisable/OnDestroy' behaviour
    |    |        |--HotUpdateBehaviourAll.cs             //Include 'ALL' behaviours in MonoBehaviour.It's a backup plan in case for
    |    |        |                                       //you forgot add your custom behaviour,we don't recommend use it.
    |    |        |--HotUpdateBehaviourApplication.cs     //Include 'OnApplicationFocus/OnApplicationPause/OnApplicationQuit' behaviours
    |    |        |--HotUpdateBehaviourCollision.cs       //Include 'OnCollisionEnter/OnCollisionExit/OnCollisionStay' behaviours
    |    |        |--HotUpdateBehaviourCollision2D.cs     //Include 'OnCollisionEnter2D/OnCollisionExit2D/OnCollisionStay2D' behaviours
    |    |        |--HotUpdateBehaviourCommon.cs          //Include 'FixedUpdate/LateUpdate/Update/OnGUI' behaviours
    |    |        |--HotUpdateBehaviourFixedUpdate.cs     //Include 'FixedUpdate' behaviour
    |    |        |--HotUpdateBehaviourLateUpdate.cs      //Include 'LateUpdate' behaviour
    |    |        |--HotUpdateBehaviourOnGUI.cs           //Include 'OnGUI' behaviour
    |    |        |--HotUpdateBehaviourTrigger.cs         //Include 'OnTriggerEnter/OnTriggerExit/OnTriggerStay' behaviours
    |    |        |--HotUpdateBehaviourTrigger2D.cs       //Include 'OnTriggerEnter2D/OnTriggerExit2D/OnTriggerStay2D' behaviours
    |    |        |--HotUpdateBehaviourUpdate.cs          //Include 'Update' behaviour
    |    |        |--HotUpdateBehaviourUpdateTrigger2D.cs //Include 'OnCollisionEnter2D/OnCollisionExit2D/OnTriggerStay2D/Update' behaviours
    |    |
    |    |--Internal                              //The internal core of the C#Like (Network and virtual machine), you can ignore it.
    |    |--KissCSV                               //Read CSV file specially made for C#Like.
    |    |--KissJson                              //JSON serialize library specially made for C#Like.
    |    |--Sample                                //The not hot update script of the Sample,you can delete this folder at any time.
    |         |--SampleCSharpLike.cs              //The sample for show how to use C#Like.Include initialize C#Like
    |         |                                   //and load hot update script binary file and call prefab which using hot update script.
    |         |--SampleNotHotUpdateScript.cs      //The not hot update script use by sample
    |         |--MyAnchor.cs                      //The scene anchor use by sample
    |         |--MyRoot.cs                        //The scene root use by sample
    |
    |--Scenes
    |    |--SampleScene.unity                     //The scene of the example,you can delete this folder at any time.
    |
    |--Plugins
         |--WebGL                                 //WebSocket lib use in WebGL.

Usage guide for the whole framework(C#Lkie+KissServerFramework). If you just care about C#Lkie, you can just need to read step 6.

1 Setup 'KissServerFramework' server
	1.1 Download source code of the server, and then using Visual Studio complie and public into a single EXE file(You can direct use the EXE file that I public if your don't want to complie yourself),put it to 'C:\KissServerFramework':
		C:\KissServerFramework
			|
			|--CSV
			|  |--Item.csv						//CSV file for test only
			|
			|--KissServerFramework.exe			//Main EXE file
			|--KissServerFramework.json			//config JSON file
			|--kiss.sql							//The SQL file use in step 3 only

1.2 If your computer did not installed .NET5 runtime library, you should go to Microsoft web site download and install it. https://download.visualstudio.microsoft.com/download/pr/a0832b5a-6900-442b-af79-6ffddddd6ba4/e2df0b25dd851ee0b38a86947dd0e42e/dotnet-runtime-5.0.17-win-x64.exe
	1.3 You can modify WebSocket port(default is 9000) and Socket port(default is 9001) and HTTP port(default is 9002) in 'KissServerFramework.json' IF you need to.
	1.4 Open the 9000-9002 TCP port IF your computer protected by Firewall.

2 Setup XAMPP
	2.1 Go to XAMPP web site download it. https://www.apachefriends.org/download.html
	2.2 Click 'Next' until XAMPP install done.(Default install to 'C:/xampp')
	2.3 Make sure both the MySQL and Apache is running, you can check it in 'XAMPP Control Panel'.
	2.4 Open the 80 TCP port IF your computer protected by Firewall.

3 Create Database 'kiss' and import from 'kiss.sql'
	3.1 Double-click to run 'files/CreateDatabase.bat' to create database 'kiss'. (Click 'Enter' while ask for password because no password as default). Modify the BAT file if your install folder is not 'C:/xampp'.
	3.2 Double-click to run 'files/ImportDatabase.bat' to import from 'kiss.sql'. (Click 'Enter' while ask for password because no password as default). Modify the BAT file if your install folder is not 'C:/xampp'.

4 (Optional step)HTTP upgrade to HTTPS, WS upgrade to WSS, change RSA certificate that use in Socket 
	4.1 Prefare SSL certificate, You can go to Tencent( https://console.cloud.tencent.com/ssl ) or "Let's Encrypt"( https://letsencrypt.org/ )apply for a free SSL certificate or buy one. I was apply the free one year SSL certificate from Tencent, and download the Apache version and Nginx version reserve for next step.
	4.2 Setup Nginx proxy
		4.2.1 Go to Nginx web site download it. http://nginx.org/en/download.html Normaly we download the stable version, we take 'nginx.Windows-1.22.1' for example.
		4.2.2 Unzip the 'nginx-1.22.1.zip' to 'C:\'.
		4.2.3 Copy 'files/QuitNginx.bat' 'files/RetartNginx.bat' 'files/StartNginx.bat' 'files/StopNginx.bat' to Nginx folder.
		4.2.4 "files/nginx.conf" replace "C:\nginx-1.22.1\conf\nginx.conf"
		4.2.5 Unzip the Nginx version SSL certificate to 'C:\nginx-1.22.1\conf\xxxx.com\'
			Final file tree:
			C:\nginx-1.22.1
				|
				|--conf
				|  |--xxxx.com				//Nginx version SSL certificate
				|  |   |--xxxx.com_bundle.crt
				|  |   |--xxxx.com.key
				|  |
				|  |--nginx.conf			//Nginx config file
				|
				|--contrib
				|--docs
				|--html
				|--logs
				|--temp
				|--nginx.exe
				|
				|--QuitNginx.bat			//Double-click it to quit Nginx
				|--RetartNginx.bat			//Double-click it to restart Nginx, use it after modify 'nginx.conf'
				|--StartNginx.bat			//Double-click it to start Nginx, use it in the first run Nginx
				|--StopNginx.bat			//Double-click it to stop Nginx

4.2.6 Modify 'C:/nginx-1.22.1/conf/nginx.conf', change the 'xxxx.com' into your real domain. In my case I use 'csharplike.com' replace 'xxxx.com'
		4.2.7 You can change the WSS port and WS port and HTTPs port and HTTP port IF you need to. Open the 10000 and 10002 TCP port IF your computer protected by Firewall.
		4.2.8 Modify 'C:\KissServerFramework\KissServerFramework.json' because we use WSS and HTTPS now:
			"WebSocketURI": "wss://www.xxxx.com:10000" INSIDE the 'serverInfos' node
			"HttpURI": "https://www.xxxx.com:10002" INSIDE the 'serverInfos' node
		4.2.9 Finally remember execute 'StartNginx.bat' to start Nginx (Execute 'RetartNginx.bat' IF you had been run Nginx).

4.3 Setup Apache SSL certificate
		4.2.1 Unzip the Apache version SSL certificate to 'C:\xampp\apache\conf\xxxx.com\'
		4.2.2 Modify 'C:\xampp\apache\conf\extra\httpd-ssl.conf'
			SSLCertificateFile "C:/xampp/apache/conf/xxxx.com/xxxx.com.crt"
			SSLCertificateKeyFile "C:/xampp/apache/conf/xxxx.com/xxxx.com.key"
			SSLCertificateChainFile "C:/xampp/apache/conf/xxxx.com/root_bundle.crt"
			Please replace the 'xxxx.com' to your real domain. In my case I use 'csharplike.com' replace 'xxxx.com'
		4.2.3 Open the 443 TCP port IF your computer protected by Firewall.

4.4 Restart the Apache server make the config take effect. (Click Start button after click Stop button in 'XAMPP Control Panel')

4.5 Our socket encrypt by RSA first and then encrypt by AES, you should modify the default RSA certificate to your unique.
		4.5.1 Generate RSA certificate
			'Menu/Window/C#Like' open the setting panel of C#Like, click 'Generate RSA' button, will generate 'Assets\C#Like\Editor\RSAPublicKey.txt' and 'Assets\C#Like\Editor\RSAPrivateKey.txt' two files.
		4.5.2 Modify the KissServerFramework config
			Modify 'socketServerRSAPrivateKey' value in 'C:\KissServerFramework\KissServerFramework.json' to the conten of 'Assets\C#Like\Editor\RSAPrivateKey.txt'
		4.5.3 Modify the C#Like config
			Modify 'socketRSAPublicKey' value in 'Assets\C#Like\HotUpdateScripts\Sample\SampleSocket.cs' to the conten of 'Assets\C#Like\Editor\RSAPublicKey.txt'

5 Double-click 'C:/KissServerFramework/KissServerFramework.exe' to start KissServerFramework
	5.1 If the EXE crash down, that may be not exist .NET runtime library, your should check the tips in 'Event Viewer' and download it from Microsoft web site.
	5.2 If the console just only show 'KissFramework version : 1.0.x.x' mean the port was used. You can click 'NetStat' button in 'XAMPP Control Panel' to check whick port was used.

6 Export C#Like or C#LikeFree to WebGL platform
	6.1 Create a empty 2D Unity project.
	6.2 Import C#Like or C#LikeFree plugin.
	6.3 Modify the HTTP connect domain and port in "Assets\C#Like\Runtime\Sample\SampleCSharpLike.cs"
		6.3.1 e.g. In HTTP:
			https://www.csharplike.com:10002/ReqGateway => http://127.0.0.1:9002/ReqGateway
		6.3.2 e.g. In HTTPS:
			https://www.csharplike.com:10002/ReqGateway => https://[Your domain]:[Your port]/ReqGateway
	6.4 'Menu/Window/C#Like' open the setting panel of C#Like. Click 'Rebuild Scripts' button, compile all '*.cs' files in 'Assets\C#Like\HotUpdateScripts' into binary file 'Assets\StreamingAssets\output.bytes'.
	6.5 (Optional step) : Delete the hold 'Assets\C#Like\HotUpdateScripts' folder after backup, to verify that our hot update script is really can be hot update!
	6.6 Click '/Assets/C#Like/Scenes/SampleScene.unity' to open the demo scene in Unity editor.
	6.7 'Menu/File/Build Settings...' open 'Build Settings' panel.
		6.7.1 Click 'Add Open Scenes' button, make 'C#Like/Scenes/SampleScene' to be the first scens in 'Scenes In Build'
		6.7.2 Choose 'WebGL' and then click 'Switch Platform' button, switch the current plaform to WebGL
		6.7.3 Click 'Player Setting...' button, and then modify as you need.
			6.7.3.1 "Resolution and Presentation"
				"Default Canvas Width" 600
				"Default Canvas Height" 960
				"Run In Background" "v"
			6.7.3.2 "Other Settings"
				"Api Compatibility Level" ".NET Standard 2.0"
				"Strip Engine Code" "v"
				"Managed Stripping Level" "Medium"
			6.7.3.3 "Publishing Settings"
				"Enable Exceptions" "Explicitly Thrown Exceptions Only"
				"WebAssembly Arithmetic Exceptions" "Throw"
				"Compression Format" "Gzip"
				"Data Caching" "v"
				"Decompression Fallback" "v"
		6.7.4 Click 'Build' button to export the final WebGL folder
			6.7.4.1 e.g. C#Like export to folder CSharpLikeDemo
			6.7.4.2 e.g. C#LikeFree export to folder CSharpLikeFreeDemo

7 Copy exported folder to 'C:\xampp\htdocs'
	7.1 e.g. Copy the 'CSharpLikeDemo' that exported in step '6.7.4.1' to 'C:\xampp\htdocs'
		7.1.1 e.g. in my case visit the demo by link : https://www.csharplike.com/CSharpLikeDemo/index.html
		7.1.2 e.g. in the local with no SSL certificate, you can visit the demo by link : http://127.0.0.1/CSharpLikeDemo/index.html
	7.2 e.g. Copy the 'CSharpLikeFreeDemo' that exported in step '6.7.4.2' to 'C:\xampp\htdocs'
		7.1.1 e.g. in my case visit the demo by link : https://www.csharplike.com/CSharpLikeFreeDemo/index.html
		7.1.2 e.g. in the local with no SSL certificate, you can visit the demo by link : http://127.0.0.1/CSharpLikeFreeDemo/index.html

Convenient KissJson

Can use both in normal script and hot update script, you can easy convert between JSON string and class/struct(include hot update script and normal script), and the JSONData is supper easy to use.

using CSharpLike.SubclassEx3;
                        using System.Collections.Generic;
                        using UnityEngine;
                        
                        namespace CSharpLike
                        {
                            public partial class SampleCSharp : LikeBehaviour
                            {
                                void TestKissJson()
                                {
                                    Debug.LogError("Test TestKissJson:");
                                    
                                    //Build-In-Type::
                                    //byte/sbyte/char/bool/short/ushort/int/uint/long/ulong/double/float/string,
                                    //byte?/sbyte?/char?/bool?/short?/ushort?/int?/uint?/long?/ulong?/double?/float?,
                                    //List<Build-In-Type:>,
                                    //Dictionary<string, Build-In-Type:>
                        
                                    //Direct assign value 'both' between Build-In-Type and JSONData.
                                    //You can direct assign Build-In-Type value to JSONData, Or direct assign JSONData value to Build-In-Type.
                        
                                    //test Build-In-Type => JSONData
                                    JSONData iData = 2;
                                    Debug.Log("JSONData iData = 2;  test iData = " + iData);//output 2
                                    JSONData fData = 88.8f;
                                    Debug.Log("JSONData fData = 88.8f;  test fData = " + fData);//output 88.8
                                    List<string> listValue = new List<string>();
                                    listValue.Add("test list str1");
                                    listValue.Add("test list str2");
                                    JSONData listData = listValue;
                                    Debug.Log("JSONData listData = listValue;  test listData = " + listData);//output ["test list str1","test list str2"]
                                    Dictionary<string, int> dictValue = new Dictionary<string, int>();
                                    dictValue.Add("key1", 11);
                                    dictValue.Add("key2", 22);
                                    JSONData dictData = dictValue;
                                    Debug.Log("JSONData dictData = dictValue;  test dictData = " + dictData);//output {"key1":11,"key2":22}
                        
                                    //test JSONData =>  Build-In-Type
                                    int iValue = iData;
                                    Debug.Log("int iValue = iData;  test iValue = " + iValue);//output 2
                                    float fValue = fData;
                                    Debug.Log("float fValue = fData;  test fValue = " + fValue);//output 88.8
                                    List<string> listValue2 = listData;
                                    string strTemp = "";
                                    foreach (var str in listValue2)
                                        strTemp += str + ",";
                                    Debug.Log("List<string> listValue2 = listData;  test listValue2 = " + strTemp);//output test list str1,test list str2,
                                    Dictionary<string, int> dictValue2 = dictData;
                                    strTemp = "";
                                    foreach (var item in dictValue2)
                                        strTemp += "(" + item.Key + "=" + item.Value + ")";
                                    Debug.Log("Dictionary<string, int> dictValue2 = dictData;  test dictValue2 = " + strTemp);//output (key1=11)(key2=22)
                        
                                    //test JSON string => JSONData
                                    string strJson = @"{
                            ""str"": ""{test str"",
                            ""i"": 11,
                            ""j"": 2.3,
                            ""k"": [
                                3,
                                null,
                                {
                                    ""m"": true
                                }
                            ],
                            ""l"": {
                                ""x"": 1,
                                ""y"": ""abc""
                            }
                        }";//@keyword same with 'string strJson = "{\"str\":\"{test str\",\"i\":11,\"j\":2.3,\"k\":[3,null,{\"m\":true}],\"l\":{\"x\":1,\"y\":\"abc\"}}";'
                                    JSONData data = KissJson.ToJSONData(strJson);
                                    //accept JSONData by ["key"] and [index]
                                    Debug.Log("JSON string => JSONData; test data[\"str\"] = " + data["str"]);//output {test str
                                    Debug.Log("JSON string => JSONData; test data[\"i\"] = " + data["i"]);//output 11
                                    Debug.Log("JSON string => JSONData; test data[\"j\"] = " + data["j"]);//output 2.3
                                    Debug.Log("JSON string => JSONData; test data[\"k\"] = " + data["k"]);//output [3,null,{"m":true}]
                                    Debug.Log("JSON string => JSONData; test data[\"l\"] = " + data["l"]);//output {"x":1,"y":"abc"}
                                    Debug.Log("JSON string => JSONData; test data[\"k\"][0] = " + data["k"][0]);//output 3
                                    Debug.Log("JSON string => JSONData; test data[\"l\"][\"y\"] = " + data["l"]["y"]);//output abc
                                    Debug.Log("JSON string => JSONData; test data[\"k\"][2][\"m\"] = " + data["k"][2]["m"]);//output true
                        
                                    //test Math Expression between JSONData with Build-In-Type
                                    JSONData exprData1 = 2;
                                    JSONData exprData2 = 3;
                                    JSONData exprData3 = exprData1 * exprData2;//test +-*/
                                    Debug.Log("test Math Expression;  exprData3 = exprData1 * exprData2; exprData3 = " + exprData3);//output 6
                                    exprData3 = exprData1 << 5;//test bit operation
                                    Debug.Log("test Math Expression;  exprData3 = exprData1 << 5; exprData3 = " + exprData3);//output 64
                                    exprData3 = exprData1 - exprData2;
                                    Debug.Log("test Math Expression;  exprData3 = exprData1 - exprData2; exprData3 = " + exprData3);//output -1
                                    exprData3 *= exprData2;//exprData3=-1;exprData2=3
                                    Debug.Log("test Math Expression;  exprData3 *= exprData2; exprData3 = " + exprData3);//output -3
                        
                                    iData = 2;
                                    if (iData > 1)//test compare operation
                                        Debug.Log("test Math Expression;  iData = 2, enter if (iData > 1)");//output
                                    else
                                        Debug.Log("test Math Expression;  iData = 2, not enter if (iData > 1)");
                        
                                    //test JSONData => JSON string
                                    JSONData listData3 = JSONData.NewDictionary();//create a JSONData object
                                    listData3.Add("key1", 10);         //add data like Dictionary use function 'Add(key,value)'
                                    listData3["key2"] = "test string"; //add data like Dictionary use index set 'this[]'
                                    listData3["key3"] = JSONData.NewList(); //we add a list
                                    if (listData3.ContainsKey("key3"))  //make sure the key 'key3' exist if you don't know whether exist(just for example here, actually, we don't need to)
                                        listData3["key3"].Add(1);       //add some data to the list
                                    listData3["key3"].Insert(0,"string2"); //insert some data to the list,we don't check the key 'key3' exist because we just know it exist!
                                    listData3["key4"] = JSONData.NewDictionary(); //we add a JSONData to it
                                    listData3["key4"]["x"] = 1;
                                    listData3["key4"]["y"] = 2;
                                    listData3["key4"]["z"] = 3;
                                    Debug.Log("test JSONData => JSON string; strJson = " + listData3.ToJson());//output {"key1":10,"key2":"test string","key3":["string2",1],"key4":{"x":1,"y":2,"z":3}}
                        
                                    //test looping through the List or Dictionary in JSONData
                                    foreach (var item in listData3["key3"].Value as List<JSONData>)//foreach looping through the List
                                    {
                                        Debug.Log("test looping through the List in JSONData using foreach; listData3[\"key3\"].Value = " + item);//output string2/output 1
                                    }
                                    List<JSONData> tempList = listData3["key3"].Value as List<JSONData>;//for looping through the List
                                    for (int i=0; i< tempList.Count; i++)
                                        Debug.Log("test looping through the List in JSONData using for; listData3[\"key3\"].Value = " + tempList[i]);//output string2/output 1
                                    foreach (var item in listData3["key4"].Value as Dictionary<string, JSONData>)//foreach looping through the Dictionary
                                    {
                                        Debug.Log("test looping through the Dictionary in JSONData using foreach; listData3[\"key4\"], Key=" + item.Key + ",Value=" + item.Value);
                                        //output Key=x,Value=1/output Key=y,Value=2/output Key=z,Value=3
                                    }
                                    
                                    //test JSON string => class/struct
                                    strJson = "{\"str\":\"{test str\",\"i\":11,\"j\":1,\"z\":2,\"k\":[3,null,7],\"datas\":{\"aa\":{\"id\":1,\"name\":\"aaa\",\"v2\":{\"x\":1,\"y\":2},\"info\":[\"a\",\"xd\",\"dt\"],\"maps\":{\"x\":1,\"y\":2}},\"bb\":{\"id\":2,\"name\":\"bbb\",\"v2\":{\"x\":3,\"y\":4},\"info\":[\"x\",\"x3d\",\"ddt\"],\"maps\":{\"x\":2,\"y\":3}}},\"data\":{\"id\":3,\"name\":\"ccc\",\"v2\":{\"x\":3,\"y\":1},\"info\":[\"ya\",\"xyd\",\"drt\"],\"maps\":{\"x\":3,\"y\":4}}}";
                                    TestJsonData testJsonDdata = (TestJsonData)KissJson.ToObject(typeof(TestJsonData), strJson);//JSON string => class/struct
                                    //test data after convert
                                    Debug.Log(testJsonDdata.str);//output Null
                                    Debug.Log(testJsonDdata.i);//output 11
                                    //"j":"Monday" or "j":"1" or "j":1 are both identified as 'DayOfWeek.Monday'
                                    //recommend use "j":1 because ToJson output as number
                                    Debug.Log(testJsonDdata.j);//output Monday
                                    Debug.Log((int)testJsonDdata.j);//output 1
                                    Debug.Log(testJsonDdata.z);//output 2
                                    Debug.Log(HotUpdateManager.ConvertEnumString(typeof(TestHotUpdateEnum),testJsonDdata.z));//output Evening
                                    foreach (var item in testJsonDdata.k)
                                        Debug.Log(item);//output 3/output null/output 7
                                    foreach(var datas in testJsonDdata.datas)
                                    {
                                        Debug.Log(datas.Key);//output aa/output bb
                                        Debug.Log(datas.Value.v2);//output (1.0, 2.0)/output (3.0, 4.0)
                                    }
                                    
                                    //test class => JSON string
                                    strTemp = KissJson.ToJson(testJsonDdata);//class => JSON string
                                    Debug.Log(strTemp);//output {"i":11,"j":1,"z":2,"k":[3,null,7],"datas":{"aa":{"id":1,"name":"aaa","v2":{"x":1,"y":2},"info":["a","xd","dt"],"maps":{"x":1,"y":2}},"bb":{"id":2,"name":"bbb","v2":{"x":3,"y":4},"info":["x","x3d","ddt"],"maps":{"x":2,"y":3}}},"data":{"id":3,"name":"ccc","v2":{"x":3,"y":1},"info":["ya","xyd","drt"],"maps":{"x":3,"y":4}}}
                                }
                            }
                            namespace SubclassEx3
                            {
                                /// <summary>
                                /// test class <=> JSON
                                /// </summary>
                                public class TestJsonDataSub
                                {
                                    public int? id;//test Nullable
                                    public string name;
                                    public Vector2 v2;//you can add other class/struct type(in hot update script or normal),such as Color/Rect/Vector3/...
                                    public List<string> info;//direct is List
                                    public Dictionary<string, int> maps;//can convert a Dictionary which key type is string
                                }
                                /// <summary>
                                /// test JSON string <=> class/struct, be mark as KissJsonDontSerialize
                                /// </summary>
                                [KissJsonDontSerialize]//mark the class as KissJsonDontSerialize,will ignore while serialize JSON
                                public class TestJsonDataSub2
                                {
                                    public int id;
                                }
                                /// <summary>
                                /// test class/struct <=> JSON
                                /// </summary>
                                public class TestJsonData
                                {
                                    [KissJsonDontSerialize]
                                    public string str;//will ignore while serialize JSON because be mark as KissJsonDontSerialize
                                    public int i;
                                    public DayOfWeek j;//test enum of not hot update
                                    public TestHotUpdateEnum z;//test enum of hot update
                                    public List<int?> k;
                                    public Dictionary<string, TestJsonDataSub> datas;//test Dictionary for class/struct
                                    public TestJsonDataSub data;//test single class/struct
                                    public TestJsonDataSub2 data2;//will ignore while serialize JSON because the class 'TestJsonDataSub2' mark as KissJsonDontSerialize
                                }
                                /// <summary>
                                /// test convert hot update enum
                                /// </summary>
                                public enum TestHotUpdateEnum
                                {
                                    Morning,
                                    Afternoon,
                                    Evening
                                }
                            }
                        }

C# feature of C#Like

class feature

Here are a interface IAnimal, and then abstract base class Animal inherit IAnimal, and then a normal class Mammals inherit Animal,finally a normal class Human inherit Mammals. This sample show the class feature.

using UnityEngine;
                        using CSharpLike.Subclass;
                        
                        namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// test class feature.
                                /// </summary>
                                void TestClass()
                                {
                                    Debug.LogError("Test class:");
                                    //test class
                                    Mammals cow = new Mammals(4, 4, "cow");
                                    Debug.Log("cow:" + cow.GetInfo());
                                    //test interface
                                    IAnimal bull = new Mammals(0, 4, "bull");
                                    bull.female = false;
                                    Debug.Log("bull:female=" + bull.female +
                                    ", CanUseTool=" + bull.CanUseTool());
                                    //test constructor
                                    //pay attention to the execute order of the constructor.
                                    Human adam = new Human("Adam", false);
                                    Debug.Log("adam:" + adam.GetInfo());
                                    Debug.Log("adam:GetTypeString=" + adam.GetTypeString());
                                    Debug.Log("adam:GetBaseTypeString=" + adam.GetBaseTypeString());
                                    //test constructor
                                    Human eve = new Human("Eve");
                                    Debug.Log("eve:" + eve.GetInfo()
                                    + ", CanUseTool=" + eve.CanUseTool());
                                    //test destructor
                                    //pay attention to the execute order of the destructor.
                                }
                            }
                        }

using UnityEngine;

namespace CSharpLike
                        {
                            /// <summary>
                            /// test for namespace in 'SampleC#_UsingAndNamespace.cs'
                            /// </summary>
                            namespace SubclassEx
                            {
                                /// <summary>
                                /// his's test namespace with CSharpLike.Subclass.Mammals
                                /// </summary>
                                public class Mammals
                                {
                                    public int breasts = 2;
                                    public int eyes = 2;
                                    public string TestNameSpace()
                                    {
                                        return "Mammals:breasts:" + breasts + ", eyes:" + eyes;
                                    }
                                }
                                public class Toys
                                {
                                    public string name;
                                    public Toys(string name)
                                    {
                                        this.name = name;
                                    }
                                }
                            }
                            /// <summary>
                            /// test for namespace in 'SampleC#_UsingAndNamespace.cs'
                            /// </summary>
                            namespace SubclassEx2
                            {
                                public class TestNamespace
                                {
                                    public static string GetTestString()
                                    {
                                        return "Test string for namespace";
                                    }
                                }
                            }
                        }

using UnityEngine;
                        namespace CSharpLike
                        {
                            /// <summary>
                            /// test class
                            /// </summary>
                            namespace Subclass
                            {
                                //interface
                                public interface IAnimal
                                {
                                    int feet { get; set; }
                                    bool female { get; set; }
                                    bool CanUseTool();
                                }
                                //abstract base class:Animal
                                public abstract class Animal : IAnimal//test interface inherit
                                {
                                    public int feet { get; set; }
                                    public string name;
                                    public bool female { get; set; }
                                    public Animal(int feet, string name)
                                    {
                                        Debug.Log("Animal(" + feet + "," + name + ")");
                                        this.feet = feet;
                                        this.name = name;
                                        female = true;
                                    }
                                    ~Animal()
                                    {
                                        Debug.Log("~Animal():" + name);
                                    }
                                    public virtual string GetInfo()
                                    {
                                        return "Animal:" + name + " with " + feet + " feet. " + clothes;
                                    }
                                    public abstract bool CanUseTool();//test 'abstract' keyword
                                    public virtual string GetTypeString()//test 'virtual' keyword
                                    {
                                        return "Animal";
                                    }
                                    public virtual string clothes
                                    {
                                        get
                                        {
                                            return "naked";
                                        }
                                    }
                                }
                                //Mammal
                                public class Mammals : Animal//test class inherit
                                {
                                    public int breasts;
                                    public Mammals(int breasts, int feet, string name)
                                        : base(feet, name)
                                    {
                                        Debug.Log("Mammals(" + breasts + "," + feet + "," + name + ")");
                                        this.breasts = breasts;
                                    }
                                    ~Mammals()//test destructor
                                    {
                                        Debug.Log("~Mammals():" + name);
                                    }
                                    public override string GetInfo()//test 'override' keyword
                                    {
                                        return "Mammals:" + name + " with " + feet + " feet and "
                                            + breasts + " breasts," + clothes;
                                    }
                                    public override bool CanUseTool()
                                    {
                                        return false;
                                    }
                                    public override string GetTypeString()
                                    {
                                        return "Mammals";
                                    }
                                }
                                //Human
                                public class Human : Mammals
                                {
                                    public Human(string name, bool female)//test constructor
                                        : base(2, 2, name)//test 'base' keyword in constructor
                                    {
                                        Debug.Log("Human(" + name + "," + female + ")");
                                        this.female = female;//test 'this' keyword
                                    }
                                    public Human(string name)//test constructor
                                        : this(name, true)//test 'this' keyword in constructor
                                    {
                                        Debug.Log("Human(" + name + ")");
                                    }
                                    ~Human()//test destructor
                                    {
                                        Debug.Log("~Human():" + name);
                                    }
                                    public override string GetInfo()
                                    {
                                        return "Human:" + name + " with " + feet + " feet and " + breasts
                                            + " breasts, and female = " + female + "," + clothes;
                                    }
                                    public override bool CanUseTool()//test 'override' keyword
                                    {
                                        return true;
                                    }
                                    public override string GetTypeString()
                                    {
                                        return "Human";
                                    }
                                    public string GetBaseTypeString()
                                    {
                                        return base.GetTypeString();//test 'base' keyword in class
                                    }
                                    public override string clothes
                                    {
                                        get
                                        {
                                            return female ? "dress" : "suit";
                                            //test custom 'get/set' accessor
                                        }
                                    }
                                }
                            }
                        }

Delegate and Lambda

We have 3 buttons('Test Delegate','Test Lambda','Test Bind') and a Text component in the interface.

using UnityEngine;
                        using UnityEngine.EventSystems;
                        using UnityEngine.UI;
                        
                        namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                void TestDelegateAndLambda()
                                {
                                    Debug.LogError("Test delegate and lambda:");
                                    //test Delegate: We binding 'OnClickDelegate' as the response function of 'Test Delegate' button by code.
                                    HotUpdateManager.AddEventTrigger(GetGameObject("TestDelegate"), EventTriggerType.PointerClick, OnClickDelegate);
                                    //test Lambda: We binding Lambda expression as the response function of 'Test Lambda' button by code.
                                    HotUpdateManager.AddEventTrigger(GetGameObject("TestLambda"), EventTriggerType.PointerClick,
                                        (BaseEventData eventData) =>
                                        {
                                            GetComponent<Text>("TestMessage").text = "OnClickLambda";
                                            Debug.Log("On click lambda :" + eventData);
                                        });
                                }
                                /// <summary>
                                /// Binding by delegate.
                                /// The response function of 'Test Delegate' button
                                /// </summary>
                                void OnClickDelegate(BaseEventData eventData)
                                {
                                    GetComponent<Text>("TestMessage").text = "OnClickDelegate";
                                    Debug.Log("OnClickDelegate:" + eventData);
                                }
                                /// <summary>
                                /// Call by Button Component of 'ButtonTestBind' in prefab.
                                /// This's the most simplest way bind OnClick event by Button.
                                /// </summary>
                                void OnClickBindButton()
                                {
                                    GetComponent<Text>("TestMessage").text = "OnClickBindButton";
                                    Debug.Log("OnClickBindButton:");
                                }
                                /// <summary>
                                /// Call by EventTrigger Component of 'ButtonTestBind' in prefab.
                                /// It's not recommend because only one EventTriggerType in one LikeBehaviour,and can't change the method name.
                                /// Recommend use HotUpdateManager.AddEventTrigger.
                                /// </summary>
                                void OnPointerEnter(BaseEventData eventData)
                                {
                                    GetComponent<Text>("TestMessage").text = "OnPointerEnter";
                                    Debug.Log("OnPointerEnter:" + eventData);
                                }
                            }
                        }

Math Expression

using UnityEngine;

namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// test math expression:
                                /// + - * / % += -= *= /= %= > >= < <= != == && || ! ++ -- is as & | ~ ^ &= |= ^= << >> <<= >>= ? ?? ?. ?:
                                /// </summary>
                                void TestMathExpression()
                                {
                                    Debug.LogError("Test MathExpression:");
                                    int i = 1;
                                    int j = 2;
                                    int k = 100;
                                    //test + - * / %
                                    Debug.Log("i = 1, j = 2, test i + j = " + (i + j));//output 3
                                    Debug.Log("i = 1, j = 2, test i - j = " + (i - j));//output -1
                                    Debug.Log("i = 1, j = 2, test i * j = " + (i * j));//output 2
                                    Debug.Log("i = 1, j = 2, test i / j = " + (i / j));//output 0
                                    Debug.Log("i = 1, j = 2, test i % j = " + (i % j));//output 1

//test += -= *= /= %=
                                    k += j;
                                    Debug.Log("j = 2, k = 100, test k += j then k = " + k);//output 102
                                    k = 100;
                                    k -= j;
                                    Debug.Log("j = 2, k = 100, test k -= j then k = " + k);//output 98
                                    k = 100;
                                    k *= j;
                                    Debug.Log("j = 2, k = 100, test k *= j then k = " + k);//output 200
                                    k = 100;
                                    k /= j;
                                    Debug.Log("j = 2, k = 100, test k /= j then k = " + k);//output 50
                                    k = 100;
                                    k %= j;
                                    Debug.Log("j = 2, k = 100, k %= j then k = " + k);//output 0
                        
                                    //test > >= < <= != ==
                                    Debug.Log("i = 1, j = 2, test (i < j) = " + (i < j));//output True
                                    Debug.Log("i = 1, j = 2, test (i <= j) = " + (i <= j));//output True
                                    Debug.Log("i = 1, j = 2, test (i == j) = " + (i == j));//output False
                                    Debug.Log("i = 1, j = 2, test (i != j) = " + (i != j));//output True
                                    Debug.Log("i = 1, j = 2, test (i > j) = " + (i > j));//output False
                                    Debug.Log("i = 1, j = 2, test (i >= j) = " + (i >= j));//output False
                        
                                    //test && || !
                                    bool b1 = true;
                                    bool b2 = false;
                                    Debug.Log("b1 = true, b2 = false, test (b1 && b2) = " + (b1 && b2));//output False
                                    Debug.Log("b1 = true, b2 = false, test (b1 || b2) = " + (b1 || b2));//output True
                                    Debug.Log("b1 = true, test (!b1) = " + (!b1));//output False
                        
                                    //test ++ --(include prefix and suffix)
                                    k = 100;
                                    Debug.Log("k = 100, test (k++) = " + (k++));//output 100
                                    Debug.Log("finally k = " + k);////output 101
                                    k = 100;
                                    Debug.Log("k = 100, test (++k) = " + (++k));//output 101
                                    Debug.Log("finally k = " + k);////output 101
                                    k = 100;
                                    Debug.Log("k = 100, test (k--) = " + (k--));//output 100
                                    Debug.Log("finally k = " + k);////output 99
                                    k = 100;
                                    Debug.Log("k = 100, test (--k) = " + (--k));//output 99
                                    Debug.Log("finally k = " + k);////output 99
                                    
                                    // We are not support '++' '--' with index get/set '[]',
                                    // such as List or Dictionary or JSONData.
                                    //// List<int> lists = new List<int>();
                                    //// lists.Add(1);
                                    //// lists[0]++;//compiler error,suggest use 'lists[0] += 1;' instead
                                    //// ++lists[0];//runtime error,suggest use 'lists[0] += 1;' instead
                        
                                    //test ternary expression: '?:'
                                    Debug.Log("i = 1, j = 2, test ((i < j) ? i : j) = " + ((i < j) ? i : j));//output 1
                                    //test nullable types '?' and coalescing operator '?.' '??'
                                    Vector2? v1 = null;//nullable types '?'
                                    Debug.Log("Vector2? v1 = null, test v1.HasValue = " + v1.HasValue);//output False
                                    //Debug.Log("Vector2? v1 = null, test v1.Value = " + v1.Value);//error
                                    Debug.Log("Vector2? v1 = null, test v1.GetValueOrDefault = " + v1.GetValueOrDefault());//output (0.0,0.0)
                                    Debug.Log("Vector2? v1 = null, test v1 = " + v1);//output null
                                    v1 = Vector2.one;
                                    Debug.Log("Vector2? v1 = Vector2.one, test v1.HasValue = " + v1.HasValue);//output True
                                    Debug.Log("Vector2? v1 = Vector2.one, test v1.Value = " + v1.Value);//output (1.0,1.0)
                                    Debug.Log("Vector2? v1 = Vector2.one, test v1.GetValueOrDefault = " + v1.GetValueOrDefault());//output (0.0,0.0)
                                    Debug.Log("Vector2? v1 = Vector2.one, test v1 = " + v1);//output (1.0,1.0)
                                    v1 = null;
                                    Vector2 v2 = v1.HasValue ? v1.Value : v1.GetValueOrDefault();//you should not force cast like 'Vector2 v2 = (Vector2)v1;'
                                    Debug.Log("Vector2 v2 = v1.HasValue ? v1.Value : v1.GetValueOrDefault(), test v2 = " + v2);//output (0.0,0.0)
                                    v1 = Vector2.one;
                                    v2 = v1 ?? Vector2.zero;//coalescing operator '??'
                                    Debug.Log("Vector2 v2 = v1 ?? Vector2.zero, test v2 = " + v2);//output (1.0,1.0)
                                    System.Random r = null;
                                    int? iNull = r?.Next(1000);
                                    Debug.Log("int? iNull = r?.Next(1000), test iNull = " + iNull);//output null
                                    r = new System.Random();
                                    iNull = r?.Next(1000); //coalescing operator '?.'
                                    Debug.Log("int? iNull = r?.Next(1000), test iNull = " + iNull);//output [0,1000)
                                    iNull += i;
                                    Debug.Log("i = 1, iNull += i, test iNull = " + iNull);//output [1,1001)

//test convert: is as
                                    object o = i;
                                    Debug.Log("int i = 1,object o = i, test (o is int) = " + (o is string));//output False
                                    Debug.Log("int i = 1,object o = i, test (o as string) = " + (o as string));//output null
                        
                                    //test bit operation: << >> <<= >>=
                                    Debug.Log("i = 1, j = 2, test i << j = " + (i << j));//output 4
                                    Debug.Log("i = 1, j = 2, test i >> j = " + (i >> j));//output 0
                                    k = 100;
                                    k <<= j;
                                    Debug.Log("j = 2, k = 100, test k <<= j then k = " + k);//output 400
                                    k = 100;
                                    k >>= j;
                                    Debug.Log("j = 2, k = 100, test k >>= j then k = " + k);//output 25
                        
                                    //test bit operation: & | ^ &= |= ^= ~
                                    Debug.Log("i = 1, j = 2, test i & j = " + (i & j));//output 0
                                    Debug.Log("i = 1, j = 2, test i | j = " + (i | j));//output 3
                                    Debug.Log("i = 1, j = 2, test i ^ j = " + (i ^ j));//output 3
                                    k = 100;
                                    k &= j;
                                    Debug.Log("j = 2, k = 100, test k &= j then k = " + k);//output 0
                                    k = 100;
                                    k |= j;
                                    Debug.Log("j = 2, k = 100, test k |= j then k = " + k);//output 102
                                    k = 100;
                                    k ^= j;
                                    Debug.Log("j = 2, k = 100, test k ^= j then k = " + k);//output 102
                                    Debug.Log("i = 1, test (~i) = " + (~i));//output -2
                                }
                            }
                        }

loop syntax

using System;
                        using System.Collections.Generic;
                        using UnityEngine;
                        
                        namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// test loop syntax
                                /// for foreach continue break if-else return while do-while switch-case-default.
                                /// </summary>
                                void TestLoop()
                                {
                                    Debug.LogError("Test Loop:");
                                    int x = 1;
                                    int y = 3;
                                    int z = 100;
                        
                                    //test if-else
                                    if (x < y)
                                        Debug.Log("test 'if-else': enter 'if'");
                                    else if (x < z)
                                        Debug.Log("test 'if-else': enter 'else if'");
                                    else
                                        Debug.Log("test 'if-else': enter 'else'");
                        
                                    List<int> ints = new List<int>();
                                    ints.Add(1);
                                    ints.Add(2);
                                    ints.Add(3);

//test for
                                    for (int i = 0; i<ints.Count; i++)
                                    {
                                        if (i == 2)
                                        {
                                            Debug.Log("test 'continue':");
                                            continue;
                                        }
                                        Debug.Log("test 'for': ints[" + i + "] = " + ints[i]);
                                    }
                        
                                    //test foreach
                                    foreach(var item in ints)
                                    {
                                        Debug.Log("test 'foreach': item = " + item);
                                        if (item == 2)
                                        {
                                            Debug.Log("test 'break':");
                                            break;
                                        }
                                    }
                        
                                    //test while
                                    while(x < y)
                                    {
                                        x++;
                                        Debug.Log("test 'while': x = " + x + ", y = " + y);
                                    }
                        
                                    //test do-while
                                    x = 1;
                                    do
                                    {
                                        x++;
                                        Debug.Log("test 'do-while': x = " + x + ", y = " + y);
                                    } while (x < y) ;
                        
                                    //test switch-case-default
                                    switch(DateTime.Now.DayOfWeek)
                                    {
                                        case DayOfWeek.Monday:
                                            Debug.Log("test 'switch-case-default': sad because have to work.");
                                            break;
                                        case DayOfWeek.Friday:
                                            Debug.Log("test 'switch-case-default': happy because rest day is coming!");
                                            break;
                                        case DayOfWeek.Saturday:
                                        case DayOfWeek.Sunday:
                                            Debug.Log("test 'switch-case-default': exciting because had fun in rest day.");
                                            break;
                                        default:
                                            Debug.Log("test 'switch-case-default': work hard.Fighting!");
                                            break;
                                    }
                                }
                            }
                        }

custom get/set accessor

using UnityEngine;

namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                void TestGetSetAccessor()
                                {
                                    Debug.LogError("Test TestGetSetAccessor:");
                                    //test automatic implement get set accessor
                                    Debug.Log("before set value testGetSetAutoImp = " + testGetSetAutoImp);//output False
                                    testGetSetAutoImp = true;
                                    Debug.Log("after set value: testGetSetAutoImp = " + testGetSetAutoImp);//output True
                        
                                    //test custom get set accessor
                                    Debug.Log("before set value testGetSet = " + testGetSetCustom);//output 101
                                    testGetSetCustom = 1;
                                    Debug.Log("after set value: testGetSet = " + testGetSetCustom);//output 1
                        
                                    //test static get set
                                    Debug.Log("before set value testStaticGetSet = " + testStaticGetSet);//output 'default string'
                                    testStaticGetSet = "I like C#";
                                    Debug.Log("after set value: testStaticGetSet = " + testStaticGetSet);//output 'I like C#'
                                }
                        
                                public bool testGetSetAutoImp { get;set; }
                        
                                int mTestGetSetCustom = 101;
                                public int testGetSetCustom
                                {
                                    get
                                    {
                                        return mTestGetSetCustom;
                                    }
                                    private set
                                    {
                                        mTestGetSetCustom = value;
                                    }
                                }
                                static string mTestStaticGetSet = "default string";
                                public static string testStaticGetSet
                                {
                                    get
                                    {
                                        return mTestStaticGetSet;
                                    }
                                    set
                                    {
                                        if (!string.IsNullOrEmpty(value))
                                            mTestStaticGetSet = value;
                                        else
                                        {
                                            Debug.Log("set value null or empty,reset to default string 'default string'");
                                            mTestStaticGetSet = "default string";
                                        }
                                    }
                                }
                            }
                        }

multi-threading

using System;
                        #if !UNITY_WEBGL
                        using System.Collections.Generic;
                        using System.Threading;
                        using UnityEngine;
                        using UnityEngine.UI;
                        using Random = UnityEngine.Random;
                        #endif
                        
                        namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                void TestThread()
                                {
                        #if !UNITY_WEBGL
                                    Debug.LogError("Test Thread:");
                                    //easy use for thread with no param
                                    HotUpdateManager.CreateThread(TestThreadRunLoop);

//test Task.Run
                                    Task.Run(() =>
                                    {
                                        Debug.LogError("Task.Run as lambda start " + DateTime.Now);
                                        Thread.Sleep(2000);
                                        Debug.LogError("Task.Run as lambda end " + DateTime.Now);
                                    });
                                    Task.Run(TestTaskRun);
                        #else
                                    Debug.LogError("Test Thread:WebGL not support thread.");
                        #endif
                                }
                        #if !UNITY_WEBGL
                                void TestTaskRun()
                                {
                                    Debug.LogError("Task.Run as delegate start " + DateTime.Now);
                                    Thread.Sleep(4000);
                                    Debug.LogError("Task.Run as delegate end " + DateTime.Now);
                                }
                                /// <summary>
                                /// Call by Button Component of 'ButtonTestThread' in prefab.
                                /// </summary>
                                void OnClickTestThread()
                                {
                                    GetComponent<Text>("TestMessage").text = "OnClickTestThread";
                                    //easy use for thread with param
                                    JSONData jsonData = JSONData.NewDictionary();
                                    jsonData["id"] = Random.Range(1, 1000);
                                    jsonData["data"] = JSONData.NewList();
                                    jsonData["data"].Add("dump1");
                                    jsonData["data"].Add("dump2");
                                    List<int> testParams = new List<int>();
                                    testParams.Add(123);
                                    jsonData.SetObjectExtern("TestExternMsg", testParams);//Set extern params to thread
                                    HotUpdateManager.CreateThread(DoSomeWorkInThread,//This's the function which call in thread
                                    	jsonData,//This's the param which call in thread and callback to main thread.
                                    	behaviour,//the current behaviour.let it null if you don't care the callback
                                    	OnDoSomeWorkInThreadDone);//This's the function which callback in main thread.let it null if you don't care the callback

//let 'TestThreadRunLoop' print log by change the value
                                    countInThread = Random.Range(1, 1000);
                        
                                }
                                bool bExist = false;
                                void OnDestroy()
                                {
                                    bExist = true;//notify thread to stop while main thread about to exist
                                }
                                object objLock = new object();
                                int countInThread = 0;
                                volatile int countLoopThread = 0;//test 'volatile' keyword
                                /// <summary>
                                /// work in thread without param
                                /// </summary>
                                void TestThreadRunLoop()
                                {
                                    Debug.LogError("TestThreadRunLoop start");
                                    while (!bExist)//until this component destroy
                                    {
                                        lock (objLock)//you may use lock protect the thread safety that depend on your work
                                        {
                                            if (countInThread > 0)
                                            {
                                                Debug.LogError("TestThreadRunLoop:countInThread=" + countInThread);
                                                countInThread = 0;
                                            }
                                        }
                                        if ((++countLoopThread) >= 10000)
                                            countLoopThread = 0;
                                        Thread.Sleep(200);//sleep 0.2 second in the loop
                                    }
                                    Debug.LogError("TestThreadRunLoop end"); 
                                }
                                /// <summary>
                                /// work in thread with param
                                /// </summary>
                                void DoSomeWorkInThread(object obj)
                                {
                                    //We transfer params by 'JSONData'.
                                    //You can storage your data in the JSONData
                                    JSONData jsonData = obj as JSONData;

List<int> testParams = jsonData.GetObjectExtern("TestExternMsg") as List<int>;//test extern param
                                    Debug.Log("DoSomeWorkInThread testParams.Count=" + testParams.Count);
                                    //do some work (you can't accept the component of unity in this thread, such as 'PlayerPrefs', just same as in native C#.)
                                    Debug.Log("DoSomeWorkInThread(" + jsonData + ") start at " + DateTime.Now);
                                    long count = 0;
                                    int id = jsonData["id"];
                                    for (int i = 0; i < 10000; i++)
                                    {
                                    	id += jsonData.Count;//Don't direct use 'jsonData["id"] += jsonData.Count;',
                                                             //because JSONData is not efficient in hot update script in this block which loop 10000 times.
                                    	Interlocked.Increment(ref count);
                                    }
                                    jsonData["id"] = id;
                                    Debug.Log("DoSomeWorkInThread(" + jsonData + ") end at " + DateTime.Now);

//callback to main thread for show the result
                                    HotUpdateManager.OnThreadDone(jsonData);//mark work done and send to main thread
                                }
                                /// <summary>
                                /// refresh UI in main thread when thread done
                                /// </summary>
                                void OnDoSomeWorkInThreadDone(object obj)
                                {
                                    JSONData jsonData = obj as JSONData;
                                    GetComponent<Text>("TestMessage").text = "OnDoSomeWorkInThreadDone:"+ jsonData["id"];//show the result calculate in thread
                                    Debug.Log("OnDoSomeWorkInThreadDone:" + jsonData["id"]);
                                }
                        #endif
                            }
                        }

macro and region

using UnityEngine;

namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// Support unity build-in define symbols and user custom define symbols
                                /// ("Edit"->"Project Settings"->"Player"->"Scripting Define Symbols").
                                /// just same with unity,except 'UNITY_EDITOR/UNITY_EDITOR_WIN/UNITY_EDITOR_OSX/UNITY_EDITOR_LINUX'
                                /// only work both in 'debug mode' and in editor.
                                /// </summary>
                                void TestMacroAndRegion()
                                {
                                    Debug.LogError("Test Macro:");
                        #if UNITY_EDITOR 
                                    Debug.Log("test macro UNITY_EDITOR: in editor and in 'debug mode'");
                        #else
                                    Debug.Log("test macro UNITY_EDITOR: not in editor");
                        #endif
                        
                        #if UNITY_2018_1_OR_NEWER && (!UNITY_2020_1)
                                    Debug.Log("Test macro:enter UNITY_2018_1_OR_NEWER && (!UNITY_2020_1)");
                            #if UNITY_ANDROID || UNITY_IOS
                                    Debug.Log("Test macro:enter UNITY_ANDROID || UNITY_IOS");
                            #elif UNITY_STANDALONE
                                    Debug.Log("Test macro:enter UNITY_STANDALONE");
                            #endif
                        #elif UNITY_2017
                                    Debug.Log("Test macro:enter UNITY_2017");
                        #else
                                    Debug.Log("test macro:enter #else");
                        #endif
                                    Debug.Log("Test LogError:");
                        #region Test Region
                                    Debug.Log("Test Region: content 1");
                        #endregion
                                    Debug.Log("Test Region: content 2");
                        #region Test Region2
                                    Debug.Log("Test Region: content 3");
                        #endregion
                                    Debug.Log("Test Region: content 4");
                                }
                            }
                        }

enum

using System;
                        using UnityEngine;
                        
                        namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                public enum MyWeek : byte
                                {
                                    Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
                                }
                                public enum MyTestEnum //base type is optional,default is ': int'
                                {
                                    MyTestEnum1,//0 //first enum default value is 0
                                    MyTestEnum2 = 0x5,//5   //test 16bit number
                                    MyTestEnum3,//6    //default value is last number + 1
                                    MyTestEnum4 = 7,
                                    MyTestEnum5 = 7,    //direct set number or math operation, same as native C#
                                    MyTestEnum6 = MyTestEnum3 * 100,//600   
                                    MyTestEnum7 = 1 << 10 + MyTestEnum12,//66559
                                    MyTestEnum8 = MyTestEnum6 & MyTestEnum7,//600
                                    MyTestEnum9 = MyTestEnum6 | MyTestEnum7,//66559
                                    MyTestEnum10 = MyTestEnum9 % 100 + (123 + MyTestEnum6 - MyTestEnum2) / 5,//202
                                    MyTestEnum11 = MyTestEnum7 >> 2,//16639
                                    MyTestEnum12 = ushort.MaxValue,//65535  //support const value, same as native C#
                                    MyTestEnum13 = UInt16.MinValue,//0
                                }
                                void TestEnum()
                                {
                                    Debug.LogError("Test Enum:");
                                    MyWeek myWeek = MyWeek.Saturday;
                                    //This's the difference from native C#.
                                    //You must be careful if you print the value of enum.
                                    Debug.Log("Test Enum:MyWeek.Saturday=" + MyWeek.Saturday);//output 6 in hot update mode, but in 'debug mode' is 'Saturday'
                                    Debug.Log("Test Enum:myWeek=" + myWeek);//output 6 in hot update mode, but in 'debug mode' is 'Saturday'
                                    //You must use 'HotUpdateManager.ConvertEnumString' to get the string of the value.
                                    Debug.Log("Test Enum:myWeek=" + HotUpdateManager.ConvertEnumString(typeof(MyWeek), myWeek));//output 'Saturday'
                                    //You must use 'HotUpdateManager.ConvertEnumNumber' to get the number by string.
                                    Debug.Log("Test Enum:'Tuesday' number = " + HotUpdateManager.ConvertEnumNumber(typeof(MyWeek), "Tuesday"));//output 2
                                    int i = 202;
                                    switch ((MyTestEnum)i)
                                    {
                                        case MyTestEnum.MyTestEnum1:
                                            Debug.Log("Test Enum in switch:MyTestEnum.MyTestEnum1");
                                            break;
                                        case MyTestEnum.MyTestEnum2:
                                            Debug.Log("Test Enum in switch:MyTestEnum.MyTestEnum2");
                                            break;
                                        case MyTestEnum.MyTestEnum3:
                                            Debug.Log("Test Enum in switch:MyTestEnum.MyTestEnum3");
                                            break;
                                        case MyTestEnum.MyTestEnum6:
                                            Debug.Log("Test Enum in switch:MyTestEnum.MyTestEnum6");
                                            break;
                                        case MyTestEnum.MyTestEnum10:
                                            Debug.Log("Test Enum in switch:MyTestEnum.MyTestEnum10");
                                            break;
                                        default:
                                            Debug.Log("Test Enum in switch:default");
                                            break;
                                    }
                                }
                            }
                        }

parameter modifier

using UnityEngine;

namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// test modifier for params of function, include 'ref' 'out' 'in' 'params' keyword.
                                /// </summary>
                                void TestModifier()
                                {
                                    Debug.LogError("Test Modifier:");
                                    //test call hot update function which param with ref/out/in modifier
                                    int v1 = 0;
                                    int v2;
                                    Vector2 v3 = new Vector2();
                                    Vector2 v4;
                                    int v5 = 5;
                                    TestRefOutIn(ref v1, out v2, ref v3, out v4, v5);
                                    //output v1=1,v2=16,v3=(1.0, 16.0),v4=(16.0, 1.0),v5=5
                                    Debug.Log("TestModifier:TestRefOutIn:v1=" + v1 + ",v2=" + v2 + ",v3=" + v3 + ",v4=" + v4 + ",v5=" + v5);
                        
                                    //test call hot update static function which param with ref/out/in modifier
                                    v3 = new Vector2(2, 10);
                                    v5 = 100;
                                    TestRefOutInStatic(ref v1, out v2, ref v3, out v4, v5);
                                    //output v1=1,v2=16,v3=(2.0, 112.0),v4=(16.0, 1.0),v5=100
                                    Debug.Log("TestModifier:TestRefOutInStatic:v1=" + v1 + ",v2=" + v2 + ",v3=" + v3 + ",v4=" + v4 + ",v5=" + v5);
                        
                                    //test call hot update function which param with params modifier
                                    Debug.Log("TestModifier:TestParams:" + TestParam("param1"));//output param1:
                                    Debug.Log("TestModifier:TestParams:" + TestParam("param2", 1));//output param2:1,
                                    Debug.Log("TestModifier:TestParams:" + TestParam("param3", 0, "abc"));//output param3:0,abc,
                                    Debug.Log("TestModifier:TestParams:" + TestParam("param4", 3, "cba", 'x'));//output param4:3,cba,x,
                        
                                    //test call not hot update function which param with ref/out/in modifier
                                    SampleNotHotUpdateScript example = new SampleNotHotUpdateScript();
                                    string str1 = "Sunday";
                                    string str2 = "Saturday";
                                    v2 = 1;
                                    example.TestRefOutIn(str1, ref str2, out v1, v2);
                                    Debug.Log("TestModifier:(not hot update)TestRefOutIn:str2=" + str2 + ",v1=" + v1);//output str2=Sunday test,v1=11
                        
                                    //test call not hot update static function which param with ref/out/in modifier
                                    string str3 = "Monday";
                                    SampleNotHotUpdateScript.TestRefOutInStatic("abc", ref str3, out v1, 123);
                                    Debug.Log("TestModifier:(not hot update)TestRefOutInStatic:str2=" + str2 + ",v1=" + v1);//output str2=Sunday test,v1=137
                        
                                    //test call not hot update function which param with params modifier
                                    Debug.Log("TestModifier:(not hot update)TestParams:" + example.TestParam());//output :
                                    Debug.Log("TestModifier:(not hot update)TestParams:" + example.TestParam(10));//output :10,
                                    Debug.Log("TestModifier:(not hot update)TestParams:" + example.TestParam(1, "xyz"));//output :1,xyz,
                                    Debug.Log("TestModifier:(not hot update)TestParams:" + example.TestParam('y', "cba", 123));//output :y,cba,123,
                                }
                                void TestRefOutIn(ref int i, out int j, ref Vector2 k, out Vector2 l, in int m)
                                {
                                    i += 1;
                                    j = 10 + i + m;
                                    k.x = i;
                                    k.y = j;
                                    l = new Vector2(j, i);
                                }
                                static void TestRefOutInStatic(ref int i, out int j, ref Vector2 k, out Vector2 l, in int m)
                                {
                                    i += 1;
                                    j = 10 + i + m;
                                    k.x = i;
                                    k.y = j;
                                    l = new Vector2(j, i);
                                }
                                string TestParam(string strValue, params object[] objs)
                                {
                                    string str = strValue + ":";
                                    foreach (var obj in objs)
                                        str += obj + ",";
                                    return str;
                                }
                            }
                        }
                        namespace CSharpLike
                        {
                            /// <summary>
                            /// Not hot update script which call by hot update script in example.
                            /// </summary>
                            public class SampleNotHotUpdateScript
                            {
                                public static void TestRefOutInStatic(string str1, ref string str2, out int i, in int j)
                                {
                                    str2 = str1 + " testStatic";
                                    i = str2.Length + j;
                                }
                                public void TestRefOutIn(string str1, ref string str2, out int i, in int j)
                                {
                                    str2 = str1 + " test";
                                    i = str2.Length * j;
                                }
                                public string TestParam(params object[] objs)
                                {
                                    string str = "";
                                    foreach (var obj in objs)
                                        str += obj + ",";
                                    return str;
                                }
                            }
                        }

default parameters and function overloading

using UnityEngine;

namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// test function overloading and function param default valu
                                /// </summary>
                                void TestOverloadingAndDefaultValue()
                                {
                                    Debug.LogError("Test OverloadingAndDefaultValue:");
                                    //test function overloading, same as native C#
                                    Debug.Log("TestOverloading:" + TestOverloading());//output Sunday
                                    Debug.Log("TestOverloading:" + TestOverloading(123));//output Monday123
                                    Debug.Log("TestOverloading:" + TestOverloading("abc"));//output Tuesdayabc
                                    Debug.Log("TestOverloading:" + TestOverloading("cba", 321));//output Wednesdaycba321
                        
                                    //test function param default value, same as native C#
                                    TestDefaultParam();//output TestDefaultParam:i=1,j=(0.0,0.0),k=str
                                    TestDefaultParam(100);//output TestDefaultParam:i=100,j=(0.0,0.0),k=str
                                    TestDefaultParam(110, new Vector2(1, 2));//output TestDefaultParam:i=110,j=(1.0,2.0),k=str
                                    TestDefaultParam(120, Vector2.one, "string2222");//output TestDefaultParam:i=120,j=(1.0,1.0),k=string2222
                                }
                                string TestOverloading()
                                {
                                    return "Sunday";
                                }
                                string TestOverloading(int i)
                                {
                                    return "Monday" + i;
                                }
                                string TestOverloading(string str)
                                {
                                    return "Tuesday" + str;
                                }
                                string TestOverloading(string str, int i)
                                {
                                    return "Wednesday" + str + i;
                                }
                                void TestDefaultParam(int i = 1, Vector2 j = new Vector2(), in string k = "str")
                                {
                                    Debug.Log("TestDefaultParam:i=" + i + ",j=" + j + ",k=" + k);
                                }
                            }
                        }

keyword

using UnityEngine;//test using command
                        using System;
                        using Random = UnityEngine.Random;//test using alias
                        using System.Text;
                        using System.IO;
                        
                        namespace CSharpLike
                        {
                            public partial class ExampleCSharp : LikeBehaviour
                            {
                                /// <summary>
                                /// test not classify keyword 
                                /// </summary>
                                void TestKeyword()
                                {
                                    Debug.LogError("Test Keyword:");
                                    //test keyword 'sizeof'
                                    //'sizeof(int/uint/long/ulong/short/ushort/char/float/double/decimal/bool/sbyte/byte)' no need allow unsafe code
                                    Debug.Log("sizeof(int) = " + sizeof(int));//output sizeof(int) = 4
                        
                                    //The define symbol open by the check box of Menu/Edit/Project Setting/Player/Other Settings/Allow 'unsafe' Code
                                    //The define symbol close by the remove it from Menu/Edit/Project Settings/Player/Other Settings/Scripting Define Symbols
                        #if _CSHARP_LIKE_ALLOW_UNSAFE_CODE_ 
                                    //test keyword 'unsafe'
                                    unsafe
                                    {
                                        Debug.Log("sizeof(Vector2) = " + sizeof(Vector2));//output sizeof(Vector2) = 8
                                    	Debug.Log("sizeof(Rect) = " + sizeof(Rect));//output sizeof(Rect) = 16
                                    }
                                    TestUnSafe();
                        #endif
                                    //test keyword 'typeof'
                                    var tType = typeof(ExampleCSharp);//don't define as 'Type tType = typeof(ExampleCSharp);', must use 'var'
                                    Debug.Log("typeof(ExampleCSharp) = " + tType);//output CSharpLike.ExampleCSharp
                                    var thisType = GetType();//don't define as 'Type thisType = GetType();', must use 'var'
                                    Debug.Log("thisType = " + thisType);//output CSharpLike.ExampleCSharp
                                    Debug.Log("thisType == tType:" + (thisType == tType));//output True
                                    if (this.GetType() == typeof(ExampleCSharp))
                                        Debug.Log("GetType() == typeof(ExampleCSharp)");
                                    else
                                        Debug.Log("GetType() != typeof(ExampleCSharp)");
                        
                                    //build-in data type,
                                    //Int32/UInt32/Int64/UInt64/Int16/UInt16/Char/Single/Double/Decimal/Boolean/SByte/Byte/String.
                                    //equal
                                    //int/uint/long/ulong/short/ushort/char/float/double/decimal/bool/sbyte/byte/string.
                                    Int32 i = 123;//equal to 'int i = 123;'
                                    Debug.Log("test Int32 i = " + i);//output 123
                                    
                                    //test keyword "$", syntactic sugar for string.Format
                                    string str = $"abc{i}sdf{"xyz"}";//same with 'string str = string.Format("abc{0}sdf{1}", i, "xyz");'
                                    Debug.Log("test keyword '$' with '\"', $\"abc{i}sdf{\"xyz\"} = " + str);//output abc123sdfxyz

//test keyword "@"
                                    str = @"{""a"":1,
                                        ""b"":""abc""}";///same with 'str = "{\"a\":1,\n                \"b\":\"abc\"}";'
                                    Debug.Log("test keyword '@' with '\"', str = " + str);
                                    
                                    //test keyword #pragma #warning #error
                        #pragma warning disable CS0168
                                    int j;//It'll get a warning(CS0168) if not set '#pragma warning disable CS0168'
                        #pragma warning restore CS0168
                        //It'll get a warning in editor
                        #warning "This's a test #warning."  
                        #if UNITY_4_0
                        #error "This's a test #error." 
                        #endif//UNITY_4_0
                                }
                        
                                //The define symbol open by the check box of Menu/Edit/Project Setting/Player/Other Settings/Allow 'unsafe' Code
                                //The define symbol close by the remove it from Menu/Edit/Project Settings/Player/Other Settings/Scripting Define Symbols
                        #if _CSHARP_LIKE_ALLOW_UNSAFE_CODE_
                                //test keyword 'unsafe' in function
                                unsafe void TestUnSafe()
                                {
                                    Debug.Log("sizeof(Vector3) = " + sizeof(Vector3));//output sizeof(Vector3) = 12
                                }
                        #endif
                            }
                        }