madhavrao…

Software Architecture is thought, designed, documented, described keeping its quality attributes in mind. There are different architecture styles like Layered system, Event based Implicit Invocation, Data abstraction and Object oriented organization and Pipe and Filter. Each have their own advantages and disadvantages which can be better explained using quality attributes. Quality attributes of the Software can be broadly classified into following categories:

1. Runtime Qualities: These are class of qualities which can be measured when system executes.
2. Non-Runtime Qualities: These are the qualities which are mainly concerned with usage of the software in long terms.
3. Business Qualities: This are non-software qualities, but can have huge impact on software qualities in terms they are the one which decide which software qualities will gain importance and which can be compromised while designing.
4. Architectural Qualities: These are the qualities specific to the architecture itself.

Few of the qualities along with their definition is covered in above mind map.

Enterprise Library 3.1 was published for Visual Studio 2005. Enterprise Library 3.1 can be divided into following parts:

1. Library which works against .Net 2.0 and can also be used with applications developed with .Net 3.5
2. Design time tool support both outside Visual Studio 2005 IDE as a standalone tool and inside Visual Studio 2005 as integrated tool.
3. Software Factory to extend Application Blocks and create new Application Block

All of this would work with Visual Studio 2005 except Visual Studio IDE integrated tool for modifying configuration files. Patterns and Practice team has developed registry script which will change it.

To enable Enterprise Library Configuration Editor inside Visual Studio 2008, one would have to follow following steps:

1. Run the registry script available at Codeplex
2. Run “devenv /Setup” command from Visual Studio Command prompt.

Share this post :

The five built-in directives are:

1. Assembly
2. Import
3. Include
4. Template
5. Output 

Assembly

The assembly directive identifies an assembly to be referenced so that you can use types within that assembly from code in the text template. Using the assembly directive is equivalent to using the Add Reference feature in Visual Studio.

In the following example, the directive name is assembly, the parameter name is name, and the parameter value is SomeLibrary.DLL:

<@ assembly name=”SomeLibrary.DLL” #>

Import

By using the import directive, you can refer to types in a text template without providing a fully qualified name.

In the following example, the directive name is import, the parameter name is namespace, and the parameter value is System.Diagnostics:

<#@ import namespace=”System.Diagnostics” #>

Include

The include directive processes text from the specified file as if that text were included verbatim in the template currently being processed. In the following example, the name of the directive is include, the parameter name is file, and the parameter value is C:\test.txt:

<#@ include file=”c:\test.txt” #>

Template

By using the template directive, you can specify characteristics of the generated transformation class, such as code language, class inheritance, culture, and the ability to debug. The template directive takes the following parameters, each of which is optional:

Output

By using the output directive, you can specify characteristics of the generated text output, such as the file name extension. The output directive takes the following parameters, each of which is optional:

Share this post :

List of How-to for Text Transformation Template Toolkit (T4)

Calling Directives

1. How to: Call a Generated Directive
2. How to: Call a Custom Directive

Basic Text Template Task

1. How to: Create Text Template
2. How to: Open Text Template for Editing
3. How to: Run Text Template

Using Built-In Directives in Text Template

1. How to: Specify File Output Types in Text Templates
2. How to: Specify a Language in Text Templates
3. How to: Specify a culture in Text Templates
4. How to: Reference Assembly in Text Templates
5. How to: Import Namespace in Text Templates
6. How to: Include files in Text Templates
7. How to: Split Text Templates Into Multiple Files

Adding Code to Text Template

1. How to: Add statement to Text Template
2. How to: Add an Expression to Text Template
3. How to: Add Helper function to Text Template
4. How to: Generate Errors and Warnings from Text Template
5. How to: Append Text to the Generated Text

Generating specific type of artifact from Text Template

1. How to: Generate HTML from Text Template
2. How to: Generate Code from Text Template
3. How to: Use Escape sequences in Text Template
4. How to: Generate templates from templates using Escape Sequences

Creating Custom Text Template Directive Processors

1. How to: Create Custom Directive Processors
2. How to: Set Registry keys for Custom Directive Processors

Creating Custom Text Template Host

1. How to: Create Custom Text Template Host

Troubleshooting Text Templates

1. How to: Debug Text Templates

Share this post :

Directives and directive processors provide additional functionality to text templates. This functionality can be a simple as the ability to specify the extension of the output file or as complex as custom directive processors that read data from a database.

A directive processor contains one or more directives, and the same directive processor can process more than one directive. As an analogy, you can think of directive processors as classes, and you can think of directives as methods in those classes. You call directives directly from your text templates.

Example of Directives are:

1. output: this is used to specify extension of the file.
2. template: this is used to specify various properties of the template, one of which is language used to write control logic.

Directives can be classified into three types:

1. Built-In Directives
2. Generated Directives
3. Custom Directives

Built-In Directives

Built-in directives are provided by the text template transformation toolkit. By using built-in directives, you can specify common options such as the programming language of the text template and the extension of the output file. There are five built-in directives: assembly, import, template, output, and include.

Generated Directives

Generated directives are based on the domain-specific language that you create. If you call a generated directive, you can access models from the statements and expressions in text templates.

Custom Directives

One can write custom directive processors to provide custom functionality to text templates. Custom directive processor can be used any time that one want to access external data or resources from a text template.

Different text templates can share the functionality that a single directive processor provides, so directive processors provide a way to factor code for reuse. The built-in include directive is similar, because you can use it to factor out code and share it among different text templates. The difference is that any functionality that the include directive provides is fixed and does not accept parameters. If you want to provide common functionality to a text template and allow the template to pass parameters, you must create a custom directive processor.

Some examples of custom directive processors could be:

1. A directive processor to return data from a database that accepts a user name and password as parameters.
2. A directive processor to open and read a file that accepts the name of the file as a parameter.