Cuemon .NET Framework Additions 2.0.2013.1350

2.0.2013.1350

This is a minor release which fixes a few bugs while adding some new functionality. The following work was completed for this release:

- A new class was introduced in the Cuemon.Xml.Serialization namespace; XmlQualifiedEntity that provides ways to assure qualified names in XML serialization logic

- The TransientFaultUtility class was extended with ten new overloads while receiving a bug fix in regards to infinite retries in case of no thrown exception
- The XsltMasterPage-, XsltPage-, Website-, WebsiteGlobalization-, WebsiteGlobalizationCultureInfo-, WebsiteGlobalizationTimeZone- and WebsiteGlobalizationTimeZoneDictionary class was refactored accordingly to the breaking changes applied to the IXmlSerialization interface
- The IXmlSerialization interface, XmlSerialization-, XmlSerializationUtility-, XmlElementWrapper-, XmlWrapper- and XsltUtility class was modified to use the newly introduced XmlQualifiedEntity class

2.0.2013.1100

This is a minor release which fixes a few bugs introduced with the last major release of the Cuemon Assemblies while adding some new functionality. The following work was completed for this release:

- A new class was introduced in the Cuemon namespace; TypeArgumentException that should be thrown when one of the type arguments provided to a method is not valid
- A new utility class was introduced in the Cuemon.Web.Configuration namespace; WebConfigurationUtility that provides ways to open a Web-application configuration file and read custom Handler configurations
- A new abstract class was introduced in the Cuemon.Xml.Serialization namespace; XmlWrapper that provides ways to override the default XML naming serialization logic
- A new class was introduced in the Cuemon.Xml.Serialization namespace; XmlElementWrapper that provides ways to override the default XML element name serialization logic
- The ConvertUtility class was extended with these new methods; ToHexString, FromHexString
- The EnumUtility class was extended with a new method; Parse
- The class was extended with a new method; Root
- The NumberUtility class was extended with these new methods; IsEven, IsOdd
- The TypeUtility class had one of its methods, SanitizeTypeName, made more resilient for generic types while extended with these new methods; IsComparer, IsComparable, IsEqualityComparer
- The GlobalModule class received a high priority bug fix which accidently caused the Content-Encoding header to be set but without compressing the content body
- The HttpRequestUtility class was extended with a new method; GetAcceptHeader
- The XmlSerializationUtility class received some minor bug fixes in the Serialize method and was extended with some static properties; MaxSerializationDepth, SkipPropertiesCallback, SkipPropertyCallback
- The Cuemon.ServiceModel assembly is still a work in progress why it is not recommended to use any classes but the Endpoint base class although many new have been added and promising progress is emerging

2.0.2013.1000

For two month this major release has been under way - and there are still so much work to be done, but slow and steady a cloud friendly framework is emerging with the guts to remove deprecated code while keeping a focus on performance and high flexibility using Action and Func delegates where appropriate. My Achilles heel is still the Cuemon.ServiceModel class, but the ground work is in place and I expect within 3 months that a REST friendly and highly flexible solution is in place.
Enough with the small talk - let’s get to the work that was implemented for 2.0.2013.1000:

- The Func delegate was extended from 5 arguments to 20 arguments
- The Action delegate was extended from 5 arguments to 20 arguments


- A new utility class was introduced in the Cuemon namespace; TransientFaultUtility that provides ways to make applications more resilient with robust transient fault handling logic
- A new class was introduced in the Cuemon namespace; TransientFaultException
- A new class was introduced in the Cuemon namespace; DefaultOr that provides - to some extent - a generic way to support the Null Object Pattern
- A new class was introduced in the Cuemon namespace; Wrapper -> IWrapper
- A new class was introduced to ease the usage of Func delegates; the FuncFactory class with up to 20 arguments
- A new class was introduced to ease the usage of Action delegates; the ActionFactory class with up to 20 arguments
- A new class was introduced in the Cuemon namespace; LoopUtility
- A new class was introduced in the Cuemon namespace; Hierarchy -> IHierarchy as well as HierarchyUtility
- A new class was introduced in the Cuemon namespace; AssignmentUtility
- A new enum was introduced in the Cuemon namespace; AssignmentOperator
- A new enum was introduced in the Cuemon namespace; RelationalOperator
- The HashUtility class was extended to support the CRC32 checksum
- The MethodSignature class was extended with these new members; HasParameters, Create, MergeParameters
- The Instrumentation class was simplified internally
- The TypeUtility class was extended with these new methods; GetAncestorOrSelf, IsEnumerable, IsDictionary, IsKeyValuePair, SanitizeTypeName, ContainsAttributeType
- The ExceptionUtility class was refactored, moved and extended with these new methods; Parse, Flatten, Refine [breaking]
- The TesterDoerUtility class was refactored to support both Action and Func delegates [breaking]
- The HttpMethod enum was renamed to HttpMethods as it now supports the Flags attribute [breaking]
- The StringUtility class was extended with these new methods; Remove
- The ConvertUtility class received optimizations and was extended with these new methods; ToWebHeaderCollection, ToString, ToEnumerable, ToDelimitedString
- The ReflectionUtility class was extended with these new methods; GetAttributes, GetAttribute, HasCircularReference, GetPropertyValue, GetObjectHierarchy


