Lightweight

WickedFlame components are lightweight with a absolute minimal footprint and leave no trace in client code. Components can be capsulated to destinct places where they can easily be managed or replaced.

Fluent

WickedFlame components support a Fluent Synthax that is simple and easy to use. The Fluent API allways leads the user to the desired result.

Configuration

WickedFlame components can be configured in code or within the application configuration. InCode configuration can allways be isolated to destinct areas to minimize the footprint of the component

Simplicity

WickedFlame components are designed to have a simple and intuitive API that is easy to use and understand.

[frameworks]

designed for speed and simplicity
open source and free
lightweight to the core

Data access and persistance

PersistanceMap lets you easily access and persist data with its intuitive, simple and fast API. The Code-First implementation allows full control over the database

DI/IoC

Get the most of DependencyInjection and Inversion of Control with InjectionMap

Logging and Diagnostics

Easily write to your favourite loggers through a simple API

Task queue and processing

Easily process Tasks asynchronously without having to care about when and how they will be processed

[persistancemap]

Persistance

PersistanceMap is a small, extremely lightweight and intuitive code fist, convention based ORM Framework for .NET.

Queries

Queries are defined using a Fluent API that compile to SQL. The SQL is executed against the RDBMS using the underlying ADO.NET.
The returned data is automaticaly projected to Typed POCO's.

Simplicity

The synthax is simple, straight forward and easy to use.

Lightweight

PersistanceMap is extremely lightweight with a minimal footprint that leaves no traces in the client code.

Fluent

PersistanceMap suports a fluent syntax to help keep the code simple and clean.

Supported Databases

PersistanceMap currently supports MSSql and SQLite RDMBS Servers.

Code first

PersistanceMap supports a code first approach. Databases and tables can be created on the go without having to depend on scripts to do the job.

Installation

PersistanceMap for SQL and Sqlite servers can be downloaded and installed as a NuGet Package.
MSSql Server
PM > Install-Package PersistanceMap
SQLite
PM > Install-Package PersistanceMap.Sqlite

Examples

The only difference in using PersistanceMap for different database types, ist in the IContextProvider.
The IContextProvider is the component that is needed to create the context of the specific database type.
For MSSql use the SqlContextProvider and for Sqlite use the SqliteContextProvider.

MSSql Database
var connectionString = "data source=.;initial catalog=DemoDatabase;integrated secutrity=true"; 
var provider = new SqlContextProvider(connectionString); 
using (var context = provider.Open()) 
{ 
	// use context to create Queries return
	return context.From<Order>()
		.Join<OrderDetail>(od, o) => od.OrderID == o.ID)
		.Select<OrderWithDetail>() 
}
Sqlite Database
var connectionString = "data source=SQLiteDemo.db"; 
var provider = new SqliteContextProvider(connectionString); 
using (var context = provider.Open()) 
{ 
	// use context to create Queries return
	return context.From<Order>() 
		.Join<OrderDetail>((od, o) => od.OrderID == o.ID) 
		.Select<OrderWithDetail>() 
}
Code first sample
var provider = new SqlContextProvider(connectionString); 
using (var context = provider.Open()) 
{ 
	// create the database
	context.Database.Create(); 
	
	// create a table with a key 
	context.Database.Table<Warrior>().Key(wrir => wrir.ID).Create();
	
	// insert item into table 
	context.Insert(() => new Warrior { ID = 1, Race = "Elf" }); 
	
	context.Commit(); 
	
	// select a item
	var wrir = context.Select<Warrior>(w => w.ID == 1).First(); 
	
	// update the item
	wrir.Skill = 500; 
	context.Update(() => wrir); 
}
For more examples please refer to the Github documentation

[injectionmap]

A intuitive and lightweight DependencyInjection framework.
InjectionMap is a small IoC/DI container for .NET that allows loose coupling betweeen a client's dependencies and the behaviour.
InjectionMap promotes reusability, testability and maintainability of any part of an application.

Lightweight

InjectionMap is a very lightweith IoC Framework that leaves no traces in the client code

Fluent

InjectionMap suports a fluent syntax to help keep the code simple, small and clean.

.NET Support

InjectionMap supports .Net 4.5, Silverlight 5, Windows Phone 8 or higher and Windows Store apps for Windows 8 or higher.

Simplicity

InjectionMap is very simple, straightforward and easy to use.

Type defined

InjectionMap uses type mapping to create a reference between contract and the implementation.

Installation

InjectionMap can be installed from NuGet through the package manager console.

Extensions

InjectionMap comes with several extensions.
Extension for injecting the DataContext with a mapping
Configure Mappings and MapInitializers in the application config file

Installation

InjectionMap can be downloaded and installed as a NuGet Package.
PM > Install-Package PersistanceMap

Examples

Mappings are always registered using a instance of a InjectionMapper.
The InjectionResolver is used to resolve instances.This helps separate the registration from the resolving.
using (var mapper = new InjectionMapper()) 
{ 
	// register InjectionMappingTest to the interface IInjectionMappingTest 
	mapper.Map<IInjectionMappingTest, InjectionMappingTest>(); 
} 

using (var resolver = new InjectionResolver()) 
{ 
	var map = resolver.Resolve<IInjectionMappingTest>(); 
	... 
}
When there is a need to map to distinct contexts intead of the global context,
the InjectionMapper and InjectionResolver accept a instance of a MappingContext.
All mappings will be set and resolved from this context only.
var context = new MappingContext();
using (var mapper = new InjectionMapper(context)) 
{ 
	// register InjectionMappingTest to the interface IInjectionMappingTest 
	mapper.Map<IInjectionMappingTest, InjectionMappingTest>(); 
} 

using (var resolver = new InjectionResolver(context)) 
{ 
	var map = resolver.Resolve<IInjectionMappingTest>(); 
	... 
}
For more examples please refer to the Github documentation

[scribe]

A wrapper component for delegating and managing Log and Trace messages.
Uses the built-in Tracing mechanism to create cutom log entries.
Easily extendable to customize and delegate Traces or custom Log messages to any desired logger.

Installation

Scribe can be downloaded and installed as a NuGet Package.
PM > Install-Package Scribe

[broadcast]

A simple and lightweight in-process fire and forget, request/response and messaging commponent. Broadcast is a simple implementation for processing queued tasks and notifications synchronous and asynchronous. Broadcast helps implement the Mediator and CQRS (Command- and Queryhandling) patterns easily.

Installation

Broadcast can be downloaded and installed as a NuGet Package.
PM > Install-Package Broadcast

Examples

Task Processing can be done Synchronous and Asynchronous
depending on the ProcessorMode passed to the Broadcaster.
IBroadcaster broadcaster = new Broadcaster();
broadcaster.Send(() => Trace.WriteLine("This is a basic synchronous processed task"));
Simple Sample of how Eventhandlers can be registered and called
// Broadcaster is usualy resolved through DependencyInjection
IBroadcaster broadcaster = new Broadcaster();

// register different handlers
broadcaster.RegisterHandler(notificationHandler);
broadcaster.RegisterHandler<Message>(delegateHandler.Handle);
broadcaster.RegisterHandler<Message>(a => expressionHandler = a.ID);

// publish a message to the handlers
broadcaster.Send(new Message(5));