Change the language id from c# to csharp in md code snippets

Author: TolikPylypchuk

README.md

@@ -123,7 +123,7 @@ libuiohook also provides functions to get various system properties. The corresp
 SharpHook provides the `IGlobalHook` interface along with three default implementations which you can use to control the
 hook and subscribe to its events. Here's a basic usage example:
 
-```c#
+```csharp
 using SharpHook;
 
 // ...
@@ -211,7 +211,7 @@ SharpHook with Rx.NET.
 SharpHook.Reactive provides the `SharpHook.Reactive.IReactiveGlobalHook` interface along with a default implementation
 which you can use to use to control the hook and subscribe to its observables. Here's a basic example:
 
-```c#
+```csharp
 using SharpHook.Reactive;
 
 // ...
@@ -263,7 +263,7 @@ R3.
 SharpHook.R3 provides the `SharpHook.R3.IR3GlobalHook` interface along with a default implementation which you can use
 to use to control the hook and subscribe to its observables. Here's a basic example:
 
-```c#
+```csharp
 using SharpHook.R3;
 
 // ...
@@ -312,7 +312,7 @@ provider can be specified for all observables.
 SharpHook provides the ability to simulate keyboard and mouse events in a cross-platform way as well. Here's a quick
 example:
 
-```c#
+```csharp
 using SharpHook;
 using SharpHook.Native;
 
@@ -367,7 +367,7 @@ surrogate pairs, e.g., emojis) is supported.
 libuiohook can log messages throughout its execution. By default the messages are not logged anywhere, but you can get
 these logs by using the `ILogSource` interface and its default implementation, `LogSource`:
 
-```c#
+```csharp
 using SharpHook.Logging;
 
 // ...
@@ -388,7 +388,7 @@ of `LogSource` in release builds.
 SharpHook.Reactive contains the `IReactiveLogSource` and `ReactiveLogSourceAdapter` so you can use them in a more
 reactive way:
 
-```C#
+```csharp
 using SharpHook.Logging;
 using SharpHook.Reactive.Logging;
 
@@ -401,7 +401,7 @@ reactiveLogSource.MessageLogged.Subscribe(this.OnMessageLogged);
 
 SharpHook.R3 contains the `IR3LogSource` and `R3LogSourceAdapter` so you can use them in a more reactive way as well:
 
-```C#
+```csharp
 using SharpHook.Logging;
 using SharpHook.R3.Logging;
 

SharpHook.R3/README.md

