Rockford Lhotka

Contributors

Wed, 23 Jul 2008 15:56:39 GMT

Contributor	Area
Keith Lawrence	CSLA .NET for Windows CE
Aaron Erickson (Magenic)	LINQ integration
Justin Chase (Magenic)	CSLA Light and CSLA .NET 3.6
Sergey Barskiy (Magenic)	CSLA Light and CSLA .NET 3.6
Chris Williams (Magenic)	CSLA Light and CSLA .NET 3.6
Grant Breems (Magenic)	CSLA Light and CSLA .NET 3.6
Miguel Castro	CslaActionExtender and BindingSourceHelper
Mark Chesney	BindingSourceRefresh
Ricky Supit	Data portal performance enhancements

All contributors to CSLA .NET sign an agreement granting RDL Enterprises the right to use their contribution in any manner, and warranting that they have the right to make that grant. The contributions are then released, as part of CSLA .NET, under the standard CSLA .NET license.

What is CSLA Light?

Wed, 23 Jul 2008 05:00:00 GMT

CSLA Light is a software development framework that helps you build a powerful, maintainable business logic layer for Silverlight applications. It a subset of CSLA .NET, one of the most widely used software development frameworks for Microsoft .NET. Click here for a brief overview of CSLA .NET.

CSLA Light enables you to create an object-oriented business layer that abstracts and encapsulates your business logic and data. CSLA Light simplifies and standardizes implementation of business logic, validation and authorization logic within your objects. The goal is to provide an easy and consistent coding pattern by which you can encapsulate all your business logic within your object-oriented business layer. The result is a business layer that supports development of rich, interactive Silverlight applications.

CSLA Light supports 3-tier and 4-tier deployment models. When using a 3-tier model, your CSLA Light business objects can invoke remote services written in asmx, WCF, ADO.NET Data Services, RSS or other technologies. In a 4-tier model your CSLA Light objects interact with a server running CSLA .NET, which allows you to take full advantage of CSLA .NET when creating your server-side code.

For existing CSLA .NET users, it is important to realize that CSLA Light follows the same programming model. If you know CSLA .NET, you already know most of CSLA Light. In fact, over 80% of your CSLA .NET business object code will typically work in CSLA Light without change. In many cases, only your data access code will be different.

CSLA stands for Component-based, Scalable Logical Architecture, and is the result of over 12 years worth of research and development. The Silverlight implementation of CSLA was started in 2007, and CSLA Light was one of the first application development frameworks available for the Silverlight platform.

CSLA .NET Feature Wish List

Mon, 21 Jul 2008 15:49:31 GMT

This is a list of possible future CSLA .NET enhancements. I maintain this list to avoid losing ideas, but there's no guarantee that any of these items will make it into CSLA .NET. (Green items are implemented in the upcoming release, Brown items will not happen, and will be removed from the wish list concurrent with the upcoming release.)

