This is a generalized list of features that .netTiers provides. You can find more information on these topics within the documentation.

Generates a fully compilable solution along with seperate projects and framework tiers for your application. You can start working on an application immediately after generating.
Creates a full suite of stored procedures that are specialized towards your domain. This code can run inline, as parameterized sql as well and does not have to be used as procedures.
Automatically generates entity objects and their relationship objects as a domain based on the tables of your database.
Advanced Enttiy Validation Rule Engine, which can use any of the pre-created or use delegates for any custom rules.
Classes inlcude both partial classes and concrete classes throughout so that you can customize logic that will not be overwritten.
Uses a custom generic List<T> for collections that supports all .net ComponentModel interfaces and more, and are Bindable, Sortable, and Filterable.
Creates a full website project, already pre-configured and ready to begin coding against your data immediately.
Creates a full set of administration web controls, that serves as a basic yet fully functional web administration console for database.
Creates a full set of typed DataSource controls for your entire API with design time support, they are similar to the ObjectDataSource, only these are full featured and are actually developer friendly.
Creates a full webservice API for your domain, perfect for a .net winforms or smart client application and is simple to configure.
Creates a full suite of unit tests for the data providers and provides about 50% coverage. These tests are for nUnit or Visual Studio Team System.
Code is fully commented throughout and ready for your documentation needs. Also follows Microsoft naming guidelines throughout.
Any code placed in a special folder in any of the projects, which by default is called App_Code, will automatically be included the generated project.
The Data API consists of query support by Primary Key, Foreign Key, Indexes, ManyToMany join relationships, All, Paged Select with Filter, and Find. Along with database write methods such as Insert/Update/Delete
You can create your own custom stored procedures for your entities and .netTiers will generate a wrapper and all the plumbing for that procedure. This enables you to have your own logic within the .netTiers API.
much, much, more. honest.

Getting Started Top

.netTiers are a set of templates written in C# and is built to work with the CodeSmith template code generation platform. CodeSmith itself uses a familiar Asp.net syntax so .netTiers is not written in any obscure language or syntax that you couldn't sit down and understand what's going on in a very short time. The power of .netTiers is that it's a templatized approach to a common problem, and does not prohibit you from changing things or knowing what's going on under the covers.

The root windows directory to output the generated project to. It's usually best that this be a new directory unless you've worked with the templates for awhile.

RootNameSpace: Root namespace for generated projects and C# classes. This will be the prefix for the other project namespaces. Example: If you enter NetTiers.Northwind here, and you enter Entities in BLLNamespace, then you will see NetTiers.Northwind.Entities for your Entity Layer.

Note: This is all that is required to generate a successful Data Access Layer from the .netTiers templates. There are many more options and other layers you can generate, you can skip down to #4, Configuration if you don't want to see the added generation options.

4. Advanced Setup Top
01b. Filter by Individual Objects - Optional: Top

The tables to generate as enums. Your columns must meet the following rules. The first column must be a primary key and an Identity column, the second column must have a unique column constraint index, the optional third column will be the description of the generated enum. You must also select this table in the SourceTable as well in order to generate the enum.

The tables you wish to generate into entities, if you do not select any SourceTables or SourceViews, and SourceDatabase is completed, then the entire database will be generated.

The views you wish to generate into entities, if you do not select any SourceTables or SourceViews, and SourceDatabase is completed, then the entire database will be generated.

If specified, indicates the name of a folder that can contains custom classes to dynamically add to each project. This is useful if you plan on adding customized code aside from using the concrete classes or helper methods to any of the generated projects.

If true the stored procedures are attempted to be installed on the sql server for you. (The SQL file is still generated and placed in the Namespace.SQL directory).

The pattern type to implement in the Component Layer. The component layer is considered to be where you core business rule implementations and in new implementations should be the entry point into your domain logic. You can choose either Service Layer (like the Manager pattern), or Domain Model.

