Microsoft .NET Framework 3.5

ASP.NET raises all of the following events (in this order):

2010-02-04T02:01:00.002-08:00

Page.Init
• Page.Load
• TextBox.TextChanged
• Button.Click
• Page.PreRender
• Page.Unload

The following list shows the major stages in the process flow of an ASP.NET page:

2010-02-04T02:01:00.001-08:00

• Page framework initialization
• User code initialization
• Validation
• Event handling
• Automatic data binding
• Cleanup

View State Chunking

2010-02-04T01:58:00.000-08:00

The size of the hidden view state field has no limit. However, some proxy servers and firewalls refuse to let pages through if they have hidden fields greater than a certain size. To circumvent this problem, you can use view state chunking, which automatically divides view state into multiple fields to ensure that no hidden field exceeds a size threshold you set.
To use view state, you simply need to set the maxPageStateFieldLength attribute of the
element in the web.config file. This specifies the maximum view state size, in bytes. Here’s an example
that caps view state at 1 KB:

When you request a page that generates a view state larger than this, several hidden input fields will be created:

Remember, view state chunking is simply a mechanism for avoiding problems with certain
proxies (which is a relatively rare occurrence). View state chunking does not improve performance (and adds a small amount of extra serialization overhead). As a matter of good design, you should strive to include as little information in view state as possible, which ensures the best performance.

ASP..NET Page Processing

2010-02-04T01:56:00.000-08:00

One of the key goals of ASP.NET is to create a model that lets web developers rapidly develop web forms in the same way that Windows developers can build made-to-measure windows in a desktop application. Of course, web applications are very different from traditional rich client applications.

There are two key stumbling blocks:

Web applications execute on the server: For example, suppose you create a form that allows the user to select a product record and update its information. The user performs these tasks in the browser, but in order for you to perform the required operations (such as updating the database), your code needs to run on the web server. ASP.NET handles this divide with a technique called postback, which sends the page (and all user-supplied information) to the server when certain actions are performed. Once ASP.NET receives the page, it can then fire the corresponding server-side events to notify your code.

Web applications are stateless: In other words, before the rendered HTML page is sent to the
user, your web-page objects are destroyed and all client-specific information is discarded. This model lends itself well to highly scalable, heavily trafficked applications, but it makes it difficult to create a seamless user experience. ASP.NET includes several tools to help you bridge this gap; most notable is a persistence mechanism called view state, which automatically embeds information about the page in a hidden field in the rendered HTML.
In the following sections, you’ll learn about both the postback and the view state features.

Together, these mechanisms help abstract the underlying HTML and HTTP details, allowing developers to work in terms of objects and events.

Core Assemblies for ASP.NET Pages Description

2010-02-04T01:51:00.000-08:00

mscorlib.dll and System.dll Includes the core set of .NET data types, common exception
types, and numerous other fundamental building blocks.

System.Configuration.dll Includes classes for reading and writing configuration informationin the web.config file, including your custom settings.

System.Data.dll Includes the data container classes for ADO.NET, along with the SQL Server data provider.

System.Drawing.dll Includes classes representing colors, fonts, and shapes. Also includes the GDI+ drawing logic you need to build graphics on the fly.

System.Web.dll Includes the core ASP.NET classes, including classes for building web forms, managing state, handling security, and much more.

System.Web.Services.dll Includes classes for building web services—units of code that can be remotely invoked over HTTP.

System.Xml.dll Includes .NET classes for reading, writing, searching, transforming, and validating XML.

System.EnterpriseServices.dll Includes .NET classes for COM+ services such as transactions.

System.Web.Mobile.dll Includes .NET classes for the mobile web controls, which are
targeted for small devices such as web-enabled cell phones.

ASP.NET File Types Description

2010-02-04T01:49:00.000-08:00

Ends with .aspx These are ASP.NET web pages (the .NET equivalent of the .asp file in
an ASP application). They contain the user interface and, optionally, the underlying application code. Users request or navigate directly to one of these pages to start your web application.

Ends with .ascx These are ASP.NET user controls. User controls are similar to web pages, except that they can’t be accessed directly. Instead, they must be hosted inside an ASP.NET web page. User controls allow you to develop an important piece of the user interface and reuse it in as many web forms as you want without repetitive code.

Ends with .asmx or .svc These are ASP.NET web services. Web services work differently than web pages, but they still share the same application resources, configuration settings, and memory. However, ASP.NET web services are gradually being phased out in favor of WCF (Windows Communication Foundation) services, which were introduced with .NET 3.0 and have the extension .svc. You’ll use web services with ASP.NET AJAX

web.config This is the XML-based configuration file for your ASP.NET application. It includes settings for customizing security, state management, memory management, and much more.

global.asax This is the global application file. You can use this file to define global variables and react to global events, such as when a web application first starts (see Chapter 5 for a detailed discussion). Visual Studio doesn’t create a global.asax file by default—you need to add it if it’s appropriate.

Ends with .cs These are code-behind files that contain C# code. They allow you to separate the application from the user interface of a web page.

NEW FEATURES IN VISUAL STUDIO 2008

2010-02-04T01:47:00.000-08:00

The latest version of Visual Studio has some long-awaited improvements. They include the following:
• Web projects: Visual Studio 2005 replaced the traditional project-based web application model with a lighterweight
system of projectless development. However, this change didn’t please everyone, and so Microsoft released an add-on that brought the web project option back. In Visual Studio 2008, developers get the best of both worlds, and can choose to create projectless or project-based web applications depending on their needs.

• Multitargeting: Web servers won’t shift overnight from .NET 2.0 to .NET 3.5. With this in mind, Visual Studio now gives you the flexibility to develop applications that target any version of the .NET Framework, from version 2.0 on.

• CSS: In order to apply consistent formatting over an entire website, developers often use the Cascading Style Sheets (CSS) standard. Now Visual Studio makes it even easier to link web pages to style sheets, and pick and choose the styles you want to apply to various elements in your page without editing the markup by hand.

HTML CONTROLS VS. WEB CONTROLS

2010-02-04T01:43:00.000-08:00

When ASP.NET was first created, two schools of thought existed. Some ASP.NET developers were most interested in server-side controls that matched the existing set of HTML Controls exactly. This approach allows you to create ASP.NET web-page interfaces in edicated HTML editors, and it provides a quick migration path for existing ASP pages. However, another set of ASP.NET developers saw the promise of something more—rich server-side controls that didn’t just emulate individual HTML tags. These controls might render their interface from dozens of distinct HTML elements while still providing a simple object-based interface to the programmer. Using this model, developers could work with programmable menus, calendars, data lists, validators, and so on.

After some deliberation, Microsoft decided to provide both models. You’ve already seen an example of HTML server controls, which map directly to the basic set of HTML tags. Along with these are ASP.NET web controls, which provide a higher level of abstraction and more functionality. In most cases, you’ll use HTML server-side controls for backward compatibility and quick migration, and use web controls for new projects.
ASP.NET web control tags always start with the prefix asp: followed by the class name. For example, the following
snippet creates a text box and a check box:

Again, you can interact with these controls in your code, as follows:
myASPText.Text = "New text";
myASPCheck.Text = "Check me!";
Notice that the Value property you saw with the HTML control has been replaced with a Text property. The Html InputText.Value property was named to match the underlying value attribute in the HTML tag. However, web controls don’t place the same emphasis on correlating with HTML syntax, so the more descriptive property
name Text is used instead.

The ASP.NET family of web controls includes complex rendered controls (such as the Calendar and TreeView), along with more streamlined controls (such as TextBox, Label, and Button), which map closely to existing HTML tags.

In the latter case, the HTML server-side control and the ASP.NET web control variants provide similar functionality, although the web controls tend to expose a more standardized, streamlined interface. This makes the web controls easy to learn, and it also means they’re a natural fit for Windows developers moving to the world of the Web, because many of the property names are similar to the corresponding Windows controls.

C# Contextual Keywords Descriptions

2010-02-04T01:34:00.000-08:00

from Used in a LINQ query. A query expression must begin with a from clause.

get Defines an accessor method in a property or indexer. It retrieves the value of the property or indexer element.

group Used in a LINQ query and returns a sequence of IGrouping < (Of < (TKey,TElement > ) > ) objects that contain zero or more items that match the key value for the group.

into Used in a LINQ query and can be used to create a temporary identifier to store the results of a group , join , or select clause into a new identifier.

join Used in a LINQ query for associating elements from different sources.

let Used in a LINQ query to store the result of a subexpression to be used in a subsequent clause.

orderby Used in a LINQ query to sort the result of a query in either ascending or descending order.

C# Keyword Description

2010-02-04T01:18:00.000-08:00

abstract A modifier that can be used with classes, methods, properties, indexers, andevents. Use it to indicate that a class is intended to be used as a base class of other classes, and abstract methods must be implemented by classes that derive from the abstract class.

as An operator that performs conversion between compatible reference types.

base Used to access members of a base class from a derived class.

bool A C# alias of the System.Boolean .NET Framework type. Its value can either true, false, or null.

break Used to transfer control out of a loop or switch statement.

byte Specifies a data type that can stores unsigned 8 - bit integer values from 0 to 255.
case Used together with the switch statement. It specifies the value to be matched so that control can be transferred to the case statement. catch Used with a try block to handle one or more exceptions.

char Specifies a data type that can store a 16 - bit Unicode character from U+0000 to U+ffff.

checked Used to explicitly enable overflow - checking integer operations.

class Used to declare classes.

const Used to specify a field or variable whose value cannot be modified.

continue Used within a loop such that control is transferred to the next iteration.

decimal Specifies a data type representing a 128 - bit data. It can approximately
represent a number from ± 1.0 – 28 to ± 7.9 1028.

default Used within a switch statement to indicate the default match if none of the other case statements is matched. Can also be used in generics to specify the default value of the type parameter.

delegate Used to declare a reference type variable that references a method name/
anonymous method.

do Executes a block of code repeatedly until a specified expression returns false.Used together with the while keyword to form a do - while statement.

double Specifies a data type that represents a 64 - bit floating point number. It can approximately represent a number from ± 5.0 10 – 324 to ± 1.7 10308.else Used with the if keyword to form an if - else statement. else defines theblock that will be executed if the expression specified in the if statement is evaluated to false.

enum Used to define an enumeration.

event Used to define an event within a class.

explicit Defines a cast operation that requires the programmer to explicitly select the
cast to be performed.

extern Declares a method that is implemented externally.false Used as either an operator or as a literal. One of the possible values in a boolvariable.

finally Used in a try - catch block to contain code that cleans up the code even if an exception occurs. Statements contained within a finally block are always executed.

fixed Prevents the garbage collector from relocating a movable variable.

float Specifies a data type that represents a 32 - bit floating point number. It can approximately represent a number from ± 1.5 10 – 45 to ± 3.4 1038. for Encloses a block of statements that will be executed repeatedly until a specified expression returns false.

foreach Used to iterate through a collection of items.

goto Used to transfer control of a program to a labeled statement. if Determines if a statement (or block of statements) is to be executed based on the result of a Boolean expression.

implicit Used to declare an implicit cast operation.

in Used in a foreach statement to specify the collection you want to iterate through.

int Specifies a data type that represents a signed 32 - bit integer number. It canrepresent a number from – 2,147,483,648 to 2,147,483,647.

interface Used to define an interface, which is a definition that contains the signatures of methods, delegates, and events. An interface does not contain any implementation.

internal An access modifier to indicate a member that can only be accessed within files in the same assembly.

is Used to check if an object is compatible with a given type.

lock Marks a statement block as a critical section so that other threads cannot execute the block while the statements within the block are being executed. long Specifies a data type that represents a signed 64 - bit integer number. It can represent a number from – 9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

namespace Used to organize your code so that it belongs to a globally unique type. new Used to create objects and invoke a class ’ s constructor. Also can be used to explicitly hide a base class ’ s member in a derived class. When used in a generic declaration, it restricts types that might be used as arguments for a type declaration.

null Represents a null reference that does not refer to any object.

object A C# alias of the System.Object .NET Framework type.

operator Used to overload a built - in operator or provide a conversion operator.

out Indicates arguments that are to be passed by reference. It is similar to ref ,except that ref requires the variable to be initialized before it is passed.

override Extends or modifies the abstract or virtual implementation of an inherited
method, property, indexer, or event.

params Specifies a parameter array where the number of arguments is variable.

private An access modifier used to indicate a member that can only be accessed within the body of the class or struct in which it ’ s declared.

protected An access modifier used to indicate a member that can only be accessed within its class and derived classes.

public An access modifier used to indicate a member that can be accessed by all code.

readonly A modifier that indicates fields that can only be initialized at declaration or in a constructor.

ref Indicates arguments that are to be passed by reference.

return Terminates execution of a method and returns control to the calling method.