- A new class was introduced in the Cuemon.Security.Cryptography namespace; CyclicRedundancyCheck32
- A new abstract class was introduced in the Cuemon.Security.Cryptography namespace; CyclicRedundancyCheck
- A new enum was introduced in the Cuemon.Security.Cryptography namespace; PolynomialRepresentation


- A new utility class was introduced in the Cuemon.Collections.Generic namespace; ListUtility
- A new utility class was introduced in the Cuemon namespace; EnumUtility with so far one method: HasFlags
- A new class was introduced in the Cuemon.Collections.Generic namespace; EnumerableSizeComparer
- The EnumerableUtility class was extended with several new methods; Select, SelectMany, FindAll, Any


- A new enum was introduced in the Cuemon.Xml.Serialization namespace; SerializableOrder
- The XmlUtility class has its ConvertEncoding method extended
- The XmlConvertUtility class was extended with these new methods; ToXmlElement, ToStream [breaking]
- The XmlSerializationUtility class completely revamped, refactored and simplified with a high degree of flexibility [breaking]
- The XmlSerialization class was extended with several new overloads of ToXml


- The DataManager, SqlDataManager and SqlCeDataManager class was refactored to use the new TransientFaultUtility class with accordingly name aligning [breaking]
- The RuntimeBusinessEntity class was extended to provide better exception details
- The DataManager class received a bug fix for those rare occasions where an exception is thrown while iterating a reader or similar; command parameters are cleared now
- The ColumnAttribute class now supports ordering of compound primary keys
- The BusinessEntityDataAdapter now support multiple steps in property hierarchy
- The MappingUtility class was extended with the new methods; ParseStorageFieldValue, SetStorageFieldPropertyValue, ParseStorageField
- The BusinessEntity class now supports multiple steps in property hierarchy
- The BusinessEntityUtility class now fully supports compound primary keys


- The XsltPage now supports entity tag resolvement when checking against client caching
- The GlobalModule class was simplified internally
- The HttpResponseFilter class was simplified internally
- The HttpResponseContentFilter class was extended and simplified internally
- The HttpResponseUtility class was refactored and extended with these new methods; SetClientSideContentCacheExpiresHeaders, CreateClientSideContentCacheExpiresHeaders [breaking]
- The HttpRequestUtility class was refactored and extended with these new methods; IsClientSideContentCached, TryGetEntityTagHeader [breaking]
- The SiteMapProtocolHandler was refactored to use the NetHttpUtility class


- The Cuemon.ServiceModel assembly is a work in progress why it is not recommended to use any classes but the Endpoint base class although many have been added

2.0.2013.0420

For this release a few minor bugs was fixed a long with refactoring and code optimization.
The following work has been implemented:

- The NetDependency class was made more flexible with several new overloads
- The XsltMasterPage class now supports XSLT parameters that will find their way to the associated XsltPage
- The XsltPage class will now include any XSLT parameters from an associated XsltMasterPage
- The GlobalModule class received a new event; SendRequestContent and the current ASP.NET lifecycle monitoring was extended with the Page lifecycle as well for complete overview of the whereabouts of the request flow
- The WebsiteModule class was reduced in complexity when providing the above mentioned lifecycle to an XsltPage where debugging is enabled
- The NetHttpUtility class received a patch when doing HTTP calls async; if a request took more than 30 seconds an exception was mistakenly thrown instead of honoring the request timeout
- The AsyncCall class was extended with timeout Timespan on the virtual Invoke method
- The NumberUtility class was strengthen in regards to generating random numbers
- The XsltUtility class was refactored to easier usability in terms of loading stylesheets through Uri and string
- The EncodingUtility class had the GetEncodings method changed to an IReadOnlyDictionary