NOTE: The ServiceLayer is by far the most flexible and offers advanced features throughout the framework, like a workflow pipeline and a workspace. The DomainModel should be used on basic applications and prototypes not requiring advanced workflow and loose coupling logic.

Indicates which database specific features to generate. The default is SQL 2000 compatibility, but you can select optionally choose Sql2005, which will generate optimized paging procedures specifically for SQL Server 2005.

Indicates type of Unit tests to be generated. The options are:

None: No unit test should be included.
NUnit: No tests should be generated.
VSTS: Visual Studio Team System tests should be included.

Indicates if the WCF Attributes, [DataContract] and [DataMember], should be included on the entity classes. Requires the latest Windows Communication Framework installed on your machine.

Indicates if the Xml attributes, [XmlElement(IsNullable=true)], should be included on all of the entity classes.

Attempts to launch Visual Studio with the generated solution only if there are no instances already open.

The sub-folder to output the SQL scripts. This name is appended to the RootNameSpace, so if you enter SQL the folder will be RootNameSpace.SQL

Indicates if the HTML generation report should be shown at the end of the report.

The sub-namespace that is added to the root namespace for the Entity Layer. So if RootNameSpace = "Northwind", and this property is "Entities" the resultant namespace for the entities would Northwind.Entities

The sub-namespace for the given business layer you choose in the IncludeComponentLayer property. So if RootNameSpace = "Northwind", and this property is "Services" the resultant namespace for the services would Northwind.Services

The sub-namespace that is added to the root namespace for the Base Data Access Layer. So if RootNameSpace = "Northwind", and this property is "Data" the resultant namespace for the base data access layer would Northwind.Data

The sub-namespace that is added to the root namespace for the UnitTest Layer. So if RootNameSpace = "Northwind", the resultant namespace for the unit test swould Northwind.UnitTests

The name of your company, or client's company. This is only for documenation and any references to the company.

The URL of your company, or client's company. This is only for documenation and any references to the company.

If true, the generated projects, when building, will try to sign the assemblies and search for the snk in the local root directory(OutputDirectory). This strong names your assemblies and is useful for advanced .net options and security.

Indicates if the web library should be generated. This contains the EntityDataSource, Specialized Typed DataSource controls of your domain and other extremely helpful Asp.Net utility classes.

Indicates if Visual Studio design-time support should be provided for the Web Library Typed DataSource controls.

Indicates if the web admin user controls should be generated. These are CRUD control admin screens that you can use to help manage

Indicates if the Webservice DataAccess Provider should be generated. If you are in a situation where you need to create an EndPoint of your Data API, then include this option.

The full path for generated WebAdmin UserControl files.

The base URL for the webservice specified above in WebServiceOutputPath, eg: http://localhost/NetTiersWS.

Indicates if a complete website should be generated. This is useful for new webform projects and you need to get up and going immediately. A full website along with all necessary references will already be included and ready to start working with your data.

Indicates whether to include a reference to the Microsoft Atlas Component Library in the website generated. This is useful if you want to immediately take advantage of the Microsoft Atlas Framework in your WebForms.

Indicates whether to include a reference to the Atlas Control Toolkit. This property is only taken into account when IncludeAtlasLibrary is true. The Microsoft Atlas Toolkit is a set of advanced controls that take full advantage of ajax and javascript behaviors.

Indicates if the Web.config should be overwritten in the GenerateWebsite generated website project. This is useful if you've customized your web.config and don't want to overwrite those settings.

Indicates if a Web Application Project file should be generated. Note: you must have the Visual Studio Maintenance Patch and the WebApplication Projects Visual Studio Extension installed in order to use this feature. This creates a project file for website project much like Visual Studio 2003.

When using custom stored procedures, if the returned rows do not match the fields in an entity, a DataSet or IDataReader will be returned. Choose One. This is useful if you've returned more than one resultset in a custom procedure; you can use a ConvertToDataSet(IDataReader) method in the Utility class to convert that to a DataSet.

