What is Reflection in .Net?

What is Reflection in .Net?

Building an Extensible Application:

In the sections that follow, you'll see a complete example that illustrates the process of building an extensible Windows Forms application that you can augment via external assemblies. To serve as a road map, the extensible sample application includes the following assemblies:

CommonSnappableTypes.dll—This assembly contains type definitions that will be implemented by each snap-in as well as referenced by the extensible Windows Forms application.

CSharpSnapIn.dll—A snap-in written in C# that leverages the types of CommonSnappableTypes.dll.

Vb2005SnapIn.dll—A snap-in written in Visual Basic 2005, which leverages the types of CommonSnappableTypes.dll.

MyPluggableApp.exe—This Windows Forms application (which also leverages CommonSnappableTypes.dll) will be the entity that may be extended by the functionality of each snap-in. This application will make use of dynamic loading, reflection, and late binding to dynamically discover the functionality of assemblies of which it has no prior knowledge.

Building CommonSnappableTypes.dll

First you'll need to create an assembly that contains the types a given snap-in must leverage to plug into your extensible Windows Forms application. The CommonSnappableTypes class library project defines two such types:

using System;

namespace CommonSnappableTypes

{

// All snap-ins must implement this interface.

public interface IAppFunctionality

{

void DoIt();

}

// Optionally, snap-in designers may supply

// company information.

[AttributeUsage(AttributeTargets.Class)]

public sealed class CompanyInfoAttribute :

System.Attribute

{

private string companyName;

private string companyUrl;

public CompanyInfoAttribute(){}

public string Name

{

get { return companyName; }

set { companyName = value; }

}

public string Url

{

get { return companyUrl; }

set { companyUrl = value; }

}

}

}

The IAppFunctionality type provides a polymorphic interface for all snap-ins that the extensible Windows Forms application can consume. Because this example is purely illustrative, it exposes a single method named DoIt(). In a more realistic example, imagine an interface (or a set of interfaces) that allows the snap-in to generate scripting code, render an image onto the application's toolbox, or integrate into the main menu of the hosting application.

The CompanyInfoAttribute type is a custom attribute that snap-in creators can optionally apply to their snap-in. As you can tell by the name of this class, [CompanyInfo] allows the snap-in developers to provide some basic details about the component's point of origin. Notice that you can create custom attributes by extending the System.Attribute base class, and you can annotate them with the [AttributeUsage] attribute to define valid targets where developers can apply your attribute (limited to class types in the preceding code example).

Building the C# Snap-In:

Next, you need to create a type that supports the IAppFunctionality interface. Again, to focus on the overall design of an extensible application, a trivial implementation is in order. Create a new C# code library named CSharpSnapIn that defines a class type named "TheCSharpModule." Given that this class must make use of the types defined in CommonSnappableTypes, be sure to set a reference to that assembly (as well as System.Windows.Forms.dll so you can display a pertinent message for the example).

using System;

using CommonSnappableTypes;

using System.Windows.Forms;

namespace CSharpSnapIn

{

[CompanyInfo(Name = "Intertech Training",Url = www.intertechtraining.com)]

public class TheCSharpModule : IAppFunctionality

{

// Using explicit interface implementation,

// as only the extensible app

// will need to obtain IAppFunctionality.

void IAppFunctionality.DoIt()

{

MessageBox.Show("You have just used the C# snap in!");

}

}

}

Notice that I chose to make use of explicit interface implementation when supporting the IAppFunctionality interface. This is not required; however, the idea is that the only part of the system that needs to directly interact with this interface type is the hosting Windows Forms application. Also note that the code uses named property syntax to specify the values used to set the Name and Url properties of the [CompanyInfo] attribute.

Building a Visual Basic 2005 Snap-In:

Now, to simulate the role of a third-party vendor who prefers Visual Basic 2005 over C#, create a new Visual Basic 2005 code library (Vb2005SnapIn) that references the same assemblies as the previous CSharpSnapIn project. The code behind this class type is again intentionally simple:

Imports System.Windows.Forms
Imports CommonSnappableTypes

Url:="www.ChuckySoft.com")> _Public Class TheVb2005Module

Implements IAppFunctionality

Public Sub DoIt()ImplementsCommonSnappableTypes.IAppFunctionality.DoIt

MessageBox.Show("You have just used the VB 2005 snap in!")

End Sub

End Class

Notice that applying attributes in Visual Basic 2005 requires angle bracket syntax (< >) rather than the C#-centric square brackets ([ ]). Additionally, note that the code uses the Implements keyword at both the class and method level to add support for interface types.

.Net Coding Standards

We Follow the Coding Standards to enforce consistent style and formatting in developing the applications. Here I am explaining the following things.

. Naming Conversions and Style
. Coding Practices
. Error Handling
. Data Access

