AutoHotkey Community

Code: Select all

c# =
(
    using System.Windows.Forms;
    class Foo {
        public void Test() {
            MessageBox.Show("Hello, world, from C#!");
        }
    }
)
asm := CLR_CompileC#(c#, "System.dll | System.Windows.Forms.dll")
obj := CLR_CreateObject(asm, "Foo")
obj.Test()

Code: Select all

vb =
(
    Imports System.Windows.Forms
    Class Foo
        Public Sub Test()
            MessageBox.Show("Hello, world, from VB!")
        End Sub
    End Class
)
asm := CLR_CompileVB(vb, "System.dll | System.Windows.Forms.dll")
obj := CLR_CreateObject(asm, "Foo")
obj.Test()

Code: Select all

; Compile the helper class. This could be pre-compiled.
FileRead c#, EventHelper.cs
helperAsm := CLR_CompileC#(c#)
helper := helperAsm.CreateInstance("EventHelper")

; Create our test object, which simply exposes a single event.
c# =
(
    public class ObjectWithEvent {
        public void RaiseEvent() {
            if (OnEvent != null)
                OnEvent(this, System.EventArgs.Empty);
        }
        public event System.EventHandler OnEvent;
    }
)
asm := CLR_CompileC#(c#)
obj := asm.CreateInstance("ObjectWithEvent")

; Add an event handler for the "OnEvent" event.  Use "" to pass the
; address as a string, since IDispatch doesn't support 64-bit integers.
helper.AddHandler(obj, "OnEvent", "" RegisterCallback("EventHandler",,, 1))

; Make an event handler (event must be of the EventHandler type).
handler := helper.MakeHandler("" RegisterCallback("EventHandler",,, 2))
obj.add_OnEvent(handler)

; Test the event handlers.
obj.RaiseEvent()


; Our event handler is called with a SAFEARRAY of parameters.  This
; makes it much easier to get the type and value of each parameter.
EventHandler(pprm)
{
    ; Wrap the SAFEARRAY pointer in an object for easy access.
    prm := ComObject(0x200C, pprm)
    ; Show parameters:
    MsgBox, 0, Event Raised, % "Callback #" A_EventInfo
        . "`nSender: " prm[0].ToString()
        . "`nEventArgs: " prm[1].ToString()
}

Code: Select all

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.InteropServices;

public class EventHelper {
    // Delegate type for the AutoHotkey callback.
    public delegate void CallbackType([MarshalAs(UnmanagedType.SafeArray)] object[] argv);
    // AddHandler: Adds a callback as a handler for the given event of the given object.
    public void AddHandler(object target, string eventName, string pcb) {
        var cb = ParseCB(pcb);
        // Reference: http://msdn.microsoft.com/en-us/library/ms228976
        EventInfo evt = target.GetType().GetEvent(eventName);
        Type handlerType = evt.EventHandlerType;
        MethodInfo handlerSig = handlerType.GetMethod("Invoke");
        ParameterInfo[] parameters = handlerSig.GetParameters();
        Type[] parameterTypes = new Type[parameters.Length+1];
        parameterTypes[0] = typeof(CallbackType);
        for (int i = 0; i < parameters.Length; i++)
            parameterTypes[i+1] = parameters[i].ParameterType;
        
        var handler = new DynamicMethod("", handlerSig.ReturnType, parameterTypes, true);
        
        var il = handler.GetILGenerator();
        var loc = il.DeclareLocal(typeof(object[]));
        il.Emit(OpCodes.Ldc_I4_2);
        il.Emit(OpCodes.Newarr, typeof(object));
        il.Emit(OpCodes.Stloc_0);
        
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Ldc_I4_0);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Stelem_Ref); 
        
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Ldc_I4_1);
        il.Emit(OpCodes.Ldarg_2);
        il.Emit(OpCodes.Stelem_Ref);
        
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Call, typeof(CallbackType).GetMethod("Invoke"));
        il.Emit(OpCodes.Ret);
        
        var delg = handler.CreateDelegate(handlerType, cb);
        var adder = evt.GetAddMethod();
        adder.Invoke(target, new object[] { delg });
    }
    // Much simpler method, restricted to a specific delegate type.
    public EventHandler MakeHandler(string pcb) {
        var cb = ParseCB(pcb);
        return (sender, e) => cb(new object[]{ sender, e });
    }
    public CallbackType ParseCB(string cb) {
        // For 32-bit, simply marking the parameter of AddHandler/MakeHandler with:
        //   [MarshalAs(UnmanagedType.FunctionPtr)] CallbackType cb
        // is adequate, but since IDispatch doesn't support 64-bit integers,
        // we have to pass the callback address as a string for x64 builds.
        return (CallbackType) Marshal.GetDelegateForFunctionPointer(
            (IntPtr)Int64.Parse(cb), typeof(CallbackType));
    }
}