include custom stored procedures, this is the pattern that NetTiers will look for your custom stored procedures to start with. A string format will be used to match the beginning of the procedure pattern. So, {0}=TableName, {1}=ProcedurePrefix(See Property Below). By default NetTiers will look at tables that starts with '_{0}_', which means it will detect the procedure _TableName_GetByBirthdate and generate the necessary plumbing to wrap your custom stored procedure. Your new method can be accessed by DataRepository.TableNameProvider.GetByBirthdate();

Indicates if you would like .netTiers to attempt to generate wrappers into the API for your custom stored procedures.

If true delete procedures will be generated into the API.

If true drop comands along with all of the stored procedures will be generated.

If true Find procedures will be generated into the API.

If true Get procedures will be generated into the API.

If true GetList procedures will be generated into the API.

If true GetList By Foreign Key procedures will be generated into the API. So if your Order Table has a CustomerId column in it, and its a foreign key back to your Customers Table. Then a method called GetByCustomerId(int customerId) will be created.

If true GetList By Index procedures will be generated into the API. So if your Order Table has a Status column in it, and its an index onf your Orders Table. Then a method called GetByStatus(string status) will be created.

If true Insert procedures will be generated into the API.

If true .netTiers will attempt to gain insight into your many to many relationships and generate procedures into the API.

If true .netTiers will use the your database meta data to discover relationships and will generate into the API.

If true save methods will be generated into the API that wrap Insert/Update/Delete.

If true update procedures will be generated into the API.

Isolation level to use for the generated procedures.

Enabling Retry will add code retry the queries that failed with data exceptions. Useful to if your database becomes temporarily unavailable. Use with caution in that if a transaction fails in the database, then the retry can not continue because the transaction is now in a failed state.

The number of attempts that will be made.

Constant - Each sleep will be the n milliseconds.
Linear - Each sleep will increase by n*attempts milliseconds.
Exponential - Each sleep will increase exponential by n^attempts milliseconds.

The number of milliseconds that the current thread will sleep between attempts. Sleep only occurs if an exception is thrown.

Suffix to use for all generated DELETE stored procedures.

Suffix to use for all generated selective FIND stored procedures.

Optional user or role to GRANT EXEC Procedure permissions to

The prefix to attach to the stored procedure names, ex: "usp_" will give you "usp_Orders_GetList"

Suffix to use for all generated selective SELECT stored procedures.

Suffix to use for all generated selective Update stored procedures.

Optional File Path to a table/object alias file. If you have a table name called "Customers" and you wanted it to be "Customer" then you would create a "Customer" table. Create a NewLine Delimited list of the table names and their Aliases, seperated by a column. This is also useful if you encounter a naming collision with a type that's already included in the .Net Framework. For example if you have a table named Environment, then you will get a naming conflict with the .Net Type Environment.

Alias.txt
------------------------------

Customers:Customer

Orders:Order

The format for any base class name. Parameter {0} is replaced by the original class name.

The format for any collection class name. Parameter {0} is replaced by the collection item class name.

The format for entity class name. Parameter {0} is replaced by the trimmed table name, in Pascal case.

The format for the tables generic class name. Parameter {0} is replaced by the name of the class that will be stored in the list.

The format for the views generic class name. Parameter {0} is replaced by the name of the class that will be stored in the list.

The format for any interface name. Parameter {0} is replaced by the original interface name based on the class name.

The format for many to many methods. Parameter {0} is replaced by the secondary class name

The format for any provider class name. Parameter {0} is replaced by the original class name

The table prefixes to strip from the classes name, delimited by comma.

The first thing you want to do is save your property set, which is noted by the Arrow and turquoise highlight. This enables you to quickly reload your property without having to re-configure your property set.

Second, click the arrows depicted by the green area to expand the window so you can see the Template Output. This will let you see any error messages, if any.

Third, click the generate button and wait approximately 30 seconds to 2 minutes depending on this size of the database. Depending on whether or not you chose to view the Generation Report, once .netTiers is completed, your default browser will pop-up showing the generation report.

