blackcat

Getting started

Install-Package Blackcat -Version 1.0.1

Install-Package Blackcat.WinForm -Version 1.0.0

All important utilities

Configuration

Basic usage

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;

{
 "Metadata": {
 "Modified": "2019年11月11日T14:29:35.3268223+07:00"
 },
 "Configs": [
 {
 "Key": "MyObject",
 "Data": {
 "Config1": "This is a string config",
 "Config2": 123,
 }
 }
 ]
}

Advance usage

// 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;
}

EventBus

Basic usage

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

Advance usage

// 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)
{
...
}

AppCrash

Basic usage

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

Advance usage

// 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"};

IoC

Basic usage

// 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();
}

Advance usage

// 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>();
 ....
}

DynamicInvoker

Basic usage

// 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");
}

Intercomm

Basic usage

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);
}

Advantage usage

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