2.0.2013.0260

For this release, the primary focus was to refactor, stabilize and improve the common thread through out the Cuemon family.
The following work has been implemented:

- The SqlDataManager class was extended with support for error code 10928 and 10929 in the IsTransientFailure method as announced by the Windows Azure Team
- The Instrumentation class was further improved in regards to automated parameter detection
- The WebsiteModule class received a minor bugfix related to request pipeline processing filtering
- The ManagementUtility class was further improved with this new method; GetProcessorInfo
- The StringUtility class was refactored and most convert related methods was moved to ConvertUtility. Also, these new members was added: Shuffle, PunctuationMarks and new overloads of Contains
- The XmlUtility class recevied a minor bugfix in the CreateXmlReader method
- The HttpRequestUtility class was extended with new overloads of; TryGetLastModifiedHeader
- The NumberUtility class was extended with these new members; RoundOffAccuracy, RoundOff
- The CompressionUtility class now reset the position of the compressed or decompressed stream
- A new class was introduced for quick platform related data; PlatformUtility
- A new class was introduced for convenient support of the Tester-Doer pattern; TesterDoerUtility

IMPORTANT NOTICE

This version has a breaking change from assembly version 1.0.2012.2500 to 2.0.50727.1433. This was done so reflect the compatible Microsoft .NET Framework also known as Microsoft .NET Framework 2.0 with Service Pack 1.
Further more was the following classes refactored: ArrayUtility, ByteUtility, CharUtility, StringUtility and StreamUtility where the Create/Convert methods was moved to the ConvertUtility with a changed name of To*.

1.0.2012.2800

For this release, the primary focus was to further stabilize and improve existing functionality of the previous two releases. The following work has been implemented:

- The EnumerableUtility class was extended with the following new generic method; Any
- The HttpRequestUtility class was extended with the following new method; GetHostAuthority
- The HttpResponseUtility class was extended with a new method that further increases IIS 6.0 compatibility; RemoveResponseHeader
- The NetDependency class received some documentation changes after a spell check and some modest infrastructure revamp
- The NetWatcher class received some modest infrastructure revamp
- The ReflectionUtility class had the newly introduced method, ToString(MethodBase method) removed and moved to MethodSignature in a refactored version
- The FileDependency class received some modest infrastructure revamp
- The DataDependency class received some modest infrastructure revamp
- The AsyncCall class received a minor - but important - infrastructure revamp
- The DataWatcher class received some modest infrastructure revamp
- The Watcher class received some documentation changes after a spell check
- The BusinessEntity class had IsDisposed property promoted to public and received some modest infrastructure revamp
- The BusinessEntityCollection class had IsDisposed property promoted to public
- The DataAdapter class had IsDisposed property promoted to public
- The DictionaryUtility class was extended with the following new generic method; ToKeyValuePairs
- The Instrumentation class received a complete refactoring after som intense research to strengthen reliability in Release mode (JIT and compiler optimization) and insure flexibility and control of the measurement. There is a slight implementation overhead compared to AOP but I hope it will suffice for a good alternative with complete control
- The ManagementUtility class was further improved with these new methods; GetPerformanceMonitorCounters and GetInstanceName
- The PerformanceMonitorCounter class was introduced to provide a simple way of representing a Performance Counter as in Windows Performance Monitor
- The MethodSignature class was introduced to provide a simple and standardized way of defining a method signature
- The ParameterSignature class was introduced to provide a simple and standardized way of defining a parameter signature
- The SerializationUtility class was extended with the following new generic method; Deserialize
- The DataCommand class was changed so it now actually follows the DefaultTimeout through out the class
- The DataManager class was modified to support Transient Failure Recovery (ideal for SQL Azure solutions) which is default enabled and further extended with two new generic scalar methods
- The SqlDataManager class was modified to support the newly introduced Transient Failure Recovery - namely IsTransientFailure method was implemented with SQL Azure codes as well as some more normal case studies
- The SqlCeDataManager class received a simple implementation of IsTransientFailure as it is file based
- The CountdownEvent class was extended with a new method; AddCount
- The SqlDataConnection class was deprecated and removed from the Cuemon.Data assembly
- The GlobalModule class received various bug fixes triggered by different scenarios - mostly related to IIS 6.0 compatibility
- The ProcessInfo class was renamed to ProcessSnapshot due to one or more naming conflicts with .NET CLR