Alter all reflection code to use Reflection.Emit, dynamic methods and/or to cache results (efficiency improvements)
1. In DataMapper
2. In UndoableBase
Enhance DataMapper
1. To support datarow types
2. To map from IDataReader to object and from object to IDataParameterCollection.
3. To only update values that are different. At least as an option, it should be able to read the current value, compare it to the new value and do the update only if necessary as per this thread.
Enhance data portal
1. Change data portal so it is possible to have it invoke the DataPortal_XYZ methods on a factory object rather than on the actual business object. The factory object should be dynamically loaded based on assembly/type name info provided by the criteria and/or business object.
2. Add a LogicalExecutionLocation property as per this thread.
3. Allow a DataPortal_Fetch() implementation to tell the data portal to return a null back to the caller rather than throwing an exception in the case that no data was found. This is Miguel's "MarkEmpty()" concept.
4. Raise pre- and post-call static events on the server-side data portal as per this thread.
5. Add a generic overload to Delete() so it matches the other data portal methods.
6. Provide some scheme by which different objects (probably identified by a ResourceRequired attribute) can be routed to different data portal servers.
Authorization
1. Add instance level object authorization methods as per this thread.
2. Add a delegate scheme by which type-level authorization can be handled by a user-supplied method.
Validation
1. Cascade the friendly name through to brokenrules as per this thread.
2. Add priority property to BrokenRule as per this thread.
3. Allow the developer to specify the description text for the RegEx rule (and maybe all common rules?)
4. Fix potential data formatting bug in DecoratedRuleArgs as per this thread.
5. Add an attribute that can be used to decorate rule methods to make them discoverable by external tools (like code generators).
Move the ISavable implementation to Core.BusinessBase, having it implement a protected virtual SaveObject() method. Then Save() in Csla.BusinessBase can delegate to that new method.
Add a control to Csla.Web that knows how to render BrokenRulesCollection information into HTML.
Allow clearing (resetting) of the validation and authorization rules at per-instance and per-type levels. The possibility for abuse here is high, and the result would be abysmal performance - so I'm not sure this is a great idea - but as per this thread, it would enable some testing scenarios.
The BindingSourceRefresh control has issues if the original property value is null and is then changed to another value. Apparently the original null value somehow stops data binding from raising the BindingComplete event from the bindingsource.
CslaDataSource
1. Change how CslaDataSource determines whether an object supports insert/update/delete as per this thread.
2. Change the SelectObject (and other) event methods to conform to the protected virtual On___() scheme to make it easier for subclass authors to work with the control.
Add a way for a subclass of ERLB to know when a child has changed as per this thread.
Fix issues with CslaDataSource and telerik grid control as per this thread.
Throw an exception in BusinessListBase.InsertItem() if the object being inserted is not a child (IsChild is false) as per this thread.
Csla.Wpf.Authorizer double-checks some controls, especially nested controls like a combobox. It should not do this.
Add overloads to the Get methods in SafeDataReader to accept a value to return in case the database value is null as per this thread.
Fix threading issue with authorization rules discussed in this thread.
Fix issue with re-adding a deleted item in a BLB as per this thread.
Add a context/connection manager for ADO.NET EF as per this thread.
FieldDataManager should have a method to expose whether a field is dirty or not as per this thread.
Add a Copy() method to BusinessBase (like Clone(), but with ability to change resulting objects). And cascade call through to child objects.
Investigate possible edit level bug in ProjectTrackervb 3.5.1 (or CSLA .NET) as per this thread and as per this thread.
Fix possible bug in FilteredBindingList.Clear() as per this thread.
Fix issue with how WPF 3.5 responds to PropertyChanged events (different from 3.0) as per this thread.
Fix issue with LINQ to CSLA where 64 bit numeric values cause failure.
Managed backing fields should have some way to be marked as NotUndoable.
Add an overload for FilteredBindingList.ApplySort() that takes a propertyName as a string? Currently you must put in a propertyDescriptor, unlike SortedBindingList which can take either.
Change GetProperty/SetProperty so the two-type overload is called GetPropertyConvert/SetPropertyConvert (or something like that). This would allow the compilers to do type inference on the type parameters, reducing code.
There is a potential issue with Windows Forms data binding in a data grid, where a newly added item doesn't disappear when the user presses ESC as per this thread.
GetProperty() is missing an overload: (propertyinfo, field, default, throwException).

Version 3.5.1 change log

Mon, 21 Jul 2008 15:43:34 GMT

This document is the change log for version 3.5.1 of CSLA .NET.

RC0 3.5.1-0807xx:

