Are arrays supported in the Soap Toolkit?

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

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?

* 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

Version 2.0 SP2, released June 21, 2001

What is Sensor Devices?

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?

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

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

"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)

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)

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)

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)

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

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

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

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

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

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

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#)

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#)

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

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)

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?

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

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?

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?

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?

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

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

• 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

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

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

• 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