Note: this version has some breaking changes from the previous version; affected classes are: ProcessInfo, Instrumentation and SqlDataConnection.

1.0.2012.2600

For this release, the primary focus was to stabilize and improve existing functionality of the previous release.

The following work has been implemented:

- The NetHttpUtility class was stabilized by removing a vexing exception found in the AsyncCallResult method
- The WorkItem class was extended with 12 new overloads of the Create method
- The HttpRequestUtility class was extended with a new method
- The HttpResponseUtility class was extended with a new method and strengthen for IIS 6.0 compatibility
- The GlobalModule class was refactored to use recently new implemented methods in both the HttpResponseUtility- and HttpRequestUtility and enhanced with the IsHeadersWrittenDoToIisAdaptiveErrorViolation property to detect ASP.NET lifecycle violations such as headers being written prematurely
- The BusinessEntityUtility class now correctly checks if a class is abstract in the CreateDescendantOrSelfEntity method
- The NumberUtility class was extended with a new method
- The EnumerableUtility class was extended with two new methods

1.0.2012.2500

This release contains several improvements related to the many new exiting features from last release.

The primary focus for this release was to stabilize, refurbish and improve the functionality of the last grand release.

The following work was implemented:

- The CountdownEvent class was stabilized and refurbished in some areas to reduce misunderstanding
- The Instrumentation class was stabilized and refurbished in some areas to ease usage as well as support time measuring of multi threaded scenarios
- The NetHttpUtility class was heavily extended and modernized to every day REST usage and beyond. Among other improvements, the most noticeable is now the support for Factory pattern towards WorkItem implementations
- The EnumerableUtility class was extended with two new methods; the ToArray method as well as a Chunk method ideal for batch task and similar
- The SqlQueryBuilder class and SqlCeQueryBuilder class both received a bug fix when computing the WHERE clause; it now supports check on IS NULL scenarios
- The BusinessEntityUtility class received a performance boost in the CreateDescendantOrSelfEntity method when looking for derived entities and a new method; ParseEntityRelation
- The MethodEnteredEventArgs and MethodExitedEventArgs both received support for a thread referenced identifier
- The TimeMeasure class was stabilized and refurbished in some areas to ease usage as well as support time measuring of multi threaded scenarios
- The ReflectionUtility class was extended with a ToString method for MethodBase derived classes to clearly describe the signature of a method or property
- New EventUtility class to safely Raise, Add and Remove events in a thread safe manner
- The BusinessEntity class was extended with a shortcut method to CreateDescendantOrSelfEntity
- The BusinessEntityCollection class was stabilized and extended with two new methods; ParseEntityRelation and CreateDescendantOrSelfEntity
- The GlobalModule class received a shortcut property to Cache
- The WorkItem class (used in conjunction with the WorkItemPool class) was heavily extended and modernized to every day WorkItem task. Among other improvements, the most noticeable is support for the Factory pattern using Action and Func delegates
- The QueryUtility class was refurbished with several new overloads of the GetQueryFragment method

Note: this version has a breaking change from assembly version 1.0.2012.390 to 1.0.1012.2500. This was done as a result of the many improvements since the 1.0.2012.390 version.

1.0.2012.2200

This release contains a lot of new features, several performance improvements and some minor bugs was fixed.

The primary focus for this release was to start enabling parts of the Cuemon assembly family for high performance multi-threading; easier access to in-depth instrumentation; provide bulk load of databinding in the Cuemon.Data.Entity assembly - and last but not least; overall improvements throughout the family.

The following work was implemented:

