The Visual Basic Team : VB_Express

Two free e-books available till April 22th to celebrate MS Press’s 25th b-day (Daniel Walzenbach)

VBTeam — Fri, 17 Apr 2009 00:30:00 GMT

2009 is the 25th anniversary of Microsoft Press! To celebrate their b-bay they’re giving away two free e-books, namely

Windows Small Business Server 2008 Administrator's Companion by Charlie Russel and Sharon Crawford (27 chapters, 3 appendices, 712 pages)
Microsoft Visual Basic 2008 Express Edition: Build a Program Now! by Patrice Pelland (9 chapters, Glossary, 254 pages)

Before opening one of the links make sure that you disable your Pop-Up blocker as the window containing the book will be opened in a new window. Additionally, when the new window gets opened give it some time to show the content as the VB book is roughly 8MB and the Windows Small Business Server book is around 24MB.

To download the book click "Page >> Save As..." and rename the download in the Save window.

Get them as soon as the offer lasts (April 22nd) :-)

Daniel

Edited April 22, 2009: Included the last section on "How to download the ebooks".

LINQ for the Web Using VB (By Paul Yuknewicz)

VBTeam — Fri, 28 Dec 2007 06:55:00 GMT

Happy holidays! It's been a long time since I've written a post, so I figure I can bring in the new year answering some great questions submitted by you.

Just this week someone gave me this feedback:
"I am having a difficult time finding information to help me adapt to LINQ in my webforms. I am hoping that someone from the team can offer a direction. "

You bet! We have a lot of attention to LINQ and Forms-over-data in VB in our learning content, but we're lacking content with attention to LINQ and Web-based Forms-over-data.

There are a number of great innovations in the Web space that make it easy to leverage LINQ's querying capabilities and mesh that with the richness and flexibility of Web-based UI. It's easy.

There are a few concepts you should learn or know about to get started:

LinqDataSource control -- allows you to use a LINQ query as a data source in Web-based data binding
LinqDataSource.Selecting event - allows you to set any LINQ custom query (including anonymous queries) as the data source. Simply pick LinqDataSource and Selecting events from the VB editor dropdowns, and set e.Result = <your LINQ query> in the event handler code
OR Designer and Linq to SQL - if you're connecting directly to a SQL database with your LINQ query (instead of objects, xml, etc), this is an easy way to create queries and what we call DataContext objects. "OR" is short for Object-Relational mapping, i.e. mapping relational database data to .NET objects
ASP.NET data binding expressions - allows you to evaluate ASP-style <%# Eval("YOURFIELD") %> expressions from data source fields or properties in simple controls or lists of controls

Creating a Simple Web Form with LINQ To SQL

The first post will cover the simplest Web form that will demonstrate this end to end span of concepts. I'll then take input from you to add features and expand on this sample in future posts.

Here's a sample of the initial desired Web form output - a very simple Employee list report for an HR application - admittedly it's bare bones and in need of UI design love:

EmployeeID: 2
Andrew Fuller
Andrew received his BTS commercial in 1974 and a Ph.D. in international marketing from the University of Dallas in 1981. He is fluent in French and Italian and reads German. He joined the company as a sales representative, was promoted to sales manager in January 1992 and to vice president of sales in March 1993. Andrew is a member of the Sales Management Roundtable, the Seattle Chamber of Commerce, and the Pacific Rim Importers Association.

EmployeeID: 1
Nancy Davolio
Education includes a BA in psychology from Colorado State University in 1970. She also completed "The Art of the Cold Call." Nancy is a member of Toastmasters International.

If you are pretty familiar with Visual Studio I expect this will take about 10-15 minutes to walk through on your own machine.

Preparation

- make sure you have Visual Studio 2008 or Visual Web Developer 2008 Express installed. Express Editions are available for download here.
- make sure you have SQL Server 2005 Express installed and running. It typically gets installed by default with VS or VS Express, however, you can also install it from here.
-if you don't have Northwind.mdf on your machine, download it from the attached files on this post.

Adding Data to the Web Site

First we're going to add the database to our project and create necessary classes to use the database in LINQ (using Linq to SQL). Note, you could choose to skip this step and create your own custom LINQ query to any other data source.

create a new Web site on the local file system via File -> New Web Site ... -> ASP.NET Web Site
add the Northwind database to your web site's App_Data folder
1. download Northwind.mdf file from this blog entry and save it to disk
2. drag and drop this file into the App_Data folder in Solution Explorer
Create LINQ to SQL classes for Northwind using the OR Designer. Linq to SQL classes will be stored in a .dbml file and can be opened in the visual OR Designer.
1. Right-click on the WebSite node in Solution Explorer, Add New Item -> Linq To SQL Classes
2. Rename the file from "DataClasses.dbml" to "NorthwindDataClasses.dbml". (This is important so classes can be found in code and in VS wizards).
4. When prompted, click Yes to add this file to the App_Code folder. This is important b/c the Web sitfe needs to dynamically compile generated code created by the designer.
6. Double click NorthwindDataClasses.dbml to open it in the OR Designer.
Add Employee table objects to your Linq to SQL classes
1. Open Server Explorer (or Database Explorer in Express)
2. Expand Northwnd.MDF -> Tables -> Employees
3. Drag and Drop the Employees table node from Server Explorer to the NorthwindDataClasses.dbml design surface (NOTE: you could continue to add more Tables, or Stored Procedures, or customize the names/properties in the designer).
4. Save All files

Laying Out Form UI & DataSource Controls

Now that we've added the database to the Web site and created necessary LINQ to SQL classes, it's time to create some UI and wire up the data to the UI. I won't do anything too fancy - just repeat data bound labels in a DataList (you could replace this with GridView, FormView or choose your favorite control).

Double-click Default.aspx to open the page in the designer
Drag n drop a DataList from the data tab of Toolbox to the Default.aspx design surface (or to the correct DIV area in mark up "Source" view)
Drop n drop a LinqDataSource control from the data tab of the Toolbox to the Default.aspx design surface (or just below the DataList in "Source" view)

Wiring up the LinqDataSource to Underlying Data (LINQ to SQL - DataContext)

The LinqDataSource needs to be wired up to the underlying LINQ data. In this case data is provided by any DataContext object or query over an object of the NorthwindDataClasses type (a LINQ to SQL file). The DataList then simply needs to use the LinqDataSource as the data source, and display data from bound fields using traditional Eval("") statements. The designer will generate a set of defaults for you if you use the Smart Tags. Let's give it a shot with defaults, and then we can fine tune it from there.

Select the LinqDataSource control in the designer. Expand the smart tag and click Configure Data Source...
A wizard pops up and should default to picking your NorthwindDataClasses as the source. (any other queryable sources you add will show up here). Click Next.
You can optionally pick any specific subset of columns/fields. I just chose * for this example. You could even configure a Where clause -- however I honestly think it's easier to do parameterized queries and other query operations in code. I'll show that later ... Click Finish.
Optionally you can Enable Delete, Insert, and Update for the LinqDataSource using the Smart Tag. TIP: This is handy if you're going to build a read/write web form.