sbyte Specifies a data type that represents a signed 8 - bit integer number. It can represent a number from – 128 to 127.

sealed Specifies a class that does not allow other classes to derive from it.

short Specifies a data type that represents a signed 16 - bit integer number. It can represent a number from – 32,768 to 32767.

sizeof Used to obtain the size in bytes for a value type.

stackalloc Used in an unsafe code context to allocate a block of memory on the stack.

static A modifier to indicate that a member belongs to the type itself, and not to a specific object.

string Specifies a data type that represents a sequence of zero or more Unicode characters. Also an alias for the System.String .NET Framework type.

struct Denotes a value type that encapsulates a group of related variables.

switch A control statement that handles multiple selections by matching the value of the switch with a series of case statements.

this Refers to the current instance of the class. Also used as a modifier of the firstparameter of an extension method.

throw Used to invoke an exception during runtime.

true Used either as an operator or as a literal. One of the possible values in a bool variable.

try Indicates a block of code that may cause exceptions. Used with one or more catch blocks to handle the exceptions raised.

typeof Used to obtain the System.Type object for a type.

uint Specifies a data type that represents an unsigned 32 - bit integer number. It can represent a number from 0 to 4,294,967,295.

ulong Specifies a data type that represents an unsigned 64 - bit integer number. It can represent a number from 0 to 18,446,744,073,709,551,615.

unchecked Used to suppress overflow - checking for integral - type arithmetic operations and conversions.

unsafe Denotes an unsafe context, which is required for any operation involving pointers.

ushort Specifies a data type that represents an unsigned 16 - bit integer number. I can represent a number from 0 to 65,535.

using A directive for creating a namespace alias or importing namespace references.It is also used for defining a scope at the end of which an object will be disposed.

virtual An access modifier to indicate a method, property, indexer, or event declaration and allow for it to be overridden in a derived class.

volatile Indicates that a field might be modified by multiple threads that are executing at the same time.

void Specifies that a method does not return any value.

while Executes a statement or a block of statements until a specified expression evaluates to false.

Keywords C#

2010-02-04T01:13:00.000-08:00

Keywords In any programming language, there is always a list of identifiers that have special meanings to the compiler. These identifiers are known as keywords, and you should not use them as identifiers in your program.

abstract event new struct as explicit null switch base extern object this bool false operator throw break finally out true byte fixed override try case float params typeof catch for private uint char foreach protected ulong checked goto public unchecked class if readonly unsafe const implicit ref ushort continue in return using decimal int sbyte virtual default interface sealed volatile delegate internal short void do is sizeof while double lock stackalloc else long staticenum namespace string

Using the C# Compiler (csc.exe)

2010-02-04T01:10:00.000-08:00

Besides using Visual Studio 2008 to compile and run the application, you can build the application using Visual Studio 2008 and use the C# compiler ( csc.exe ) to manually compile and then run the application. This option is useful for large projects where you have a group of programmers working on different sections of the application.

Alternatively, if you prefer to code a C# program using a text editor, you can use the Notepad (Programs Accessories Notepad) application included in every Windows computer. (Be aware, however, that using Notepad does not give you access to the IntelliSense feature, which is available only in Visual Studio 2008.)

1. Using Notepad, create a text file, name it HelloWorld.cs , and save it into a folder on your hard disk, say in C:\C#.

2. Populate HelloWorld.cs with the following:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(“Hello, world! This is my first C# program!”);
Console.ReadLine();
return;
}
}
}

Use the command - line C# compiler ( csc.exe ) that ships with Visual Studio 2008 to compile the program. The easiest way to invoke csc.exe is to use the Visual Studio 2008 command prompt, which has all the path references added for you.

To launch the Visual Studio 2008 command prompt, select Start Programs Microsoft Visual
Studio 2008 Visual Studio Tools Visual Studio 2008 Command Prompt.

In the command prompt, change to the directory containing the C# program (C:\C# for this
example), and type the following command
C:\C# > csc HelloWorld.cs

Once the program is compiled, you will find the HelloWorld.exe executable in the same directory (C:\C#). Type the following to execute the application.
C:\C# > HelloWorld

To return to the command prompt, press Enter.

.NET Framework 3.5 builds upon version 2.0 and 3.0

2010-02-04T01:09:00.000-08:00

The .NET Framework 3.5 builds upon version 2.0 and 3.0 of the .NET Framework, so it essentially contains the following components:

.NET Framework 2.0 and .NET Framework 2.0 Service Pack 1
.NET Framework 3.0 and .NET Framework 3.0 Service Pack 1
New features in .NET 3.5

Versions of the . NET Framework and Visual Studio

2010-02-04T01:07:00.000-08:00

Microsoft officially released the .NET Framework in January 2002. Since then, the .NET Framework has gone through a few iterations, and at the time of writing it stands at version 3.5. While technically you can write .NET applications using a text editor and a compiler, it is always easier to write .NET applications using Visual Studio, the integrated development environment from Microsoft. With Visual Studio, you can use its built - in debugger and support for IntelliSense to effectively and efficiently build .NET applications. The latest version of Visual Studio is Visual Studio 2008.
The following table shows the various versions of the .NET Framework, their release dates, and theversions of Visual Studio that contain them.
Version Number -Release Date-Versions of Visual Studio
1.0 1.0.3705.0 2002 - 01 - 05 Visual Studio .NET 2002
1.1 1.1.4322.573 2003 - 04 - 01 Visual Studio .NET 2003
2.0 2.0.50727.42 2005 - 11 - 07 Visual Studio 2005
3.0 3.0.4506.30 2006 - 11 - 06 Shipped with Windows Vista
3.5 3.5.21022.8 2007 - 11 - 19 Visual Studio 2008

Starting with Visual Studio 2005, Microsoft dropped the .Net name from the Visual Studio.

Assemblies and the Microsoft Intermediate Language ( MSIL )

2010-02-04T01:05:00.000-08:00

In .NET, an application compiled into MSIL bytecode is stored in an assembly. The assembly is contained in one or more PE (portable executable) files and may end with an EXE or DLL extension.

Some of the information contained in an assembly includes:
Manifest — Information about the assembly, such as identification, name, version, and so on.
Versioning — The version number of an assembly.
Metadata — Information that describes the types and methods of the assembly .

To get a better idea of a MSIL file and its content, take a look at the following example, which has two console applications — one written in C# and the other written in VB.NET.
The following C# code displays the “ Hello, World ” string in the console window:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HelloWorldCS
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(“Hello, World!”);
Console.ReadLine();
}
}
}

Likewise, the following VB.NET code displays the “ Hello, World ” string in the console window:

Module Module1
Sub Main()
Console.WriteLine(“Hello, World!”)
Console.ReadLine()
End Sub
End Module

When both programs are compiled, the assembly for each program has an .exe extension. To view the content of each assembly, you can use the ildasm (MSIL Disassembler) tool.
Launch the ildasm tool from the Visual Studio 2008 Command Prompt window (Start Programs Microsoft Visual Studio 2008 Visual Studio Tools Visual Studio 2008 Command Prompt).

The following command uses the ildasm tool to view the assemblies for the C# and VB.NET programs:

C:\MSIL > ildasm HelloWorldCS.exe
C:\MSIL > ildasm HelloWorldVB.exe

. NET Framework Class Library

2010-02-04T01:04:00.000-08:00

The .NET Framework class library contains classes that allow you to develop the following types of applications:

Console applications
Windows applications
Windows services
ASP.NET Web applications
Web Services
Windows Communication Foundation (WCF) applications
Windows Presentation Foundation (WPF) applications
Windows Workflow Foundation (WF) applications

Common Language Runtime

2010-02-04T01:02:00.000-08:00

The Common Language Runtime (CLR) is the virtual machine in the .NET Framework. It sits on top of the Windows operating system (Windows XP, Windows Vista, Windows Server 2008, and so on). A .NET application is compiled into a bytecode format known as MSIL

(Microsoft Intermediate Language). During execution, the CLR JIT ( just - in - time)

compiles the bytecode into the processor ’ s native code and executes the application. Alternatively, MSIL code can be precompiled into native code so that JIT compiling is no longer needed; that speeds up the execution time of your application.

The CLR also provides the following services:
Memory management/garbage collection
Thread management
Exception handling
Security

.NET developers write applications using a .NET language such as C#, VB.NET, or C++. The MSIL bytecode allows .NET applications to be portable (at least theoretically) to other platforms because the application is compiled to native code only during runtime.

What’s the . NET Framework?

2010-02-04T00:57:00.000-08:00

The .NET Framework has two components:

Common Language Runtime
.NET Framework class library

The Common Language Runtime (CLR) is the agent that manages your .NET applications at execution time. It provides core services such as memory, thread, and resource management.

Applications that run on top of the CLR are known as managed code ; all others are known as unmanaged code.

The .NET Framework class library is a comprehensive set of reusable classes that provides all the functionalities your application needs. This library enables you to develop applications ranging from desktop Windows applications to ASP.NET web applications, and Windows Mobile applications that run on Pocket PCs.

Are arrays supported in the Soap Toolkit?

2009-09-24T22:22:00.001-07:00

One-dimensional arrays of simple types, arrays of complex types and multi-dimensional arrays are supported in the Soap Toolkit. Several improvements and fixes to array handling are included in the next service pack.

Describe WSML

2009-09-24T22:21:00.000-07:00

WSML is best described as the Soap Toolkit configuration file. It contains the information required to map the Soap message described by a WSDL file to a COM interface. This includes the standard COM'isms like ProgID's and DispID's. WSML will never be a standard because it makes sense only to the Soap Toolkit.

How do I run the Soap trace utility using MSSOAPT?

2009-09-24T22:19:00.000-07:00

* To trace on the server using MSSOAPT:

1. Modify the location attribute of the soap:address element in the WSDL to direct clients to port 8080. For example, if the WSDL contains , change it to .

2. Run MSSOAPT on the server.