- New DictionaryUtility class that supplements the EnumerableUtility class; ToDictionary and FirstOrDefault
- New ProcessInfo class that provides a snapshot of information about an associated process
- New namespace in the Cuemon assembly; Management
- ManagementUtility class that provides easy access to common management operations through the Windows Management Instrumentation (WMI) infrastructure
- New namespace in the Cuemon assembly; Net.Http
- New HttpMethod enum that follows RFC 2616, section 9
- New NetHttpUtility class that provides stunningly fast HTTP implementations
- New namespace in the Cuemon assembly; Threading
- New initial AsyncCall class which provides a way of encapsulating asynchronous operations using a synchronous programming model
- New AsyncCallResult class designed to encapsulate the result of an asynchronous operation
- New CountdownEvent class which is a lightweight implementation of the one found in .NET 4
- New CountdownEventEventArgs to provide data for a CountdownEvent
- New ISortedWorkItem interface that defines a method to control thread related work operations while keeping them sorted
- New IWorkItem interface that defines a method to control thread related work operations
- New IWorkItemPool interface that defines a way to control a thread pool to execute work items
- New SortedWorkItem abstract class providing a way for outsourcing thread intensive work
- New SortedWorkItemPool that provides a pool of threads to execute work items
- New WorkItem abstract class providing a way for outsourcing thread intensive work
- New WorkItemPool that provides a pool of threads to execute work items
- New Action delegates as found in .NET 4
- New Func delegates as found in .NET 4
- Renamed Cuemon.ServiceModel.ServiceInstrumentation to Cuemon.ServiceModel.EndPoint
- Extended the ArrayUtility class with a Cast member
- Extended the EnumerableUtility class with support for an extra overload of Count and three new members; FirstOrDefault, FindAll and Cast
- Extended the NumberUtility class with four new methods; BytesToKilobytes, BytesToMegabytes, BytesToGigabytes and BytesToTerabytes
- Extended the DataCommand class with string formatting
- Extended the StreamUtility class with support for two new overloads of CopyStream
- Extended the HttpRequestUtility class with an extra overload of ParseFieldValuePairs, which now supports option for urlEncode and urlDecode
- Extended the GlobalModule with support for AppPoolUptime property and OnApplicationEnd method
- Extended the DataManager class with several new members; ParseDbType, GetReaderColumnNames, GetReaderColumnValues, GetReaderColumns and GetReaderColumnsAsDictionary
- Refactored BusinessEntityDataAdapter to support bulk loading of dataset
- Overall performance improvements of BusinessEntityDataAdapter Open and OpenList methods - up to factor 5
- Some minor bugs fixed in the XmlSerializationUtility class
- One minor bug fix in SimpleSerializationSurrogate class

There are even more improvements, but the above are the highlights. Do enjoy this release.

1.0.2012.1760

Compared to last release, this release is more modest but equally as important. The following changes have happened in the last week:

- Fixed a bug that prevented HttpResponseContentFilter to write anymore than 16KB of data
- Fixed a bug that could cause hosting on none-default ports checksum exception in ParseTamperingProtectedUri
- New delayed dependency feature for Watcher, WatcherEventArgs, DataWatcher and DataDependency
- New ArgumentEmptyException for empty string arguments
- New IData interface to supply user-defined information about a class
- New OnMethodExited method overloads to ease the usage of the Instrumentaion class including a brand new method; ParseMethodParameters
- New methods on the ReflectionUtility class; ParseMethodParametersa, GetMethod, GetMethods, GetProperty, GetProperties and GetAttribute
- New fields on the ReflectionUtility class: BindingInstancePublic, BindingInstancePublicAndPrivate, BindingInstancePublicAndPrivateNoneInherited and BindingInstancePublicAndPrivateNoneInheritedIncludeStatic
- New methods on the BusinessEntity class; CreateDescendantOrSelfEntity and some overall refactoring making the class easier and more intuitive to use
- Refactoring of the BusinessEntityDataAdapter class; moved a lot of private/internal methods to BusinessEntityUtility
- Refactoring of the SqlBusinessEntityDataAdapter class
- New infrastructure class; RuntimeBusinessEntity
- New method on the BusinessEntityUtility class; CreateDescendantOrSelfEntity
- Refactoring of the abstract Log class; now includes a type parameter for Entry collection
- Refactoring of the abstract ExceptionLog class; updated to use the above mentioned type parameter
- Refactoring of the abstract PerformanceLog class; updated to use the above mentioned type parameter and to include details about the performance measuring
- New PerformanceLogEntry class to be used in conjuction with the PerformanceLog class
- Refactoring of the DataAdapter class

Do enjoy this release - and happy coding :-)

1.0.2012.1570

This release contains only two bug fixes in regards to an early disposing of an object.

Affected classes was the recently introduced Cuemon.Xml.XmlConvertUtility and the otherwise well tested Cuemon.Web.HttpResponseContentFilter.