Here is the resulting mark up for the LinqDataSource as seen in "Source" view. Note how the ContextTypeName="NorthwindDataClassesDataContext" -- this matches the name of the type we created in the designer (the code gen appends "DataContext" to the end -- whew that's long!). The TableName is set to the Table or Property we want to display -- Employees in this case. You could use this pattern to bind to any DataContext type and class property within.

<asp:LinqDataSource ID="LinqDataSource1" runat="server" ContextTypeName="NorthwindDataClassesDataContext"
    TableName="Employees">
</asp:LinqDataSource>

Binding UI Controls to LinqDataSource

Now let's wire up the DataList to the LinqDataSource. The nice thing here is the DataList only cares about the field names returned from the LINQ query via the LinqDataSource -- this shields you as you continue to refine the fields and row results of your dynamic LINQ queries.

Select the DataList in the designer. Expand the smart tag and Choose Data Source = LinqDataSource1
Customize the DataList's ItemTemplate
Run it! (F5 or View in Browser)

The wizard will create a series of bound labels by default. You can use the designer in edit mode to get the specific fields, look and feel you want. TIP: This is typically where I drop in the html mark up "Source" view. In my example, I'll simply show the full name, notes, and have a place holder to show an employee photo image. I also format the data in a two column table.

If you look at the DataList mark up, you see the ItemTemplate contains a number of bound labels. Binding to data from the query is simply a matter of typing in <%# Eval("YOURFIELDNAME") %> in your server control fields using classic ASP-style & VB data binding eval statements. This gives you a lot of flexibility to display just the data you want, formatted how you want. Here's my customization:

<div>
    <asp:DataList ID="DataList1" runat="server" DataKeyField="EmployeeID" DataSourceID="LinqDataSource1">
        <HeaderTemplate>
            <table>
        </HeaderTemplate>
        <ItemTemplate>
            <tr>
                <td>
                    <img src="PLACEHOLDER.jpg" class="" style="border: 4px solid white" 
                          alt='Photo Number XXX' />
                    <br /><br />
                </td>
                <td>
                    EmployeeID:
                    <asp:Label ID="EmployeeIDLabel" runat="server" Text='<%# Eval("EmployeeID") %>' />
                    <br />
                    <asp:Label ID="LastNameLabel" runat="server" 
                          Text='<%# Eval("FirstName") & " " & Eval("LastName") %>' />
                    <br />
                    <asp:Label ID="NotesLabel" runat="server" Text='<%# Eval("Notes") %>' />
                </td>
            </tr>
        </ItemTemplate>
        <FooterTemplate>
            </table>
        </FooterTemplate>
    </asp:DataList>
</div>

Using Custom LINQ Queries

The technique above provides a zero-code method for binding Web forms to LINQ data. However, you might be asking yourself, where is the LINQ and VB here? It's true the LinqDataSource hides all the querying code and constrains what you can do via the designer. This is fine for some simple cases, but the real power of LINQ is being able to use your own free form queries and VB logic. The good news is LinqDataSource supports using your own LINQ queries using the LinqDataSource.Selecting event. This is your hook to tell the control exactly what query should be used. It's easy. Here's how:

Right-click on Default.aspx and select View Code ... to see the VB code behind file (Default.aspx.vb).
In the left-hand-side dropdown above the code editor, select the LinqDataSource1 object.
In the right-hand-side dropdown above the code editor, select the Selecting event. The event handler is stubbed out.
Write your custom LINQ query in the event handler. Make sure you set e.Result = <your LINQ query variable> before the event handler routine is finished running.

In my example I will query over Northwind employees, define a custom expression column called FullName (=First + Last), filter by full name starting with A or N, and sort by last name. Note I'm creating aliases for each property and hence the query is now an anonymous type -- and the schema is now custom vs. my default NorthwindDataContext with all (*) columns. TIP: if you're getting runtime errors when you try this make sure all the fields expected by your Web form are there -- e.g. if the form is expecting "EmployeeID" make sure your query Selects it.

Protected Sub LinqDataSource1_Selecting(ByVal sender As Object, ByVal e _
                                        As System.Web.UI.WebControls.LinqDataSourceSelectEventArgs) _
                                        Handles LinqDataSource1.Selecting

    Dim northwind As New NorthwindDataClassesDataContext

    'custom anonymous LINQ query
    Dim query = From emp In northwind.Employees _
                Select emp.EmployeeID, emp.FirstName, emp.LastName, emp.Notes, _
                    FullName = emp.FirstName & " " & emp.LastName _
                Where FirstName.ToUpper.StartsWith("A") Or FirstName.ToUpper.StartsWith("N") _
                Order By FullName

    'sets LinqDataSource query equal to custom query.  
    'use data binding expressions to look up aliased fields above. 
    e.Result = query
End Sub

You can run the app again and see the custom query is working -- only two rows are returned -- Andrew Fuller and Nancy Davolio. We could also tweak the markup to make use of our new aliased expression column -- "FullName". Here's how that would look in the DataList:

<asp:DataList ID="DataList1" runat="server" DataKeyField="EmployeeID" DataSourceID="LinqDataSource1">
    <HeaderTemplate>
        <table>
    </HeaderTemplate>
    <ItemTemplate>
        <tr>
            <td>
                <img src="PLACEHOLDER.jpg" class="" style="border: 4px solid white" alt='Photo Number XXX' />
                <br /><br />
            </td>
            <td>
                EmployeeID:
                <asp:Label ID="EmployeeIDLabel" runat="server" Text='<%# Eval("EmployeeID") %>' />
                <br />
                <asp:Label ID="LastNameLabel" runat="server" Text='<%# Eval("FullName") %>' />
                <br />
                <asp:Label ID="NotesLabel" runat="server" Text='<%# Eval("Notes") %>' />
            </td>
        </tr>
    </ItemTemplate>
    <FooterTemplate>
        </table>
    </FooterTemplate>
</asp:DataList>

Summary & More Info

To wrap things up, it's easy to map what you know about Web Forms to what you're learning about Linq in VB. The LinqDataSource connects your underlying Linq to SQL DataContext, or any generalized Linq query, to the rest of your Web Form. You can create totally custom queries in the LinqDataSource.Selecting event and pass that to the control via e.Result. And then you can get at any field or property in your Linq query using classic Eval("MYFIELD") data binding expressions.

What do you think? What additions would you like to see?

If you want more info now, ScottGu put together an awesome series of Linq to SQL posts for the Web, and he included VB sample code. Another great portal for learning and How To content is www.asp.net.

Best,

Paul

----------------------------------

Paul Yuknewicz
Lead Program Manager
Microsoft Visual Studio
http://msdn.com/vbasic/

Channel 9 Interview: Brian Beckman Does Higher Algebra with Visual Basic (Beth Massi)

VBTeam — Wed, 19 Dec 2007 19:01:00 GMT

I just posted an interview on Channel 9 with Brian Beckman, Principal Developer (currently working with Erik Meijer), where he attempts to teach me higher algebra using Visual Basic, generics, and operator overloading. Brian is a wonderful person and brilliant physicist and we have a lot of fun with vectors and matrices and VB. I actually think I understood some of what Brian showed me ;).

Visual Basic is a great language for mathematics as well as all kinds of other applications. Brian makes the point that he has fun coding in VB because of its intuitive style and how easy it is to be immediately productive. Check out Brian's blog post on the VB Team blog! And for all you abstract algebra aficionados, here's the code to play with.

Enjoy,
-Beth Massi, VS Community

Higher Algebra with Operator Overloads (Brian Beckman)

VBTeam — Wed, 19 Dec 2007 19:00:00 GMT

Recently I did a Channel 9 interview with Beth Massi where I walked through a Visual Basic program that used Generics and Operator overloads to perform some higher mathematics. I thought I'd follow up with a post explaining the details of exactly what I did.

Operator overloads with Generics enable some beautiful designs for data types in Higher Algebra, a branch of mathematics, sometimes called Abstract Algebra. Consider fields and vector spaces. I'll show you operator overloads at THREE levels in a single design. First, background: In this context, a "field" is a collection of unspecified objects, closed under two associative operators, + and *, that obey the distributive law.

Closed means that for any a, b, and c in the field, a+b and a*c are in the field. Associative means

a + (b + c) = (a + b) + c

a * (b * c) = (a * b) * c

Distributive means

a * (b + c) = a * b + a * c

(b + c) * a = b * a + c * a

The field must also have two special members: the additive unit 0 and the multiplicative unit 1, where

a + 0 = 0 + a = a

a * 1 = 1 * a = a

and must have for every a, an additive inverse, -a, such that a + -a = -a + a = 0. There must also be a multiplicative inverse for every element except 0, written 1/a, such that a * 1/a = 1/a * a = 1.

Some authors insist on the commutative laws (a + b = b + a, a * b = b * a), too, but we don't, here. The most common examples of fields are the Rationals, the Real numbers, the Complex numbers, all of which have commutative addition and multiplication; and the Quaternions, which have non-commutative multiplication.

Don't confuse the mathematical "field" with a "field" in a record, structure or class.

In each instance of a field, we define + and * to do anything we want so long as they obey the associative and distributive laws. A "vector space over a field" is the set of n-tuples or vectors built up from members of the field and closed under an additional linear combination law, written with no operator symbol, or sometimes with *. If v and w are any two vectors, and f and g are any two members of the underlying field, then f v + g w is a vector, and, furthermore,

f (v + w) = f v + f w

(v + w) g = v g + w g

(f + g) v = f v + g v

w (f + g) = w f + w g

Vector spaces are central in physics and simulation. Imagine 6-vectors of real numbers; such things represent particle states in "phase space" in classical mechanics. Imagine 4-vectors of complex numbers; such things appear in quantum mechanics. Similar structures occur all over Quantum Theory and Gravitation