@@ -18,7 +18,7 @@ Refer to the [SharpHook](https://www.nuget.org/packages/SharpHook) package for t
 SharpHook.R3 provides the `IR3GlobalHook` interface along with a default implementation and an adapter which you can use
 to use to control the global hook and subscribe to its observables. Here's a basic example:
 
-```c#
+```csharp
 using SharpHook.R3;
 
 // ...
@@ -66,7 +66,7 @@ provider can be specified for all observables.
 
 SharpHook.R3 contains `IR3LogSource` and `R3LogSourceAdapter` so you can use them in a more reactive way:
 
-```c#
+```csharp
 using SharpHook.Logging;
 using SharpHook.R3.Logging;
 

SharpHook.Reactive/README.md

@@ -18,7 +18,7 @@ Refer to the [SharpHook](https://www.nuget.org/packages/SharpHook) package for t
 SharpHook.Reactive provides the `IReactiveGlobalHook` interface along with a default implementation and an adapter
 which you can use to use to control the global hook and subscribe to its observables. Here's a basic example:
 
-```c#
+```csharp
 using SharpHook.Reactive;
 
 // ...
@@ -67,7 +67,7 @@ to `IGlobalHook`. A default scheduler can be specified for all observables.
 SharpHook.Reactive contains `IReactiveLogSource` and `ReactiveLogSourceAdapter` so you can use them in a more reactive
 way:
 
-```c#
+```csharp
 using SharpHook.Logging;
 using SharpHook.Reactive.Logging;
 

SharpHook/README.md

@@ -46,7 +46,7 @@ libuiohook also provides functions to get various system properties. The corresp
 SharpHook provides the `IGlobalHook` interface along with three default implementations which you can use to control the
 hook and subscribe to its events. Here's a basic usage example:
 
-```c#
+```csharp
 using SharpHook;
 
 // ...
@@ -133,7 +133,7 @@ Use the [SharpHook.R3](https://www.nuget.org/packages/SharpHook.R3) package for
 SharpHook provides the ability to simulate keyboard and mouse events in a cross-platform way as well. Here's a quick
 example:
 
-```c#
+```csharp
 using SharpHook;
 using SharpHook.Data;
 
@@ -188,7 +188,7 @@ surrogate pairs, e.g., emojis) is supported.
 libuiohook can log messages throughout its execution. By default the messages are not logged anywhere, but you can get
 these logs by using the `ILogSource` interface and its default implementation, `LogSource`:
 
-```c#
+```csharp
 using SharpHook.Logging;
 
 // ...

docs/articles/custom.md

@@ -11,7 +11,7 @@ subscribers).
 
 As an example, here's the implementation of `SimpleGlobalHook` (with XML comments removed):
 
-```c#
+```csharp
 namespace SharpHook;
 
 public sealed class SimpleGlobalHook : GlobalHookBase
@@ -59,7 +59,7 @@ itself extends: `HandleHookEvent`, `BeforeRun`, `AfterStop`, and `Dispose`.
 As an example, here's a global hook which raises a single event for all hook events instead of different events for each
 event type:
 
-```c#
+```csharp
 public sealed class StraightforwardGlobalHook : BasicGlobalHookBase
 {
     protected override void HandleHookEvent(ref UioHookEvent e) =>
@@ -78,21 +78,21 @@ hook, but you may nonetheless want to implement everything from scratch. You can
 When calling `SetDispatchProc`, the function must be wrapped into a delegate reference and the reference must be stored
 to prevent garbage collection. This is because the following code:
 
-```c#
+```csharp
 provider.SetDispatchProc(someObj.SomeMethod, IntPtr.Zero);
 ```
 
 is actually transformed into this code by the C# compiler:
 
-```c#
+```csharp
 provider.SetDispatchProc(new DispatchProc(someObj.SomeMethod), IntPtr.Zero);
 ```
 
 The CLR protects the `DispatchProc` reference from being garbage-collected only until the `SetDispatchProc` methods
 exits (which happens almost instantly). The CLR does not and cannot know that the reference will be used later and so it
 will happily collect this reference thinking it's not needed anymore. Instead, the following should be done:
 
-```c#
+```csharp
 DispatchProc dispatchProc = someObj.SomeMethod; // This reference should be stored, e.g., as a field of the object
 provider.SetDispatchProc(dispatchProc, IntPtr.Zero);
 ```

docs/articles/hooks.md

@@ -6,7 +6,7 @@ SharpHook provides the `SharpHook.IGlobalHook` interface along with three defaul
 control the hook and subscribe to its events. This way is preferred to using native functions since it's more
 convenient. Here's a basic usage example:
 
-```c#
+```csharp
 using SharpHook;
 
 // ...

docs/articles/logging.md

@@ -24,7 +24,7 @@ to use the debug level for long periods of time since a debug message is logged
 
 Here's a usage example:
 
-```c#
+```csharp
 using SharpHook.Data;
 using SharpHook.Logging;
 
@@ -50,7 +50,7 @@ message format and arguments so you don't have to do it yourself.
 SharpHook.Reactive contains the `IReactiveLogSource` and its implementation – `ReactiveLogSourceAdapter`. Here's a
 usage example:
 
-```c#
+```csharp
 using SharpHook.Logging;
 using SharpHook.Native;
 using SharpHook.Reactive.Logging;
@@ -68,7 +68,7 @@ scheduler can be set for the `MessageLogged` observable.
 
 SharpHook.R3 contains the `IR3LogSource` and its implementation – `R3LogSourceAdapter`. Here's a usage example:
 
-```c#
+```csharp
 using SharpHook.Logging;
 using SharpHook.Native;
 using SharpHook.R3.Logging;
@@ -97,21 +97,21 @@ usually shouldn't use it.
 When calling `SetLoggerProc`, the function must be wrapped into a delegate reference and the reference must be stored
 to prevent garbage collection. This is because the following code:
 
-```c#
+```csharp
 provider.SetLoggerProc(someObj.SomeMethod, IntPtr.Zero);
 ```
 
 is actually transformed into this code by the C# compiler:
 
-```c#
+```csharp
 provider.SetLoggerProc(new LoggerProc(someObj.SomeMethod), IntPtr.Zero);
 ```
 
 The CLR protects the `LoggerProc` reference from being garbage-collected only until the `SetLoggerProc` methods exits
 (which happens almost instantly). The CLR does not and cannot know that the reference will be used later and so it will
 happily collect this reference thinking it's not needed anymore. Instead, the following should be done:
 
-```c#
+```csharp
 LoggerProc loggerProc = someObj.SomeMethod; // This reference should be stored, e.g., as a field of the object
 provider.SetLoggerProc(loggerProc, IntPtr.Zero);
 ```
@@ -134,7 +134,7 @@ arguments. It then parses the log message and the log format and extracts the ar
 
 If you want to use your own callback, then its form should be the following:
 
-```c#
+```csharp
 private void OnLog(LogLevel level, IntPtr userData, IntPtr format, IntPtr args)
 {
     // Filter by log level if needed

docs/articles/os-constraints.md

@@ -78,7 +78,7 @@ other than the main one then you should take care of it yourself. You can do tha
 `CFRunLoopRun` function on the main thread:
 
 
-```c#
+```csharp
 internal static partial class CoreFoundation
 {
     private const string CoreFoundationLib = "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation";

docs/articles/reactive.md

@@ -8,7 +8,7 @@ SharpHook with Rx.NET.
 SharpHook.Reactive provides the `SharpHook.Reactive.IReactiveGlobalHook` interface along with a default implementation
 which you can use to use to control the hook and subscribe to its observables. Here's a basic example:
 
-```c#
+```csharp
 using SharpHook.Reactive;
 
 // ...
@@ -79,7 +79,7 @@ R3.
 SharpHook.R3 provides the `SharpHook.R3.IR3GlobalHook` interface along with a default implementation which you can use
 to use to control the hook and subscribe to its observables. Here's a basic example:
 
-```c#
+```csharp
 using SharpHook.R3;
 
 // ...

docs/articles/simulation.md

@@ -12,7 +12,7 @@ property.
 
 Input event simulation is quite straightforward. Here's a quick example:
 
-```c#
+```csharp
 using SharpHook;
 using SharpHook.Data;