1.0.2012.1500

The primary focus for this release was the new JsonWriter class (and associated; JsonInstance, JsonInstanceCollection, and JsonTextWriter) in the Cuemon assembly, together with the new XmlConvertUtility class, XmlJsonInstance class and some bug fixing of the XmlSerializationUtility class - all three found in the Cuemon.Xml assembly.

First things first; the new JsonWriter was designed for speed (in compliance with RFC 4627) why the design is initial; this means no runtime validation of of your JSON writing. However - as a proof of concept - a fully working XML to JSON implementation has been made available on the XmlConvertUtility class; ToJson(Stream) and ToJson(Stream, Encoding).

Next, a new helper method has been introduced on the ConvertUtility class; ChangeType(String). The purpose of this method was to easily determine if a string value can be cast to a more suitalbe Type such as Boolean or Numeric value. An example of this can be found when converting XML to JSON.

Last but not least, minor refactorings has occured through out the Cuemon assembly family and a bug in the XmlSerializationUtility was located and fixed. Last mentioned now fixes possible serialization issues when serializing classes with no public constructor and again opens for working overrides of WriteXml for custom serialization scenarios.

I hope you will enjoy this release as much as i did creating and maintaining it :-)

1.0.2012.1150

Focusing on the Cuemon.Web and Cuemon.Xml assembly, some important improvements has been implemented as well as some minor bug fixes.

Starting with the Cuemon.Web assembly, the SetClientCacheExpiresHeaders method on the HttpResponseUtility class was extended with support for custom cache-control capability; same thing goes for the GlobalModule along with a bug fix in the OnApplicationStart that prevented thread safety. The XsltPage now uses the XsltOutput class metioned later for controlling the response output.

Next, the Cuemon.Xml assembly has been extended with the new XsltOutput class that is equivalent to the xsl:output element. This was implemented in the above mentioned XsltPage in the Cuemon.Web assembly. Last but not least; a bug in the PurgeNamespaceDeclarations found on the XmlUtility class was fixed.

Enjoy.

1.0.2012.930

Focusing on the Cuemon.Web assembly, several improvements (while refactoring and streamlining) has been implemented.

First - and foremost - the GlobalModule has been revamped for easier usage by the implementor; easy adoption to comression, caching expires headers (static and dynamic) and last but not least - HTML related content parsing for guranteed forced refresh of cached content.

Further, one of my more "hidden" away method has been made generic and static and implemented on the HttpResponseUtility class; SetClientCacheExpiresHeaders.

Last but not least, the WebsiteModule (inheriting from GlobalModule) has been updated accordingly to the revamped GlobalModule. This means, that the special performance tweaks i found necessary on the cuemon.net website now ports directly to the new and improved GlobalModule.

Enjoy.

1.0.2012.800

A bug (that appeared when using exotic URI's) was discovered and fixed in the WebSecurityUtility class, CreateTamperingProtectedUri method.

New features this time consist only of a new DisableClientSideCache method located in the HttpResponseUtility class and supplementing CreateTamperingProtectedUri method overloads in the WebSecurityUtility class.

1.0.2012.700

One minor bugfix in the BusinessEntityDataAdapter class and some new features and improvements in the SecurityToken class.

New features counts a new PerformanceLog class as well as the handy WebSecurityUtility class just introduced. Last mentioned will help you protect REST API calls as well as other sensitive URL calls which need tampering protection. MITM is theoretically eliminated with this specialized Utility class.

1.0.2012.630

Some bugfixes prior to the last two release, some new features and several improvements through out the Cuemon assembly family.

Furthermore the SqlCeClient related assemblies was correctly adjusted to target .NET Framework 2.0 instead of 4.0, meaning all assemblies are correctly in sync again.

Last but not least; as an experiment, only the AssemblyFileVersion was changed to 1.0.2012.630, leaving the AssemblyVersion unchanged prior to 1.0.2012.390 - this should make an update with strong bindings less painfull.

1.0.2012.390

Minor bugfixes prior to last release and several new features and improvements through out the Cuemon assembly family.

1.0.2012.320

Minor bugfixes prior to last release. Improvements in Cuemon.Data.dll, Cuemon.Data.Entity.dll and Cuemon.Web.dll.

1.0.2012.300

Updated with support of DataDependency (ideal for Caching dependencies) and fixed some minor bugs in Cuemon.Web.dll.