<cat>Dev.Intro</cat> <title>From Lua to C#</title> # What is this guide This is meant to give an idea of the major differences between Lua and C#. # Comments ```lua -- Lua comments start with two minus signs --[[ Lua multiline comment example --]] ``` ```csharp // csharp comments start with two slashes, like most other languages /* csharp multiline comment example */ ``` # Global Variables ```lua -- you can define globals anywhere globalVar = 100 ``` ```csharp public class MyClass { // globals need to be in a class public static int GlobalVar = 100; } ``` # Variable Types ```lua -- variables in Lua don't have a static type and can store any data local a = 100 a = "Hello" a = function() print( "Hi" ) end ``` ```csharp var a = 100; // translated as "int a = 100;" because 100 is an int a = "Hello"; // error: can't assign a string to an int ``` ⤶ #Dynamic typization⤶ ⤶ To create dynamic typized object, you need to use `dynamic` keyword.⤶ C# is strong typed language, but `dynamic` is workaround for those who like saving everything in one always changing variable.⤶ With `dynamic` compiler don't know does type have required by you functions or not, it can cause Runtime only errors, you get them only on code execution. To avoid most of them you should use static typization⤶ ⤶ ```csharp⤶ dynamic a = 100; // create local variable like local a = 100 in lua⤶ a++; // call int's increment operator method⤶ Console.WriteLine(a); // writes 101 to console as int type⤶ a = "i was int"; // set a to string⤶ Console.WriteLine(a); // writes "i was int" to console as string type⤶ a+=", now i'm string";⤶ Console.WriteLine(a); // writes "i was int, now i'm string" to console as string type⤶ ⤶ // a++; compiles here, but will cause Runtime Exception⤶ // a changed type from int to string, all int methods will not work, because it's a string⤶ ```⤶ # Type conversion ```lua local a = 123 local b = tostring( a ) -- "123" local c = tonumber( b ) -- 123 ``` ```csharp var a = 123; var b = a.ToString(); // "123" var c = int.Parse(b); // 123, will throw an exception if 'b' isn't int-ish // operator 'as' converts an object reference or returns 'null' on failure var vehicle = new Car() as Vehicle; // downcast Car reference to Vehicle var vehicle = vehicle as Car; // upcast Vehicle reference to Car ``` # Numbers ```lua local a = 100 a = 5.5 a = -300.1 ``` ```csharp // integer types are sbyte, byte, short, ushort, int, uint, long, ulong int a = -300; uint b = 333333; // decimal types are float, double, decimal double d = -500.888; ``` # Strings ```lua local str = "Hello" local str2 = 'Hello2' local multilineStr = [[ Hello Multiline ]] print(#str) -- 5, string length local concated = "I have " .. 3 .. " apples!" local formatted = string.format( "I have %d apples!", 3 ) ``` ```csharp var str = "Hello"; var singleChar = 'a'; // single quotes are for a single character, not a string var multilineStr = @" Hello Multiline "; // putting '@' before a string literal makes it a verbatim string literal Console.WriteLine(str.Length); // 5, string length var concated = "I have " + 3 + " apples!"; // {0} and {1} here correspond to the order of value arguments // argument number 0 is '3' and argument number 1 is '2' var formatted = string.Format("I have {0} apples and {1} oranges!", 3, 2); // putting '$' before a string allows interpolating values into it using '{value}' var interploated = $"I have {3} apples!"; ``` # Collections ```lua local stuff = { 1, 2, 3, "Oh", "Hi", "Mark", { myFunc = function() end } } ``` ```csharp var numbers = new int[3] { 1, 2, 3 }; var strings = new List<string> { "Oh", "Hi", "Mark" }; var functions = new Dictionary<string, Action> { ["myFunc"] = () => { } }; ``` # Member Access In Lua anything is accessible from anywhere as long as you have a reference. ```lua -- myFile.lua myTable = { field = 100 } ``` ```lua -- otherFile.lua print( myTable.field ) -- 100 ``` In C# things can be **public**, **private**, **protected** and **internal**. ```csharp // MyClass.cs public class MyClass { public static void PublicMethod() { ... } protected static void ProtectedMethod() { ... } private static void PrivateMethod() { ... } } ``` ```csharp // OtherClass.cs public class OtherClass : MyClass { public static void Test() { MyClass.PublicMethod(); // OK MyClass.ProtectedMethod(); // we inherit from MyClass so OK MyClass.PrivateMethod(); // error: PrivateMethod is private } } ```