References:

"Vector Calculus, Linear Algebra, and Differential Forms" [VCLADF], by John H. Hubbard, Barbara Burke Hubbard;
"Lie Groups, Lie Algebras, and Some of Their Applications," by Robert Gilmore
"The Geometry of Physics," by Theodore Frankel

Applications for vectors of quaternions are not so easy to come by, but, they are perfectly well defined, and, if we do our software design right, they "just work." Ditto for vectors over a purely symbolic field or over any other kind. It's not difficult to support field-like algebraic structures with non-associative multiplication within the same software design. Such things include the Cayley numbers or octonions, but, because of non-associativity, they don't mesh easily with linear algebra, and that's where we want to go. Stop with the quaternions.

We extend the design to inner-product spaces, in which every vector has a dual, and to linear algebras: sets of linear transformations of vectors, realized as matrices. With just a little code, we build a general, extensible, optimizable library suitable for physics, engineering, and mathematics in any finite-dimensional vector spaces.

We want three layers:

underlying types
field types, generic over the underlying types
linear-algebra types, generic over the field types

The underlying types comprise built-ins like Double, and custom types like Rational, Complex, Quaternion, and Symbol. Underlying types should implement the basic field operations, but can have many more operations for convenience, like optimized division routines. Operator overloading is a no-brainer for the underlying types.

At the top level of the linear-algebra types, operator overloads are again a no-brainer for vector + vector, matrix * vector, vector * matrix, matrix * matrix, vector * vector, and so on.

At the middle layer, the field types abstract and narrow the operations down to the bare minimum so that the linear-algebra types know what and only what to expect. In this layer, operator overloading is not quite a no-brainer, and there are a couple of different ways to go with a design.

The first paragraph showed the field axioms, and these are what we must design into our field types. One way to do that is to impose the field operations by interface:

Public Interface IField(Of U) 'U is the "UNDERLYING" type

    'Get the underlying value.

    Property UValue() As U

    'Generic users of IField type shouldn't be able to tell 
    'whether the Underlying type U has copy-reference 
    'semantics or copy-value semantics, so let's insist that 
    'providers of IField implement a Dup operation.

    Function Dup() As IField(Of U)

    'This is what fields do (would be nice to have a contract 
    'for the distributive law). Must use a design like this 
    'since Interfaces cannot host Shared functions in general, 
    'and operator overloads in particular. 

    Function Add(ByVal that As IField(Of U)) As IField(Of U)
    Function Mul(ByVal that As IField(Of U)) As IField(Of U)
    Function AdditiveInverse(ByVal that As IField(Of U)) _
    As IField(Of U)
    Function MultiplicativeInverse(ByVal that As IField(Of U)) _
    As IField(Of U)

    'Every field must have these. Implement them as Shared and 
    'even Const if possible. 

    ReadOnly Property Zero() As IField(Of U)
    ReadOnly Property Unity() As IField(Of U)

    'The following is an auxiliary operation for the Normed 
    'Division Algebras to support Inner Product, or 
    '"Sesquilinear mappings." This computes the complex 
    'conjugate, the quaternion conjugate, and so on. If the 
    'underlying field does not have a natural dual field, then 
    'it's probably self-dual and just implement "Dual" as "Dup."

    Function Dual() As IField(Of U)

End Interface

An upside of this design is that both Structure types and Class types can implement the interface. Thus, the linear-algebra classes are independent of differences of copy semantics. Programmers may use Structure types for run-time speed at both the underlying-type level and at the field level.

Here's an example of a Structure implementing a field of Doubles

Public Structure SFDouble
    Implements IField(Of Double)
...
    Private mValue As Double
    Public Property UValue() As Double Implements IField(Of Double).UValue
        Get
            Return mValue
        End Get
        Set(ByVal value As Double)
            mValue = value
        End Set
    End Property

    Public Sub New(ByVal d As Double)
        mValue = d
    End Sub
...
    Public Function Add(ByVal that As IField(Of Double)) As IField(Of Double) _
    Implements IField(Of Double).Add
        Return New SFDouble(Me.UValue + that.UValue)
    End Function

    Public Function Dual() As IField(Of Double) Implements IField(Of Double).Dual
        Return New SFDouble(Me.UValue)
    End Function

    Public Function Dup() As IField(Of Double) Implements IField(Of Double).Dup
        Return New SFDouble(Me.UValue)
    End Function

    Public Function AdditiveInverse(ByVal that As IField(Of Double)) As IField(Of Double) _
    Implements IField(Of Double).AdditiveInverse
        'Let the underlying math throw exception here if that.UValue == 0
        Return New FDouble(-Me.UValue)
    End Function

    Public Function MultiplicativeInverse(ByVal that As IField(Of Double)) As IField(Of Double) _
    Implements IField(Of Double).MultiplicativeInverse
        'Let the underlying math throw exception here if that.UValue == 0
        Return New FDouble(1 / Me.UValue)
    End Function

    Public Function Mul(ByVal that As IField(Of Double)) As IField(Of Double) _
    Implements IField(Of Double).Mul
        Return New SFDouble(Me.UValue * that.UValue)
    End Function

    Private Shared sUnity = New SFDouble(1.0)
    Private Shared sZero = New SFDouble(0.0)

    Public ReadOnly Property Unity() As IField(Of Double) Implements IField(Of Double).Unity
        Get
            Return sUnity
        End Get
    End Property

    Public ReadOnly Property Zero() As IField(Of Double) Implements IField(Of Double).Zero
        Get
            Return sZero
        End Get
    End Property
...
End Structure

A Big Downside though, for the purposes of this exercise, is no operator overloads at the field level, because operator overloads
are Shared by definition (i.e., static) and interfaces can't support static methods (the reason is that static virtual methods don't make sense in .NET, and all methods in an interface are virtual).

But, we want operator overloads at the field level, and we can get them through an alternative base-class design for fields. We lose Structures at the field level, since particular fields must inherit from a base Class, but the underlying types can still be structures.

Public MustInherit Class AField(Of U) 'U is the "UNDERLYING" type
...
    Private mUValue As U
    Public Property UValue() As U
        Get
            Return mUValue
        End Get
        Set(ByVal value As U)
            mUValue = value
        End Set
    End Property

    'Now, our operator overloads just call virtual MustOverride Functions. 
    'Magically, these are NON-COMMUTATIVE in general, just as we want.

    Public Shared Operator +(ByVal e1 As AField(Of U), _
                             ByVal e2 As AField(Of U)) As AField(Of U)
        Return e1.Add(e2)
    End Operator

    Public Shared Operator -(ByVal e1 As AField(Of U), _
                             ByVal e2 As AField(Of U)) As AField(Of U)
        Return e1.Add(e2.AdditiveInverse())
    End Operator

    Public Shared Operator *(ByVal e1 As AField(Of U), _
                             ByVal e2 As AField(Of U)) As AField(Of U)
        Return e1.Mul(e2)
    End Operator

    Public Shared Operator /(ByVal e1 As AField(Of U), _
                             ByVal e2 As AField(Of U)) As AField(Of U)
        Return e1.Mul(e2.MultiplicativeInverse())
    End Operator

    Public Shared Operator -(ByVal that As AField(Of U)) As AField(Of U)
        Return that.AdditiveInverse()
    End Operator

    Public Shared Operator Not(ByVal that As AField(Of U)) As AField(Of U)
        Return that.Dual()
    End Operator

    'This is what fields do (would be nice to have a contract for the 
    'distributive law). 

    MustOverride Function Add(ByVal that As AField(Of U)) As AField(Of U)
    MustOverride Function Mul(ByVal that As AField(Of U)) As AField(Of U)
    MustOverride Function AdditiveInverse() As AField(Of U)
    MustOverride Function MultiplicativeInverse() As AField(Of U)

    'Every field must have these. Implement them as Shared and even Const if
    'possible. 

    MustOverride ReadOnly Property Zero() As AField(Of U)
    MustOverride ReadOnly Property Unity() As AField(Of U)

    'Generic users of IField type shouldn't be able to tell 
    'whether the Underlying type U has copy-reference 
    'semantics or copy-value semantics, so insist that 
    'subclasses of AField implement a Dup operation.

    MustOverride Function Dup() As AField(Of U)

    'The following is an auxiliary operation for the Normed 
    'Division Algebras to support Inner Product, or 
    '"Sesquilinear mappings." This computes the complex 
    'conjugate, the quaternion conjugate, and so on. If the 
    'underlying field does not have a natural dual field, then 
    'it's probably self-dual and just implement "Dual" as "Dup."

    MustOverride Function Dual() As AField(Of U)