1. Naming Conversions and Style
1. Use Pascal casing for type and method and constants
Ex:
public class SomeClass
{
const int DefaultSize= 100;
public SomeMethod ()
{ }
}
2. Use camel casing for local variable names and method arguments
Ex:
int number;
void MyMethod (int someNumber)
{ }
3. Prefix member variables with m_. Use Pascal casing for the rest of a member variable
name following the m_.
Ex:
public class SomeClass
{
private int m_Number;
}
4. Name methods using verb-object pair, such as ShowDialog ().
5. Method with return values should have a name describing the value returned, such as
GetObjectState ().
6. Use descriptive variable names.
7. Always use C# predefined types rather than the aliases in the System Namespace.
For Example:
object NOT Object
string NOT String
int NOT Int32.
8. Use meaningful namespace such as the product name or the company name.
9. Avoid fully qualified type names. Use the using statement instead.
10. Avoid putting a using statement inside a namespace.
11. Group all framework namespaces together and put custom or third-party namespaces
underneath.
Example:
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using MyCompany;using MyControl;
12. Maintain strict indentation. Do not use Tabs or non standard indentation. Such as one
space. Recommended values are three or four spaces, and the value should be
uniformed across.
13. Indent comment at the same level of indentation as the code you are documenting.
14. All comments should pass spell checking. Misspelled comments indicate sloppy
development.
15. All member variables should be declared at the top, with one line separating them from
the properties or methods.
public class MyClass
{
int m_Number;
string m_Name;
public void SomeMethod1()
{ }
public void SomeMethod2()
{ }
}
16. Declare a local variable as close as possible to its first use.
17. A file name should reflect the class it contains.
18. Always place an open curly ({) in a new line.

2. Coding Practices:
1. Avoid putting multiple classes in a single file.
2. A single file should contribute types to only a single namespace. Avoid having multiple
namespaces in the same file.
3. Avoid files with more than 500 lines (Excluding machine-Generated code)
4. Avoid method with more than 25 lines.
5. Avoid methods with more than 5 arguments. Use structures for passing multiple
arguments.
6. Do not manually edit any machine generated code.
7. If modifying machine generated code, modify the format and style to match this coding
standard.
8. Use partial classes whenever possible to factor out the maintained portions.
9. Avoid comments that explain the obvious. Code should be self-explanatory. Good code
with readable variables and method names should not require comments.
10. Document only operational assumptions, algorithms insights and so on.
11. Avoid method level documentation.
12. With the exception of zero or one, never hard-code a numeric value; always declare a
constant instead.
13. Use the const directive only on natural constants such as the number of days of the
week.
14. Avoid using const on read-only variables. For that, use the readonly directive.
15. Every line of code should be walked through in a “white Box” testing manner.
16. Catch only exceptions for which you have explicit handling.
17. Avoid error code as method return values.
18. Avoid defining custom exception classes.
19. Avoid multiple Main () methods in a single assembly.
20. Make only the most necessary types public. Mark other as internal.
21. Avoid friend assemblies. As they increases inter assembly coupling.
22. Avoid code that relies on an assembly that running form a particular location.
23. Minimize code in application assemblies (EXE client assemblies). Use class libraries
instead to contain business logic.
24. Always use a curly brace scope in an if statement, even if it contains a single statement.
25. Always use zero based arrays.
26. Do not provide public or protected member variables. Use properties instead.
27. Avoid using “new” inheritance qualifier. Use “override” instead.
28. Never use unsafe code. Except using interop.
29. Always check a delegate for null before invoking it.
30. Classes and Interfaces should have at least 2:1 ratio of methods to properties.
31. Avoid Interfaces with one member. Strive to have three to five members per interface.
Don’t have more than 20 members per interface.12 is probably principle limit.
32. Prefer using explicit interface implementation.
33. Never hardcode strings that might change based on deployment such as connection
strings.
34. When building a long string use “StringBuilder”, not “String”.
35. Don’t use late binding invocation when early-binding is possible.
36. Use application logging and tracing.
37. Never use “go to” unless in a switch statement fall-through.
38. Don’t use the “this” reference unless invoking another constructor from within a
constructor.
39. Avoid casting to and from “System.Object” in code that uses generics. Use constraints
or the “as” operator instead.
40. Do not use the base word to access base class members unless you wish to resolve a
conflict with a subclasses member of the same name or when invoking a base class
constructor.

3. Error Handling:
1. Error handler should be present whenever you anticipate possibility of error.
2. Do not use Try-catch for flow- control.
3. Never declare an empty catch block.
4. Error Message should be user friendly, simple and understandable.
5. Errors should be raised in the routines present in the components and captured in the
application’s GUI.
6. Use Try-Catch statements in each and every function you write. Adhere to it strictly
with out fail.
7. Use dispose on types holding scarce resources, i.e., files, database connections.

4. Data Access:
1. ANSI SQL 92 standards have to be followed for writing queries.
2. Do not put order by clause in the query unless required.
3. Do not encapsulate readonly database operations in transactions.
4. Use a stored procedure with output parameters instead of single record SELECT
statements when retrieving one row of data.
5. Stored procedure execution is fast when we pass parameters by position (the order in
which the parameters are declared in the stored procedure) rather then by name.
6. After each data modification statement inside a transaction, check for an error by testing
the global variable @@ERROR
7. Verify the row count when performing DELETE operation
8. Use RETURN statement in stored procedures to help the calling program know whether
the procedure worked properly.
9. Key words should be capital. For example; SELECT, UPDATE, DELETE, INSERT,
FROM, AND WHERE, etc.
10. Do not use “SELECT * FROM” type of query. If all the columns of the table are to be
selected, list all columns in the SELECT in same order as they appear in the table
definition.
11. While writing a query as a string, do not put any space after single quote (‘). There
should be a single space between every two words. There should not be a space between
the last word and the concluding single quote (‘).
12. Where multiple columns are selected, there should be a single space after every ‘,’
between two columns.
13. All the major keywords should come on the new lines
14. The number of columns in a SELECT statement should not be more than 6. The line
separator should be placed in this case after the (,) of the last column of this line and a
single space.
15. For any new line separator, the separator should come after a single space after the last
word of the line.
16. Place a tab after each key word on a new line.

OVERVIEW OF .NET FRAMEWORK 3.0 FEATURES

.NET FRAMEWORK 3.0

.NET Framework 3.0 comprises of four different foundations with complete support of .NET 2.0. These four foundations are as follows:

1. Windows Communication Foundation (WCF)
2. Windows Presentation Foundation (WPF)
3. Windows Workflow Foundation (WF)
4. Windows CardSpace (WCS)

This Framework supports Windows Vista, Windows XP and Windows 2003. WCF is introduction to overcome the problem of communication with application that are based on other different platforms. WCS also addresses the problem of digital identities and phishing and is introduced to overcome the problem of user-friendly interface that supports 2D and 3D graphics. It also overcomes the problem of process-oriented architecture. All these four foundations provide different technologies in a single framework. This helps the developer by increasing their productivity.

Architecture of .NET FRAMEWORK 3.0

As you know that Microsoft dose little change in an existing technology with additional capabilities. Following that same trend, they did not change the basic structure of .NET Framework 2.0; instead it added four new foundations to it.

Let’s now elaborate upon these foundations and discuss them in detail.

WINDOWS WORKFLOW FOUNDATION

Workflow means performing any task in order. Today, each application is based on workflow approach and involves some process to be executed. While creating an application, developers are still following the traditional approach that leads to create steps in the process implicit in the code. This traditional approach works fine, but requires a deep programming logic making the process difficult to change and execute.

One can use the workflow technology to implement the process in an effective manner and without deep programming logic. According to this technology, instead of defining the process logic in the code, one can divide the process in steps and define them explicitly. After having defined the same process logic, it can be executed by workflow engine. Workflow engine is an environment used for execution of processes and activities.

Workflow engine is not a new technology; it came into existence in early 2000. In the market, several workflow engines are available for windows and other platform. Today, all applications are based on workflow approach. So, defining different engines for different applications is a cumbersome task. To avoid this, Microsoft has decided to define a single common workflow engine for all windows-based applications. This is what Windows Workflow Foundation (WF) performs. WF provides a common workflow technology for all the windows-based applications, such as Microsoft Office 2007 and Windows Share Point Services.

Now question arises, how this Workflow technology meets the requirements of different workflow applications. This can be answered by understanding how the WF works. Basically, WF takes each activity as a class and that class comprises of any work which WF finds necessary. These classes can be used with different application workflows with little modifications.

WF also addresses the problem of making changes in the running workflow. There are two types of workflows- Sequential Workflow and State-machine workflow. WF includes support for both workflows.

Sequential workflow is the one that performs the execution of the activities in a chronological order. It contains classes, loops and control structures. This workflow is used by software-based process and is easy to understand and develop.

State-machine workflow is the one that executes activities at a particular time. This time is based on the event occurred and the state of the machine. The workflow is used when you are not aware of execution time. For example, you have created an application and somebody calls the cancel event, which is less predictable, and you are not aware of the exact execution time, but you are interacting with people at the same time.this interaction demands for state machine workflow.

Components of WF

By now you must be familiar with workflow, which is basically a group of activities. These activities are classes that can be created in code. WF provides components, such as Workflow designer, which is a GUI for developing workflows. You can create the workflow activities using Base Activity Library (BAL), which comes with WF. BAL provides some of the common activities, which help in creating custom activities easily and fast. Some of the common activities included in BAL are as follows:

1. IFElse- It is used for executing the multiple activities based on the conditions met.
2. While- It is used for executing the same activity multiple times till the time condition is true.
3. Sequence- It is used for executing activities on a particular time in a predefined order.
4. Parallel- It is used for executing two or more activity groups in parallel.
5. Code- It is used for executing a code snippet.
6. Listen-It is used for executing the activities based on the event received or occurred.
7. InvokeWebServices- It is used for invoking a Web service.
8. State- It is used in State-machine workflow for representing a state.
9. EventDriven- It is used to define a transition containing one or more activities at a time of particular event received.
10.Policy- It is used for executing the business rules which comes with WF.

WF also provides a runtime engine for executing the defined workflow. It also manages the execution of workflow. For running a runtime engine, WF provides runtime services.

WINDOWS COMMUNICATION FOUNDATION

Today, most of the applications need to communicate with other applications. But communication requires a reliable protocol which earlier was difficult to choose. Applications used to communicate using different protocols due to which some applications were unable to communicate with other applications, as the protocols used them would not mutually support each other. To avoid this problem , all the major application vendors decided to use a common protocol named SOAP. This protocol will be used by web services and it will help in creating interoperability between different technologies. With this a new architecture, named as service-oriented architecture (SOA), came into existence.

In .NET 2.0, there exists multiple technologies used for communication. Some of these technologies are enterprise services, .NET remoting, and ASP.NET web services. But sometimes, these multiple technologies confuse the developer and create dilemma while selecting the technologies. To overcome this dilemma, Microsoft decided to introduce a single foundation for application communication and support the interoperability between different technologies. This new single foundation is named as Windows Communication Foundation (WCF). WCF provides a common method for communication with support for SOA. Now the developer can use the WCF, instead of multiple technologies used earlier.

WCF supports multiple protocols, such as SOAP and binary. WCF also provides interoperable communication, which is compulsory for communicating between different technologies such as J2EE and .NET. WCF uses the SOA and resolves the issue, which arises at the time of application communication.

In WCF there are four phases, which are as follows:
1. Contracts.
2. Service Runtime.
3. Messaging.
4. Activation and Hosting Services.

Contracts:
Contracts phase gives you information about different features of the message system. Message system is the one, which involves sending, and receiving the messages from one end to another. In contracts, there are four components, which are as follows:

1. Data Contract- It is used for describing message parameters. These parameters are XML-based and used for creating a message that will be formed or used by the service. This allows any system to process the message.

2. Message Contract- It is used for defining specific part of the message using SOAP. This allows the message to be communicated in interoperable communication.

3. Service Contract- It is used to indicate the signatures which are distributed as an interface.

4. Policy and Binding- It is used to specify the transport media, such as HTTP or TCP. It also includes some of the security requirements, which are must for communication.

Service Runtime:
Service Runtime phase gives information about the different behaviours that takes place at the runtime. Some of the behaviours are as follows:

1. Throttling Behaviour- It is used to control the number of messages processed.
2. Metadata Behaviour- It is used to check the processing of metadata for its availability to the external clients.
3. Instance Behaviour- It is used to specify the number of instances, which will be available to the client.
4. Transaction Behaviour- It is used to change the state of the transaction if a failure occurs.
5. Concurrency Behaviour- It is used to control the parallel functions, which are running at the time of client and service communication.

Messaging:

Messaging phase gives information about the different channels, which are required at the time of processing a message. These channels help in message processing. This phase deals with the message content that need to be communicated. It uses transport and protocol channels for communicating the message body. Transport channel is used for reading and writing message. In addition, sometimes there is a need to convert the message to an XML format and that too is performed by the transport channels. Protocol channel includes the protocols, which are used for processing a message. Some of the protocols are WS-Security and WS-Reliability.

Note: WS-Security is a protocol used for securing the message at the messaging phase. WS-Reliability is a protocol which gives assurance of message delivery.

Activation and Hosting Services:

This is the final phase of the WCF where the service is formed. Here any service can be hosted using the IIS or Windows Activation Service. Service can also be manually deployed in an executable form.

Windows Card space

In this modern world, people access the resources on Internet by digital identities, which are represented as username. But username is not the single element. It is combined with password for accessing resources. People have different user names for different websites on the Internet. For example, for email, website, or online banks, a user will have different user names. Now the user needs to remember each of these user names, which is a cumbersome task. Also, some times, phishers attract the reader of the email to access a particular website, which looks like the original website, for example, the email may contain the name of a website of a trading company say a bank, with which the user does online trading or transaction. When the reader access that website, the phisher will steal the reader identity information and use the same at the original website.

To avoid this problems, Microsoft has introduced the Windows Card Space (WCS). WCS helps in managing the digital identities. The mail purpose of the WCS is to convert each identity into unique information cards. These cards contain information about the user, which will be used for accessing the resources on the Internet.

However, WCS only works with those websites, which accepts the CardSpace logins. When a user tries to access the resources on the website which accepts the CardSpace, the user is presented with a CardSpace selection screen. The user can select the required card and access the resources on the website. You can create a card using the window card space utility that comes with .NET 3.0.

Now the user needs to remember the only card instead of multiple user names and passwords. Technically speaking, all the identities created on a card need some provider for converting an identity into card. For this conversion some organisations provide their own identity provides to create a card based on same. Even WCS comes with its own self-issue identity providers which are accepted by websites for validating the user using the card. These cards avoids the use of passwords. Due to this identity through a card, phishers are unable to steal the password. Despite everything, if phishers succeeded attracting the reader, they will steal some personal information. To avoid this, a new certificate is introduced known as high-assurance certificate. This certificate differentiates the original and phisher-based websites.

WCS is based on the identity metasystem. This system allows to you use different digital identities across different platforms. There are two types of cards available, which are as follows:

1. Personal Cards- These cards are based on self-issued identity providers.
2. Managed Cards- These cards are based on identity providers provided by vendors other than Microsoft.

Windows Presentation Foundation

User interface is an important aspect of any web or windows application. Traditionally user interface are menu based but still have to face challenges related to displays of videos, 2D and 3D animation. Sometimes user interface also needs to provide a functionality that allows working with different kinds of documents, such as MicrosoftWord or PDF files. To address this problem, developers need to use different technologies for creating a single user interface which addresses all the above the challenges. Using different technologies is a cumbersome task for a developer.

Now comes Microsoft to resolve this issue. To overcome this issue, Microsoft decided to introduce a single common foundation which is known as Windows Presentation Foundation (WPF). WPF provides supports for 2D and 3D graphics, videos, and support for different document types in a single foundation.

WPF works on Extensible Application Mark up Language (XAML). This language is used by designers for creating a user interface. Even Microsoft comes with expression studio that uses XAML for developing User Interface for any web- or windows-based applications. The architecture of WPF contains parts like Windows Presentation Framework, Presentation Core, CLR, MilCore, are User 32/GDI, DirectX and Kernel run-time/Hardware Adaptation Layer. This architecture is mainly represented through the managed code. The CLR is used to handle tasks, such as memory management and error handling. CLR increases the productivity and makes the application robust. Presentation Framework, Presentation Core, and MilCore are the important parts of the WPF architecture. Both Presentation Framework and Presentation Core are developed using managed code. On the other hand MilCore is developed using the unmanaged code. This is done so that milcore can communicate with DirectX easily. As DirectX is based on unmanaged code, the question arises, how does the unmanaged and managed code communicate with each other. This is done using the following class hierarchy:

1. System.Threading.Dispatcherobject- It is used for managing the threats and concurrency.
2. System.Windows.Dependencyobject- It is used for providing properties to a user object, such as buttons.
3. System.Windows.Media.Visual- It is used for drawing the tree of the visual objects. These objects contain drawing instructions for managing the data. This class is the main entry point for communication between managed and unmanaged code.
4. System.Windows.UIElement- This class is used for defining the layouts and events for the user interface.
5. System.Windows.FrameworkElement- It is used for providing policies and customisation facility at the user-end. This is also enter point for animation.
6. System.Windows.Controls.Control- It is used for managing the controls used on the user interface.

WTF provides the following user interface functionalities other than the basic functions:

1. Documents- WPF provides support for XPS and flow documents. XPS are supported by XAML FixedDocument tag. It also uses the FlowDocument tag for displaying the Flow Documents. XPS documents are the documents which are based on XML paper specification used by Windows Vista. The flow documents are those, which are used for optimizing the content according to the runtime variables, such as windows size and device resolution.

2. Graphics- WPF provides support for 2D and 3D graphics. It provides brushes, shapes and pens for drawing 2D graphics. It also provides XAML-based elements for drawing 3D graphics, which require lighting and camera positions. WPF don’t rely on GDI+ for 3D graphics.

3. Images- WPF uses the XAML’s image tag for providing support for different types of image formats, such as jpeg, gif, png and others. It uses Windows Imaging Component to provide software that displays and stores images.

4. Media- WPF uses the MediaElement tag of XAML for displaying video and audio formats. These formats include WMV, AVI and MPEG file types. You can use this tag with other XAML tags for displaying 3D cubes, etc.

5. Animation- WPF provides support for animation. You can use this support for creating storyboards, including timeline animations.

6. Data Binding- WPF provides support for data binding which is automatically performed in any WPF application. It also provides sorting and filtering of data.

What's new in .Net Framework Version 3.5

What's New in the .NET Framework Version 3.5

This topic contains information about new and enhanced features in the .NET Framework version 3.5.

.NET Compact Framework

The .NET Compact Framework version 3.5 expands support for distributed mobile applications by including the Windows Communication Foundation (WCF) technology. It also adds new language features such as LINQ, new APIs based on community feedback, and improves debugging with updated diagnostic tools and features.

For details about these new features and enhancements, see What's New in the .NET Compact Framework Version 3.5

ASP.NET

The .NET Framework 3.5 includes enhancements in targeted areas of ASP.NET and Visual Web Developer. The most significant advance is improved support for the development of AJAX-enabled Web sites. ASP.NET supports server-centric AJAX development with a set of new server controls and APIs. You can enable an existing ASP.NET 2.0 page for AJAX by adding a ScriptManager control and an UpdatePanel control so that the page can update without requiring a full page refresh.

ASP.NET also supports client-centric AJAX development with a new client library called the Microsoft AJAX Library. The Microsoft AJAX Library supports client-centric, object-oriented development, which is browser-independent. By using the library classes in your ECMAScript (JavaScript) you can enable rich UI behaviors without roundtrips to the server. You can mix the degree of server-centric and client-centric development to meet the needs of your application. Furthermore, Visual Web Developer includes improved IntelliSense support for JavaScript and support for the Microsoft AJAX Library.

ASP.NET and Visual Web Developer now support the creation of both ASMX and WCF-based Web services and the seamless use of either implementation from Web pages using Microsoft AJAX Library. Furthermore, server-side application services including forms authentication, roles management, and profiles are now exposed as Web services that can be consumed in WCF-compatible applications, including client script and Window Forms clients. ASP.NET enables all Web-based applications to share these common application services.

Other improvements in ASP.NET include a new data control, ListView, for displaying data; a new data source control, LinqDataSource, that exposes Language Integrated Query (LINQ) to Web developers through the ASP.NET data source control architectures; a new tool, ASP.NET Merge Tool (Aspnet_merge.exe), for merging precompiled assemblies; and tight integration with IIS 7.0. ListView is a highly customizable control (using templates and styles) that also supports edit, insert, and delete operations, as well as sorting and paging functionality. The paging functionality for ListView is provided by a new control called DataPager. You can use the merge tool to combine assemblies to support a range of deployment and release management scenarios. The integration of ASP.NET and IIS 7.0 includes the ability to use ASP.NET services, such as authentication and caching, for any content type. It also includes the ability to develop server pipeline modules in ASP.NET managed code and supports unified configuration of modules and handlers.

Other improvements in Visual Web Developer include multitargeting support, inclusion of Web Application Projects, a new Design view, new Cascading Style Sheets (CSS) design tools, and support for LINQ for SQL databases. Multitargeting enables you to use Visual Web Developer to target development of Web applications to specific versions of the .NET Framework, including versions 2.0, 3.0, and 3.5.

For more information, see What's New in ASP.NET and Web Development.

Add-Ins and Extensibility

The System.AddIn.dll assembly in the .NET Framework 3.5 provides powerful and flexible support to developers of extensible applications. It introduces a new architecture and model that helps developers with the initial work to add extensibility to an application and by ensuring that their extensions continue working as the host application changes. The model provides the following features:

Discovery:

You can easily find and manage sets of add-ins in multiple locations on a computer with the AddInStore class. You can use this class to search for and obtain information about add-ins by their base types without having to load them.

Activation:

After an application chooses an add-in, the AddInToken class makes it easy to activate. Simply choose the isolation and sandboxing level and the system takes care of the rest.

Isolation:

There is built-in support for application domains and process isolation of add-ins. The isolation level for each add-in is in the control of the host. The system handles loading application domains and processes and shutting them down after their add-ins have stopped running.

Sandboxing:

You can easily configure add-ins with either a default or customized trust level. Support includes Internet, Intranet, Full Trust, and “same-as-host” permission sets, as well as overloads that let the host specify a custom permission set.

UI Composition:

The add-in model supports direct composition of Windows Presentation Foundation (WPF) controls that span application domain boundaries. You can easily allow add-ins to contribute directly to the UI of the host while still retaining the benefits of isolation, ability to unload, sandboxing, and versioning.

Versioning:

The add-in architecture makes it possible for hosts to introduce new versions of their object model without breaking existing add-ins or impacting the developer experience for new ones. For more information, see Add-ins and Extensibility.

Common Language Runtime (CLR)

Collections:

HashSet(T) provides high performance set operations to the .NET Framework. A set is a collection that contains no duplicate elements, and whose elements are in no particular order. For more information, see HashSet Collection Type.

Diagnostics:

The EventSchemaTraceListener class provides tracing of end-to-end, schema-compliant events. You can use end-to-end tracing for a system that has heterogeneous components that cross thread, AppDomain, process, and computer boundaries. A standardized event schema (see Event Representation for Event Consumers) has been defined to enable tracing across these boundaries. This schema is shared by various tracing technologies, including Windows Vista diagnostics tools such as Event Viewer. The schema also enables the addition of custom, schema-compliant elements.

The EventSchemaTraceListener class is tuned for logging performance with implicit support for lock-free tracing.

I/O and Pipes

Pipes provide interprocess communication between any processes running on the same computer, or on any other Windows computer within a network. The .NET Framework provides access to two types of pipes: anonymous pipes and named pipes. For more information about pipes, see Pipes.

Garbage Collection

The GCSettings class has a new LatencyMode property that you can use to adjust the time that the garbage collector intrudes in your application. You set this property to one of the values of the new GCLatencyMode enumeration.

The GC class has a new Collect(Int32, GCCollectionMode) method overload that you can use to adjust the behavior for a forced garbage collection. For example, you can use this overload to specify that the garbage collector should determine whether the current time is optimal to reclaim objects. This overload takes a value from the new GCCollectionMode enumeration.

Reflection and Reflection Emit in Partial Trust

Assemblies that run with partial trust can now emit code and execute it. Emitted code that calls only public types and methods needs no permissions beyond the permissions demanded by the types and methods that are accessed. The new DynamicMethod(String, Type, Type[]) constructor makes it easy to emit such code.

When emitted code needs to access private data, the new DynamicMethod(String, Type, Type[], Boolean) constructor allows restricted access. The host must grant ReflectionPermission with the new RestrictedMemberAccess flag to enable this feature, which gives emitted code the ability to access private data only for types and methods in assemblies with equal or lesser trust levels. See Walkthrough: Emitting Code in Partial Trust Scenarios.

For reflection, a host grant of RestrictedMemberAccess similarly allows restricted use of methods that access private properties, call private methods, and so on, but only for target assemblies with equal or lesser trust levels.

Threading

Better Reader/Writer LockThe new ReaderWriterLockSlim class provides performance that is significantly better than ReaderWriterLock, and comparable with the lock statement (SyncLock in Visual Basic). Transitions between lock states have been simplified to make programming easier and to reduce the chances of deadlocks. The new class supports recursion to simplify migration from lock and from ReaderWriterLock.

ThreadPool Performance Enhancements:

Throughput for the dispatch of work items and I/O tasks in the managed thread pool is significantly improved. Dispatch is now handled in managed code, without transitions to unmanaged code and with fewer locks. The use of ThreadPool is recommended over application-specific thread pool implementations.

Time Zone Improvements

Two new types, DateTimeOffset and TimeZoneInfo, improve support for time zones and make it easier to develop applications that work with dates and times in different time zones. For a discussion of which type to use in particular situations, see Choosing Between DateTime, DateTimeOffset, and TimeZoneInfo.

TimeZoneInfo

The new TimeZoneInfo class largely supplants the existing TimeZone class. You can use TimeZoneInfo to retrieve any time zone defined in the registry, rather than just the local time zone and Coordinated Universal Time (UTC). You can also use this class to define custom time zones, to serialize and deserialize custom time zone data, and to convert times between time zones. For more information about developing applications that use the TimeZoneInfo class, see Times and Time Zones.

DateTimeOffset

The new DateTimeOffset structure extends the DateTime structure to make working with times across time zones easier. The DateTimeOffset structure stores date and time information as a UTC date and time together with an offset value that indicates how much the time differs from UTC.

Cryptography

ClickOnce Manifests:

There are new cryptography classes for verifying and obtaining information about manifest signatures for ClickOnce applications. The ManifestSignatureInformation class obtains information about a manifest signature when you use its VerifySignature method overloads. You can use the ManifestKinds enumeration to specify which manifests to verify. The result of the verification is one of the SignatureVerificationResult enumeration values. The ManifestSignatureInformationCollection provides a read-only collection of ManifestSignatureInformation objects of the verified signatures. In addition, the following classes provide specific signature information:

StrongNameSignatureInformation:- Holds the strong name signature information for a manifest.

AuthenticodeSignatureInformation:- Represents the Authenticode signature information for a manifest.

TimestampInformation:- Contains information about the time stamp on an Authenticode signature.

TrustStatus:- Provides a simple way to check whether an Authenticode signature is trusted.

Suite B Support

The .NET Framework 3.5 supports the Suite B set of cryptographic algorithms published by the National Security Agency (NSA). For the NSA documentation, see www.nsa.gov/ia/industry/crypto_suite_b.cfm.

The following algorithms are included:

Advanced Encryption Standard (AES) with key sizes of 128 and 256 bits for encryption. Secure Hash Algorithm (SHA-256 and SHA-384) for hashing. Elliptic Curve Digital Signature Algorithm (ECDSA) using curves of 256-bit and 384-bit prime moduli for signing. This algorithm is provided by the ECDsaCng class. It allows you to sign with a private key and verify with a public key. Elliptic Curve Diffie-Hellman (ECDH) using curves of 256 and 384-bit prime moduli for key exchange/secret agreement. This algorithm is provided by the ECDiffieHellmanCng class. Managed code wrappers for the Federal Information Processing Standard (FIPS) certified implementations of the AES, SHA-256, and SHA-384 implementations are available in the new AesCryptoServiceProvider, SHA256CryptoServiceProvider, and SHA384CryptoServiceProvider classes.

The Cryptography Next Generation (CNG) classes provide a managed implementation of the native Crypto API (CAPI). Central to this group is the CngKey key container class, which abstracts the storage and use of CNG keys. This class allows you to store a key pair or a public key securely and refer to it using a simple string name. The ECDsaCng and ECDiffieHellmanCng classes use CngKey objects.

The CngKey class is used for a variety of additional operations, including opening, creating, deleting, and exporting keys. It also provides access to the underlying key handle to use when calling native APIs directly.

There are a variety of supporting CNG classes, such as CngProvider, which maintains a key storage provider, CngAlgorithm, which maintains a CNG algorithm, and CngProperty, which maintains commonly used key properties.

Networking

Peer-to-Peer Networking:

Peer-to-peer networking is a serverless networking technology that allows several network devices to share resources and communicate directly with each other. The System.Net.PeerToPeer namespace provides a set of classes that support the Peer Name Resolution Protocol (PNRP) that allows the discovery of other peer nodes through PeerName objects registered within a peer-to-peer cloud. PNRP can resolve peer names to IPv6 or IPv4 IP addresses.

Collaboration Using Peer-to-Peer Networking:

The System.Net.PeerToPeer.Collaboration namespace provides a set of classes that support collaboration using the Peer-to-Peer networking infrastructure. These classes simplify the process by which applications can:

Track peer presence without a server.

Send invitations to participants.

Discover peers on the same subnet or LAN.

Manage contacts.

Interact with peers.

Microsoft’s Peer-to-Peer collaboration infrastructure provides a peer-to-peer network-based framework for collaborative serverless activities. Use of this framework enables decentralized networking applications that use the collective power of computers over a subnet or the Internet. These types of applications can be used for activities such as collaborative planning, communication, content distribution, or even multiplayer game matchmaking.

Socket Performance Enhancements

The Socket class has been enhanced for use by applications that use asynchronous network I/O to achieve the highest performance. A series of new classes have been added as part of a set of enhancements to the Socket namespace. These classes provide an alternative asynchronous pattern that can be used by specialized high-performance socket applications. These enhancements were specifically designed for network server applications that require the high-performance.

Windows Communication Foundation

WCF and WF Integration—Workflow Services:

The .NET Framework 3.5 unifies the Windows Workflow Foundation (WF) and Windows Communication Foundation (WCF) frameworks so that you can use WF as a way to author WCF services or expose your existing WF workflow as a service. This enables you to create services that can be persisted, can easily transfer data in and out of a workflow, and can enforce application-level protocols. For more information, see Creating Workflow Services and Durable Services. For code samples, see Workflow Services Samples.

Durable Services:

The .NET Framework 3.5 also introduces support for WCF services that use the WF persistence model to persist the state information of the service. These durable services persist their state information on the application layer, so that if a session is torn down and re-created later, the state information for that service can be reloaded from the persistence store. For more information, see Creating Workflow Services and Durable Services. For a code sample, see Durable Service Sample.

WCF Web Programming Model:

The WCF Web Programming Model enables developers to build Web-style services with WCF. The Web Programming Model includes rich URI processing capability, support for all HTTP verbs including GET, and a simple programming model for working with a wide variety of message formats (including XML, JSON, and opaque binary streams). For more information, see Web Programming Model. For code samples, see Web Programming Model Samples.

WCF Syndication:

WCF now includes a strongly typed object model for processing syndication feeds, including both the Atom 1.0 and RSS 2.0 formats. For more information, see WCF Syndication. For code samples, see Syndication Samples.

WCF and Partial Trust:

In .NET Framework 3.5, applications running with reduced permissions can use a limited subset of WCF features. Server applications running with ASP.NET Medium Trust permissions can use the WCF Service Model to create basic HTTP services. Client applications running with Internet Zone permissions (such as XAML Browser Applications or unsigned applications deployed with ClickOnce) can use the WCF proxies to consume HTTP services. In addition, the WCF Web Programming Model features (including AJAX and Syndication) are available for use by partially trusted applications. For more information, see Partial Trust. For code samples, see Partial Trust WCF Samples.

WCF and ASP.NET AJAX Integration:

The integration of WCF with the Asynchronous JavaScript and XML (AJAX) capabilities in ASP.NET provides an end-to-end programming model for building Web applications that can use WCF services. In AJAX-style Web applications, the client (for example, the browser in a Web application) exchanges small amounts of data with the server by using asynchronous requests. Integration with AJAX features in ASP.NET provides an easy way to build WCF Web services that are accessible by using client JavaScript in the browser. For more information, see AJAX Integration and JSON Support. For code samples, see AJAX Samples.

Web Services Interoperability:

In the .NET Framework 3.5, Microsoft maintains its commitment to interoperability and public standards and introduces support for the new secure, reliable, and transacted Web services standards:

Web Services Reliable Messaging v1.1, Web Services Reliable Messaging Policy Assertion v1.1 , WS-SecureConversation v1.3, WS-Trust v1.3, WS-SecurityPolicy v1.2, Web Services Atomic Transaction (WS-AtomicTransaction) Version 1.1, Web Services Coordination (WS-Coordination) Version 1.1, Web Services Policy 1.5 - Framework, Web Services Policy 1.5 - Attachment.

Implementation of these protocols is made available using the new standard bindings, and , which are documented in the Web Services Protocols Interoperability Guide. For a code sample, see WS Binding Samples.

Windows Presentation Foundation

In the .NET Framework 3.5, Windows Presentation Foundation contains changes and improvements in numerous areas, including versioning, the application model, data binding, controls, documents, annotations, and 3-D UI elements.

For details about these new features and enhancements, see What's New in Windows Presentation Foundation Version 3.5.

Windows Workflow Foundation

WCF and WF Integration—Workflow Services:

The .NET Framework 3.5 unifies the Windows Workflow Foundation (WF) and Windows Communication Foundation (WF) frameworks so that you can use WF as a way to author WCF services or expose your existing WF workflow as a service. This enables you to create services that can be persisted, can easily transfer data in and out of a workflow, and can enforce application-level protocols. For more information, see Creating Workflow Services and Durable Services. For code samples, see Workflow Services Samples (WF).

Rules:

The WF rules engine now supports extension methods, operator overloading, and the use of the new operator in your rules. For more information, see Rule Changes in .NET Framework 3.5. For code samples, see Rules and Conditions Samples.

Windows Forms

ClickOnce Improvements:Several improvements have been made to ClickOnce. Improvements include deployment from multiple locations and third-party branding. For more information, see Deploying ClickOnce Applications without Resigning and Creating ClickOnce Applications for Others to Deploy.

The Mage.exe tool, which is sometimes used together with ClickOnce, has been updated for the .NET Framework 3.5. For more information, see Manifest Generation and Editing Tool (Mage.exe).

Authentication, Roles, and Settings Services:

Client application services are new in the .NET Framework 3.5 and enable Windows-based applications (including Windows Forms and Windows Presentation Foundation applications) to easily access the ASP.NET login, roles, and profile services. These services enable you to authenticate users and retrieve user roles and application settings from a shared server.

You can enable client application services by specifying and configuring client service providers in your application configuration file or in the Visual Studio Project Designer. These providers plug into the Web extensibility model and enable you to access the Web services through existing .NET Framework login, roles, and settings APIs. Client application services also support occasional connectivity by storing and retrieving user information from a local data cache when the application is offline.

For more information, see Client Application Services.

Windows Vista Support

Existing Windows Forms applications work seamlessly on Windows Vista, and they are upgraded to have the same appearance as applications written specifically for Windows Vista whenever possible. Common file dialog boxes are automatically updated to the Windows Vista version. The .NET Framework 3.5 also supports the User Account Control (UAC) Shield icon. For more information, see FileDialog Class and Shield.

WPF support

You can use Windows Forms to host Windows Presentation Foundation (WPF) controls and content together with Windows Forms controls. You can also open WPF windows from a Windows Form. For more information about how to use Windows Forms and WPF together, see Migration and Interoperability.

LINQ

Language-Integrated Query (LINQ) is a new feature in Visual Studio 2008 and the .NET Framework 3.5. LINQ extends powerful query capabilities to the language syntax of C# and Visual Basic in the form of standard, easily-learned query patterns. This technology can be extended to support potentially any kind of data store. The .NET Framework 3.5 includes LINQ provider assemblies that enable the use of LINQ for querying .NET Framework collections, SQL Server databases, ADO.NET Datasets, and XML documents.

The components of LINQ that are part of the .NET Framework 3.5 are:

The System.Linq namespace, which contains the set of standard query operators and types and interfaces that are used in the infrastructure of a LINQ query. This namespace is in the System.Core.dll assembly.

The System.Data.Linq namespace, which contains classes that support interaction with relational databases in LINQ to SQL applications.

The System.Data.Linq.Mapping namespace, which contains classes that can be used to generate a LINQ to SQL object model that represents the structure and content of a relational database.

The System.Xml.Linq namespace, which contains the classes for LINQ to XML. LINQ to XML is an in-memory XML programming interface that enables you to modify XML documents efficiently and easily. Using LINQ to XML, you can load XML, serialize XML, create XML trees from scratch, manipulate in-memory XML trees, and validate by using XSD. You can also use a combination of these features to transform XML trees from one shape into another.

New types in the System.Web.UI.WebControls and System.Web.UI.Design.WebControls namespaces. These new types, such as LinqDataSource, support the use of LINQ in ASP.NET Web pages through a data source control.

The DataRowComparer, DataRowExtensions, and DataTableExtensions classes in the System.Data namespace support LINQ queries against ADO.NET DataSet objects. In the class library, the LINQ extension methods that apply to a class are listed in the members page for the class, in the Contents pane, and in the Index pane.

Expression Trees

Expression trees are new in the .NET Framework 3.5, and provide a way to represent language-level code in the form of data. The System.Linq.Expressions namespace contains the types that are the building blocks of expression trees. These types can be used to represent different types of code expressions, for example a method call or an equality comparison.

Expression trees are used extensively in LINQ queries that target remote data sources such as a SQL database. These queries are represented as expression trees, and this representation enables query providers to examine them and translate them into a domain-specific query language.

The System.Linq.Expressions namespace is in the System.Core.dll assembly.

OVERVIEW OF .NET FRAMEWORK

.NET Framework Conceptual Overview:

The .NET Framework is an integral Windows component that supports building and running the next generation of applications and XML Web services. The .NET Framework is designed to fulfill the following objectives: To provide a consistent object-oriented programming environment whether object code is stored and executed locally, executed locally but Internet-distributed, or executed remotely. To provide a code-execution environment that minimizes software deployment and versioning conflicts. To provide a code-execution environment that promotes safe execution of code, including code created by an unknown or semi-trusted third party. To provide a code-execution environment that eliminates the performance problems of scripted or interpreted environments. To make the developer experience consistent across widely varying types of applications, such as Windows-based applications and Web-based applications. To build all communication on industry standards to ensure that code based on the .NET Framework can integrate with any other code. The .NET Framework has two main components: the common language runtime and the .NET Framework class library. The common language runtime is the foundation of the .NET Framework. You can think of the runtime as an agent that manages code at execution time, providing core services such as memory management, thread management, and remoting, while also enforcing strict type safety and other forms of code accuracy that promote security and robustness. In fact, the concept of code management is a fundamental principle of the runtime. Code that targets the runtime is known as managed code, while code that does not target the runtime is known as unmanaged code. The class library, the other main component of the .NET Framework, is a comprehensive, object-oriented collection of reusable types that you can use to develop applications ranging from traditional command-line or graphical user interface (GUI) applications to applications based on the latest innovations provided by ASP.NET, such as Web Forms and XML Web services.The .NET Framework can be hosted by unmanaged components that load the common language runtime into their processes and initiate the execution of managed code, thereby creating a software environment that can exploit both managed and unmanaged features. The .NET Framework not only provides several runtime hosts, but also supports the development of third-party runtime hosts.For example, ASP.NET hosts the runtime to provide a scalable, server-side environment for managed code. ASP.NET works directly with the runtime to enable ASP.NET applications and XML Web services, both of which are discussed later in this topic.Internet Explorer is an example of an unmanaged application that hosts the runtime (in the form of a MIME type extension). Using Internet Explorer to host the runtime enables you to embed managed components or Windows Forms controls in HTML documents. Hosting the runtime in this way makes managed mobile code (similar to Microsoft® ActiveX® controls) possible, but with significant improvements that only managed code can offer, such as semi-trusted execution and isolated file storage.The following illustration shows the relationship of the common language runtime and the class library to your applications and to the overall system. The illustration also shows how managed code operates within a larger architecture.The following sections describe the main components and features of the .NET Framework in greater detail.Features of the Common Language Runtime The common language runtime manages memory, thread execution, code execution, code safety verification, compilation, and other system services. These features are intrinsic to the managed code that runs on the common language runtime.With regards to security, managed components are awarded varying degrees of trust, depending on a number of factors that include their origin (such as the Internet, enterprise network, or local computer). This means that a managed component might or might not be able to perform file-access operations, registry-access operations, or other sensitive functions, even if it is being used in the same active application.The runtime enforces code access security. For example, users can trust that an executable embedded in a Web page can play an animation on screen or sing a song, but cannot access their personal data, file system, or network. The security features of the runtime thus enable legitimate Internet-deployed software to be exceptionally feature rich.The runtime also enforces code robustness by implementing a strict type-and-code-verification infrastructure called the common type system (CTS). The CTS ensures that all managed code is self-describing. The various Microsoft and third-party language compilers generate managed code that conforms to the CTS. This means that managed code can consume other managed types and instances, while strictly enforcing type fidelity and type safety.In addition, the managed environment of the runtime eliminates many common software issues. For example, the runtime automatically handles object layout and manages references to objects, releasing them when they are no longer being used. This automatic memory management resolves the two most common application errors, memory leaks and invalid memory references.The runtime also accelerates developer productivity. For example, programmers can write applications in their development language of choice, yet take full advantage of the runtime, the class library, and components written in other languages by other developers. Any compiler vendor who chooses to target the runtime can do so. Language compilers that target the .NET Framework make the features of the .NET Framework available to existing code written in that language, greatly easing the migration process for existing applications.While the runtime is designed for the software of the future, it also supports software of today and yesterday. Interoperability between managed and unmanaged code enables developers to continue to use necessary COM components and DLLs.The runtime is designed to enhance performance. Although the common language runtime provides many standard runtime services, managed code is never interpreted. A feature called just-in-time (JIT) compiling enables all managed code to run in the native machine language of the system on which it is executing. Meanwhile, the memory manager removes the possibilities of fragmented memory and increases memory locality-of-reference to further increase performance.Finally, the runtime can be hosted by high-performance, server-side applications, such as Microsoft® SQL Server™ and Internet Information Services (IIS). This infrastructure enables you to use managed code to write your business logic, while still enjoying the superior performance of the industry's best enterprise servers that support runtime hosting..NET Framework Class Library The .NET Framework class library is a collection of reusable types that tightly integrate with the common language runtime. The class library is object oriented, providing types from which your own managed code can derive functionality. This not only makes the .NET Framework types easy to use, but also reduces the time associated with learning new features of the .NET Framework. In addition, third-party components can integrate seamlessly with classes in the .NET Framework.For example, the .NET Framework collection classes implement a set of interfaces that you can use to develop your own collection classes. Your collection classes will blend seamlessly with the classes in the .NET Framework.As you would expect from an object-oriented class library, the .NET Framework types enable you to accomplish a range of common programming tasks, including tasks such as string management, data collection, database connectivity, and file access. In addition to these common tasks, the class library includes types that support a variety of specialized development scenarios. For example, you can use the .NET Framework to develop the following types of applications and services: Console applications. See Building Console Applications. Windows GUI applications (Windows Forms). See Windows Forms. Windows Presentation Foundation (WPF) applications. See Introduction to Windows Presentation Foundation. ASP.NET applications. See Creating ASP.NET Web Pages. Web services. See Creating Web Services in Managed Code. Windows services. See Introduction to Windows Service Applications. Service-oriented applications using Windows Communication Foundation (WCF). See What Is Windows Communication Foundation? Workflow-enabled applications using Windows Workflow Foundation (WF). See Introduction to Programming Windows Workflow Foundation. For example, the Windows Forms classes are a comprehensive set of reusable types that vastly simplify Windows GUI development. If you write an ASP.NET Web Form application, you can use the Web Forms classes.

Free Download Software to Install .Net 3.5

Dotnet framework 3.5 Free DownloadDotnet framework 3.5 Free Download,Dotnet framework 3.5 Software Collection Download. ... A software component that can be added to Microsoft Windows. It is an new version of Microsoft's .Net Framework and you can get complete collection of .Net Framework versions from the below link.

CLICK THIS LINK TO DOWNLOAD complete collection .Net Framework Softwares.
www.brothersoft.com/downloads/dotnet-framework-3.5.html - 18k

Windows Workflow Foundation in .NET 3.0

Introduction:
Workflow is an arrangement of work. And the way we express that is through activities, which are really fundamentally units of work, that's the building block for workflows. The first thing that Windows Workflow Foundation provides is a framework for building those activities. Out of the box a number shipped with Windows Workflow Foundation but a very important part is building activities.

WF is part of the Microsoft's new programming model .NET Framework 3.0. It enables business processes to be expressed graphically and linked directly to business logic. With WF, workflows can be expressed in either:

* Declarative XAML.
* Imperative code using any .NET targeted language.
* Developed visually through Visual Studio Designer.

The WF programming model is made up of a number of exposed APIs that are encapsulated in the Microsoft .NET Framework 3.0 namespace called System.Workflow

Workflow and its types:
In the business world, workflow is simply a business process (independent of technology) necessary to complete a task. There can be various steps involved in any business process that can be either optional or required. So simply put, "workflow" is just the flow of work.

If we add more to it, "flow of work" can be either in a sequential manner (i.e. steps are performed one after another), or there could be several points in the flow where some decisions need to be made. Since a flow cannot move from one point to another without some criteria being met, we have a state-based workflow.

Thus, we can simply say there are two types of workflow:
*Sequential
*State Machine

A state-based workflow waits on external entities to perform some action before moving on to the next step. On the other hand, a sequential workflow is just a continuous flow of operations, which might include branching, but steps in the sequential workflow don't wait for an external entity to perform the operation, and then continue.

Trends in workflow today:
First I think it is important to point out that workflow is an overloaded term it means a lot of different things to a lot of different people. Even within a development community it means a number of different things, anywhere from the rudimentary logic that you put into your program, all the way up to a full-featured business process management or a BPM solution, everything in the middle. The problem that we are trying to solve with Windows Workflow Foundation is to provide an engine upon which to build workflow-enabled applications. That are not a lot of trends around that level, we are targeting down at the framework level, targeting developers to bring to the development tool kit a workflow engine. Up in the BPM space there are all sorts of trends, in the EAI space, ESB, all these are different technologies, buzz words, which involve workflow.

Summary:
Workflow Foundation is a new workflow engine from Microsoft. Microsoft is embedding Workflow Foundation in many of its products like Office 2007, Windows Vista and soon Biztalk itself. Matt Winkler, Microsoft Technical Evangelist, walks through the story of Workflow Foundation, when to use it and the futures planned in the next version.

Features of .NET Framework 3.0

.Net Framework 3.0

.NET Framework version 3.0 is Microsoft’s managed-code programming model for developing software on the Windows platform. It builds on .NET Framework 2.0, combining the power of the existing Framework 2.0 application programming interfaces with new technologies for building applications that provide visually stunning user experiences, seamless interoperable communications, and the ability to model a range of business processes. .NET Framework 3.0 includes Windows Presentation Foundation, Windows Communication Foundation, Windows Workflow Foundation, and Windows CardSpace technologies. It provides a consistent and familiar development experience, bringing new technology to the millions of developers programming in managed code today.

Windows Presentation Foundation

The Microsoft Windows Presentation Foundation provides the foundation for building applications and high fidelity experiences in Windows Vista, blending together application UI, documents, and media content, while exploiting the full power of your computer.

Windows Communication Foundation (WCF)

Windows Communication Foundation is a set of .NET technologies for building and running connected systems. It is a new breed of communications infrastructure built around the Web services architecture.

Windows Workflow Foundation (WF)

Windows Workflow Foundation is the programming model, engine and tools for quickly building workflow enabled applications on Windows. It consists of .NET classes, an in-process workflow engine, and designers for Visual Studio.

Windows CardSpace

Windows CardSpace is a Microsoft .NET Framework version 3.0 component that provides the consistent user experience required by the identity metasystem. It is specifically hardened against tampering and spoofing to protect the end user's digital identities and maintain end-user control.

Windows Forms

Microsoft Windows Forms is the core development platform for building smart client applications. The Windows Forms classes contained in the .NET Framework are designed to be used for GUI development.

ADO.NET

ADO.NET provides consistent access to data sources such as Microsoft SQL Server, as well as data sources exposed through OLE DB and XML. Data-sharing consumer applications can use ADO.NET to connect to these data sources and retrieve, manipulate, and update data.

ASP.NET

Microsoft ASP.NET is a set of Web application development technologies that enables programmers to build dynamic Web sites, web applications, and XML Web services.

.NET Compact Framework

The Microsoft .NET Compact Framework is a key part of realizing Microsoft's goal to provide customers with great experiences - any time, any place, and on any device.