The summary section of the report gives you an overall synopsis of total objects or errors that occured during the generation process.

The .netTiers Quick Configuration is a section that enables you to quickly configure your winforms or web application. Essentially it requires you to add a section to your configuration section to your web/app config of the NetTiersServiceSection. This allows .netTiers to read critical information during runtime.

The documentation section has a link back to the official .netTiers documentation. Which will most likely be this file. It also contains a very useful quick start of sample API calls, which is meant to get you used to how you make calls into your customized API.

This is a "rather long" list of all your generated objects. This is useful if you added a new table to your generation process, but you don't see the objects for them, you can check here and verify if the table actually got created.

Using Windows Explorer, browse to the OutputDirectory that you chose earlier in the setup process. You will see a solution file, along with several directories. Each directory represents usually Tier in generated code. Let's make sure your generation process was completely successful before you import this into an existing solution if you already have one.

Double click this solution file. You can later attach any new project to this solution. However, even if you're starting from scratch we recommend making a new solution, that is yours and simply importing this solution into your solution. This will allow you to change things up as much as you want in a flexible manner and still not have to worrry about ruining anything. Things like SCC can potentially change the way you work with the templates, so careful seperation will allow you to be happy with the results. This new solution can be a Master Solution of sorts that can contains a web/winforms app, and includes the NetTiers projects. You would also have our Generated solution, which is nice and lean for your quick entity and data layer modifications.

Project Organization:

Compile Solution:
Now that you're solution is open, the first thing we want to do is build all the libraries to ensure that .netTiers generated valid c# code. If you've configured your solution as I have, that's 7 projects that were fully generated for you.

How's that for a Time Saver!

Compile Your Generated Code:

Build Result: You can monitor the build process through the output window, we've shown it here completed and more importantly successful.

Build Results:

6. .netTiers Configuration Top
Generate:

Configuration:

Open Web/App.config: Opening the web/app configuration. If you've chosen to have .netTiers generate a web application project for you, then you should already have a configuration that is property configured. You can choose to skip over this step. Otherwise, if you're working on an existing project or a winforms application, then follow along.
The configuration depicted has the configuration along with the Enterprise Library and Atlas configuration.
The configSection that you need to be concerned with is:

<section name="Northwind.Data" type="Northwind.Data.Bases.NetTiersServiceSection, Northwind.Data" allowDefinition="MachineToApplication" restartOnExternalChanges="true" />

Remember, the Connection String name corresponds to the Asp.Net ConnectionString config section you are using. The Northwind.Data Section of the configuration is the critical data that .netTiers needs to know in order to run successfully at runtime.
Name: This is the name of your provider. You will be able to access this provider by name if you don't configure it as the default provider.
Type: This is the Fully qualified Type string of this configured provider.
ConnectionStringName: The first thing you want to do is save your property set, which is noted by the Arrow and turquoise highlight. This enables you to quickly reload your property without having to re-configure your property set.
EntityFactoryType: The entity factory type provides an entity creational factory that dynamically finds where your entity is located and creates a version of that entity. hooks for user interaction during the creational process of the entity. It allows you to maybe subscribe to event if you needed to or have something process the entity prior to setting the data from the data reader. This is also useful in case you've selected the DomainModel, in which case, you want to create Domain objects, but they are not visible to the Data Layer, so you would have to "discover" these types.
Ex:Northwind.Entities.EntityFactory
UseEntityFactory: Indicating if you want to use the EntityFactory for creation of the entities. This is required to be true, if youv'e selected the domain model.
EnableEntityTracking: This allows you to have a performant entity cache using Enterprise Library's ObjectBuilder, Locator class in your application using weak references so that if there no references to the entity, it will be garbage collected.
EnableMethodAuthorization: If using one of the two component layer projects, this will enable runtime code authorization utilizing Microsoft Asp.net's Role Provider and Microsoft Enterprise Library Authorization Provider. You might want to leave this as false until you can get a grasp of the framework, and have time to configure the required rules for using Method Authorization.
UseStoredProcedure: If you chose not to execute all of those procs onto the server, there is a file called procedures.xml that essentially is an xml抏d version of the procedures. Setting useStoredProcedure to false, causes NetTiers to simply use parameterized SQL instead of the crud procs. This is useful if you would like to organize your stored procedures.