End Class

Now we have operator overloads at the field level, but they're not virtual (they can't be). What they do is statically dispatch to
virtual ADD and MUL methods, which are just like the ones we had in the interface design for the field level. Nice, eh? Here are the implementations for the field of Complexes, which are implemented in an underlying Structure type:

Public Class AComplex
    Inherits AField(Of Complex)
...

    Public Overrides Function Add(ByVal that As AField(Of Complex)) As AField(Of Complex)
        Return New AComplex(Me.UValue + that.UValue)
    End Function

    Public Overrides Function AdditiveInverse() As AField(Of Complex)
        Return New AComplex(-Me.UValue.R, -Me.UValue.I)
    End Function

    Public Overrides Function Dual() As AField(Of Complex)
        Return New AComplex(Not Me.UValue)
    End Function

    Public Overrides Function Dup() As AField(Of Complex)
        Return New AComplex(Me)
    End Function

    Public Overrides Function MultiplicativeInverse() As AField(Of Complex)
        Return New AComplex(1.0 / Me.UValue)
    End Function

    Public Overrides Function Mul(ByVal that As AField(Of Complex)) As AField(Of Complex)
        Return New AComplex(Me.UValue * that.UValue)
    End Function
...

    Public Overrides ReadOnly Property Unity() As AField(Of Complex)
        Get
            Return New AComplex(1.0, 0.0)
        End Get
    End Property

    Public Overrides ReadOnly Property Zero() As AField(Of Complex)
        Get
            Return New AComplex(0.0, 0.0)
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return UValue.ToString()
    End Function

End Class

And here is its underlying type:

Imports System.Text

Public Structure Complex

    Private mR As Double
    Public Property R() As Double
        Get
            Return mR
        End Get
        Set(ByVal value As Double)
            mR = value
        End Set
    End Property

    Private mI As Double
    Public Property I() As Double
        Get
            Return mI
        End Get
        Set(ByVal value As Double)
            mI = value
        End Set
    End Property
...
    Public Shared Operator -(ByVal that As Complex) As Complex
        Return New Complex(-that.R, -that.I)
    End Operator

    Public Shared Operator +(ByVal c1 As Complex, ByVal c2 As Complex) As Complex
        Dim result = New Complex()
        result.R = c1.R + c2.R
        result.I = c1.I + c2.I
        Return result
    End Operator

    Public Shared Operator *(ByVal c1 As Complex, ByVal c2 As Complex) As Complex
        Dim result = New Complex()
        result.R = (c1.R * c2.R) - (c1.I * c2.I)
        result.I = (c1.R * c2.I) + (c1.I * c2.R)
        Return result
    End Operator

    Public Shared Operator Not(ByVal c1 As Complex) As Complex
        Return New Complex(c1.R, -c1.I)
    End Operator
...

    Public Shared Operator *(ByVal c As Complex, ByVal scalar As Double) As Complex
        Return New Complex(c.R * scalar, c.I * scalar)
    End Operator

    Public Shared Operator /(ByVal c As Complex, ByVal scalar As Double) As Complex
        Return New Complex(c.R / scalar, c.I / scalar)
    End Operator

    Public Shared Operator /(ByVal c1 As Complex, ByVal c2 As Complex) As Complex
        Return c1 * Not c2 / c2.MagnitudeSquared()
    End Operator
...

End Structure

Now, we have an example of a Field generic on an underlying type, How about the Vector space? I wrote one vector space generic
on the interface-style Field design, and another vector space generic on the base-class Field design. Here is the latter one, it's prettier:

Imports System.Text

'The only reason I must mention the underlying type, U, here, is to pass it to the
'Generic AField interface. I don't use U anywhere explicitly inside this. If I had 
'"Monads" in the Generic type language, then I could thread U through this via a 
'"bind" operator, very pretty, but dreamland.

Public Class ANVector(Of U, T As {New, AField(Of U)})

    Private mDimension As Integer
    Public ReadOnly Property Dimension() As Integer
        Get
            Return mDimension
        End Get
    End Property

    Private mComponents() As T
    Default Property Component(ByVal i As Integer) As T
        Get
            Component = mComponents(i)
        End Get
        Set(ByVal Value As T)
            mComponents(i) = Value
        End Set
    End Property
