<cat>Code.Misc</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 // C# comments start with two slashes, like most other languages /* C# multiline comment example */ ``` # Global Variables ```lua -- you can define globals anywhere in Lua globalVar = 100 ``` ```csharp public class MyClass { // in C# 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 ``` # 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 interpolated = $"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 } } ``` # Arrays <validate></validate> # For Loops In Lua there are two **for** types, numeric and generic. ```lua -- numeric local str = "" for i=1,5 do if (i ~= 5) then str = str .. tostring(i) .. ", " else str = str .. tostring(i) end end print(str) -- outputs "1, 2, 3, 4, 5" ``` The generic for loop allows you to traverse all values returned by an iterator function. ```lua -- generic -- ipairs() iteriates only through numbers indexes local str = "" local a = {"a", "b", "c", key = "e", key2 = "f", "d"} for i,v in ipairs(a) do if (i ~= #a) then str = str .. v .. ", " else str = str .. v end end print(str) -- "a, b, c, d" ``` ```lua -- pairs() iteriates through all, but number indexes first and then all keys.⤶ -- However while the number indexes are in order, the key indexes are not. Lua does not guarantee the order of the key indexes. -- However, you can reinsert keys into a table and use table.sort() but it can not sort the way on how they were written up in the table. So don't rely on the position if the keys have a weird name. --[[⤶ pairs() iteriates through all, but number indexes first and then all keys. However while the number indexes are in order, the key indexes are not. Lua does not guarantee the order of the key indexes. However, you can reinsert keys into a table and use table.sort()⤶ but it can not sort the way on how they were written up in the table.⤶ So don't rely on the position if the keys have a weird name. ⤶ --]]⤶ local str = "" local a = {"a", "b", "c", key = "e", key2 = "f", "d"} for k,v in pairs(a) do if not (next(a,k) == nil) then str = str .. v .. ", " else str = str .. v end end print(str) -- can output "a, b, c, d, e, f" or "a, b, c, d, f, e" ``````⤶