7. Ready to Code Top
Typed DataSource:

Intellisense:

Strongly Typed DataSource controls: You will find that just by typing <data: you will see a list of your DataSource controls ready to be used to get ahold of your data. These maintain the ObjectDataSource controls event model, except they are geared to your data.

Intellisense:

When you select the SelectMethod Attribute, you will see via intellisense a list of all available methods from your domain. How cool is that!

WebForm:

Here's an example of a webform in it's minimilist form, that would display a grid of all Employees with Auto-Generated columns.

Design View:
Taking the form and selecting only the columns that I want, we create a nice grid.

Here's the result of of the form. The wonderful part of the Typed DataSource control is that you don't have to do anything when you want to edit/insert/delete an object. You simply have the grid call the Edit/Delete/Insert command, which can be done a variety of ways in ASP.net 2.0.

Results:
Edit:
After Edit:

Include Directives: When you want to actually interact with the data, you simply have to include your the generated tiers as using directives. We recommend as much encapsulation as possible, with both your Service Objects and your Collection/Entity classes.

How to Access Code:

Quick Start Sample API: Top

AccountService accountsService = new AccountsService();

//GetAll()

            TList<Accounts> accountList = accountsService.GetAll();

            //GetPagedl()

            TList<Accounts> accountList =

            accountsService.GetPaged("IsActive = 1 AND AccountName LIKE 'smi%'");

            //GetByFk()

            TList<Accounts> accountList = accountsService.GetByCustomerId(25);

            //GetIX()

            TList<Accounts> accountList = accountsService.GetByAccountCreatedDate(new DateTime("1/1/2006"));


            
//Get()

            entity.Entitykey;

            TList<Accounts> accountList = accountsService.Get(entity.EntityKey);

            Account accountEntity = new Account();
accountEntity.AccountName = "MyAccountName";
accountEntity.CreatedDate = DateTime.Now;


            //Insert()

            TList<Accounts> accountList = accountsService.Insert(accountEntity);


            
//Delete()

            TList<Accounts> accountList = accountsService.Delete(accountEntity);

            //Delete()

            TList<Accounts> accountList = accountsService.Delete(23);

            //Update()

            accountEntity.AccountName = "MyAccountName 2";

            TList<Accounts> accountList = accountsService.Update(accountEntity);

            //GetByManyToManyl()

            TList<Customers> accountList = accountsService.GetCustomers_From_AccountsReceivable();

            //GetCustomProcedureName()

            TList<Accounts> accountList = accountsService.GetByAccountMaturationDate();

            //DeepLoadByIdl() using PK

            Account account = accountsService.DeepLoadByAccountId(id, false, DeepLoadType.IncludeChildren, typeof(Customers), typeof(TList<ChartOfAccounts>));


            
//DeepLoadByIdl() using FK

            TList<Account> account = accountsService.DeepLoadByCustomerId(id, false, DeepLoadType.IncludeChildren, typeof(Customers), typeof(TList<ChartOfAccounts>));


            
//already instatiated objects

            //DeepLoad

            TList<Account> account = accountsService.DeepLoad(myAccountEntity, false, DeepLoadType.IncludeChildren, typeof(Customers), typeof(TList<ChartOfAccounts>));


            
//DeepSave

            TList<Account> account = accountsService.DeepSave(myAccountEntity, false, DeepSaveType.IncludeChildren, typeof(Customers), typeof(TList<ChartOfAccounts>));

Working with the Code: Top

You will quickly discover that while there is a slew code being generated, the concepts themselves are simple, and familiar concepts based on proven practices and patterns.

