public class MyConfig
{
  public string Config1 {get;set;}
  public int Config2 {get;set;}
}

// MyConfig will be loaded from file or create new one if needed
var myConfig = ConfigLoader.Default.Get<MyConfig>();
textBox1.Text = myConfig.Config1;

// Inherits from AutoNotifyPropertyChanged class and marks properties as virtual.
public class MyConfig : AutoNotifyPropertyChanged
{
  public virtual string Config1 {get;set;}
  public virtual int Config2 {get;set;}
}

// Change save mode to:
//  OnChange: save immediately when config changes
//  OnExit: save when app's closed
//  ReadOnly: don't save
ConfigLoader.Default.SaveMode = SaveMode.OnChange;
var myConfig = ConfigLoader.Default.Get<MyConfig>();
myConfig.Config1 = "New config";// config will be saved after this call

[ConfigClass(Description = "Describe your config here")]
public class MyConfig
{
    [Description("First string config")]
    public string Config1 { get; set; }

    [Description("Second int config")]
    public int Config2 { get; set; }
}

var myConfig = ConfigLoader.Default.Get<MyConfig>();
using (var form = new SettingsForm { Settings = myConfig })
{
    form.ShowDialog(this);
    var changed = form.SettingsChanged;
}

public class MyEvent
{
    public string Data1 {get; set;}
    public int Data2 {get; set;}
}

class MyService
{
    MyService()
    {
        // Start subscribing incomming events (call Unregister to unsubscribe events)
        EventBus.Default.Register(this);
    }

    [Subscribe]
    private void SubscribeMethod1(MyEvent myEvent)
    {
        // do you stuff here
    }

    [Subscribe]
    private void SubscribeMethod2(MyEvent2 myEvent2)
    {
        // do you stuff here
    }
}

// Somewhere else in your project

EventBus.Default.Post(new MyEvent {Data1 = "my data1", Data2 = 123});// SubscribeMethod1 will be called
EventBus.Default.Post(new MyEvent1 {...});// SubscribeMethod2 will be called

// Currently we're supporting several thread modes:
//  Post: default mode, invokes subscribers immediately in current caller thread
//  Thread: invokes subscribers in a new background thread if caller thread is main thread, otherwise invokes subscribers immediately in current caller thread 
//  Async: Always invokes subsribers in a new background thread
//  Main: Invokes subscribers in main thread (UI thread) in blocking mode
//  MainOrder: Invokes subsribers in main thread (UI thread) in non-blocking mode
[Subscribe(ThreadMode = ThreadMode.Thread)]
private void WillBeCalledInBackgroundThread(MyEvent myEvent)
{
    // this stuff will be called in background thread
}

[Subscribe]
private PostHandled CancelableSubscriber(MyEvent myEvent)
{
    // do you stuff here
    return new PostHandled {Canceled = true};
}

// From subscribers
[Subscribe]
private PostHandled ReturnValueForCaller1(MyEvent myEvent)
{
    // do you stuff here
    return new PostHandled {Data = "any data here"};
}
[Subscribe]
private string ReturnValueForCaller2(MyEvent myEvent)
{
    // do you stuff here
    return "any data here";
}

// From caller
var results = EventBus.Default.Post(new MyEvent{...});

// Posts a sticky event
EventBus.Default.Post(new MyEvent{...}, true);// MyEvent likes other events but it's still remaining in memory after called
EventBus.Default.Post(new MyEvent{...}, true);// this will replace the first event

// Queries a specific sticky event
var myStickyEvent = EventBus.Default.GetStickyEvent(typeof(MyEvent));

// Removes a specific sticky event
EventBus.Default.RemoveStickyEvent(myStickyEvent);

var eventbus = ClientEventBus.StartNew("my-eventbus");
eventbus.Post(new MyEvent{...});

var eventbus = ServerEventBus.StartNew("my-eventbus);
eventbus.Register(this);
.....

[Subscribe]
private void ListenMyEvent(MyEvent myEvent)
{
...
}

private AppCrash appCrash = new AppCrash(); // defines it as a global variable to prevent GC collects this.

// defines you report form
public class YourReportForm : Form, IReportWindow
{
    ....
    public void Initialize(Exception exception, string productName, string devMail)
    {
        textBox1.Text = exception.Message;
        textBox2.Text = productName;
        textBox3.Text = devMail;
    }
}

// Registers you report form
var appCrash = new AppCrash
{
    ProductName = "My product",
    DeveloperMail = "xuanson33bk@gmail.com"
};
appCrash.Register(typeof(YourReportForm));

var appCrash = new AppCrash {CrashDir = @"C:\newCrashLogsDir"};

// You can annotate your class by Component, Service, Repository or Controller, they are the same but for easier to understand their roles.
[Controller]
public class MyApp
{
    // Properties which are annotated with Autowired attribute will
    // be injected automatically
    [Autowired]
    public MyComponent MyComponent {get; set;}

    // myService will be injected automatically
    public MyApp(MyService myService) {...}
    ....
}
[Service]
public class MyService {....}
[Component]
public class MyComponent{....}

// Somewhere else...
// App32Context will scan the entry assembly to find classes which are annotated with Controller, Component, Repository or Service attributes.
using (var context = new App32Context())
{
    var myApp = context.Resolve<MyApp>();
    myApp.Start();
}

// If you don't pass any assembly, the entry assembly will be used
using (var context = new App32Context(assembly1, assemly2, assembly3))
{
    ....
}

// By default, only one instance of a component will be created (singleton mode). If you want to create a new instance of a component each time it's injected to another component, set Singleton to false
[Service(Singleton = false)]
public class MyService {....}

using (var context = new App32Context())
{
    var config = context.Resolve<IConfigLoader>();
    ....
}

// Gets Control class from winform namespace, if current project doesn't reference to winform, return type will be null
var type = DynamicInvoker.GetType("System.Windows.Forms", "Control");

// Registers ApplicationExit event on Application class
var type = DynamicInvoker.GetType("System.Windows.Forms", "Application");
if (type != null)
{
    DynamicInvoker.AddEventHandler<EventHandler>(type, "ApplicationExit", Application_ApplicationExit);
}

// Invokes CreateControl method on Control instance
var type = DynamicInvoker.GetType("System.Windows.Forms", "Control");
if (type != null)
{
    var control = Activator.CreateInstance(type);
    DynamicInvoker.InvokeMethod(control, "CreateControl");
}

// Gets ProductName from Application class
var type1 = DynamicInvoker.GetType("System.Windows.Forms", "Application");
if (type1 != null)
{
    var productName = DynamicInvoker.GetPropertyValue(type1, "ProductName") as string;
}

// Sets "My text" to Text property
var type2 = DynamicInvoker.GetType("System.Windows.Forms", "Control");
if (type2 != null)
{
    var control = Activator.CreateInstance(type2);
    DynamicInvoker.SetPropertyValue(control, "Text", "My text");
}

using (var sender = new Sender("my-intercomm"))
{
  var response = await sender.SendAsync<string>("Hi server, I'm client1");
  Console.WriteLine("Response from the other process is: " + response);
}

using (var receiver = new SingleReceiver("my-intercomm"))
{
  var request = await receiver.ReceiveAsync<string>();
  await receiver.SendAsync("Hello " + request);
}

using (var receiver = new MultiReceiver("my-intercomm"))
{
    await receiver.WaitForSessionAsync(async session =>
    {
        var request = await session.ReceiveAsync<string>();
        await session.SendAsync("Hello " + request);
    });
}