3. Choose File, New, Formatted Trace (if you don't need to see HTTP headers) or File, New Unformatted Trace (if do want to see HTTP headers like ContentType and SoapAction).

4. Click OK on the Trace Setup dialog to accept the default values.

Note:- Now all requests/responses to/from the address specified in the WSDL willshow up in the trace.

* To trace on the client using MSSOAPT:

1. Make a local copy of the service's WSDL document.

2. Modify the location attribute of the soap:address element in the WSDL to direct the client to localhost:8080 and make a note of the current host and port. For example, if the WSDL contains , change it to and make note of "MyServer".

3. Run MSSOAPT on the client.

4. Choose File, New, Formatted Trace (if you don't need to see HTTP headers) or File, New Unformatted Trace (if do want to see HTTP headers).

5. In the Trace Setup dialog, enter the host and port noted in step 2 as the destination host and destination port values, then click OK.

Now, any request/response sent from/to the client will show up in the trace.

latest Soap Toolkit Version

2009-09-24T22:18:00.000-07:00

Version 2.0 SP2, released June 21, 2001

What is Sensor Devices?

2009-09-24T22:14:00.000-07:00

Sensors come in many configurations and, from a certain perspective, almost anything that provides data about physical phenomena can be called a sensor. Although we typically think of sensors as hardware devices, logical sensors can also provide information through emulation of sensor functionality in software or firmware. Also, a single hardware device can contain multiple sensors.

The sensor and location platform organizes sensors into categories, which represent broad classes of sensor devices, and types, which represent specific kinds of sensors. For example, a sensor in a video game controller that detects the position and movement of a player's hand (perhaps for a video bowling game) would be categorized as an Orientation sensor, but its type would be 3-D Accelerometer. In code, Windows represents categories and types by using globally unique identifiers (GUIDs), many of which are predefined. Device manufacturers can create new categories and types by defining and publishing new GUIDs when required.

Location devices make up one especially interesting category. By now, most people are familiar with global positioning systems (GPS). In Windows, a GPS is a sensor in the Location category. The Location category also includes other sensor types. Some of these sensor types are software based, such as an IP resolver that provides location information based on an Internet address, a mobile phone tower triangulator that determines location based on nearby towers, or static providers, such as a Wi-Fi network location provider that reads location information from the connected wireless network hub.

What's New in Office 2003 for Developers?

2009-09-24T22:12:00.000-07:00

Just because the Office 2003 Visual Basic Editor and the VBA language remain, for the most part, unchanged from their Office XP counterparts, this doesn't mean that there will be no Office 2003 developer innovation. Far from it! Office 2003 provides lots of improvements over Office XP solution development, including:

*Expanded XML support in Word 2003 and Excel 2003, including object model programmability and the use of customer-defined XML schemas.
*A new Office 2003 solutions model called smart documents.
*"Visual Studio Tools for Office."
*Significant smart tag enhancements.
*List technology.
*Office 2003 object model additions.
*A new business-form oriented product code-named Microsoft "XDocs," which includes a programmable object model.

Working with Tables and Lists in Excel

2009-09-24T22:09:00.000-07:00

Tables and lists are excellent for organizing related data neatly into rows and columns. This makes the data easy to read, concise, and easy to filter. There are a number of benefits to putting your data into tables:

You can filter the data even if there are empty rows or columns.
Clicking into the table displays the filter arrows in the header row which give you options to sort and filter the data.
When you scroll past the column headers, the headers at the top of screen automatically switch to display the header names.
If you add a row after the last row or a column to the left of the last column in the table, the table expands to encapsulate the new row or column.
Charts or PivotTable dynamic views based on a table automatic update if the table size changes.
If you enter a formula in the first cell of the table row, the formula automatically fills down the entire column.
If you edit a formula in one field, all formulas in that row/column update automatically.

Microsoft code name "Oslo" Modeling Technologies

2009-09-24T22:08:00.000-07:00

"Oslo" is the code name for a set of future Microsoft modeling technologies that provide significant productivity gains across the lifecycle of .NET applications by enabling developers, architects, and IT professionals to work together more effectively.

More Details

Feature Highlights - .NET diffrent version (2.0/2.0SP1/2.0SP2/3.0/3.0SP1/3/5/3.5SP1)

2009-09-24T22:03:00.000-07:00

NET Framework Version

Reports

Feature Highlights

3.5 SP1

3.0 SP2

2.0 SP2

Changes in 3.5 SP1

API Differences - 3.5 to 3.5 SP1:
- Summary
- by Namespace
- by Assembly

Note that the .NET Framework 2.0 SP2 and 3.0 SP2 service packs are installed by installing the .NET Framework 3.5 SP1. They provide functionality for future infrastructure.

Documentation: .NET Framework Class Library Version 3.5

Provides performance improvements for the common language runtime (CLR), Windows Presentation Foundation (WPF), and Windows Communication Foundation (WCF). This version also provides the following new features:

The .NET Framework Client Profile, which is a subset of the full .NET Framework that targets client applications.
Garbage collection notifications.
Customized branding for ClickOnce applications.
An expanded ADO.NET data platform.

3.5

3.0 SP1

2.0 SP1

Obsolete in 3.5

Documentation: .NET Framework Class Library Version 3.5

Provides several CLR performance improvements and introduces the following technologies:

Language Integrated Query (LINQ).
Add-ins and extensibility.
Garbage collection latency modes.
Interprocess communication with pipes.
Reflection emit in partial trust.
Cryptography Suite B support.
New compilers for C#, Visual Basic, and C++.
Improved support for the development of AJAX-enabled Web sites.

3.0

Documentation: .NET Framework Class Library Version 3.0

Adds the following technologies to the .NET Framework:

Windows Presentation Foundation (WPF).
Windows Communication Foundation (WCF).
Window Workflow Foundation (WF).

No new features were added to the common language runtime and base class libraries in the .NET Framework 3.0.

2.0

Obsolete in 2.0

Breaking Changes in 2.0

Documentation: .NET Framework Class Library Version 2.0

Provides the core architecture for versions 2.0, 3.0, and 3.5.

Extends the version 1.0 and 1.1 functionality of the CLR and base class libraries in the following areas:

Support for generic types and methods.
New compilers for C#, Visual Basic, C++, and J#.
ADO.NET.
ASP.NET.
Windows Forms.
Web services.

LINQ Query : How to Join in LINQ (with example)

2009-09-23T02:21:00.000-07:00

Join operations create associations between sequences that are not explicitly modeled in the data sources. For example you can perform a join to find all the customers in London who order products from suppliers who are in Paris. In LINQ the join clause always works against object collections instead of database tables directly. In LINQ you do not have to use join as often as you do in SQL because foreign keys in LINQ are represented in the object model as properties that hold a collection of items. For example, a Customer object contains a collection of Order objects. Rather than performing a join, you access the orders by using dot notation:

from order in Customer.Orders...

LINQ Query : How to group in LINQ Query (with example)

2009-09-23T02:19:00.000-07:00

The group clause enables you to group your results based on a key that you specify. For example you could specify that the results should be grouped by the City so that all customers from London or Paris are in individual groups. In this case, cust.City is the key.

// queryCustomersByCity is an IEnumerableIGrouping>
var queryCustomersByCity =
from cust in customers
group cust by cust.City;

// customerGroup is an IGrouping
foreach (var customerGroup in queryCustomersByCity)
{
Console.WriteLine(customerGroup.Key);
foreach (Customer customer in customerGroup)
{
Console.WriteLine(" {0}", customer.Name);
}
}

When you end a query with a group clause, your results take the form of a list of lists. Each element in the list is an object that has a Key member and a list of elements that are grouped under that key. When you iterate over a query that produces a sequence of groups, you must use a nested foreach loop. The outer loop iterates over each group, and the inner loop iterates over each group's members.

If you must refer to the results of a group operation, you can use the into keyword to create an identifier that can be queried further. The following query returns only those groups that contain more than two customers:

// custQuery is an IEnumerableIGrouping>
var custQuery =
from cust in customers
group cust by cust.City into custGroup
where custGroup.Count() > 2
orderby custGroup.Key
select custGroup;

LINQ Query : How to order/sort in LINQ (with example)

2009-09-23T02:18:00.000-07:00

Often it is convenient to sort the returned data. The orderby clause will cause the elements in the returned sequence to be sorted according to the default comparer for the type being sorted. For example, the following query can be extended to sort the results based on the Name property. Because Name is a string, the default comparer performs an alphabetical sort from A to Z.

var queryLondonCustomers3 =
from cust in customers
where cust.City == "London"
orderby cust.Name ascending
select cust;

LINQ Query : Filtering / Where

2009-09-23T02:17:00.000-07:00

Probably the most common query operation is to apply a filter in the form of a Boolean expression. The filter causes the query to return only those elements for which the expression is true. The result is produced by using the where clause. The filter in effect specifies which elements to exclude from the source sequence. In the following example, only those customers who have an address in London are returned.

var queryLondonCustomers = from cust in customers
where cust.City == "London"
select cust;

You can use the familiar C# logical AND and OR operators to apply as many filter expressions as necessary in the where clause. For example, to return only customers from "London" AND whose name is "Devon" you would write the following code:

where cust.City=="London" && cust.Name == "Devon"

To return customers from London or Paris, you would write the following code:

where cust.City == "London" || cust.City == "Paris"

LINQ query :Obtaining a Data Source

2009-09-23T02:16:00.000-07:00

In a LINQ query, the first step is to specify the data source. In C# as in most programming languages a variable must be declared before it can be used. In a LINQ query, the from clause comes first in order to introduce the data source (customers) and the range variable (cust).

//queryAllCustomers is an IEnumerable
var queryAllCustomers = from cust in customers
select cust

LINQ :Performing Operations on Source Elements

2009-09-23T02:15:00.002-07:00

An output sequence might not contain any elements or element properties from the source sequence. The output might instead be a sequence of values that is computed by using the source elements as input arguments. The following simple query, when it is executed, outputs a sequence of strings whose values represent a calculation based on the source sequence of elements of type double.

LINQ Queries : Transforming in-Memory Objects into XML

2009-09-23T02:15:00.001-07:00

LINQ queries make it easy to transform data between in-memory data structures, SQL databases, ADO.NET Datasets and XML streams or documents. The following example transforms objects in an in-memory data structure into XML elements.

class XMLTransform
{
static void Main()
{
// Create the data source by using a collection initializer.
List students = new List()
{
new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores = new List{97, 92, 81, 60}},
new Student {First="Claire", Last="O’Donnell", ID=112, Scores = new List{75, 84, 91, 39}},
new Student {First="Sven", Last="Mortensen", ID=113, Scores = new List{88, 94, 65, 91}},
};

// Create the query.
var studentsToXML = new XElement("Root",
from student in students
let x = String.Format("{0},{1},{2},{3}", student.Scores[0],
student.Scores[1], student.Scores[2], student.Scores[3])
select new XElement("student",
new XElement("First", student.First),
new XElement("Last", student.Last),
new XElement("Scores", x)
) // end "student"
); // end "Root"

// Execute the query.
Console.WriteLine(studentsToXML);

// Keep the console open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}

The code produces the following XML output:

< Root>

Svetlana
Omelchenko
97,92,81,60

Claire
O'Donnell
75,84,91,39

Sven
Mortensen
88,94,65,91

LINQ Query with Example :Selecting a Subset of Each Source Element

2009-09-23T02:13:00.000-07:00

There are two primary ways to select a subset of each element in the source sequence:

1.To select just one member of the source element, use the dot operation. In the following example, assume that a Customer object contains several public properties including a string named City. When executed, this query will produce an output sequence of strings.

var query = from cust in Customers
select cust.City;

2. To create elements that contain more than one property from the source element, you can use an object initializer with either a named object or an anonymous type. The following example shows the use of an anonymous type to encapsulate two properties from each Customer element:

var query = from cust in Customer
select new {Name = cust.Name, City = cust.City};

LINQ:Joining Multiple Inputs into One Output Sequence

2009-09-23T02:12:00.000-07:00

You can use a LINQ query to create an output sequence that contains elements from more than one input sequence. The following example shows how to combine two in-memory data structures, but the same principles can be applied to combine data from XML or SQL or DataSet sources. Assume the following two class types:

class Student
{
public string First { get; set; }
public string Last {get; set;}
public int ID { get; set; }
public string Street { get; set; }
public string City { get; set; }
public List Scores;
}

class Teacher
{
public string First { get; set; }
public string Last { get; set; }
public int ID { get; set; }
public string City { get; set; }
}

The following example shows the query:

class DataTransformations
{
static void Main()
{
// Create the first data source.
List students = new List()
{
new Student {First="Svetlana",
Last="Omelchenko",
ID=111,
Street="123 Main Street",
City="Seattle",
Scores= new List {97, 92, 81, 60}},
new Student {First="Claire",
Last="O’Donnell",
ID=112,
Street="124 Main Street",
City="Redmond",
Scores= new List {75, 84, 91, 39}},
new Student {First="Sven",
Last="Mortensen",
ID=113,
Street="125 Main Street",
City="Lake City",
Scores= new List {88, 94, 65, 91}},
};

// Create the second data source.
List teachers = new List()
{
new Teacher {First="Ann", Last="Beebe", ID=945, City = "Seattle"},
new Teacher {First="Alex", Last="Robinson", ID=956, City = "Redmond"},
new Teacher {First="Michiyo", Last="Sato", ID=972, City = "Tacoma"}
};

// Create the query.
var peopleInSeattle = (from student in students
where student.City == "Seattle"
select student.Last)
.Concat(from teacher in teachers
where teacher.City == "Seattle"
select teacher.Last);

Console.WriteLine("The following students and teachers live in Seattle:");
// Execute the query.
foreach (var person in peopleInSeattle)
{
Console.WriteLine(person);
}

Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
The following students and teachers live in Seattle:
Omelchenko
Beebe
*/

Data Transformations with LINQ (C#)

2009-09-23T02:11:00.000-07:00

Language-Integrated Query (LINQ) is not only about retrieving data. It is also a powerful tool for transforming data. By using a LINQ query, you can use a source sequence as input and modify it in many ways to create a new output sequence. You can modify the sequence itself without modifying the elements themselves by sorting and grouping. But perhaps the most powerful feature of LINQ queries is the ability to create new types. This is accomplished in the select clause. For example, you can perform the following tasks:

* Merge multiple input sequences into a single output sequence that has a new type.
* Create output sequences whose elements consist of only one or several properties of each element in the source sequence.
* Create output sequences whose elements consist of the results of operations performed on the source data.
* Create output sequences in a different format. For example, you can transform data from SQL rows or text files into XML.

Type Relationships in LINQ Query Operations (C#)

2009-09-23T02:09:00.000-07:00

To write queries effectively, you should understand how types of the variables in a complete query operation all relate to each other. If you understand these relationships you will more easily comprehend the LINQ samples and code examples in the documentation. Furthermore, you will understand what occurs behind the scenes when variables are implicitly typed by using var.

LINQ query operations are strongly typed in the data source, in the query itself, and in the query execution. The type of the variables in the query must be compatible with the type of the elements in the data source and with the type of the iteration variable in the foreach statement. This strong typing guarantees that type errors are caught at compile time when they can be corrected before users encounter them.

IEnumerable variables in LINQ Queries

2009-09-23T02:05:00.000-07:00

LINQ query variables are typed as IEnumerable<(Of <(T>)>) or a derived type such as IQueryable<(Of <(T>)>). When you see a query variable that is typed as IEnumerable, it just means that the query, when it is executed, will produce a sequence of zero or more Customer objects.

IEnumerable customerQuery =
from cust in customers
where cust.City == "London"
select cust;

foreach (Customer customer in customerQuery)
{
Console.WriteLine(customer.LastName + ", " + customer.FirstName);
}

Language-Integrated Query (LINQ)

2009-09-23T02:02:00.000-07:00

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

Why Use Windows Communication Foundation/Feature of WCF?

2009-09-23T01:59:00.000-07:00

A distributed application built with Web services is a service-oriented application. ASP.NET Web Services (ASMX) has been available for building Web services since .NET was first released. Why then do you need Windows Communication Foundation? WCF provides a number of benefits over ASP.NET Web Services, including:

Support for sending messages using not only HTTP, but also TCP other network protocols.
The ability to switch message protocols with minimal effort.
Support for hosting services on hosts other than a Web server.
Built-in support for the latest Web services standards (SOAP 1.2 and WS-*) and the ability to easily support new ones.
Support for security, transactions and reliability.
Support for sending messages using formats other than SOAP, such as Representational State Transfer (REST).

WCF:Configuring Service Endpoints

2009-09-23T01:54:00.000-07:00

Hardcoding endpoint information into the host application is not ideal since endpoint details may change over time. It's not hard to imagine how you could store the endpoint information in a configuration file or database and read it while initializing ServiceHost. Since this is a common need, WCF automatically provides this functionality through the predefined configuration section.

The following configuration file defines the same two endpoints that were specified by calling AddServiceEndpoint:

Configuring Transport Security

...

How do developers target the Client Profile Preview?

2009-09-23T01:52:00.001-07:00

Visual Studio 2008 SP1 has the option to target the "Client-only Framework Subset". Visual Studio developers can view their project properties and view the Advanced Compiler Options. The options will allow users to target the framework their application will require (.NET Framework 2.0, 3.0 or 3.5). There will also be a check-box to target the "Client-only Framework Subset". This option will change the project in two subtle ways.

First, at compile time, the reference list of DLLs will be matched up against the known "Client List" of DLLs that are included in the Client Profile. If the project has a reference to an assembly that is not included, in the "Client List", the developer will see compile-time warnings/errors.
Second, the project will add a configuration file that will specifically declare the application as a "client" application. The configuration file will allow their application to run on a computer with just the Client Profile installed. Without the configuration file, the end-user will be prompted to install .NET Framework 3.5 SP1 or greater

How does the .NET Framework Client Profile Preview correlate to the full .NET Framework?

2009-09-23T00:56:00.000-07:00

The .NET Framework Client Profile Preview is a subset of the full .NET Framework 3.5 SP1. The Client Profile Preview subset does not contain any assemblies that are not found in the full framework. In addition, the deployment of the .NET Framework Client Profile Preview will also allow users to update their computers to the full .NET Framework 3.5 SP1. The .NET Framework 3.5 SP1 will be a critical update to .NET Framework 3.5, pushed out to users via Windows Update. On Windows Vista and later versions of Windows, the Client Profile Preview setup bootstrapper will install updates to the full framework as needed since those versions of Windows already have the full profile of the .NET Framework.

What is the .NET Framework Client Profile Preview?

2009-09-23T00:55:00.001-07:00

The .NET Framework Client Profile Preview is a new setup option for the .NET Framework available for the first time in 3.5 SP1. This new setup installer enables a faster, simpler installation experience for .NET Framework-based client applications on Windows XP and Windows Vista.

C# 3.0 Top New Features

2009-09-23T00:51:00.000-07:00

Implicitly Typed Local Variables

Local variables can be declared as type ‘var’ which means compiler to determine the actual type based on the data by which its is initialized.
var i = 10; // i is created of type int
var name = “MyName” ; // name is created of type string
can only be used when declared and initialized in same statement.
Cannot be initialized to null.
Cannot be used as class members.
Mostly used to store anonymous types as in LINQ based programming.

Object & Collection Initializers

Allow assigning values to any accessible members or properties of a type at the time of initiation without invoking the constructor with parameters.
The default constructor gets executed before assigning the values.
E.g. Coordinate c1 = new Coordinate {x=1 , y=2};
Used in LINQ query expressions along with anonymous types.
Collection Initializers use Object Initializers to specify multiple elements of collection without calling Add method multiple times.

Extension Methods

Allows adding new methods to existing types without modifying the existing type.
Are special kind of static methods but are called as if they are instance methods.
The first parameter passed to Extension methods specifies to which type they operate on preceded by ‘this’ keyword.
They cannot access the private variables of type which they are extending.
Extension Methods need to defined in a non-nested and non-generic static class.
Instance methods take priority over extension methods in case they have same signature.

Anonymous Types

Are of class types which can have only public read-only properties as their members. No other class members like methods are allowed.
They are of reference types and are derived from ‘Object’ class.
Internally compiler gives them the name but its not accessible by application code.
They have a method scope.
Can be initiated directly e.g. new { property1=1, property2=”Hello World”};

Lambda Expressions

Very similar to anonymous methods introduced in C# 2.0.
Its an inline expression or statement block which can be used to pass arguments to method call or assign value to delegate.
All lambda expression use lambda operator => where the left side denotes result and right contains statement block or expression.

Auto-Implemented Properties

Helps in simplifying property declaration in cases where there is no custom logic required in accessors methods.
E.g. public int Price {get; set;};
Internally compiler creates an anonymous field for assigning values.

.NET Framework 3.5 : What's new in ASP.NET

2009-09-23T00:49:00.000-07:00

Support for enabling existing ASP.NET 2.0 pages for AJAX
Creation of ASMX & WCF based web services and consuming them from AJAX Library
ASP.NET server side application services like authentication, roles management exposed as web services
ASP.NET Merge Tool - a new tool for merging pre-compiled assemblies
New ListView control which supports edit, insert, delete, sorting & paging
ASP.NET integrated with core IIS 7.0 which makes ASP.NET services like authentication & caching available for other content types also.
Microsoft AJAX Library to support AJAX based web development

ASP.NET 3.5 as an Alternative to CGI

2009-05-05T22:27:00.001-07:00

Microsoft’s alternative to a Common Gateway Interface (CGI) is ASP.NET, now in version 3.5. As a unified web platform, ASP.NET provides what you need to develop applications that hold state and use the information that you put into the HTML form. Instead of sending form information into a vacuum when you click a submit button, your data goes where it can be stored temporarily or permanently. Usually, when we think of saving state, we imagine writing the data to a storage device like a hard drive. Using a word processor, every time you save your file, you save its state. Using ASP.NET, you can do the same thing with information from anyone who uses your web application. This allows you to build applications where the information entered can be stored for use with either the next HTTP request or with a whole set of data entered by users all over the world—that’s quite a feat compared with saving state in your word processor file.
ASP.NET’s state-management facilities provide you with the tools that you need to control state. You do not necessarily want to save all states of a web page, but you certainly want to save the state of data entered by users and perhaps the URL of a page. Having state
management allows you to do this.

It seems that the term state is used in different ways in programming. I’ve heard of everything from “State Machines” to “State Design Patterns.” What

2009-05-05T22:24:00.000-07:00

Answer: An object’s state refers to a condition of the object. For example, a Boolean can have two states–true or false. When you enter information into an input form, the information you enter reflects the current state of that form. To save that state, you have to put it somewhere that will hold that state until you need it. One place you can put state data is in a variable, and it can hold it for you temporarily. For permanent storage of a state, you can use a database or some other file you can store on a hard drive.

ASP.NET 3.5: Key Skills & Concepts

2009-05-05T22:22:00.000-07:00

Moving from client-side to server-side computing
Understanding thin client
Understanding stateless HTTP
How ASP.NET 3.5 is an alternative to HTTP and CGI
How server-side applications work with your browser
Understanding the organization of the Microsoft .NET framework
How to set up your computer or LAN to run ASP.NET applications
The advantages of an ASP.NET hosting service
What languages can be run with ASP.NET

DNS

2008-06-19T00:21:00.003-07:00

The DNS is capable of translating a server name like www.google.com into a real IP address, and it can be used with the .NET Micro Framework, like in the full .NET Framework, with the static System.Net.Dns class.

Dynamic DNS, which is enabled by default, attempts to automatically discover the DNS servers. You can verify if dynamic DNS is enabled by checking the read-only IsDynamicDnsEnabled property. You can also explicitly specify a list of DNS server IP addresses on your network using the EnableStaticDns method.

DHCP Service

2008-06-19T00:21:00.001-07:00

You need not set the IP address, gateway address, and subnet mask explicitly. If your local network provides a reachable DHCP service, you can let the DHCP service automatically configure these parameters. The EnableDhcp method enables the DHCP service, which is the default setting.
Alternatively, calling EnableStaticIP will deactivate the usage of DHCP.
Dynamic IP addresses are assigned temporarily. You can release a dynamic IP address with ReleaseDhcpLease or renew it with RenewDhcpLease. The IsDhcpEnabled property indicates if DHCP is currently enabled.

What is Gateway Address?

2008-06-19T00:20:00.001-07:00

When you send an IP packet to an endpoint outside of your local subnet, it must pass a gateway (typically a router). You can set the gateway address explicitly as part of an EnableStaticIP call or let the DHCP (Dynamic Host Configuration Protocol) service automatically configure it, as described in the next section.

What is Subnet Mask?

2008-06-19T00:19:00.003-07:00

A subnet is a part of the overall address space. A subnet mask indicates to which subnet a device belongs. A common subnet mask is 255.255.255.0, which indicates that the last byte of an IP address contains host information. You can obtain the actual subnet mask as a string with the read-only SubnetMask property. You can set the subnet mask explicitly with the EnableStaticIP method.

What is MAC Address?

2008-06-19T00:19:00.001-07:00

The Media Access Control (MAC) address is a globally unique identifier for your network adapter on its network. You can obtain it with the PhysicalAddress property of the NetworkInterface instance. Although changing the physical address is possible, you should use the unique
identifier provided by default, and you should ensure that all devices on your network have a unique identifier.

UDP protocol

2008-06-19T00:18:00.001-07:00

UDP is a connectionless protocol that is lightweight and faster than TCP, but it's error prone because data can be lost in transmission or arrive more than once. UDP is used for streaming services such as Voice over IP, where real time matters but dropping packets just affects the sound quality.

One of the additional advantages of using UDP is the ability to broadcast or multicast data across a network. The DNS service to resolve Internet addresses and the discovery service of the Device Profile for Web Services use the broadcast feature of UDP.

With UDP, a client does not need to connect to a server. Connectionless transmission takes place with the SendTo and ReceiveFrom methods. ReceiveFrom returns an endpoint object that is populated with the actual sender information. Listing 6-4 shows a UDP client and Listing 6-5 a UDP server. They demonstrate the usage of a connectionless end-to-end transmission but are not using the broadcast feature.

If you want to send a broadcast message that theoretically all network nodes will get, you can use the IP address 255.255.255.255. There is no predefined broadcast address like Any or Loopback as there is with the full .NET Framework. You can also create a broadcast IP address object using new IPAddress(0xFFFFFFFF);.

Transmitting Data with a Socket

2008-06-19T00:16:00.001-07:00

Once you have a connection, you can send data synchronously with the socket's Send method:
clientSocket.Send(Encoding.UTF8.GetBytes("Hello World!"));

And you can receive data with the Receive method. The maximum number of bytes the Receive method reads is limited by the amount the specified buffer can hold. The method returns the actual number of bytes that were read:

byte[] inBuffer = new byte[100];
int count = clientSocket.Receive(inBuffer);
char[] chars = Encoding.UTF8.GetChars(inBuffer);
string str = new string(chars, 0, count);
Debug.Print(str);

You can poll the socket to test if data has been received. The first polling parameter specifies the amount of time, in microseconds, you want your application to wait for a response. Set it to –1 or System.Threading.Timeout.Infinite to let your application to wait an infinite amount of time:
if (communicationSocket.Poll(-1, //timeout in microseconds (-1 = infinite)
SelectMode.SelectRead))
{
...//read data here
}
Using the Available property of the Socket class, you can determine the number of bytes that are available to read before receiving them, which allows you to allocate a buffer that can hold all available bytes before reading the data.

Addressing NET Micro Framework

2008-06-19T00:15:00.001-07:00

An IP version 4 address is coded as 4-byte integer value but usually indicated in the more legible dotted decimal notation, for example, 192.168.101.100. When creating an instance of the IPEndPoint and IPAddress classes, you need to specify the address coded as a long value.
You cannot directly parse an IP address from a string with the Parse method of IPAddress as you can with the full .NET Framework; the .NET Micro Framework does not provide a Parse method for IPAddress. You can indirectly parse using the System.Net.Dns class, but first, take a look at the following code snippet, which demonstrates how you can convert a dotted decimal IP address to an IP address of the long value type.

public static long DottedDecimalToIp(byte a1, byte a2, byte a3, byte a4)
{
return (long)((ulong)a4 << 24 | (ulong)a3 << 16 | (ulong)a2 << 8 | (ulong)a1);
}

Using the preceding snippet, you can easily create an endpoint with legible decimal notation:
IPEndPoint ep = new IPEndPoint(DottedDecimalToIp(192, 168, 101, 100), 80);

As I said, there is a way to convert the IP address using the System.Net.Dns class, which allows you to use the Internet Domain Name System (DNS). The Dns class is responsible for resolving server names. Server addresses can be specified either in decimal notation or as a server name like www.microsoft.com. The GetHostEntry method returns a collection of the entries found in the DNS database. If you pass a particular address in decimal notation, you will always get one entry in the form of an IPAddress object:
IPHostEntry entry = Dns.GetHostEntry("192.168.101.100");
IPAddress ipAddr = entry.AddressList[0];
IPEndPoint ep = new IPEndPoint(ipAddr, 80);

Passing an empty string ("") to the GetHostEntry method will deliver the local IP address of the device.
The IPAddress class possesses two predefined static addresses properties: IPAddress.Loopback and IPAddress.Any IPAddress.Loopback describes the address 127.0.0.1, which is used if the client and server are on the same PC or device. IPAddress.Any is 0.0.0.0 and does not have a meaning for client applications; we will discuss that parameter in detail later, with server
applications.
For example, to connect with a server at the address 192.168.101.100 on the port 80, you need the following code:
Socket clientSocket = new Socket(Addressfamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint serverEndPoint = new IPEndPoint(DottedDecimalToIp(192, 168, 101, 100),
80); // port no
clientSocket.Connect(serverEndPoint);
You can obtain the two endpoints of the socket when a connection is available with the RemoteEndPoint and LocalEndPoint properties. Casting these into an IPEndPoint object will make the IP address available over the Address property.

You can determine the individual bytes of an IP address with the GetAddressBytes method, which supplies a byte array. With IP version 4, GetAddressBytes returns a byte array of 4 bytes.

In addition, the ToString method provides a string displaying the IP address in dotted decimal notation.
IPEndPoint remoteIPEndPoint = (IPEndPoint)communicationSocket.RemoteEndPoint;
byte[] addressBytes = remoteIPEndPoint.Address.GetAddressBytes();

TCP Programming

2008-06-19T00:13:00.001-07:00

A TCP/IP connection is the right choice when you need a reliable two-way, connection-based communication that ensures that data packets will be received in the correct order and that no data will be lost or transferred multiple times. You can create a TCP/IP socket with the following code:

Socket socket = new Socket(Addressfamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

Connecting to a Server as a Client

After you have created a socket object, you are able to initiate a connection to a (remote) server with the Connect method of your socket. Your .NET Micro Framework application is thereby the client application. The connection establishment takes place synchronously, so your client application will be blocked until a connection is available.

public void Connect(EndPoint remoteEP);

Take note of the remoteEP parameter of the abstract type System.Net.EndPoint in the signature of the Connect method. For IP connections, you need to pass an instance of the System.Net.IPEndPoint class to the Connect method. IPEndPoint contains the IP address and the communication port, and it is derived from EndPoint.

You can create an IPEndPoint object with one of the following two constructors:
public IPEndPoint(long address, int port)
public IPEndPoint(IPAddress address, int port)

Sockets Programming

2008-06-19T00:10:00.001-07:00

Programming applications that access a network was originally a complicated affair, but with the .NET Framework, this is no longer the case. The .NET Framework provides classes that substantially simplify complex network programming. These classes are in the System.Net and System.Net.Sockets namespaces in the System.dll assembly.

The most important class for network programming is System.Net.Sockets.Socket. The Socket class abstracts and implements the Socket API and/or Berkeley socket interface standard.

The Socket API was developed at the beginning of the 1980s at the University of California,Berkeley for Berkeley Software Distribution (BSD) UNIX.

A socket is an endpoint of a connection. With sockets, you can read and send data to and from a network on both the client and server sides. To send or receive data from a socket, you need to know the IP address of the other communication partner (endpoint) and one agreedupon port number, which can vary depending on application purposes. A client application, thus, must know the IP address of the server and connect with that server on a particular port.

The server listens on the agreed port or ports and accepts incoming connections from one or more clients.

Accessing SPI Devices with the .NET Micro Framework

2008-06-19T00:08:00.001-07:00

The .NET Micro Framework. SPI devices are represented by the Microsoft.SPOT.Hardware.

Why Reserve Pins?

2008-06-19T00:07:00.001-07:00

By reserving CPU pins, you can explicitly control the usage of the pins. By registering a hardware provider, you are able to reserve the required pins for the serial interface and the I²C and SPI busses to detect multiple usage of a pin and to avoid the resulting conflicts. The use of hardware providers is optional, but they provide simple and central management of shared pins.

The RS232 Serial Port

2008-06-19T00:06:00.001-07:00

Even though the concept of the serial interface has been around for years and USB is becoming more and more established, there are still many devices that need to be interfaced with a serial port, for example, measuring instruments and GPS receivers. In addition, the Bluetooth standard defines several protocols (profiles) to access different devices like head sets and printers, and it also has a communication profile via Bluetooth named Serial-Port. Some serial-to-Bluetooth adapters exist already. If such an adapter is connected to the serial interface of the microcontroller, a .NET Micro Framework application can communicate wirelessly with a PC, PDA,smartphone, or other microcontroller (see Chapter 7).

Together with the serial interface, you quite often hear the terms "UART," "USART," and "RS232." UART and USART are names for the serial hardware component, the Universal (Synchronous) Asynchronous Receiver Transmitter. The RS232 standard describes how data will be physically transferred over the cable. Further standards are RS422 and RS485.

What Are GPIO Ports?

2008-06-19T00:05:00.001-07:00

General purpose input/output (GPIO) ports are probably the most frequently used way for a microcontroller to contact its environment. A GPIO port can be initialized and used either as an input or output line. A typical example of an output line is one to control a light-emitting
diode (LED). Monitoring a push button or a switch is the function of an input line.

A GPIO port can have either a low (0 volts) or high (a positive voltage, usually 3.3 volts) status. In the .NET Micro Framework, the status of a GPIO port is represented as a Boolean value. The value false corresponds to low status and true to high.

TFConvert Tool

2008-06-19T00:04:00.001-07:00

The .NET Micro Framework uses the .tinyfnt file format to work with fonts. This special format uses fixed size bitmaps for a simpler way to render fonts. Two sample .tinyfnt fonts are included in the Fonts subdirectory of your .NET Micro Framework installation. To create other fonts in the size, style, and language tailored to your application, you can use the TFConvert tool to create a .tinyfnt font from TrueType or OpenType font files. That enables you to select character sets and even create fonts for displaying Cyrillic and Chinese characters.
In the Tools\Fonts subdirectory, you can find some sample TrueType fonts from Ascender Corporation, which you can convert to meet your needs. These free sample fonts provide a reduced character set; the full versions can be purchased from the company.

The TFConvert command line tool is located in the Tools subdirectory of your .NET Micro Framework installation. TFConvert accepts a path to a font definition file that describes the font's size, style, and characters to convert.

The system tool character map (charmap.exe) provided with your Windows installation can help you determine which characters or character ranges to convert.

To get more information about creating .tinyfnt fonts with the TFConvert tool, please see the .NET Micro Framework SDK documentation, where this is described in detail.

In addition, on the SJJ Embedded Micro Solutions web site, you can find a great article that describes how to convert fonts with TFConvert (www.sjjmicro.com/SJJ_Articles.html).

On the web site of a Czech .NET Micro Framework enthusiast, Jan Kucera, at www.microframework.eu, you can find the Tiny Font Tool GUI. This tool provides a graphical user interface that assists you in creating the font definition files.

MFDeploy [.NET Micro Framework Deployment Tool ]

2008-06-19T00:03:00.001-07:00

The .NET Micro Framework provides the .NET Micro Framework Deployment Tool (MFDeploy), which you can find in the Tools subfolder of the SDK. The primary purpose of MFDeploy is to copy your application to devices. MFDeploy provides a GUI (see Figure 3-5), can be invoked from the command line, and provides a .NET API, and thus allows you to use MFDeploy in your production environment to replicate a standard deployment on your devices without Visual Studio.

The features of MFDeploy include the following:

• Discovering and pinging devices to test if they are responsive
• Creating a standard deployment from a master device
Copying your application to the device
• Upgrading firmware
• Creating and updating device keys
• Signing code
• Setting network parameters and USB names
• Use via a UI or automatically via the command line or programmatically

.NET Micro Framework Base Class Library

2008-06-19T00:00:00.001-07:00

The Base Class Library Runtime Assemblies
The runtime libraries that you can find in the Assemblies subdirectory of your .NET Micro Framework installation include the following:
• Mscorlib.dll: A subset of the core .NET classes.
• System.dll: Only the System.Net namespace.
• System.Xml.dll: A subset of the core .NET XML classes necessary to read XML files.
• Microsoft.SPOT.Native.dll: Core .NET Micro Framework classes.
• Microsoft.SPOT.Hardware.dll: Managed hardware drivers.
• Microsoft.SPOT.Graphics.dll: Low-level graphics classes.
• Microsoft.SPOT.TinyCore.dll: User interface elements for complex WPF GUIs.
• Microsoft.SPOT.Net.dll: Internal socket drivers.

When using network sockets, you need to include System.dll and Microsoft.SPOT.Net.dll.
Further assemblies for the Device Profile for Web Services (DPWS) stack are also included.

Although provided with the .NET Micro Framework 2.5 SDK release, the implementation of the DPWS stack is still in beta, and therefore, the DPWS libraries are not installed by default with the .NET Micro Framework SDK. When installing the SDK you need to choose either the Install All option or the Custom Installation option with DPWS selected.

.NET Micro Framework System Requirements

2008-06-18T23:57:00.001-07:00

System Requirements

Developing for the .NET Micro Framework requires the following:
• Microsoft Windows XP or Vista
• Microsoft Visual Studio 2005 Standard Edition or better, with Service Pack 1
• .NET Micro Framework SDK version 2 with Service Pack 1 or version 2.5

The free Express editions of Visual Studio cannot be used with the .NET Micro Framework,because they do not allow installing extensions at all. Do not forget to install Visual Studio 2005 Service Pack 1.

What Is the .NET Micro Framework?

2008-06-18T23:52:00.001-07:00

The Microsoft .NET Micro Framework is a small and efficient .NET runtime environment used to run managed code on devices that are too small and resource constrained for Windows CE and the .NET Compact Framework.

The .NET Micro Framework enables you to write embedded applications for small, connected, embedded devices with Visual Studio and C#. That means you can now use the same development tools and language that you use to build desktop and smart device (PDA and smartphone) applications to develop applications for microcontrollers. The .NET Micro Framework also provides an extensible hardware emulator for rapid prototyping and debugging.

The .NET Micro Framework requires no underlying operating system. A scaled-down version of the Common Language Runtime (TinyCLR) sits directly on the hardware, so the framework is often called a bootable runtime. The runtime has a small footprint; it uses only a few hundred kilobytes of RAM and does not require the processor to have a memory management unit (MMU).

Therefore, the .NET Micro Framework can run on small and inexpensive 32-bit processors without consuming a lot of power.

How to: Improve the Startup Time of WCF Client Applications using the XmlSerializer

2008-06-17T08:52:00.001-07:00

Services and client applications that use data types that are
serializable using the XmlSerializer generate and compile
serialization code for those data types at runtime, which can result
in slow start-up performance.

Note:
Pre-generated serialization code can only be used in client
applications and not in services.

The ServiceModel Metadata Utility Tool (Svcutil.exe) can improve
start-up performance for these applications by generating the
necessary serialization code from the compiled assemblies for the
application. Svcutil.exe generates serialization code for all data
types used in service contracts in the compiled application assembly
that can be serialized using the XmlSerializer. Service and operation
contracts that use the XmlSerializer are marked with the
XmlSerializerFormatAttribute.

To generate XmlSerializer serialization code
Compile your service or client code into one or more assemblies.

Open an SDK command prompt.

At the command prompt, launch the Svcutil.exe tool using the following format.

svcutil.exe /t:xmlSerializer <assemblyPath>*

The assemblyPath argument specifies the path to an assembly that
contains service contract types. Svcutil.exe generates serialization
code for all data types used in service contracts in the compiled
application assembly that can be serialized using the XmlSerializer.

Svcutil.exe can only generate C# serialization code. One source code
file is generated for each input assembly. You cannot use the
/language switch to change the language of the generated code.

To specify the path to dependent assemblies, use the /reference option.

Make the generated serialization code available to your application by
using one of the following options:

Compile the generated serialization code into a separate assembly with
the name [original assembly].XmlSerializers.dll (for example,
MyApp.XmlSerializers.dll). Your application must be able to load the
assembly, which must be signed with the same key as the original
assembly. If you recompile the original assembly, you must regenerate
the serialization assembly.

Compile the generated serialization code into a separate assembly and
use the XmlSerializerAssemblyAttribute on the service contract that
uses the XmlSerializerFormatAttribute. Set the AssemblyName or
CodeBase properties to point to the compiled serialization assembly.

Compile the generated serialization code into your application
assembly and add the XmlSerializerAssemblyAttribute to the service
contract that uses the XmlSerializerFormatAttribute. Do not set the
AssemblyName or CodeBase properties. The default serialization
assembly is assumed to be the current assembly.

Example
The following command generates serialization types for XmlSerializer
types that any service contracts in the assembly use.

svcutil /t:xmlserializer myContractLibrary.exe

How to: Use Svcutil.exe to Download Metadata Documents

2008-06-17T08:50:00.003-07:00

You can use Svcutil.exe to download metadata from running services and
to save the metadata to local files. For HTTP and HTTPS URL schemes,
Svcutil.exe attempts to retrieve metadata using WS-MetadataExchange
and XML Web Service Discovery. For all other URL schemes, Svcutil.exe
uses only WS-MetadataExchange.

By default, Svcutil.exe uses the bindings defined in the
MetadataExchangeBindings class. To configure the binding used for
WS-MetadataExchange, you must define a client endpoint in the
configuration file for Svcutil.exe (svcutil.exe.config) that uses the
IMetadataExchange contract and that has the same name as the Uniform
Resource Identifier (URI) scheme of the metadata endpoint address.

To download metadata using Svcutil.exe
Locate the Svcutil.exe tool at the following location:

C:\Program Files\Microsoft SDKs\Windows\v1.0.\bin

At the command prompt, launch the tool using the following format.

svcutil.exe /t:metadata <url>* | <epr>

You must specify the /t:metadata option to download metadata.
Otherwise, client code and configuration are generated.

The <url> argument specifies the URL to a service endpoint that
provides metadata or to a metadata document hosted online. The <epr>
argument specifies the path to an XML file that contains a
WS-Addressing EndpointAddress for a service endpoint that supports
WS-MetadataExchange.

For more options about using this tool for metadata download, see
ServiceModel Metadata Utility Tool (Svcutil.exe).

Example
The following command downloads metadata documents from a running service.

svcutil /t:metadata http://service/metadataEndpoint

How to: Use Svcutil.exe to Validate Compiled Service Code

2008-06-17T08:50:00.001-07:00

You can use the ServiceModel Metadata Utility Tool (Svcutil.exe) to
detect errors in service implementations and configurations without
hosting the service.

To validate a service
Compile your service into an executable file and one or more dependent
assemblies.

Open an SDK command prompt

At the command prompt, launch the Svcutil.exe tool using the following format.

svcutil.exe /validate /serviceName:<serviceConfigName> <assemblyPath>*

You must use the /serviceName option to indicate the configuration
name of the service you want to validate.

The assemblyPath argument specifies the path to the executable file
for the service and one or more assemblies that contain the service
types to be validated. The executable assembly must have an associated
configuration file to provide the service configuration. You can use
standard command-line wildcards to provide multiple assemblies.

How to: Use Svcutil.exe to Export Metadata from Compiled Service Code

2008-06-17T08:49:00.001-07:00

Svcutil.exe can export metadata for services, contracts, and data
types in compiled assemblies, as follows:

To export metadata for all compiled service contracts for a set of
assemblies using Svcutil.exe, specify the assemblies as input
parameters. This is the default behavior.

To export metadata for a compiled service using Svcutil.exe, specify
the service assembly or assemblies as input parameters. You must use
the /serviceName option to indicate the configuration name of the
service you want to export. Svcutil.exe automatically loads the
configuration file for the specified executable assembly.

To export all data contract types within a set of assemblies, use the
/dataContractOnly option.

Note:

Use the /reference option to specify the file paths to any dependent assemblies.

How to generating a WCF Client from Service Metadata

2008-06-17T08:48:00.001-07:00

Metadata documents can be on a durable storage or be retrieved online.
Online retrieval follows either the WS-MetadataExchange protocol or
the Microsoft Discovery (DISCO) protocol. Svcutil.exe issues the
following metadata requests simultaneously to retrieve metadata:

WS-MetadataExchange (MEX) request to the supplied address.

MEX request to the supplied address with /mex appended.

DISCO request (using the DiscoveryClientProtocol from ASP.NET Web
services) to the supplied address.

Svcutil.exe generates the client based on the Web Services Description
Language (WSDL) or policy file received from the service. The user
principal name (UPN) is generated by concatenating the user name with
"@" and then adding a fully-qualified domain name (FQDN). However, for
users who registered on Active Directory, this format is not valid and
the UPN that the tool generates causes a failure in the Kerberos
authentication with the following error message: The logon attempt
failed. To resolve this problem, manually fix the client file that the
tool generated.

svcutil.exe [/t:code] <metadataDocumentPath>* | <url>* | <epr>

ServiceModel Metadata Utility Tool (Svcutil.exe)

2008-06-17T08:47:00.001-07:00

The ServiceModel Metadata Utility tool is used to generate service
model code from metadata documents and metadata documents from service
model code.

Installing ASP.NET AJAX

2008-05-21T23:40:00.001-07:00

Introduction

This topic describes how to install Microsoft ASP.NET AJAX. It also
describes how to install the optional ASP.NET 2.0 AJAX Futures CTP and
optional ASP.NET AJAX Control Toolkit.

ASP.NET AJAX

ASP.NET AJAX enables you to create dynamic Web pages that support
partial-page updates. It includes Microsoft ASP.NET 2.0 AJAX
Extensions, which is a server framework, and the Microsoft AJAX
Library, which consists of client script that runs on the browser.

note

The installation process installs the ASP.NET AJAX assembly
(System.Web.Extensions.dll) in the global assembly cache (GAC). Do not
include the assembly in the Bin folder of your AJAX-enabled Web site.

You can install and use ASP.NET AJAX with Microsoft Visual Studio 2005
or Microsoft Visual Web Developer Express Edition. However, you do not
require Visual Studio 2005 to use ASP.NET AJAX to create ASP.NET Web
applications.

You can install and use the Microsoft AJAX Library without the .NET
Framework. You can also install it on non-Windows environments to
create client-based Web applications for any browser that supports
ECMAScript (JavaScript).

ASP.NET 2.0 AJAX Futures CTP

The CTP release is community supported. The features in the CTP
release might be added to the supported features in future versions of
ASP.NET AJAX. The CTP release is compatible with ASP.NET AJAX.

ASP.NET AJAX Control Toolkit

The ASP.NET Control Toolkit provides features that extend
functionality of ASP.NET AJAX version 1.0. These features enhance the
depth and breadth of the platform and include new ideas and concepts.
The ASP.NET Control Toolkit is community supported and community
driven.

System Requirements for Installation

Microsoft ASP.NET AJAX requires the following software.

Supported Operating Systems

Windows Server 2003

Windows XP Home Edition

Windows XP Professional

Windows Vista

Any Windows operating system version (including Windows 2000) that
supports the Microsoft .NET Framework version 2.0. Note that support
will be limited to the terms of support for that platform.

Required Software

The .NET Framework 2.0 or version 3.0.

Internet Explorer 5.01 or later.

Optional Software

Microsoft Visual Studio 2005 or Visual Web Developer Express Edition

Installing Microsoft ASP.NET AJAX

Follow these steps to install ASP.NET AJAX.

To install Microsoft ASP.NET AJAX

Make sure that you are logged in with an account that has Administrator rights.

If your account does not have Administrator rights, the installation
process displays the error "The system administrator has set policies
to prevent this installation."

Uninstall any earlier versions of ASP.NET AJAX. If the installation
process finds an earlier version on your computer, it will stop.

You can remove earlier versions with the Add or Remove Programs
application in Control Panel.

Download the ASPAJAXExtSetup.msi installation package from the ASP.NET
AJAX Downloads Web site.

To install ASP.NET AJAX from the Windows interface, double-click
ASPAJAXExtSetup.msi in Windows Explorer.

By default, the .msi file is installed in the following location:

drive:\..\Program Files\Microsoft ASP.NET\ASP.NET 2.0 AJAX Extensions\v1.0.nnnn.

To install ASP.NET AJAX from the command line, execute the following
command at a command prompt:

msiexec /i ASPAJAXExtSetup.msi [/q] [/log <log file name>]
[INSTALLDIR=<installation path>]

Specify the /q option to perform the installation without user
prompts. You can optionally provide an installation path and a file
name for logging. If you do not provide an installation path, the
default installation path is used.

If you want to add the ASP.NET 2.0 AJAX Futures CTP, download and
install it from the ASP.NET AJAX Downloads Web site.

If you want to add the ASP.NET AJAX Control Toolkit, download and
install it from ASP.NET AJAX Control Toolkit Web site.

Using ASP.NET AJAX with Visual Studio

If you have Microsoft Visual Studio 2005 installed on your computer,
the installation process installs templates for AJAX-enabled Web site
projects. It also installs an assembly (AJAXExtensionToolbox.dll) that
extends the Visual Studio toolbox. When you create a new AJAX-enabled
Web site by using Microsoft Visual Studio 2005, the template
automatically includes the Web.config file that includes the elements
required for ASP.NET AJAX components.

To add ASP.NET AJAX components to an existing site, modify the
Web.config file in the Web application by using the configuration
values from the sample Web.config file in the installation path. For
more information about ASP.NET AJAX configuration values, see
Configuring ASP.NET AJAX.

Using ASP.NET AJAX Without Visual Studio

If Microsoft .NET Framework version 2.0 is installed on a computer
without Microsoft Visual Studio 2005 or Visual Web Developer Express
Edition, the ASP.NET AJAX installation process adds the
System.Web.Extensions.dll assembly that contains server components to
the global assembly cache. It also copies a sample Web.config file to
the installation path. It does not install templates for AJAX-enabled
Web site projects or install the assembly for extending the Visual
Studio toolbox.

You can use ASP.NET AJAX in a Web application by adding the sample
Web.config file from the installation folder to the Web site
directory. You can also modify the Web.config file in an existing Web
application by using the configuration values from the sample
Web.config file. For more information about the ASP.NET AJAX
configuration values, see Configuring ASP.NET AJAX.

Installing the Microsoft AJAX Library on Non-Windows Environments

You do not have to build a Web site on a Windows-based environment to
use the client framework provided by the Microsoft AJAX Library. The
Microsoft AJAX Library consists of JavaScript files and will work with
any browsers that can run JavaScript code.

note

The Microsoft AJAX Library is installed with the full installation.
You do not have to install the Microsoft AJAX Library separately if
you have completed the full installation.

To install Microsoft AJAX Library

Download the MicrosoftAJAXLibrary.zip package from the ASP.NET AJAX
Downloads Web site.

Unzip the MicrosoftAJAXLibrary.zip package.

Copy the JavaScript files to the Web site.

ASP.NET AJAX Client Life-Cycle Events

2008-05-21T23:34:00.001-07:00

Introduction

A Microsoft ASP.NET AJAX page raises the same server life-cycle events as an ASP.NET 2.0 Web page and also raises client life-cycle events. The client events enable you to customize the UI for both postbacks and for asynchronous postbacks (partial-page updates). The client events also help you manage custom script components during the lifetime of the page in the browser.

The client events are raised by classes in the Microsoft AJAX Library. These classes are automatically instantiated when a page contains ASP.NET AJAX server controls. The client classes provide APIs that enable you to bind to events and to provide handlers for those events. Because the Microsoft AJAX Library is browser independent, the code you write for your handlers works the same in all supported browsers.

The key event for initial requests (GET requests) and synchronous postbacks is the load event of the Application instance. When script in a load event handler runs, all scripts and components have been loaded and are available. When partial-page rendering with UpdatePanel controls is enabled, the key client events are the events of the PageRequestManager class. These events enable you to handle many common scenarios. These include the ability to cancel postbacks, to give precedence to one postback over another, and to animate UpdatePanel controls when their content is refreshed.

Client events are useful whether you are creating pages or writing components. If you are a page developer, you can provide custom script that is called when the page loads and unloads in the browser.

Client Classes

The two main Microsoft AJAX Library classes that raise events during the client life cycle of an ASP.NET AJAX Web page are the Application and PageRequestManager classes.

The Application class is instantiated in the browser when the page contains a ScriptManager control. The Application class resembles the Page server control, which derives from the Control class, but provides additional functionality for raising server events. Similarly, the Application class derives from the Sys.Component class, but raises client life-cycle events that you can handle.

If a page contains a ScriptManager control and one or more UpdatePanel controls, the page can perform partial-page updates (if partial-page rendering is enabled and supported in the browser). In that case, an instance of the PageRequestManager class is automatically available in the browser. The PageRequestManager class raises client events that are specific to asynchronous postbacks. For details about partial-page rendering, see Partial-Page Rendering Overview.

Adding Handlers for Client Events

To add or remove handlers for events raised by the Application and PageRequestManager classes, use the add_eventname and remove_eventname methods of those classes. The following example shows how to add a handler named MyLoad to the init event of the Application object.

CS

Sys.Application.add_init(MyInit);
function MyInit(sender) {
}
Sys.Appplication.remove_init(MyInit);

VB

Sys.Application.add_init(MyInit);
function MyInit(sender) {
}
Sys.Appplication.remove_init(MyInit);

note

This example shows just the syntax of the add_eventname and remove_eventname methods. Details about what you can do with specific events are provided later in this topic.

Handling the Application Load and Unload Events

To handle the load and unload events of the Application object, you do not have to explicitly bind a handler to the event. Instead, you can create functions that use the reserved names pageLoad and pageUnload. The following example shows how to add a handler for the load event of the Application object by using this approach.

CS

function pageLoad(sender, args) {
}

VB

function pageLoad(sender, args) {
}

Events for Other Client Classes

This topic describes only the events that are raised by the Application and PageRequestManager classes. The Microsoft AJAX Library also contains classes for adding, clearing, and removing handlers for DOM element events. These classes include the following:

The Sys.UI.DomEvent.addHandler method or the shortcut $addHandler.
The Sys.UI.DomEvent.clearHandlers method or the shortcut $clearHandlers.
The Sys.UI.DomEvent.removeHandler method or the shortcut $removeHandler.

Events raised by DOM elements are not discussed in this topic.

Client Events of the Application and PageRequestManager Classes

The following table lists client events of the Application and PageRequestManager classes that you can handle in AJAX ASP.NET-enabled pages. The order in which the events are raised is described later in this topic.

Event	Description
init Event	Raised after all scripts have been loaded but before any objects are created. If you are writing a component, the init event gives you a point in the life cycle to add your component to the page. The component can then be used by other components or by script later in the page life cycle. If you are a page developer, you should use the load event instead of the init event for most scenarios. The init event is raised only one time when the page is first rendered. Subsequent partial-page updates do not raise the init event.
load Event	Raised after all scripts have been loaded and all objects in the application that are created by using $create are initialized. The load event is raised for all postbacks to the server, which includes asynchronous postbacks. If you are a page developer, you can create a function that has the name pageLoad, which automatically provides a handler for the load event. The pageLoad handler is called after any handlers that have been added to the load event by the add_load method. The load event takes an eventargs parameter, which is an Sys.ApplicationLoadEventArgs object. You can use the event arguments to determine whether the page is being refreshed as a result of a partial-page update and what components were created since the previous load event was raised.
unload Event	Raised before all objects are disposed and before the browser window's window.unload event occurs. If you are a page developer, you can create a function that has the name pageUnload, which automatically provides a handler for the unload event. The pageUnload event is called just before the page is unloaded from the browser. During this event, you should free any resources that your code is holding.
propertyChanged Event	Potentially raised when a property of a component changes. The Application object inherits this event from the Component class. This event is raised only if a component developer has called the Sys.Component.raisePropertyChange method in a property set accessor. For more information, see Defining Custom Component Properties and Raising PropertyChanged Events. The propertyChanged event takes an eventargs parameter, which is a Sys.applicationLoadEventArgs object.
disposing Event	Raised when the Application instance is disposed. The Application object inherits this event from the Component class.
initializeRequest Event	Raised before an asynchronous request starts. You can use this event to cancel a postback, such as to give precedence to another asynchronous postback. The initializeRequest event takes an eventargs parameter, which is a Sys.WebForms.InitializeRequestEventArgs object. This object makes available the element that caused the postback and the underlying request object. InitializeRequestEventArgs also exposes a cancel property. If you set cancel to true, the new postback is canceled.
beginRequest Event	Raised before an asynchronous postback starts and the postback is sent to the server. If there is a postback already processing, it is stopped (by using the abortPostBack method). You can use this event to set request headers or to begin an animation on the page to indicate that the request is in process. The beginRequest event takes an eventargs parameter, which is a Sys.WebForms.BeginRequestEventArgs object. This object makes available the element that caused the postback and the underlying request object.
pageLoading Event	Raised after the response from the server to an asynchronous postback is received, but before any content on the page is updated. You can use this event to provide a custom transition effect for updated content. The pageLoading event takes an eventargs parameter, which is an Sys.WebForms.PageLoadingEventArgs object. This object makes available information about what panels will be deleted and updated as a result of the most recent asynchronous postback.
pageLoaded Event	Raised after all content on the page is refreshed, as a result of either a synchronous or an asynchronous postback. For synchronous postbacks, panels can only be created, but for asynchronous postbacks, panels can be both created and updated. You can use this event to manage a custom transition effect for updated content. The pageLoaded event takes an eventargs parameter, which is an Sys.WebForms.PageLoadedEventArgs object. This object makes available information about which panels were updated and created in the most recent postback.
endRequest Event	Raised after the response for an asynchronous postback is processed and the page is updated, or during the processing of the response if there is an error. If an error occurs, the page is not updated. Use this event to provide customized error notification to users or to log errors. The endRequest event takes an eventargs parameter, which is a Sys.WebForms.EndRequestEventArgs object. This object makes available information about errors that have occurred and whether the error was handled. It also makes available the response object.

Browser Compatibility and Security Settings for AJAX-Enabled ASP.NET Sites

2008-05-21T23:30:00.001-07:00

Introduction

ASP.NET AJAX is compatible with most modern browsers. It runs with the default security settings for these browsers.

Browser and Operating System Compatibility

Users can view your AJAX-enabled ASP.NET sites by using most modern browsers. The following lists show compatible browser versions and operating systems.

Supported Browsers

Microsoft Internet Explorer 6.0 or later versions.
Mozilla Firefox version 1.5 or later versions.
Opera version 9.0 or later versions.
Apple Safari version 2.0 or later versions.

Supported Operating Systems

Microsoft Windows XP with Service Pack 2 installed.
Microsoft Vista.
Apple OSX (Intel architecture only).

Security and Privacy Settings

The following table lists required browser security and privacy settings for both user browsing and site development. In all cases, the recommended settings are the default settings for that browser.

Internet Explorer 6	Make sure that the Internet Zone in the Security Zones settings is set to Medium.
Internet Explorer 7	Make sure that the Internet Zone in the Security Zones settings is set to Medium-High.
FireFox 1.5 or later versions	In the Tools menu under Options, make sure that Enable JavaScript is selected.
Opera 9.0 or later versions	In the Tools menu under Quick preferences, make sure that Enable JavaScript is selected.
Safari 2.0 or later versions	Click Safari, Preferences, Security, and then Web Content and make sure that Enable JavaScript is selected.

Configuring ASP.NET AJAX

2008-05-21T23:28:00.001-07:00

Introduction

This topic describes the elements in the Web.config file that support Microsoft ASP.NET AJAX. It also describes how to incorporate those elements into the Web.config file for an existing ASP.NET application.

Using the ASP.NET AJAX Web Configuration File in a New Web Site

When you create a new AJAX-enabled Web site, you can use the Web.config file provided in the installation package to add the required configuration settings. In Visual Studio, the Web.config file for Microsoft ASP.NET AJAX is included in your project when you create a new ASP.NET AJAX-enabled Web Site.

If you have to manually add the Web.config file to a new Web site, you can get a copy of it from the installation path. By default, the file is in the following location:

drive:\Program Files\Microsoft ASP.NET\ASP.NET 2.0 AJAX Extensions\v1.0.nnnn

Adding ASP.NET AJAX Configuration Elements to an Existing Web Site

In an existing Web site, you typically have values in the Web.config file that you want to retain. In that case, you can add the new ASP.NET AJAX elements into the existing Web.config file.

The new elements are part of the following configuration sections:

The <configSections> element
The <controls> element
The <assemblies> element
The <httpHandlers> element
The <httpModules> element
The <system.web.extensions> element
The <system.webserver> element

The <configSections> Element

The <configSections> element creates a configuration section and subsections for the SystemWebExtensionsSectionGroup class. You set the properties for these sections in the <system.web.extensions> element.

The following example shows the <configSections> element for ASP.NET AJAX. Add this section to the existing Web.config file as a child of the <configuration> element.

<configuration>
  <configSections>
    <sectionGroup name="system.web.extensions" 
        type="System.Web.Configuration.SystemWebExtensionsSectionGroup, 
        System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, 
         PublicKeyToken=31bf3856ad364e35">
      <sectionGroup name="scripting" 
        type="System.Web.Configuration.ScriptingSectionGroup, 
        System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, 
         PublicKeyToken=31bf3856ad364e35">
          <section name="scriptResourceHandler" 
            type="System.Web.Configuration.ScriptingScriptResourceHandlerSection, 
            System.Web.Extensions, Version=1.0.61025.0, 
             Culture=neutral, PublicKeyToken=31bf3856ad364e35" 
            requirePermission="false" 
            allowDefinition="MachineToApplication"/>
        <sectionGroup name="webServices" 
             type="System.Web.Configuration.ScriptingWebServicesSectionGroup, 
            System.Web.Extensions, Version=1.0.61025.0, 
            Culture=neutral, PublicKeyToken=31bf3856ad364e35">
          <section name="jsonSerialization" 
               type="System.Web.Configuration.ScriptingJsonSerializationSection, 
              System.Web.Extensions, Version=1.0.61025.0, 
              Culture=neutral, PublicKeyToken=31bf3856ad364e35" 
               requirePermission="false" allowDefinition="Everywhere" />
          <section name="profileService" 
              type="System.Web.Configuration.ScriptingProfileServiceSection, 
               System.Web.Extensions, Version=1.0.61025.0, 
              Culture=neutral, PublicKeyToken=31bf3856ad364e35" 
              requirePermission="false" 
              allowDefinition="MachineToApplication" />
           <section name="authenticationService" 
              type="System.Web.Configuration.ScriptingAuthenticationServiceSection, 
              System.Web.Extensions, Version=1.0.61025.0, 
              Culture=neutral, PublicKeyToken=31bf3856ad364e35" 
               requirePermission="false" 
              allowDefinition="MachineToApplication" />
        </sectionGroup>
      </sectionGroup>
    </sectionGroup>
  </configSections>
 </configuration>

The <controls> Element

The <controls> element registers ASP.NET AJAX namespaces in the System.Web.Extensions assembly and maps the asp tag prefix as an alias for these namespaces. The controls in the ASP.NET AJAX namespaces can be referenced in a Web page with syntax such as the following:

<asp:ScriptManager ID="ScriptManager1" runat="server" />

The following example shows the <controls> element for ASP.NET AJAX. Add this section to the existing Web.config file as a child of the <system.web><pages> element.

<system.web>
  <pages>
    <controls>
      <add tagPrefix="asp" namespace="System.Web.UI" assembly="System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
     </controls>
  </pages>
</system.web>

The <assemblies> Element

The <assemblies> element registers the System.Web.Extensions assembly.

The following example shows the <assemblies> element for ASP.NET AJAX. Add this section to the existing Web.config file as a child of the <system.web><compilation> element.

<system.web>
  <compilation>
    <assemblies>
      <add assembly="System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
    </assemblies>
   </compilation>
</system.web>

The <httpHandlers> Element

The <httpHandlers> element adds new handlers for script requests.

The following example shows the <httpHandler> element for ASP.NET AJAX. Add this section to the existing Web.config file as a child of the <system.web> element.

<system.web>
  <httpHandlers>
    <remove verb="*" path="*.asmx"/>
    <add verb="*" path="*.asmx" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
     <add verb="*" path="*_AppService.axd" validate="false" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
     <add verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" validate="false"/>
   </httpHandlers>
</system.web>

The <httpModules> Element

The <httpModules> element defines HTTP modules used in ASP.NET AJAX.

The following example shows the <httpModules> element for ASP.NET AJAX. Add this section to the existing Web.config file as a child of the <system.web> element.

<system.web>
  <httpModules>
    <add name="ScriptModule" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
   </httpModules>
</system.web>

The <system.web.extensions> Element

The <system.web.extensions> element provides elements that can be uncommented to configure how Web services are called from Microsoft ASP.NET AJAX applications. The <jsonSerialization> element is used to specify custom type converters and to override default settings for JSON serialization. The <converters> element specifies custom type converters. The <authenticationService> element is used to enable or disable the authentication service. The <profileService> element is used to enable or disable the profile service and to specify which properties are exposed by the service. The <scriptResourceHandler> element is used to enable or disable caching and compression of resources used with scripts.

The <scriptResourceHandler> element, <authenticationService> element, and <profileService> element can be defined only in the Machine.config file or in the Web.config file in the application root directory. The <jsonSerialization> element can be defined in the Machine.config file, in the Web.config file in the application root directory, or in a Web.config file in a subfolder of the Web site.

The following example shows the <system.web.extensions> element for ASP.NET AJAX. Add this section and its subsections to the existing Web.config file as a child of the <configuration> element.

<system.web.extensions>
  <scripting>
    <webServices>
    <!-- Uncomment this line to customize maxJsonLength and add a 
         custom converter -->
      <!--
      <jsonSerialization maxJsonLength="500">
         <converters>
          <add name="ConvertMe" 
             type="Acme.SubAcme.ConvertMeTypeConverter"/>
        </converters>
      </jsonSerialization>
      -->
       <!-- Uncomment this line to enable the authentication service. 
           Include requireSSL="true" if appropriate. -->
      <!--
      <authenticationService enabled="true" requireSSL = "true|false"/>
       -->

      <!-- Uncomment these lines to enable the profile service. To 
           allow profile properties to be retrieved
           and modified in ASP.NET AJAX applications, you need to add 
            each property name to the readAccessProperties and
           writeAccessProperties attributes. -->
      <!--
      <profileService enabled="true"
        readAccessProperties="propertyname1,propertyname2"
         writeAccessProperties="propertyname1,propertyname2" />
      -->
    </webServices>
    <!-- 
    <scriptResourceHandler enableCompression="true" 
        enableCaching="true" />
     -->
  </scripting>
</system.web.extensions>

The <system.webserver> Element

The <system.webserver> element contains configuration settings used by Microsoft Internet Information Server (IIS) 7.0.

The following example shows the <system.webserver> element for ASP.NET AJAX. Add this section to the existing Web.config file as a child of the <configuration> element.

<system.webServer>
  <validation validateIntegratedModeConfiguration="false" />
  <modules>
    <add name="ScriptModule" 
      preCondition="integratedMode" 
       type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
  </modules>
  <handlers>
    <remove name="WebServiceHandlerFactory-ISAPI-2.0"/>
     <add name="ScriptHandlerFactory" verb="*" path="*.asmx" 
      preCondition="integratedMode"
      type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"/>
     <add name="ScriptHandlerFactoryAppServices" verb="*" 
      path="*_AppService.axd" preCondition="integratedMode"
      type="System.Web.Script.Services.ScriptHandlerFactory, 
       System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, 
      PublicKeyToken=31bf3856ad364e35"/>
    <add name="ScriptResource" preCondition="integratedMode" 
      verb="GET,HEAD" path="ScriptResource.axd" 
       type="System.Web.Handlers.ScriptResourceHandler, 
      System.Web.Extensions, Version=1.0.61025.0, Culture=neutral, 
      PublicKeyToken=31bf3856ad364e35" />
  </handlers>
</system.webServer>

Explain ASP.NET AJAX Client Architecture

2008-05-21T23:22:00.001-07:00

The ASP.NET AJAX client-script libraries consist of JavaScript (.js) files that provide features for object-oriented development. The object-oriented features included in the ASP.NET AJAX client-script libraries enable a high level of consistency and modularity in client scripting. The following layers are included in the ASP.NET AJAX script libraries:

A browser compatibility layer. This provides compatibility across the most frequently used browsers (including Microsoft Internet Explorer, Mozilla Firefox, and Apple Safari) for your ASP.NET AJAX scripts.
ASP.NET AJAX core services, which include extensions to JavaScript, such as classes, namespaces, event handling, inheritance, data types, and object serialization.
An ASP.NET AJAX base class library, which includes components such as string builders and extended error handling.
A networking layer that handles communication with Web-based services and applications, and that manages asynchronous remote method calls.
Support for JavaScript libraries that are either embedded in an assembly or are provided as standalone JavaScript (.js) files. Embedding JavaScript libraries in an assembly can make it easier to deploy applications and can solve versioning issues.
Support for accessing server-based forms authentication and profile information in client script. This support is also available to Web applications that are not created by using ASP.NET, as long as the application has access to the Microsoft AJAX Library.
Support for release and debug modes and localization support for both assembly-embedded and standalone JavaScript files

What are ASP.NET AJAX Server Controls?

2008-05-21T23:21:00.001-07:00

The ASP.NET AJAX server controls consist of server and client code that integrate to produce AJAX-like behavior. The following list describes the most frequently used ASP.NET AJAX server controls.

ScriptManager: Manages script resources for client components, partial-page rendering, localization, globalization, and custom user scripts. The ScriptManager control is required in order to use the UpdatePanel, UpdateProgress, and Timer controls.
UpdatePanel: Enables you to refresh selected parts of the page, instead of refreshing the whole page by using a synchronous postback.
UpdateProgress: Provides status information about partial-page updates in UpdatePanel controls.
Timer: Performs postbacks at defined intervals. You can use the Timer control to post the whole page, or use it together with the UpdatePanel control to perform partial-page updates at a defined interval.

Why Use ASP.NET AJAX?

2008-05-21T23:19:00.001-07:00

ASP.NET AJAX enables you to build rich Web applications that have many advantages over Web applications that are completely server-based. ASP.NET AJAX applications offer:

Improved efficiency by performing significant parts of a Web page's processing in the browser.
Familiar UI elements such as progress indicators, tooltips, and pop-up windows.
Partial-page updates that refresh only the parts of the Web page that have changed.
Client integration with ASP.NET application services for forms authentication and user profiles.
Integration of data from different sources through calls to Web services.
A framework that simplifies customization of server controls to include client capabilities.
Support for the most popular and generally used browsers, which includes Microsoft Internet Explorer, Mozilla Firefox, and Apple Safari.

Introduction to the .NET Framework 3.0 (Google Video)

2007-06-10T23:55:00.001-07:00

What Improvements does WCF offers over its earlier counterparts?

2007-04-26T07:59:00.002-07:00

A lot of communication approaches exist in the .NET Framework 2.0 such as ASP.NET Web Services, .NET Remoting, System.Messaging supporting queued messaging through MSMQ, Web Services Enhancements (WSE) - an extension to ASP.NET Web Services that supports WS-Security etc. However, instead of requiring developers to use a different technology with a different application programming interface for each kind of communication, WCF provides a common approach and API.

What are WCF features and what communication problems it solves?

2007-04-26T07:59:00.001-07:00

WCF provides strong support for interoperable communication through SOAP. This includes support for several specifications, including WS-Security, WS-ReliableMessaging, and WS-AtomicTransaction. WCF doesn't itself require SOAP, so other approaches can also be used, including optimized binary protocol and queued messaging using MSMQ. WCF also takes an explicit service-oriented approach to communication, and loosens some of the tight couplings that can exist in distributed object systems, making interaction less error-prone and easier to change. Thus, WCF addresses a range of communication problems for applications. Three of its most important aspects that clearly stand out are:

Unification of Microsoft's communication technologies.
Support for cross-vendor interoperability, including reliability, security, and transactions.
Rich support for service orientation development.

What contemporary computing problems WCS solves?

2007-04-26T07:58:00.004-07:00

WCS provides an entirely new approach to managing digital identities. It helps people keep track of their digital identities as distinct information cards. If a Web site accepts WCS logins, users attempting to log in to that site will see a WCS selection. By choosing a card, users also choose a digital identity that will be used to access this site. Rather than remembering a plethora of usernames and passwords, users need only recognize the card they wish to use. The identities represented by these cards are created by one or more identity providers. These identities will typically use stronger cryptographic mechanisms to allow users to prove their identity. With this provider, users can create their own identities that don't rely on passwords for authentication.

What contemporary computing problems WPF solves?

2007-04-26T07:58:00.003-07:00

User interfaces needs to display video, run animations, use 2/3D graphics, and work with different document formats. So far, all of these aspects of the user interface have been provided in different ways on Windows. For example, a developer needs to use Windows Forms to build a Windows GUI, or HTML/ASPX/Applets/JavaScript etc. to build a web interface, Windows Media Player or software such as Adobe's Flash Player for displaying video etc. The challenge for developers is to build a coherent user interface for different kinds of clients using diverse technologies isn't a simple job.

A primary goal of WPF is to address this challenge! By offering a consistent platform for these entire user interface aspects, WPF makes life simpler for developers. By providing a common foundation for desktop clients and browser clients, WPF makes it easier to build applications.

What is XAML ?

2007-04-26T07:58:00.001-07:00

WPF relies on the eXtensible Application Markup Language (XAML). An XML-based language, XAML allows specifying a user interface declaratively rather than in code. This makes it much easier for user interface design tools like MS Expression Blend to generate and work with an interface specification based on the visual representation created by a designer. Designers will be able to use such tools to create the look of an interface and then have a XAML definition of that interface generated for them. The developer imports this definition into Visual Studio, then creates the logic the interface requires.

What is XBAP?

2007-04-26T07:57:00.003-07:00

XAML browser application (XBAP) can be used to create a remote client that runs inside a Web browser. Built on the same foundation as a stand-alone WPF application, an XBAP allows presenting the same style of user interface within a downloadable browser application. The best part is that the same code can potentially be used for both kinds of applications, which means that developers no longer need different skill sets for desktop and browser clients. The downloaded XBAP from the Internet runs in a secure sandbox (like Java applets), and thus it limits what the downloaded application can do.

What is a service contract ( In WCF) ?

2007-04-26T07:57:00.001-07:00

In every service oriented architecture, services share schemas and contracts, not classes and types. What this means is that you don't share class definitions neither any implementation details about your service to consumers.

Everything your consumer has to know is your service interface, and how to talk to it. In order to know this, both parts (service and consumer) have to share something that is called a Contract.

In WCF, there are 3 kinds of contracts: Service Contract, Data Contract and Message Contract.

A Service Contract describes what the service can do. It defines some properties about the service, and a set of actions called Operation Contracts. Operation Contracts are equivalent to web methods in ASMX technology

In terms of WCF, What is a message?

2007-04-26T07:56:00.004-07:00

A message is a self-contained unit of data that may consist of several parts, including a body and headers.

In terms of WCF, What is a service?

2007-04-26T07:56:00.003-07:00

A service is a construct that exposes one or more endpoints, with each endpoint exposing one or more service operations.

In terms of WCF, What is an endpoint?

2007-04-26T07:56:00.001-07:00

An endpoint is a construct at which messages are sent or received (or both). It comprises a location (an address) that defines where messages can be sent, a specification of the communication mechanism (a binding) that described how messages should be sent, and a definition for a set of messages that can be sent or received (or both) at that location (a service contract) that describes what message can be sent.

An WCF service is exposed to the world as a collection of endpoints.

In terms of WCF, What is an application endpoint?

2007-04-26T07:55:00.000-07:00

An endpoint exposed by the application and that corresponds to a service contract implemented by the application.

In terms of WCF, What is an infrastructure endpoint?

2007-04-26T07:54:00.002-07:00

An endpoint that is exposed by the infrastructure to facilitate functionality that is needed or provided by the service that does not relate to a service contract. For example, a service might have an infrastructure endpoint that provides metadata information.

In terms of WCF, What is an address?

2007-04-26T07:54:00.001-07:00

An address specifies the location where messages are received. It is specified as a Uniform Resource Identifier (URI). The schema part of the URI names the transport mechanism to be used to reach the address, such as "HTTP" and "TCP", and the hierarchical part of the URI contains a unique location whose format is dependent on the transport mechanism.

In terms of WCF, What is an address?

2007-04-26T07:48:00.001-07:00

In terms of WCF, What is binding?

2007-04-26T07:47:00.003-07:00

A binding defines how an endpoint communicates to the world. It is constructed of a set of components called binding elements that "stack" one on top of the other to create the communication infrastructure. At the very least, a binding defines the transport (such as HTTP or TCP) and the encoding being used (such as text or binary). A binding can contain binding elements that specify details like the security mechanisms used to secure messages, or the message pattern used by an endpoint.

What is an operation contract?

2007-04-26T07:47:00.001-07:00

An operation contract defines the parameters and return type of an operation. When creating an interface that defines the service contract, you signify an operation contract by applying the OperationContractAttribute attribute to each method definition that is part of the contract. The operations can be modeled as taking a single message and returning a single message, or as taking a set of types and returning a type. In the latter case, the system will determine the format for the messages that need to be exchanged for that operation.

What is a message contract?

2007-04-26T07:45:00.002-07:00

A message contact describes the format of a message. For example, it declares whether message elements should go in headers versus the body, what level of security should be applied to what elements of the message, and so on.