What is the CarCake Framework?
CarCake is a collection of .NET libraries, written in C# designed to address a range of specific and cross-cutting concerns for those working with any or all of the following:
The framework, which is open source and available free of charge under the Microsoft Public License (Ms-PL), offers a variety of features and components designed to aid productivity and produce robust and performant systems from tried and trusted code, patterns, and practices.
CarCake makes Windows Service development a richer more joined-up experience for developers and DevOps. It even provides a desktop server edition of your Windows Service integrated into the service framework.
CarCake Publish Subscribe
An advanced yet simple to use 'publish-subscribe' messaging system, providing rich communications between all types of applications including Desktop Applications, System Services, Web Services and Web Applications.
The server runs as a system service on one or more machines and caters for both publishing and subscribing clients. The services are accessed by clients using the CarCake.PublishSubscribeClientAssistant classes. The underlying communications provided by the Microsoft .NET WCF libraries and a TCP transport.
Messages are composed using the CarCake.GridXsd class which is a remotable type based upon System.DataSet. This Class and its helpers allow the developer to create messages using a relational grid container. The routines that pack and unpack Messages are User-developed through interfaces that define the business use case. This logical abstraction allows the communications interfaces to remain fixed and unchangeable thus keeping the deployment terrain stable.
Configuration implemented at machine level in xml configuration files (located under 'ProgramData') provides better control.
CarCake.PublishSubscribe provides full support for WCF's rich configuration model.
A highly robust framework based on the .NET Remoting libraries for inter-application or cross-app domain communications
.NET Remoting is a handy tool in the CarCake library. Where .NET WCF provides the rich configuration and tooling for sophisticated communication solutions that include timeouts, limits, and the like, it's not nimble, or 'low level' enough to deal with some communications requirements. WCF sits on top of .NET Remoting's Channel classes, and it is these classes that are the foundation of .NET Remoting. The layer is a thin one for Remoting, and this delivers the robustness and agility of socket programming, with the payload sophistication of .NET Channels.
CarCake.Remoting provides quick and convenient access to this technology using the CarCake.RemotingAssistant classes. It also takes the same message payload as CarCake.PublishSubscribe providing compatibility in the payload. Both use the CarCake.GridXsd class as the message payload.
CarCake System Services
A comprehensive set of classes, components, tools, and a framework with which to develop and host your Windows System Services. Development of services becomes more productive with features that include desktop server hosting providing an accurate recreation of the service command pattern, including the facility to review program output in the Console Pane, console input for issuing Start, Stop commands, etc., and a real-time display of memory consumption, thread counts and more.
Add to this the ability to hook up all your services, desktop and web services, and applications to a comprehensive diagnostics and management framework and the ability to add controls to the Multi-Tabbed or MDI document container service development becomes a first-class developer experience.
CarCake Threading & Queueing
.NET support for multi-threaded programming is excellent. Now add to this the ability to structure your programs in a threaded way at the structural level, and you get a highly stable and inherently multi-threaded program environment.
With the CarCake Assistant-Worker pattern, you can structure your threaded environment with lifetime managed dedicated threads and efficiently manage interactions between them. A range of worker variants provides 'plain threads,' blocking queues, and asynchronous patterns.
CarCake Diagnostics is a library that addresses the critical concerns associated with service development and runtime - visibility, and control.
A complete system might comprise several system services, web services, websites, desktop applications, with a whole mixture of interrelated dependencies. We need to be able to see the state of the system, what's running, faulted, offline and the like, and do whatever is needed.
Further, we might need to start services in a particular order or disconnect dependencies in a controlled way when stopping a service or site. We may want to intervene and send commands to reconnect when disruption has occurred.
CarCake Diagnostics provides the complete infrastructure and tools to provide 100% system visibility. There's a base class from which to derive your Diagnostics Desktop which hooks up with a low-level remoting framework, tried and tested in providing a reliable system dashboard.
CarCake Rich Client
A CUA (Common User Access) compliant framework for building Multi-Document Windows Desktop Applications.It's A .NET Winforms based Application Framework with all aspects of document and 'rich client' support built in.
Full support for logical managers and instance control with an internal request/reply message bus. Support and full integration of both application level and document level Ui metaphors including menus, tabs, task panes, and palletes. Sophisticated pixel perfect skinning (which includes support for non-client areas) enables the creation of stunning Ui's
The built in support for serialization makes application document support simply a matter of following the framework pattern.
There is task pane, menu, ambient, and toolbar support at both Application and Document level.
A dedicated build service and framework for building *.csproj based projects which includes desktop applications, services, web applications, and web services.
Add to this the complete automation of WiX MSI installer composition and MSI production for all of these project types and a stable and robust deployment facility is guaranteed.
The framework is based on a simple configuration convention and includes full control of multiple product versions support.
The underlying technology is MSBuild and WiX.
In situations where continuous deployment is not appropriate, for instance where a controlled release program with 'well-known' versions and their support are required, the CarCake Install framework is a collection of tools and a methodology for automating the production of installers as part of a continuous build process.
The CarCake WiX model is a solution layout convention for producing build and automation-ready installer projects. It is highly reliable and uses the CarCake ProjectLab component to generate the project information during the build. This works in automated builds as well as in Visual Studio during installer development.
CarCake Components is a collection of controls and base classes designed to unify and speed up the creation of Winforms Gui's related to services and systems development. This type of 'Workhorse' application is often neglected and underdeveloped, which can lead to an unnecessarily poor presentation layer on what might be an otherwise excellent set of services.
CarCakes support for Desktop Servers for services uses these components to create the primary application interface. Includes the InfoWriter control for presenting information, the ConsoleWriter control for displaying trace and output and receiving commands from the keyboard, and a whole range of support for menuing, tabs, etc.
CarCake Data Service
CarCake Data Service is a WCF based server implementation for providing a multi-channeled TCP data service. Your applications, web services, web sites, and services can use the complementary data service client to asynchronously retrieve and commit data.
The payload is the same CarCake GridXsd used by the Publish-Subscribe and Remoting libraries providing complete compatibility. The interface is also the same allowing development of service calls to continue without disruption to the middleware layer.