Code: Select all

;http://stackoverflow.com/questions/7119806/c-sharp-reading-data-from-xml

#include clr.ahk

c# =
(
    using System;
    using System.Windows.Forms;
    using System.Xml.Linq;
    class Foo {
        public void Test() {
            MessageBox.Show("Ready for XML from C# via Autohotkey?");
        }

		public void ahkxml(){
			XDocument doc = XDocument.Load( "polycom-test-cfg.cfg" );
			var info = doc.Descendants( "reg" );
			foreach ( var thisinfo in info ){
				MessageBox.Show(thisinfo.Value);
			}     
		}
		
    }
)
asm := CLR_CompileC#(c#, "System.dll | System.Windows.Forms.dll | System.Xml.Linq")
obj := CLR_CreateObject(asm, "Foo")
obj.Test()
obj.ahkxml()

Code: Select all

; Return a string type
cSharp =
(
    class MainReturnValTest
    {
        public string Main()
        {
            string var = "some string";
            return var;
        }
    }
)

obj := CLR_CreateObject( CLR_CompileC#( cSharp ), "MainReturnValTest")
msgbox % obj.Main()

Code: Select all

; Return an integer type
cSharp =
(
    class MainReturnValTest
    {
        public int Main()
        {
            int n = 5;
            return n;
        }
    }
)

obj := CLR_CreateObject( CLR_CompileC#( cSharp ), "MainReturnValTest")
msgbox % obj.Main()

Code: Select all

; Return both string and integer types
cSharp =
(
    class MainReturnValTest
    {
        private int Integer()
        {
            int n = 5;
            return n;
        }

        public string Main()
        {
            string str = "High ";
            return str + Integer();
        }
    }
)

obj := CLR_CreateObject( CLR_CompileC#( cSharp ), "MainReturnValTest")
msgbox % obj.Main()

Code: Select all

; Return string and decimal types
cSharp =
(
    class MainReturnValTest
    {
        private decimal Decimal()
        {
            decimal d = 5.3m; // decimals must be appended with M or m suffix
            return d;
        }

        public string Main()
        {
            string str = "Decimal ";
            return str + Decimal();
        }
    }
)

obj := CLR_CreateObject( CLR_CompileC#( cSharp ), "MainReturnValTest")
msgbox % obj.Main()

Code: Select all

; Compile an executable in C#
cSharp =
(
    using System;
    namespace HelloWorld
    {
        class Hello 
        {
            static void Main() 
            {
                Console.WriteLine("Hello World!");

                // Keep the console window open in debug mode.
                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();
            }
        }
    }
)

FileName := A_ScriptDir "\HelloWorld.exe"

CLR_CompileC#( cSharp, "System.dll",, FileName ) 

Run % FileName

Code: Select all

; Pass arguments to compiled executable
cSharp =
(
    using System;
    namespace HelloWorld
    {
        class Hello 
        {
            static void Main(string[] arr) 
            {
                for (int i = 0; i < arr.Length; i++)
                {
                    Console.Write(arr[i] + "{0}", i < arr.Length - 1 ? " " : "");
                }
                Console.WriteLine();

                // Keep the console window open in debug mode.
                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();
            }
        }
    }
)

FileName := A_ScriptDir "\HelloWorld.exe"

CLR_CompileC#( cSharp, "System.dll",, FileName ) 

RunWait % FileName " arg1 arg2"
Run % FileName " Some more arguments"

Code: Select all

Kodes =
(
    class Tecting
    {
        public string Main()
        {
            int ABC = 123 ;
            return ABC.ToString( "000###" )  ;
        }
    }
)
Ovject := CLR_CreateObject( CLR_CompileC#( Kodes ), "Tecting")
Msgbox % Ovject.Main()

Code: Select all

Sample =
(
using System.Windows.Forms;
    class Testing
    {
        public void Main()
        {
            MessageBox.Show( "a" ) ;
        }
    }
)
Ovject := CLR_CreateObject( CLR_CompileC#( Sample ), "Testing")
Ovject.Main()

Code: Select all

c# =
(
    using System.Windows.Forms;
    class Foo {
        public void Test() {
            MessageBox.Show("Hello, world, from C#!");
        }
    }
)
CLR_Start()

asm := CLR_CompileC#(c#, "System.dll | System.Windows.Forms.dll")
obj := CLR_CreateObject(asm, "Foo")
obj.Test()

Code: Select all

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.IO;										
using System.Diagnostics;								
using System.Windows.Forms;				
using System.Runtime.InteropServices;			
using System.Text.RegularExpressions;		
using aEXL = Microsoft.Office.Interop.Excel ;
using aWRD = Microsoft.Office.Interop.Word ;
using aCOR = Microsoft.Office.Core;			

Code: Select all

asm := CLR_CompileC#(c#, "System.dll 
| System.Collections.Generic.dll
| System.ComponentModel.dll
| ...
| ...dll")

Code: Select all

; Change Fore/Background console colors
c# =
(
using System;
class ChangeColors
{
    public static void Main() 
    {
        ConsoleColor[] colors = (ConsoleColor[]) ConsoleColor.GetValues(typeof(ConsoleColor));
        foreach (var color in colors)
        {
            if ( color == colors[ 0 ] ) continue;
            else
            {
                Console.BackgroundColor = colors[ 0 ]; Console.ForegroundColor = color;
                Console.WriteLine( "ForegroundColor: {0}", color );

                Console.ForegroundColor = colors[ 0 ]; Console.BackgroundColor = color;
                Console.WriteLine( "BackgroundColor: {0}", color ); 
            }
        }
        Console.ReadKey();
    }
}
)

CLR_CompileC#( c#,,, FileName := A_ScriptDir "\Colors.exe" )
Run % FileName

Code: Select all

; Change entire background color
c# =
(
using System;
class ChangeBackgroundColor
{
    public static void Main() 
    {
        ConsoleColor[] colors = (ConsoleColor[]) ConsoleColor.GetValues(typeof(ConsoleColor));
        int ColorsLeft = ( colors.Length-2 );

        foreach (var color in colors)
        {
            if ( color != colors[ 0 ] )
            {
                Console.ForegroundColor = colors[ 0 ]; Console.BackgroundColor = color;
                Console.Clear();   // Used to color the entire buffer 
                Console.WriteLine( "BackgroundColor: {0}",  color );
                Console.WriteLine( "Colors left: {0}. Press any key to continue...", ColorsLeft-- );
                Console.ReadKey();
           }
        }
    }
}
)

CLR_CompileC#( c#,,, FileName := A_ScriptDir "\BGColors.exe" )
Run % FileName

Code: Select all

c# =
(
using System.Windows.Forms;
class KeyStrokes
{
    public void Main(string var) 
    {
        Keys( var );
    }

    private void Keys(string var) // recommeded approach
    {
        SendKeys.SendWait( var );
    }
}
)

csObj := CLR_CreateObject( CLR_CompileC#( c#, "System.dll | System.Windows.Forms.dll" ), "KeyStrokes" )

csObj.Main( "Send this string.." )

Code: Select all

Kodes =
(
    using System.Windows.Forms;
    using System.Linq;                          
    using System.Collections.Generic;                   
    using System.Text.RegularExpressions;               
    class Klass
    {
        public void Mesod()
        {
            string KnTs = @"
            abc123def
            abc1234def
            abc1def
            abc12def
            ";  
            var Arrey = Regex.Matches( KnTs, @".*?(\d+).*?")
                        .Cast<Match>()
                        .Select( a => a.Groups[1].Value)
                        .OrderByDescending( a => a.Length);
            MessageBox.Show ( string.Join("\n", Arrey )) ;  
        }
    }
)
Leferences = 
(	Join|
	System.Windows.Forms.dll
	System.Core.dll
	mscorlib.dll
	System.dll
)
CLR_CreateObject( CLR_CompileC#( Kodes, Leferences), "Klass").Mesod()