BusinessBase (080721-C#/VB)

BusinessBase no longer raises a PropertyChanged event when a child object changes. This is because doing so caused nasty side-effects in Windows Forms data binding, and is therefore obviously not intended behavior for that event. Instead, BusinessBase now raises a ChildChanged event when a child object (list or not) changes. The original sender and PropertyChangedEventArgs/ListChangedEventArgs values are provided to the handler of ChildChanged.

Beta 2 3.5.1-080717:

PropertyInfo (080713-C#/VB)

Remove one constructor overload: New(name, defaultValue). This ctor could be an ambiguous overload if <T> was string, so removal of this overload was necessary. This is a breaking change for anyone using this overload.

BusinessBase/ReadOnlyBase (080709-C#/VB)

Add missing overload of

GetProperty(PropertyInfo, field,default,noaccess).

FieldData (080703-C#/VB)

Make several properties virtual to enable extensibility scenarios.

DecoratedRuleArgs (080626-C#/VB)

Fix possible formatting issues with special characters and null values.

Beta 1 3.5.1-080623:

SmartDate (080623-C#/VB)

Fix bug converting a DateTime to a SmartDate.

Pre-release 3.5.1-080610:

Linq (080610-C#/VB)

Updated the expression evaluator in the CslaQueryProvider to more appropriately match expressions that get passed through to Queryable to the correct method in cases with nested generic parameters.

Pre-release 3.5.1-080530:

BusinessBase & ValidationRules (080530-C#/VB)

Mark obsolete methods so they no longer appear in Intellisense.

ApplicationContext (080530-C#/VB)

Add a PropertyChangedMode property to allow configuration of CSLA .NET to raise PropertyChanged events the correct way for Windows Forms or WPF/XAML as appropriate.

BusinessBase (080530-C#/VB)

In PropertyHasChanged() (and thus SetProperty()), optionally raise PropertyChanged events for all properties for which validation rules are run. This change only takes effect if Csla.ApplicationContext.PropertyChangedMode is set to PropertyChangedModes.Xaml.

Pre-release 3.5.1-080529:

UndoableBase (080527-C#/VB)

Fix an issue where the FieldDataManager could find its edit level out of sync with its containing business object.

Pre-release 3.5.1-080527:

FieldDataManager (080527-C#/VB)

Fix a null reference bug and some related issues around n-level undo, data binding and managed property values.

FieldDataManager (080527-C#/VB)

Add an IsFieldDirty() method so a business object can determine if a specific field is dirty.

FilteredBindingList (080527-C#/VB)

Change Clear() to only clear the items in the filtered view.

Security\AuthorizationRulesManager (080527-C#/VB)

Fix threading issue where an ArgumentException could occur as two threads attempted to add the same item to the dictionary.

EditableRootListBase (080527-C#/VB)

Add a virtual OnChildPropertyChanged() method that is called when a PropertyChanged event is handled from a child of the list.

Pre-release 3.5.1-080426:

Linq (080405-C#/VB)

Fix a bug with the way BLB cross-references positions of an item that caused a failure scenario when calling Insert() to add a new item to a list.

Criteria (080424-C#/VB)

Add ICriteria interface and have CriteriaBase implement it. Have MethodCaller use ICriteria instead of CriteriaBase to detect the business object type.

UndoableBase (080426-C#/VB)

Fix problem where managed backing fields in FieldDataManager were not processed corrected during undo operations triggered by data binding.

Unit Driven test framework

Tue, 15 Jul 2008 05:00:00 GMT

While building CSLA Light it has become clear that the prototype unit test framework supplied by Microsoft is inadequate for testing Silverlight applications. The primary issue is the lack of support for testing any asynchronous operations, and in Silverlight any server communication is asynchronous. So to test things like the data portal and asynchronous validation rules we needed something more robust.

Also, many of the async features in CSLA Light have been added to CSLA .NET, to maintain parity between the two frameworks. This means that the existing nunit/mstest cslatest project needs to support async tests as well. While nunit is capable of doing this, we created some helpers that make it far easier to create the tests.

The result is a unit test framework and library. A full unit test engine for Silverlight, and an add-on library for nunit/mstest.

We've chosen to donate this to the community as a separate project named Unit Driven, because it is useful for testing any application, not just CSLA .NET and CSLA Light.

You can find the project here: http://www.codeplex.com/UnitDriven

It is a pure open-source project, so if you'd like to contribute to the effort you are more than welcome. While we're using this code as we build CSLA Light and CSLA .NET 3.6, there's no doubt that it can be improved quite a lot to cover numerous other scenarios.

Version 3.6.0 change log

Tue, 15 Jul 2008 05:00:00 GMT

This document is the change log for version 3.6.0 of CSLA .NET.

Pre-release 3.6.0-080715:

Unit tests (080715-C#/VB)

The cslatest project now has a dependency on UnitDriven, an open-source unit test framework that extends nunit and MSTest. UnitDriven is a spin-off effort from building CSLA Light, and is available at www.codeplex.com/UnitDriven.

The specific UnitDriven assemblies required by cslatest are part of the cslatest release download, or you can get them from CodePlex, or you can get them from svn://svn.lhotka.net/csla/trunk/Dependencies.

IsSavable (080715-C#/VB)

Move IsSavable from IEditableBusinessObject and IEditableCollection interfaces to the ITrackStatus interface.

Data Portal (080714-C#/VB-tbd)

Add ObjectFactory attribute. When used on a business class, causes the data portal to create an instance of the specified factory and invoke methods on that factory rather than the normal DataPortal_XYZ methods. The factory assumes all responsibility for creating the business object and managing its state (including IsNew/IsDirty/etc.) – nothing is automatic.

The CslaObjectFactoryLoader config setting can be used to specify an IObjectFactoryLoader object that is responsible for creating the object factory objects. Alternately, the Csla.Server.DataPortalSelector.FactoryLoader property can be directly set to an instance of an IObjectFactoryLoader object, which again is responsible for creating object factory objects.

Validation (080714-C#/VB-tbd)

Added support for async validation rules. These rules are started along with normal rule methods, but run asynchronously. The rule method is responsible for calling back into CSLA when the rule completes, so an appropriate PropertyChanged event can be raised by the business object. The rule method is responsible for ensuring that the callback occurs on the UI thread (in WPF or Windows Forms), and for dealing with any possible threading issues in other environments (such as ASP.NET or WAS).

Silverlight Data Portal (080714-C#/VB-tbd)

Add a CslaMobileFactoryLoader config switch to allow an advanced user to replace the default creation of a MobileFactory object with their own approach. To do this, they need to create a class that implements IMobileFactoryLoader.

PropertyInfo (080713-C#/VB)

Validation (080711-C#/VB-tbd)

Change the initialization of per-type business rules so an exception in AddRule() won’t leave a partially loaded rule manager object in memory. While unlikely to ever affect real application code, this problem was affecting some unit test scenarios in CSLA Light.

Project structure (080709-C#/VB-tbd)

Rearrange files in the DataPortal folder so they are now in folders that match their namespaces.

BusinessBase/ReadOnlyBase (080709-C#/VB)

Add missing overload of

GetProperty(PropertyInfo,field,default,noaccess).

Async Data Portal (080701-C#/VB-tbd)

Added a new DataPortal<T> class to provide asynchronous data portal behaviors comparable to those in CSLA Light. This also required modification of the pre-existing data portal so it no longer caches the proxy object, because the proxy objects may or may not be threadsafe.

The pre-existing data portal functionality is the same as in the past. This is not a breaking change. However, a business object or UI developer can now use the data portal in an async manner like this:

Dim dp = New DataPortal(Of CustomerEdit)

AddHandler dp.CreateCompleted, AddressOf dp_CreateCompleted

dp.BeginCreate()

Private Sub dp_CreateCompleted( _

sender As Object, e As DataPortalResult(Of CustomerEdit))

If e.Error IsNot Nothing Then

' do something about exception

Else

' do something with the result in e.Object

End If

End Sub

As in Silverlight, the callback event will run on the UI thread when possible. This is automatic in WPF and Windows Forms. In other environments, such as ASP.NET, the callback event will run on a background thread.

Pre-release 3.6.0-080626:

GetProperty/SetProperty/ReadProperty/LoadProperty (080626-C#/VB-tbd)

Change all <P, F> overloads to include the word ‘Convert’. For example, GetProperty<P,F> is now GetPropertyConvert<P,F>. This avoids an ambiguity scenario and allows the compiler to do better type inference. This is a breaking change for any code using the previous <P,F> overloads.

MobileFormatter (080626-C#/VB-tbd)

Added a MobileFormatter, which provides limited capabilities like the BinaryFormatter, but works in Silverlight and .NET. This formatter is used by the CSLA Light data portal to transfer objects to/from a .NET app server.

MobileFormatter support includes the introduction of IMobileObject, and enhancements to numerous other Serializable classes within CSLA .NET so they are able to serialize their private fields without reflection as required by the MobileFormatter.

Silverlight Data Portal (080626-C#/VB-tbd)

Added a CSLA Light compatible data portal host. This host is designed to listen for inbound requests from a Silverlight client running CSLA Light.

Those calls are either routed directly into the standard CSLA .NET data portal, or they are routed to a special factory/observer object defined using the new MobileFactory attribute.

Version 3.6.0 change log

Tue, 15 Jul 2008 05:00:00 GMT

This document is the change log for version 3.6.0 of CSLA Light.

Pre-release 3.6.0-080715:

Unit tests (080715-C#/VB)

The cslalighttest project now has a dependency on UnitDriven, an open-source unit test framework that extends nunit and MSTest. UnitDriven is a spin-off effort from building CSLA Light, and is available at www.codeplex.com/UnitDriven.

The specific UnitDriven assemblies required by cslalighttest are part of the cslalighttest release download, or you can get them from CodePlex, or you can get them from svn://svn.lhotka.net/csla/trunk/Dependencies.

Authentication (080715-C#)

Added initial support for custom authentication. The model is the same as with CSLA .NET, where you create your own custom principal and identity classes, and use the data portal to load the identity class with user and role information on the server.

Validation (080714-C#)

Validation (080713-C#)

Added support for validation rules equivalent to that in CSLA .NET.

BusinessBase (080709-C#)

Add missing overload of

GetProperty(PropertyInfo, field,default,noaccess).

Read-Only Base Classes (080707-C#)

Base implementation of ReadOnlyBase and ReadOnlyListBase for serialization added, along with associated cloning and data portal tests.

Pre-release 3.6.0-080626:

Base classes (080626-C#)

All primary base classes used to create business objects exist, at least in shell form. BusinessBase, BusinessListBase and CriteriaBase support serialization (cloning and travel through the data portal).

ReadOnlyBase, ReadOnlyListBase, NameValueListBase, EditableRootListBase and CommandBase are incomplete shells.

BusinessBase does not yet support validation or authorization, but does support both managed and private backing fields for properties.

MobileFormatter (080626)

MobileFormatter support includes the introduction of IMobileObject, and a Serializable/NonSerialized attribute definitions similar to those in .NET.

Support for the MobileFormatter exists in most Serializable classes within CSLA Light so they are able to serialize their private fields without reflection as required by Silverlight and the MobileFormatter.

Business objects that only use managed backing fields are serialized automatically. Business objects that use private backing fields must override OnGetState() and OnSetState() methods to get/set their private backing fields into the serialization data stream.

Data Portal (080626)

The CSLA Light data portal supports Create/Fetch/Update/Delete operations. The data portal uses an asynchronous call pattern just like all other Silverlight technologies for calling a server. This means the data portal works differently from the one in CSLA .NET, but still provides the same conceptual behavior. Here’s how to invoke the data portal to create an object:

var dp = new DataPortal<Customer>();
dp += dp_CreateCompleted; // callback event
dp.BeginCreate();

Then you must implement the callback event handler to handle the result:

private void dp_CreateCompleted(

object sender, DataPortalResult<Customer> e)

{

if (e.Error != null)

// process exception

this.DataContext = e.Object; // use result

}

Alternately you can use a lambda to shorten the code to this:

var dp = new DataPortal<Customer>();
dp += (o, e) =>

{

if (e.Error != null)

// process exception

this.DataContext = e.Object; // use result

}
dp.BeginCreate();

The data portal supports both local (3-tier) and remote (4-tier) modes.

The local mode runs DataPortal_XYZ methods in the objects on the Silverlight client. This allows you to write methods like DataPortal_Fetch() that run on the client so you can manually call remote services as you choose. For instance, you could use this technique to retrieve data from a server running ADO.NET Data Services for the Web, and use the results to populate your object graph with data.

The remote mode uses WCF as the network transport to communicate with a CSLA .NET data portal running on a .NET web server. The CSLA .NET data portal is not the “normal” data portal, but is a new data portal in CSLA .NET 3.6 designed to support a CSLA Light client. See the Csla.Server.Hosts.Silverlight namespace for the code. The service contract to expose is IWcfPortal, and the service implementation is WcfPortal.

With a remote data portal your object would be loaded on the server using normal CSLA .NET techniques (again, in a DataPortal_XYZ method – but one running in .NET on your servers).

The remote data portal operates in two possible modes. One mode is a passthrough, where each CSLA Light call is simply passed through to the CSLA .NET data portal, and the result is transparently returned. This is appropriate when the Silverlight client is trusted, and you want the simplest and most “CSLA like” experience.

The other mode will invoke an “observer” object on the .NET server so you can examine the inbound client request (the objects sent to the server from the client) before allowing further processing. To do this, the root business class should have the MobileFactory attribute applied to specify the type name and methods for the observer object.

Silverlight does not currently have a good configuration story. At the moment, the data portal is configured through code by your client application. Typically you’ll configure the data portal once, as the application starts running. You can use the following settings:

Csla.DataPortal.ProxyTypeName = "Local"; // or "WcfProxy"

Csla.DataPortalClient.WcfProxy.DefaultUrl =

"http://myserver/mysite/service.svc"; // URL to .NET data portal

Csla.DataPortalClient.WcfProxy.DefaultBinding =

new BasicHttpBinding(); // WCF binding, BasicHttpBinding is default

The end result is that you can specify whether to run the data portal locally or over WCF, and if you choose WCF you can specify the URL and (optionally) the binding to the remote server.

N-level Undo (080626)

BusinessBase and BusinessListBase support n-level undo in Silverlight just like in .NET. the BeginEdit(), CancelEdit() and ApplyEdit() methods work the same as they do in CSLA .NET.

There is no support for IEditableObject, because that interface doesn’t exist in Silverlight. This means that n-level undo is only used if you use it. There is no overhead to its existence unless you call BeginEdit() in your code.

The n-level undo functionality does need to do a type of serialization of object data – it relies on the Memento design pattern. The approach taken in CSLA Light uses the same serialization scheme as the MobileFormatter, so a business object author that makes their object work with the MobileFormatter automatically supports n-level undo. No extra effort is required unless you use private backing fields in your objects.

GetProperty/SetProperty/ReadProperty/LoadProperty (080626-C#)

Unit testing (080626-C#)

While there is a Microsoft-supplied unit testing framework for Silverlight, it doesn’t support tests against asynchronous methods. This meant we had no way of testing the data portal behaviors in CSLA Light. Unfortunately Microsoft’s framework source isn’t available, so we were unable to enhance it.

To resolve this issue, the cslalighttest project includes an nunit-like unit testing engine. This engine is a subset of what you might expect in other testing frameworks, but it is sufficient for executing unit tests against Silverlight code, and it supports testing asynchronous methods.

CSLA Light downloads

Tue, 15 Jul 2008 05:00:00 GMT

Please consider making a donation to help support the ongoing development of CSLA .NET.

Why donate?

Version 3.6 preview:

Version	VB	C#	Test	Notes
CSLA .NET	n/a	Download	Download	Change log
CSLA Light	n/a	Download	Download	Change log

Building CSLA Light requires the CSLA .NET code base. This is because numerous code files from CSLA .NET are linked into the CSLA Light project. You need to download both CSLA Light and CSLA .NET to build CSLA Light. Put the cslacs and cslalightcs folders at a peer level:

\cslacs
\cslalightcs

For client-only development you can use just CSLA Light 3.6 in Silverlight to build your application. In this case, you'll need to run the data portal in local mode, and your client-side DataPortal_XYZ methods will need to make calls to your services from the client.

For client/server scenarios using the data portal to communicate from Silverlight client to .NET server, you will also need to use CSLA .NET 3.6 to configure a web/application server. In this case, you'll configure the Silverlight data portal to communicate with this .NET web server, and your business objects will move between client and server automatically.

All code requires Visual Studio 2008, .NET 3.5 SP1 (pre-release), Silverlight Beta 2 and the Silverlight Beta 2 pre-release tools for Visual Studio 2008.

The cslatest and cslalighttest projects need either nunit or MSTest. Also, the cslalighttest project requires files from cslatest, and so you must download both. They also need UnitDriven (required assemblies are in the download). All folders should be placed at a peer level:

\cslacs
\cslalightcs
\cslalighttest
\cslatest
\Dependencies

Please remember these downloads are offered as early previews only.
There is no guarantee of features or stability!

CSLA CE downloads

Mon, 14 Jul 2008 05:00:00 GMT

Please consider making a donation to help support the ongoing development of CSLA .NET.

Why donate?

For use with Windows CE and .NET CF 2.0:

Version	VB	C#	Test	Notes
3.0 (beta)	n/a	Download	n/a	n/a

CSLA Light 3.6 License

Wed, 09 Jul 2008 18:14:42 GMT

LICENSE AND WARRANTY

You can use this Software for any noncommercial purpose, including
distributing derivative works. You can use this Software for any commercial
purpose other than you may not use it, in whole or in part, to create a
commercial framework product.

In short, you can use CSLA Light and modify it to create other commercial or
business software, you just can't take the framework itself, modify it and
sell it as a product.

In return, the owner simply requires that you agree:

This Software License Agreement ("Agreement") is effective
upon your use of CSLA Light ("Software").

1. Ownership.
The CSLA Light framework is Copyright 2008 by Rockford Lhotka,
Eden Prairie, MN, USA.

2. Copyright Notice.
You must not remove any copyright notices from the Software source code.

3. License.
The owner hereby grants a perpetual, non-exclusive, limited license to use
the Software as set forth in this Agreement.

4. Source Code Distribution.
If you distribute the Software in source code form you must do so only under
this License (i.e. you must include a complete copy of this License with
your distribution).

5. Binary or Object Distribution.
You may distribute the Software in binary or object form with no requirement
to display copyright notices to the end user. The binary or object form must
retain the copyright notices included in the Software source code.

6. Restrictions.
You may not sell the Software. If you create a software development framework
based on the Software as a derivative work, you may not sell that derivative
work. This does not restrict the use of the Software for creation of other
types of non-commercial or commercial applications or derivative works.

7. Disclaimer of Warranty.
The Software comes "as is", with no warranties. None whatsoever. This means
no express, implied, statutory or other warranty, including without
limitation, warranties of merchantability or fitness for a particular
purpose, noninfringement, or the presence or absence of errors, whether or
not discoverable. Also, you must pass this disclaimer on whenever you
distribute the Software.

8. Liability.
Neither Rockford Lhotka nor any contributor to the Software will be liable
for any of those types of damages known as indirect, special, consequential,
incidental, punitive or exemplary related to the Software or this License, to
the maximum extent the law permits, no matter what legal theory it’s based
on. Also, you must pass this limitation of liability on whenever you
distribute the Software.

9. Patents.
If you sue anyone over patents that you think may apply to the Software
for a person's use of the Software, your license to the Software ends
automatically.

The patent rights, if any, licensed hereunder only apply to the Software,
not to any derivative works you make.

10. Termination.
Your rights under this License end automatically if you breach it in any way.

Rockford Lhotka reserves the right to release the Software under different
license terms or to stop distributing the Software at any time. Such an
election will not serve to withdraw this Agreement, and this Agreement will
continue in full force and effect unless terminated as stated above.

11. Governing Law.
This Agreement shall be construed and enforced in accordance with the laws
of the state of Minnesota, USA.

12. No Assignment.
Neither this Agreement nor any interest in this Agreement may be assigned
by Licensee without the prior express written approval of Developer.

13. Final Agreement.
This Agreement terminates and supersedes all prior understandings or
agreements on the subject matter hereof. This Agreement may be modified
only by a further writing that is duly executed by both parties.

14. Severability.
If any term of this Agreement is held by a court of competent jurisdiction
to be invalid or unenforceable, then this Agreement, including all of the
remaining terms, will remain in full force and effect as if such invalid
or unenforceable term had never been included.

15. Headings.
Headings used in this Agreement are provided for convenience only and shall
not be used to construe meaning or intent.

CSLA .NET 2.0/3.0/3.5 License

Wed, 09 Jul 2008 18:08:50 GMT

LICENSE AND WARRANTY

In short, you can use CSLA .NET and modify it to create other commercial or
business software, you just can't take the framework itself, modify it and
sell it as a product.

In return, the owner simply requires that you agree:

This Software License Agreement ("Agreement") is effective
upon your use of CSLA .NET ("Software").

1. Ownership.
The CSLA .NET framework is Copyright 2006-2008 by Rockford Lhotka,
Eden Prairie, MN, USA.