string custId = "TRAIH";

            //I get a single instance of the customer I want.

            Customers customer = DataRepository.CustomersProvider.GetByCustomerID(custId);

            Type [] typesToDeepLoad = new Type[] { typeof(TList<Orders>), typeof(TList<Products>) };

            //go further than one level down object graph

            bool goMoreThanOneLevelDeep = true;

            // I'm going to deep load this customer, but I only want 

            // to see his orders and the products that he's made, 

            // I really don't care about the line items

            // But the neat thing is that the relationship to products is through // line items.

            /// the object graph looks somethign like this

            /// - Customer

            /// --Order

            /// ---OrderDetails

            /// ---ProductCollection

            /// --CustomerDemographics

            /// --CustomerDemographicsCollection_From_CustomerCustomerDemo 

            /// (a strangely named northwind thing, but shows how many to many relationships work.)

            DataRepository.CustomersProvider.DeepLoad(

            customer, // my customer

            goMoreThanOneLevelDeep, //go further than one level down object graph

            DeepLoadType.IncludeChildren, //be Inclusive, instead of exclusive

            typesToDeepLoad );

8. Architecture   Top
.netTiers Architecture:   Top
This data tiers concept is composed of custom business entities components (the data itself) and data access logic components (the persistence logic).

This design is inspired from the Microsoft patterns & practices guide:
Designing Data Tier Components and Passing Data Through Tiers:

.netTiers Patterns:   Top
The .netTiers team tries very hard to write an application with best practices in mind. We've followed the guidances given from Microsoft in how best to use their platform, this includes the usage of many of the Microsoft Patterns and Practices Team Libraries.

Here's general information on the patterns used in .netTiers 2.

Information mostly aggregated from these wonderful developer resources:
patternshare.org   |  dofactory.com   |  DavidHayden.com

ServiceLayer
http://patternshare.org/default.aspx/Home.MF.ServiceLayer

Processors
By default is a Pipeline:
http://patternshare.org/default.aspx/Home.HW.PipesAndFilters

but easily can be used with workflow management in:
http://patternshare.org/default.aspx/Home.HW.ProcessManager

Each Processor -
Command
http://www.dofactory.com/Patterns/PatternCommand.aspx

Flexible enough to be used within a strategy passed into the ctor to manage different behaviors in complex logic.
http://www.dofactory.com/Patterns/PatternStrategy.aspx

DomainModel + ActiveRecord
http://patternshare.org/default.aspx/Home.MF.DomainModel
http://patternshare.org/default.aspx/Home.MF.ActiveRecord

Data Access Layer
DataRepository.cs - Singleton, Decorator
http://patternshare.org/default.aspx/Home.PP.Singleton
http://www.dofactory.com/Patterns/PatternDecorator.aspx

Uses the entities as Data Transfer Objects:
http://patternshare.org/default.aspx/Home.MF.DataTransferObject

Repository Provider:
http://davidhayden.com/blog/dave/archive/2004/05/19/259.aspx

Entity Layer - Factory, Memento, State
Entity - Memento, State, DomainModel, TableModule
http://www.dofactory.com/Patterns/PatternMemento.aspx
http://www.dofactory.com/Patterns/PatternState.aspx#_self2
http://patternshare.org/default.aspx/Home.MF.DomainModel
http://patternshare.org/default.aspx/Home.MF.TableModule

Entity Factory
http://www.dofactory.com/Patterns/PatternFactory.aspx

WebService Client - Proxy
http://www.dofactory.com/Patterns/PatternProxy.aspx

New Sql Expression Code - Builder
http://www.dofactory.com/Patterns/PatternBuilder.aspx

.NetTiers Documentation

.netTiers Documentation

Table of Contents

Code Generation Top

.netTiers, An Introduction Top

Current .netTiers Feature Set Top

Getting Started Top

How's that for a Time Saver!

你可能感兴趣的:(document)