...

    Public Sub New(ByVal that As ANVector(Of U, T))
        mDimension = that.Dimension
        ReDim mComponents(Dimension)
        For i = 1 To Dimension
            'Cannot call New with parameters on Generic types ... Sorry)
            ' --> Me.mComponents(i) = New T(that(i))
            Me.mComponents(i) = that(i).Dup()
        Next
    End Sub

    'Add two vectors. PROPERLY, vectors should themselves implement IModule, etc. Some day...
    Public Shared Operator +(ByVal V1 As ANVector(Of U, T), ByVal V2 As ANVector(Of U, T)) _
    As ANVector(Of U, T)
        If V1.Dimension <> V2.Dimension Then
            Throw New VectorSpaceException("Cannot add vectors of different dimensions")
        Else
            Dim result = New ANVector(Of U, T)(V1) 'clone
            For i = 1 To result.Dimension
                result(i) = result(i) + V2(i)''' OPERATOR OVERLOADS BEING USED 
            Next
            Return result
        End If
    End Operator

    'Scale a vector
    Public Shared Operator *(ByVal that As ANVector(Of U, T), ByVal scalar As T) _
    As ANVector(Of U, T)
        Dim result = New ANVector(Of U, T)(that)
        For i = 1 To result.Dimension
            result(i) = result(i) * scalar''' OPERATOR OVERLOADS BEING USED 
        Next
        Return result
    End Operator

    Public Shared Operator *(ByVal scalar As T, ByVal that As ANVector(Of U, T)) _
    As ANVector(Of U, T)
        Return that * scalar''' OPERATOR OVERLOADS BEING USED 
    End Operator

    Public Function Dual()
        Dim result = New ANVector(Of U, T)(Me.Dimension)
        For i = 1 To result.Dimension
            result(i) = Not result(i)''' OPERATOR OVERLOADS BEING USED 
        Next
        Return result
    End Function

    Public Shared Operator Not(ByVal V As ANVector(Of U, T)) As ANVector(Of U, T)
        Return V.Dual()
    End Operator

    'Inner product
    Public Shared Operator *(ByVal Left As ANVector(Of U, T), ByVal Right As ANVector(Of U, T)) _
    As T
        If Left.Dimension <> Right.Dimension Then
            Throw New VectorSpaceException _
            ("Cannot compute inner product of vectors with different dimensions")
        Else
            Dim result As New T()
            Dim temp As New T()
            For i = 1 To Left.Dimension
                result = result + Left(i) * Not Right(i)''' OPERATOR OVERLOADS BEING USED 
            Next
            Return result
        End If
    End Operator
...
End Class
'================================================================

Imports System.Text

Public Class AMNMatrix(Of U, T As {New, AField(Of U)})

    Private mRowCount As Integer
    Public ReadOnly Property Rows() As Integer
        Get
            Return mRowCount
        End Get
    End Property

    Private mColumnCount As Integer
    Public ReadOnly Property Columns() As Integer
        Get
            Return mColumnCount
        End Get
    End Property

    Private mElements As T(,)
    Default Property Element(ByVal i As Integer, ByVal j As Integer) As T
        Get
            Return mElements(i, j)
        End Get
        Set(ByVal Value As T)
            mElements(i, j) = Value
        End Set
    End Property
...
    'Scale a matrix
    Public Shared Operator *(ByVal scalar As T, ByVal that As AMNMatrix(Of U, T)) _
    As AMNMatrix(Of U, T)
        Dim result = New AMNMatrix(Of U, T)(that)
        For i = 1 To that.Rows
            For j = 1 To that.Columns
                result(i, j) = result(i, j) * scalar ''' OPERATOR OVERLOADS BEING USED
            Next
        Next
        Return result
    End Operator

    'Scale a matrix
    Public Shared Operator *(ByVal that As AMNMatrix(Of U, T), ByVal scalar As T) _
    As AMNMatrix(Of U, T)
        Return scalar * that''' OPERATOR OVERLOADS BEING USED 
    End Operator

    'Matrix plus matrix 
    Public Shared Operator +(ByVal M1 As AMNMatrix(Of U, T), ByVal M2 As AMNMatrix(Of U, T)) _
    As AMNMatrix(Of U, T)
        If M1.Rows <> M2.Rows Or M1.Columns <> M2.Columns Then
            Throw New VectorSpaceException("Cannot add matrices of different dimensions")
        Else
            Dim result = New AMNMatrix(Of U, T)(M1)
            For i = 1 To M1.Rows
                For j = 1 To M1.Columns
                    result(i, j) = result(i, j) + M2(i, j) ''' OPERATOR OVERLOADS BEING USED
                Next
            Next
            Return result
        End If
    End Operator

    'Matrix times a vector
    Public Shared Operator *(ByVal m As AMNMatrix(Of U, T), ByVal v As ANVector(Of U, T)) _
    As ANVector(Of U, T)
        If m.Columns <> v.Dimension Then
            Throw New VectorSpaceException("The number of columns in the matrix must equal " & _
                                           "the dimension of the vector")
        Else
            Dim result = New ANVector(Of U, T)(m.Rows)
            For i = 1 To m.Rows
                For j = 1 To m.Columns
                    result(i) = result(i) + v(j) * m(i, j) ''' OPERATOR OVERLOADS BEING USED
                Next
            Next
            Return result
        End If
    End Operator

    'Vector times a Matrix 
    Public Shared Operator *(ByVal v As ANVector(Of U, T), ByVal m As AMNMatrix(Of U, T)) _
    As ANVector(Of U, T)
        If m.Rows <> v.Dimension Then
            Throw New VectorSpaceException("The dimension of the vector must equal" & _
                                           "the number of rows in the matrix")
        Else
            Dim result = New ANVector(Of U, T)(m.Columns)
            For j = 1 To m.Columns
                For i = 1 To m.Rows
                    result(j) = result(j) + v(i) * m(i, j) ''' OPERATOR OVERLOADS BEING USED
                Next
            Next
            Return result
        End If
    End Operator

    'Matrix times Matrix
    Public Shared Operator *(ByVal left As AMNMatrix(Of U, T), ByVal right As AMNMatrix(Of U, T)) _
    As AMNMatrix(Of U, T)
        If left.Columns <> right.Rows Then
            Throw New VectorSpaceException("The number of columns in the left matrix must equal" & _
                                           "The number of rows in the right matrix")
        Else
            Dim result = New AMNMatrix(Of U, T)(left.Rows, right.Columns)
            Dim inner = left.Columns
            For i = 1 To result.Rows
                For j = 1 To result.Columns
                    For k = 1 To inner ''' OPERATOR OVERLOADS BEING USED
                        result(i, j) = result(i, j) + left(i, k) * right(k, j)
                    Next
                Next
            Next
            Return result
        End If
    End Operator
...
End Class

There we go: operator overloading at three levels! I've uploaded a zipped Visual-Studio 2008 project to my Public folder with all this code.
Play around, let me know what you think.

Hidden Gems in Visual Basic 2008 (Amanda Silver)

VBTeam — Wed, 21 Nov 2007 09:24:16 GMT

Yesterday I promised to post about the hidden gems in Visual Basic and Visual Studio 2008 that you haven’t read about in blog posts or seen at conferences. I forgot that I mentioned a few of my favorite features in the Beta1 announcement where I showed off the improvements in the Intellisense experience – statement completion for keywords, local variables, and expressions. In that post, I also cover a new language feature called Relaxed Delegates which allows you to provide alternate signatures for events. Both of those are pretty great features – but I promised to tell you about some new stuff.

I polled the team and we came up with the following top ten that weren’t mentioned in my previous post. There’s so much I could talk about – but you’re going to have to check back. But first, I have to start with a keynote feature…

0) Multi-targetting

In short, multi-targetting allows you to use Visual Studio 2008 (and VB 9!) to target the .NET 2.0 frameworks. All of the following features I’ll show you can be leveraged even if you’re targeting .NET 2.0! (With the exception of items #5 & #7 as they depend on the LINQ to Objects and LINQ to XML APIs which reside in .NET 3.5) To do this, when you start up Visual Studio and create a new project, just make sure that the target framework is set to .NET Framework 2.0.

Note that projects you’re upgrading, will automatically target .NET Framework 2.0 until you add references to .NET 3.0 or 3.5 assemblies.

1) Type Inference

In Visual Basic 9, in the following bit of code and NOTHING is late-bound – everything is bound at compile-time which means you get Intellisense and type checking.

        Dim dialog = New OpenFileDialog()
        Dim result = dialog.ShowDialog()
        Dim printStr = "C:\"
        If result = Windows.Forms.DialogResult.OK Then
            printStr = dialog.FileName
        End If
        MsgBox(printStr)

This makes prototyping very quick, easy, and type-safe! This feature and the mechanisms that control it are comprehensively covered in this article by a member of our QA team, Bill Horst.

2) If Operator

Ever notice that the IIF function returns something of type Object? This means that you don’t get Intellisense or type-checking by default on that result. For those of you that insist on type-safe, early-bound code, you have to cast the result. The code then looks something like this:

        Dim intC As Integer = CInt(IIf(intA = intB, intA, intB - 1))

With the If operator, you can now write that line as:

        Dim intD As Integer = If(intA = intB, intA, intB)

And with type inference it gets even easier on the eyes:

I'm a fan of any feature that improves readability.

3) Object Initializers

Generally, in the .NET frameworks, we try to design APIs that use the create-set-call pattern as our usability studies have indicated they are the easiest to use by the average programmer. Nevertheless, objects that don’t have a parameterless constructor exist in the .NET framework. When that happens, it’s really nice to be able to leverage Object Initializers which are kind of like a Dim and a With statement combined into an expression. That makes parameterized constructors somewhat easier to tolerate:

        Dim strm As New StreamWriter( _
                      New FileStream("C:\out.txt", FileMode.OpenOrCreate) _
                        With {.Position = 10})

It also makes creating arrays of objects much easier.

        Dim Capitals() As City = {New City With {.Name = "Antanarivo", .Country = "Madagascar"}, _
          New City With {.Name = "Belmopan", .Country = "Belize"}, _
          New City With {.Name = "Monaco", .Country = "Monaco"}, _
          New City With {.Country = "Palau", .Name = "Koror"}}

4) Nullable

Nullable is the feature you’ll notice but rarely have to think about. It’s basically the .NET representation for a Nullable value type (Integer, Date, etc.) Using the designer for LINQ to SQL, the Object-Relational Mapping layer introduced in Visual Studio 2008, nullable columns in your database are mapped to this type. The result is that you can write the following expression in VB and the right thing happens – null valued rows propagate null. In the example below, the Independence property on the Country type is a nullable date, denoted as Date?

        Dim virginIslands As New Country With {.Independence = Nothing}
        Dim palau As New Country With {.Independence = #10/1/1994#}

        Dim vILength = #8/24/2005# - virginIslands.Independence ' Nothing
        Dim pLength = #8/24/2005# - palau.Independence ' 3980.00:00:00

5) LINQ to DataSet

I love this feature because it means never having to say you’re sorry… No, really, it means that you don’t need to migrate to a new data access technology to reap the benefits of LINQ. I fill my DataSet just as before, and then I can query against the DataSet:

        Me.EmployeesTableAdapter.Fill(Me.NORTHWNDDataSet.Employees)
        Dim query = From emp In Me.NORTHWNDDataSet.Employees _
                    Where emp.Country = "USA" _
                    Order By emp.HireDate _
                    Select emp
        Me.EmployeesBindingSource.DataSource = query

6) Syntax Tooltips

How cool is this?

How about this?

What do you think of this?

7) XML Namespace support in Intellisense

We’ve blogged about XML Intellisense before. But there’s a tidbit we’ve overlooked.

When namespaces are used in the XML document you’re reading from, the Intellisense engine matches the namespace prefix and the local name. This little productivity boost can yield a significant savings in keystrokes. Instead of typing the prefix then the colon and then the local name, you just type a little bit of the local name and hit enter. Here is a small example of how it works, starting with an input document and the applicable intellisense:

If we just type the letter “t” the “tomato” entry will be selected:

If we type the letter “e” the “exa:eggplant” will be selected and the completion list will also contain the prefix “exa” and the “elephant” entry:

The next character that will be typed will determine which single entry will get selected. Now, how easy was that?

8) GoTo Type Definition

Often, when you define a variable, you want to view the type definition in code or in the Object Browser. There’s a new option in the context menu which allows you to go directly to the type definition instead of just the variable declaration. This is great when combined with type inference as it allows you confirm that the type of the variable is actually what you believe it to be.

9) Type inference for loop variables

Check out the following code:

And this code:

Without having to specify the type of the control variable, it’s inferred from right-hand-side expression or the collection we’re iterating over.

10) Performance improvements and… Non-blocking operations!

The background compiler is an awesome feature that gives you immediate feedback on the correctness of the code you write. We’ve made some tremendous strides in the performance of the background compiler in this release. We believe that the background compiler is 3 times faster uses 3 times less memory. Anyone who has migrated their project to 2008 should notice an improvement after a couple minutes of use.

While we’ve made huge improvements on the throughput, certain operations like changing the declaration of a base class that’s used many times in a large project is computationally expensive. If you attempted to invoke a feature that relied on compiled information before the background compiler has a chance to do its magic, like Intellisense or the Drop Downs, previous versions of Visual Studio would grind to a halt until the compilation was complete. Those operations are no-longer blocking. So, while you might occasionally get the drop downs to look like this:

The IDE will still be responsive.

Now do you have to download it? Remember, you can always grab the Express Edition!

Visual Basic 2008 Ships!!! (Amanda Silver)

VBTeam — Mon, 19 Nov 2007 20:27:00 GMT

Hooray! Today we’ve finally shipped Visual Studio 2008, previously known as “Orcas”, previously known as some symbol which doesn’t have an ascii representation. We’ve come a long way, but it’s been a great ride. In his blog, Soma mentions many of the flagship features at a high-level that will undoubtedly make the every developer and head of IT salivate, but this blog is about Visual Basic. :)

This is a tremendous release for Visual Basic users everywhere as it’s the first to introduce query expressions and XML as a first class data-type. Not only does this make Visual Basic the most productive choice for programming data-centric applications, it also makes us VB developers the envy of many an alpha-geek. If you'd like to just try it out -- be sure to check out Visual Basic Express which comes with all the features I talk about below.

With query the entire .NET frameworks become a queryable data source. You can now query against anything available in the .NET Frameworks – the registry, file system, live processes, etc. For example, the code below queries against the running processes and returns those with a thread count greater than 10, orders them by the thread count:

        Dim query = From proc In Process.GetProcesses _
            Let ThreadCount = proc.Threads.Count _
            Where ThreadCount > 10 _
            Order By ThreadCount _
            Select proc.ProcessName, proc.Id, ThreadCount

Using the LINQ to SQL Object-Relational Mapping framework, you can query against a SQL database as though it was just another collection of objects exposed by the frameworks. The following query finds all the products that have been discontinued, groups them into categories, and finds the total number of units in stock for each category:

        Dim db As New NorthwindDataContext(My.Settings.NORTHWNDConnectionString)
        Dim query = From prod In db.Products _
                    Where prod.Discontinued = True _
                    Group By prod.CategoryID _
                    Into Count(), NumInStock = Sum(prod.UnitsInStock) _
                    Join cat In db.Categories On cat.CategoryID Equals CategoryID _
                    Select cat.CategoryName, Count, NumInStock

Unlike writing huge SQL query strings, I get immediate feedback on the query I write.

Intellisense:

Syntax checking:

Schema checking:

I can use the same query language (VB!) to query against relational databases, XML, and collections of objects – I don’t need to learn any domain specific language, VB gives me access to all! It’s really easy for me to join across domains (I’ll take that up in a later blog post.)

With XML as a first class data-type, Visual Basic becomes a full XML transform language. But it’s also really easy for me to project to XML from my SQL database:

        Dim query = From prod In db.Products _
            Where prod.Discontinued = True _
            Group By prod.CategoryID _
            Into prodGroup = Group, NumInStock = Sum(prod.UnitsInStock) _
            Join cat In db.Categories On cat.CategoryID Equals CategoryID _
            Select <Products>
                       <Category CategoryID=<%= CategoryID %> CategoryName=<%= cat.CategoryName %>>
                           <%= From prod In prodGroup _
                               Select <Product Price=<%= prod.UnitPrice %>><%= prod.ProductName %></Product> %>
                       </Category>
                   </Products>

Last but not least, for those of you who aren’t so excited about the LINQ (Language INtegrated Query) project, Visual Basic 2008 comes with a tremendous improvement in the Intellisense experience overall. One of our MVPs said that he literally types two characters and hits tab, two characters, tab – it’s as though the code writes itself!

Obviously, we’re very excited about this release and hope it meets you with open arms eager to embrace the productivity! If you're ready to go to the next level and dig in, be sure to check out our learning pages and How-Do-I videos which walk you through these features and so much more.

Tomorrow I’ll blog about the least often mentioned goodies hidden in Visual Basic 2008 so that you can become the guru master of VB9. ‘Til then…

Creating Visual Basic Add-ins for Windows Home Server (Beth Massi)

VBTeam — Thu, 08 Nov 2007 22:00:00 GMT

We recently announced the availability of Windows Home Server. Here's an interview on Channel 9 with Dev Lead, Chris Gray, where he talks about the extensibility model and then walks through how to create an add-in for the Home Server console using Visual Basic Express. A couple people on the thread have also posted VB templates that you may find useful. Get Chris's code here.

Enjoy,
-Beth Massi, VS Community

Sons and Daughters Day: a pure blast!

VBTeam — Mon, 16 Jul 2007 02:35:00 GMT

On Friday, Chris Smith and I (Chris is a test engineer on the VB Team) attended an event called 'Sons and Daughters' day. The day consisted of 2 sessions (20-25 kids in each) where kids aged 6-13 were run through a class of writing an app in VB (20-25 kids in each). The class was very introductory, but eas very appropriate for the audience. Parents typically hung out with their kids to help things along. The role Chris and I played was to be additional helpers, to be able to provide extra assistance as necessary (parents were typically good at helping their kids along, but the odd issue or question wuld arise that needed extra help). Of course, the target version of VS was VB Express.

Talk about FUN!

I was concerned going in that it would be hard to lower the bar enough to let people use the product for the age of the audience. But the combination of the following meant that pretty much everyone had a great day. The feedback was all positive, and some kids clearly had the time of their lives. But our product really is pretty darn easy to use. I sometimes forget that getting started with Express really is easy. I had this nagging feeling that people would have to know more about what was going on for the day to be successful. But the presenter (Robin Reynolds-Haertle) did a great job at preparing the material, and targeting it well for the day. She basically showed people the environment, got them to make a winfors app, add a control, change properties and add some code. From there, she had a project for people to start with that was a simple game, but demonstrated a few more concepts. Straightforward, but esential, and fun stuff.

It didn't hurt that the kids were all enthusiastic, and the parents engaged well ;-).

My highlights of the day:

I don’t know if you remember that time (and I’m sure it happens for all of us) when you write an app and you get this ‘jolt’ of excitement because you literally see the program do yourcode. I saw that jolt all over the place today. The first app of course, is to drop a button on a form, and put a msgbox(“Hello World!”) behind it. There were audible cries of ‘wow, awesome!’ all around the room for this step. That’s the jolt, and I just love seeing that. Even more, I’d suggest to the odd person they should change it to be their name such as “Hello, Sarah!”. This gets an even bigger grin
The first person I helped out was a young boy about age 8. As soon as I arrived, he matter of factly said ‘I can’t type, I need you to walk me through this’. So I did. All the way down to how to type in a double-quote (which he could barely manage with one hand: he had to contort his small fingers to get the combo right, but he seemed to insist on doing it because his neighboring pupil did it that way). This kid was completely aware of what he could and couldn’t do, talk about a good pupil
One girl was very excited about her app, and proudly showed it off to Chris. It had two buttons, with different colors and different Msgbox’s. The message on one of the msgbox’s was very professional. Chris, giving an appropriately enthusiastic response stated “That’s awesome! You could SELL that!”. To which the young girl, in complete earnestness responded ‘I KNOW!!!’. Bring on the money
One of the apps was a ‘fortune teller’ which got the children to click on three buttons (color, age, favorite number) and then gave a string as a ‘fortune’ (“Be happy” for example). The kids were encouraged to change the strings displayed. One child’s frank appraisal of the extremes of fortunes appealed to my own sensibilities. He wrote as one fortune ‘You wil get 1,000,000’ and as another ‘you will be poor’. His next was “You will get the measles”. Lucky thing I went to the doctor that morning

- On a whim, I decided to show them my space invaders game at the end of each session, just to hammer home ‘this is where you can get to, you have the basics!’. This went over well of course.

Some issues for me to raise with the team:

By far, the most annoying issue throughout the day, is that its REALLY hard to see when the designer is in ‘run’ mode. Many, MANY times, a child, and/or parent would be blocked, and arriving to help out, it’s often not immediately obvious to us even, what’s wrong. We need to better differentiate when the app is running. And if you try to do actions in the designer, we need to make it more obvious that the designer can’t because it’s in run mode!
If you change the available drives, after you’ve opened save all, it doesn’t refresh. Not a major issue, but came up at least 10-11 times today, because of the way the lab was run (kids would be told to open the screen to save the app, and plugin the thumb drive to save the app to. Having done that, the save project dialog wouldn’t have the thumb drive listed, you’d have to close the dialog, and do it over. This was not at all clear when looking at the dialog)
Line continuation character with a space, could be pretty listed to do the right thing

If you have code like "SomeMethod(Arg1,_ " it doesn’t get pretty listed, it just gets an error. This hit a couple of kids

Thanks very much to April Reagan and the other organizers, this was a very fun day. I look forward to doing these more often!

AmandaS' LINQ talk at VSLive Orlando

VBTeam — Tue, 08 May 2007 08:21:00 GMT

I escaped from Redmond this week to present at VSLive Orlando on LINQ in Visual Studio Orcas. As promised, please find the slides and demos included as an attachment below.

As mentioned during the talk – that was intended to be an overview. If you want really want to understand the nitty-gritty details behind what make LINQ possible, be certain to tune into my LINQ Deep Dive WebCast on May 23^rd. If you’d like me to go into something specific during the webcast, just respond to this post. I can’t promise to get to everything in the webcast itself, but I do promise to answer any LINQ related questions in response to this post or the webcast. Be sure to pose questions to the LINQ forum if you think others might be able to help or have the same question.

I had a great time at VSLive today, I hope you enjoyed it as much as I did. I’m looking forward to TechEd!

Working with Shortcut Keys (Lisa Feigenbaum)

VBTeam — Wed, 25 Apr 2007 11:26:00 GMT

Since we have so many Orcas posts going up on this blog, I've decided to continue with a few that you can use TODAY in Visual Studio 2005. This one is about working with shortcut keys...

For those of you using the Visual Basic Development Settings, your keyboard scheme is set to Visual Basic 6 by default. You can verify this by checking the setting in Tools->Options->Environment->Keyboard.

The complete list of keyboard shortcuts for the currently bound commands in the VB6 scheme is located here. (Note: This is also a good source for command descriptions.)

Once you have this initial set of keyboard shortcuts, there are a number of things you might want to do... You might want to change the shortcut for an existing binding; you might want to add a shortcut for a command that does not yet have one; or you might want to export your keybinding set to import it on another machine.

The information pasted below is actually an excerpt from one of our MSDN docs: How To: Work with Shortcut Key Combinations. It addresses the commonly asked questions we often get about these tasks. So, read on!

Determine the Shortcut Key Assigned to a Command

You can manually search for a command to determine whether or not it has a shortcut key combination.

To determine the shortcut key combination for a command

On the Tools menu, click Options.
Expand the Environment folder and select Keyboard

Note: If you do not see the Keyboard page, check Show all settings located in the lower left of the Options dialog box.
In the Show commands containing box, enter the name of the command without spaces.
For example, solutionexplorer.
In the list, select the correct command.

For example, View.SolutionExplorer.
If a shortcut key combination exists for the command, the combination appears in the Shortcut(s) for selected command drop-down list.

Create Custom Shortcut Keys

You can create new shortcut key combinations for any command or change the shortcut key combination for commands with existing combinations.

To create a new shortcut key combination

On the Tools menu, click Options.
Expand the Environment folder, and select Keyboard.

Note: If you do not see the Keyboard page, check Show all settings located in the lower left corner of the Options dialog box.
In the Show commands containing box, enter the name of the command without spaces.

For example, solutionexplorer.
In the list, select the command you want to assign to a shortcut key combination.
On the Use new shortcut in drop-down list, select the feature area in which you want to use the shortcut. For example, you can choose Global if you want the shortcut to work in all contexts. Unless the same shortcut is mapped (as Global) in another editor, you can use it. Otherwise, the editor overrides the shortcut.
Place the cursor in the Press shortcut key(s) box, and then use the keyboard to enter the key combination you intend to use for the command.

Note: Shortcuts can contain the SHIFT, ALT, and/or CTRL keys in combination with letters.

Note: The following keys cannot be assigned: ESC, PRINT SCRN/SYS RQ, SCROLL LOCK, PAUSE/BREAK, TAB, CAPS LOCK, INSERT, HOME, END, PAGE UP, PAGE DOWN, Windows logo keys, Application key, any of the ARROW keys, or ENTER; NUM LOCK, DEL, or CLEAR on the numeric keypad; or CTRL+ALT+DELETE

Be sure to check the Shortcut currently used by box to see if the key combination is already assigned to another command in the mapping scheme. Press BACKSPACE to delete the key combination, if the combination is already in use, before trying another combination.
Click Assign.

Note: Changes made using the Assign button are not cancelled, if you click the Cancel button.

Exporting and Importing Shortcut Keys

You can share the shortcut key combinations in the current keyboard mapping scheme by exporting the information to a file so others can import the data.

To export shortcut keys only

On the Tools menu, choose Import and Export Settings Wizard.
Select Export select environment settings, and then click Next.
Under What settings do you want to export?, clear all categories selected by default.
Expand Options, and then expand Environment.
Select Keyboard and then click Next.
For What do you want to name your settings file?, enter a name, and then click Finish.

To import only shortcut keys

On the Tools menu, click Import and Export Settings Wizard.
Select Import select environment settings, and then click Next.
Click No, just import new settings, overwriting my current settings, and then click Next.
Under My Settings, select the settings file that contains the shortcut keys you want to import, or click Browse to locate the correct settings file.
Click Next.
Under Which settings do you want to import?, clear all categories.
Expand Options, and then expand Environment.
Select Keyboard, and then click Finish.

Save Time – Use Keyboard Shortcuts! (Lisa Feigenbaum)

VBTeam — Tue, 24 Apr 2007 23:45:00 GMT

Visual Studio is all about developer productivity. To help developers be more efficient, Visual Studio has built keyboard shortcuts into the product for most of the functions normally found through the user interface – just like CTRL-C for copy. To help you take advantage of these shortcuts, we’ve created posters that map out the default key bindings for our most popular Visual Studio 2005 languages – Visual Basic, Visual C# and Visual C++. These key binding reference posters are available as free pdf’s through the download center at Microsoft.com. They are provided in print quality color and grey-scale for you to print locally.

Microsoft Download Center Poster URLs

Visual Basic 2005 Visual C# 2005 Visual C++ 2005

The VB download is here: http://www.microsoft.com/downloads/details.aspx?FamilyID=6bb41456-9378-4746-b502-b4c5f7182203&DisplayLang=en

And now for Lisa’s Top Ten VB Keyboard Shortcuts…!

1. Ctrl+Tab to display the IDE Navigator, and then Tab to cycle through the files and active tool windows. (Just like Windows’ Alt+Tab, but in VS!)

2. Ctrl+Down Arrow and Ctrl+Up Arrow to navigate to the next and previous method in the current file.

3. Ctrl+M, Ctrl+M to toggle outlining for the current region. This applies to the +/- signs automatically inserted by VS for blocks including method bodies, as well as #Regions defined by users themselves.

4. Ctrl+K, Ctrl+C and Ctrl+K, Ctrl+U to comment and uncomment the current line or currently selected lines.

5. Ctrl+‘>’ and Ctrl+‘<’ to toggle between the Common and All tabs in VB intellisense. Also, use Ctrl+Space to invoke the intellisense list.

6. Ctrl while a debugger tip is up, to make the debugger tip transparent and view the code beneath. Try this out in Orcas Beta1, where you’ll be able to do the same trick with the intellisense window!

7. Ctrl+Dot (.) to expand the available options for a Smart Tag menu.

8. Shift+F2 and Ctrl+Shift+F2 to Go To Definition on a symbol and then Navigate Back.

9. ‘Shortcut’+Tab to insert a snippet by its shortcut. For example, try typing ‘Property’+Tab on a new line within a class. Or, use ‘?’+Tab to display the Snippet Picker with all currently available snippets. (See Tools->Code Snippets Manager for a list of snippets and their associated shortcuts.)

10. F1 to display a contextual Help for the current cursor position. For example: Press F1 on any VB keyword for help on how to use the language construct; press F1 on a Framework type to learn about its members and usage; etc.

Download the poster, and then try out the shortcuts to form your own Top Ten!

Visual Basic "Orcas" Beta1 is in the wild! (Amanda Silver)

VBTeam — Fri, 20 Apr 2007 02:20:00 GMT

Woohoo! Its official, we finally got Orcas Beta1 out the door! We’re very excited to get this release out to you so we can finally talk about some of the stuff we’ve been working on in addition to the LINQ and XML feature-set. We believe that Orcas Beta1 displays all of the essential value in the Orcas product but it’s important to keep in mind that it’s not feature-complete. There are many features (for example: lambda expressions, support for nullable types, etc.) that will be coming online in a later milestone.

That said, back to Beta1! Recently, there’s been a lot of discussion on this blog about the LINQ features, but I’d like to take the time to discuss some of the language and compiler related features in Orcas Beta1 that will radically improve your productivity even if you don’t give a hoot or holler about the revolution in programming that we fondly call LINQ.

The first thing that’s going to jazz you is Intellisense Everywhere. In short, this feature is about providing statement completion suggestions at new points in your editing experience. Some examples are best shown as screen shots:

Expressions:

Keywords:

Variable names:

I’ll save the rest so as not to steal the thunder from another blogger on our team….

Another great feature that you’ll notice in Beta1 is Relaxed Delegates. In short, relaxed delegates are a way to extend VB’s implicit conversions to delegate types. With relaxed delegates, you can write the following code:

Private Sub Button1_Click(ByVal sender As Object, ByVal e As EventArgs) _

Handles Button1.Click, Button1.MouseClick

MsgBox("Do Something")

End Sub

You can even omit *all* of the event arguments if your method body doesn’t need them. This improves readability without compromising type safety:

Option Strict On

Public Class Form1

Private Sub Button1_Click() Handles Button1.Click, Button1.MouseClick

MsgBox("Do Something")

End Sub

End Class

Lastly, Multi-Targeting enables you to use Orcas Beta1 to write applications that target .NET 2.0, 3.0, or 3.5. This has been a long requested feature that is now in your hands. The idea is that by supporting multi-targeting, it’s a no-brainer to go out and pick up Orcas because it doesn’t necessarily require that you deploy a new runtime if you don’t use the features of .NET 3.5 – just your app. You can see this by going to FileàNew Project and changing the option in the dialog:

Hope these features find you well! Download the Beta and tell us what you think!

Visual Studio 2005 SP1 and Visual Basic 2005 Command-line Compiler (VBC.exe) Hotfix Released!

VBTeam — Wed, 03 Jan 2007 21:46:00 GMT

Visual Studio 2005 SP1 is now available for download. We’d like to thank everyone in the Visual Basic community for providing feedback on SP1 and helping us identify and address issues for this service pack. In some areas, more than 50% of the bugs addressed were reported by customers through the MSDN Product Feedback Center. Overall, SP1 offers customers improvements in responsiveness, stability and performance for Visual Basic 2005.

This service pack rolls up all of the Visual Basic 2005 hotfixes we’ve made to date and provides you the best overall performance and stability when developing in Visual Basic 2005.

We recommend VB developers install SP1. You can get SP1 at:

http://msdn.microsoft.com/vstudio/VS2005SP1

Service Pack 1 Update to Visual Basic 2005 Command-line Compiler (Vbc.exe)

This hotfix provides the SP1 improvements for the Visual Basic 2005 command line compiler, (vbc.exe).

After installing SP1, install this hotfix to development and deployed machines to get the SP1 fixes for vbc.exe if any of the following apply:

You are developing web sites with ASP.NET 2.0 in Visual Basic 2005
You are deploying ASP.NET 2.0 web sites written in Visual Basic 2005
You are building Visual Basic 2005 projects outside the IDE using VBC.exe

http://go.microsoft.com/fwlink/?LinkID=78807

Thanks for your contribution to Visual Studio 2005 SP1. We welcome your feedback on this release.

Chris Mayo

Visual Basic Program Manager

Visual Basic Express Edition Videos

VBTeam — Wed, 13 Sep 2006 22:58:00 GMT

by Kathleen McGrath

Have you ever wished that you could have someone show you how to accomplish a programming task instead of having to read through the steps on how to perform the task? Or maybe you just need a little more clarification about where a particular option is located. They say a picture is worth 1,000 words, so imagine what a video can do.

I'm creating a series of video demonstrations that follow the Visual Basic Guided Tour in the Visual Basic Express documentation as a way to supplement the great content you'll find there. My first set of videos are based on Creating Your First Visual Basic Program.

You can watch the video for each topic individually:

Step 1: Create a Project in Visual Basic	View Video Screencast
Step 2: Create a User Interface	View Video Screencast
Step 3: Customize Looks and Behavior	View Video Screencast
Step 4: Add Visual Basic Code	View Video Screencast
Step 5: Run and Test Your Program	View Video Screencast

Or watch the entire process:

Creating Your First Visual Basic Program

View Video Screencast

Enjoy! And please feel free to send me your feedback about these video screencasts.

-- Kathleen

Beginners coding in ASP.NET

VBTeam — Mon, 11 Jul 2005 23:04:00 GMT

posted by Emily Yaich

Hello everyone! I am Emily Yaich and I am another one of the Microsoft Explorers working on the visual basic team. I have been here since the second week in June, and I am loving every minute of it! We haven't gotten into the heavy coding and testing of our app yet, which will be a challenge, but I am sure that it will be just as much fun.

For those of you that are not familiar with the explorers program, it is an internship opportunity that allows first and second year students to come to Microsoft and gain valuable industry experience. We spent the first couple of weeks in class in the mornings and shadowing the various roles on the visual basic team in the afternoons. We got to see first hand what goes on behind the scenes to develop Whidbey.

Also, we were each assigned a starter kit to evaluate and extend. I was assigned the personal website starter kit. Being only a sophomore next term, the only coding I have done is in C++, so this is the first experience that I have had coding in visual basic. If anyone else is brand new, here are some great starter videos that start from the very beginning. They were very helpful to me. So in working with this website I also got my first experience with ASP.NET. I decided to create an address book application so the user could keep track of their contacts. The couple areas that I got stuck on were data-binding and importing an image for the button. The data-binding is quite simple, for no real coding is really involved; it is mostly drag and drop. My problem came because first I tried to bind an access database to a sequel server source, and then when I bound it to an access source, I did not set a primary key. With several visits from Jeff King, a Program Manager in Web platform and tools, I finally figured that out. For more information on primary keys you can check out Greg Osefo’s blog, a fellow explorer, entitled “My First Database by Greg Osefo.”

The second problem was a bit more complicated. In my starter kit all of the buttons were images that were linked to the pages that they brought up. They were not just buttons that you can drag and drop. I discovered that first there was a black and a white theme. Within each theme there were several images that corresponded to each image on the website. I added my own image to the list using paint but could not get it to integrate into my webpage. With help from Paul Yuknewicz, a Program Manager in Visual Basic, I discovered that under App_Themes, under Black (which was the theme that I chose for my webpage), under Images, I had to add the following line to Default.skin:

<asp:image runat="server" Imageurl="Images/button-view4.GIF" skinid="view" />

Button-view4.GIF was the name of the button that I created in paint. You then have to pick a name for the skinid, I chose view. Then on the designer view of the page that you want to add the image, you have to choose the image that you want to make your new image, and change the skinid in the properties menu to the skinid that you chose for your image. The name you chose will be in the drop-down menu if you put it in the Default.skin. It is quite simple once you know what you are doing.

I was very glad that I was given the website starter kit though because it was fun exploring something that I had never done before. Also, the project that we are working on now as a group will not be a website, so that is another reason I was glad I got to work with it.

So we are currently working on an app for the Pocket PC. It is just getting off the ground, but I will keep you posted!