Gary Gumbiner, MCT, MCPD, MCSD .NET

Ria Services And Odata

2010-07-23T14:12:00.000-05:00

When adding a Domain Service Class (RIA) to a Silverlight project (the Web project), a dialog titled Add New Domain service Class appears. In this dialog you can select via a checkbox to expose Odata endpoint.

Depending on you selection, the code generated for the Silverlight client will be different. If you look in the Silverlight Generated Code folder (Show all folders on the solution explorer) open the projname.web.gs file and note the following differences:

If OData not checked, 2 namespaces are generated: ProjName and ProjName.Web. If Odata is checked you get 3 namespaces: ProjName, ProjName.Web.Views, ProjName.Web.Models.

Silverlight Toolkit Theme Controls

2010-06-30T14:37:00.002-05:00

I downloaded the Silverlight toolkit from http://silverlight.codeplex.com/releases/view/43528 (Silverlight_4_Toolkit_April_2010.msi). When I ran the msi, and subsequently opened Visual studio 2010, in the toolbox under the tab "All Silverlight Controls" I found several "Theme Controls" such as BubbleCremeTheme, RainierOrangeTheme etc.

These can be used as controls rather easily. For example, open a new Silverlight application. On MainPage.xaml select a theme control from the toolbox and drag it onto the design surface. This causes a reference to be added to the Silverlight project for the associated theme control (System.Windows.Controls.Theming.BubbleCreme).

I used the XAML tab to get the xaml to look like the following:

<grid name="LayoutRoot" background="White">
<?xml:namespace prefix = toolkit />
<toolkit:bubblecremetheme name="BubbleCremeTheme1">
<toolkit:bubblecremetheme.content>
</toolkit:bubblecremetheme.content>
</toolkit:bubblecremetheme>
</grid>

I added some controls to <toolkit:bubblecremetheme.content>. An example follows:

<grid name="LayoutRoot" background="White">
<toolkit:bubblecremetheme name="BubbleCremeTheme1">
<toolkit:bubblecremetheme.content>
<grid>
<button name="Button1" type="submit" content="Button" height="23" horizontalalignment="Left" margin="56,30,0,0" verticalalignment="Top" width="75">
<checkbox content="CheckBox" name="CheckBox1" height="16" horizontalalignment="Left" margin="58,62,0,0" verticalalignment="Top">
</grid>
</toolkit:bubblecremetheme.content>
</toolkit:bubblecremetheme>
</grid>

The themes are encapsulated in the associated control (System.Windows.Controls.Theming.BubbleCreme) - they should be treated like any other control when used. During my experimentation I had to switch between design and xaml views in Visual Studio 2010 to get the xaml just right.

Xaml source for the themes are available and can be found at the installation path for the Silverlight 4.0 toolkit: (on my Windows 7 64 bit machine: C:\Program Files (x86)\Microsoft SDKs\Silverlight\v4.0\Toolkit\Apr10\Themes\Xaml)

ODATA

2010-06-25T12:00:00.002-05:00

After attending the OData roadshow in Chicago a few weeks ago I have been inspired to learn and practice OData. After some absence from the blogging world, I decided to write some entries about my experiences.

My very first comment about OData--it is awesome, exposing data with ease, improving and streamlining application development.

I also have done some work with RIA (domain services). During my learning cycle I found that a RIA domain service can also be exposed as Odata. When creating the domain service be sure to check "Expose OData endpoint" check box.

Then through the browser you can access the domain service as an odata endpoint.

It took me awhile to actually get this to work, as most of my problems were syntax related.

Here is what I learned: to access an OData endpoint that is a RIA domain service in a Silverlight project (4.0) the following should work:

If your Silverlight Web project is named: SilverlightApplicationSimpleRIA.Web

Then the link to access the OData endpoint is:
http://localhost:2551/SilverlightApplicationSimpleRIA-Web-DomainServiceNW_RIA.svc/OData/

Notice
1) . (period) is replaced with a - (In web project name)

2) appended to the project name SilverlightApplicationSimpleRIA-Web is a - and then the name of the Domain Service (as defined in the Web project), followed by .svc, followed by a /
i.e. SilverlightApplicationSimpleRIA-Web-DomainServiceNW_RIA.svc/
Be aware that the "silverlight web" project has no .svc file defined, this is constructed "virtually" for a domain service

3) then add OData/ (the syntax here caused me a bit of a problem--OData is case sensitive -- also do not forget the ending / (if you do you'll probably get endpoint not found message when doing the access)

I tested this with IE 8 along with Silverlight 4, and it worked like a champ.

WPF & Datargidview Control

2007-07-26T12:36:00.000-05:00

The Windows Forms DataGridView control may be hosted in a WPF form using a <WindowsFormsHost> tag
(in fact any Windows Forms Control may be hosted within this tag, which provides a solution to the lack of a WPF Data Grid control).

The following XAML and VB.Net code was done using Visual Studio 2005 .

In a WPF Windows application:

add a reference to WindowsFormsIntegration (WindowsFormsIntegration.dll)

In a XAML file (i.e. Window1.xaml)

add a reference to System.Windows.Forms:

<Window
xmlns:wf="clr-namespace:System.Windows.Forms;assembly=System.Windows.Forms" ...

add the following XAML to host the DataGridView control

<wf:DataGridView x:Name="dgv"> </wf:DataGridView>

</WindowsFormsHost>

</StackPanel>

Note: it appears that the <WindowsFormsHost> should have Width and Height attributes to ensure that the DataGridView will render with scrollbars

Build the Project

In the associated code view for the XMAL(Windows.xaml.vb) :

Add the following code to the Window1_Loaded event handler:

'Use the Authors table in the Pubs database

Dim conn As New System.Data.SqlClient.SqlConnection("integrated security=true;database=pubs")

Dim da As New System.Data.SqlClient.SqlDataAdapter("select * from employee", conn)

Dim ds As New System.Data.DataSetda.Fill(ds)
Me.dgv.DataSource = ds.Tables(0)

Me.dgv.DataMember = ds.Tables(0).TableName

Me.dgv.ScrollBars = System.Windows.Forms.ScrollBars.Both

Me.dgv.Visible = True

Run the program to display the WPF with the DataGridView.

Note that <WindowsFormsHost> may only contain one Windows Forms Control. Use multiple <WindowsFormsHost> tags or create a Windows Forms User Control with the desired layout and host in using in <WindowsFormsHost>. Also, the DataGridView will not render with any WPF styles that may have defined.

Flow Documents and Code Behind

2007-07-08T20:57:00.000-05:00

It is possible to have XAML controls with event handlers in a Flow Document. This can be accomplished using Visual studio 2005 by:

Add a FlowDocument (WPF) to a Visual Studio 2005 .NET 3.0 WPF project (i.e. FlowDocument2.xaml)
Add a class to the project named FlowDocument2.xaml.vb (VS 2005 does not automatically add an associated "code-behind" class)
In FlowDocument2.xaml in the <FlowDocument> element add the attribute: <FlowDocument a:Class="FlowDocument2" ....
Within a <Paragraph> element add:
Test Text<InlineUIContainer><Button Name="TestCmd" Content="Press Me"></Button></InlineUIContainer>Test Text
Build the project
In the Code-behind class (FlowDocument2.xaml.vb) for TestCmd (the button) add a click event
In the click event place some code (i.e. MessageBox.Show("clicked")
Make FlowDocument2.xaml the startup URI for the project
Run the project (F5 or <Shift>F5

XAML & Flow Documents

2007-07-08T20:43:00.000-05:00

For WPF projects in Visual Studio 2005 you can have the project display a Flow Document when starting.

In the App.Xaml file, for the < Application> element add the following attribute:

StartupUri="FlowDocument1.xaml"

With this approach it is easy to see what the associated flow document looks like. Just run the project using F5 (Start Debugging) or <Shift> F5 (Start Without Debugging).

Note that Flow Documents cannot be viewed in design mode within Visual Studio 2005, so this technique provides an easy way to see the actual formatting of a Flow Document.

WPF and Windows Forms

2007-04-22T13:08:00.000-05:00

While learning WPF, in order to take advantage of its neat features (i.e graphics, animation etc), you will most likely want to get busy using WPF in your projects as soon as possible. You can do this even if you are not up to speed on all WPF features.

It is possible to have both WPF Windows and traditional Windows Forms within the same VS 2005 .NET Framework 3.0 Windows Application (WPF). You can use WPF forms where you feel comfortable, but use Windows Forms for other situations.

For example, suppose that you have not yet got up to speed with WPF data binding -- you could implement that in a Win Form using the traditional data binding techniques, but do other application interfaces using WPF (i.e About Form, Search Form).

In .NET code, both WPF Windows and Windows Forms are objects and can be thought of as a "form"

For example:
Dim f as SomeForm 'could be a WPF or Win Form
f.show

You can show a WPF form from a Windows Form or show a Windows Form from a WPF form.

Some Beginning XAML

2007-04-21T15:15:00.000-05:00

XMAL gives developers the means to customize their user interfaces in ways that have not been available using traditional tools (i.e. Windows Forms).

The following XMAL snippet gives a simple example:

<StackPanel Background="Beige">

<Button>

<Button.ToolTip>
<TextBlock FontWeight="UltraBold" TextAlignment="Center">
<Ellipse Width="20" Height="20" Stroke="Blue" Fill="AliceBlue"></Ellipse>
<Label>A ToolTip Message</Label>
<Rectangle Height="20" Width="20" Fill="AliceBlue" Stroke="Blue" StrokeThickness="2" ></Rectangle>
</TextBlock>
</Button.ToolTip>

<Button.Content>
<TextBlock FontWeight="UltraBold" TextAlignment="Center">
<Ellipse Width="20" Height="20" Stroke="Red" Fill="Pink"></Ellipse>
<Label>Press Me</Label>
<Rectangle Height="20" Width="20" Fill="Pink" Stroke="Red" StrokeThickness="2" ></Rectangle>
</TextBlock>
</Button.Content>

</Button>
</StackPanel>

The button defines its own content and a tooltip. Notice that the content and tool tip defintions can contain other XAML, allowing for very interesting presentation. Here, both the button and tool tip have tradtional text (i.e. Press Me) as well as a Rectangle and Ellipse. No longer are developers constrained by text only or creating their own images with hope that a control supports display of an image.

The other good news is that when the window with the above is resized, the button contents are automatically adjusted to ensure that it continues to have a consistent look and feel -- and the best part, a developer does not have to do anything to get this behavior!!

I'm Back

2007-04-19T12:15:00.000-05:00

After a long, long break from blogging, I am back!! For a while I have been using/learning Windows Presentation Foundation. I find this feature of .NET 3.0 to have huge potential for changing, enhancing the way user interfaces are designed and implemented for applications.

I have been using VS 2005 with the Visual Studio 2005 extensions for .NET Framework 3.0. concentrating on standalone applications (the traditional Windows Forms application development that we all know and love)

The good news is that I am able to leverage my knowledge of Visual Studio in order to get right to work creating .xaml to define the UI along with implementation of business intelligence code (usually in VB.NET). Actually when beginning to learn/experiment with Windows Foundation Presentation, which more then likely means being exposed to XAML (eXtensible Application Markup Language) rather quickly, keep in mind what I like to think of as ".NET/Visual Studio" patterns.

For example in a VS 2005 NET Framework 3.0 Windows Application, when adding a new WPF Window to a project results in 2 files being added to that project, one for the xaml (aName.xmal) and one for managed code (i.e aName.xaml.vb). These files are associated with one another - in the xaml file the user interface is defined using XAML, while in the.xaml.vb file holds any associated managed code.

For ASP.NET Web developers this mirrors the "code-behind" approach; user interface defined in .aspx using HTML and code in the associated .aspx.vb file. As is the case with ASP.NET, you could decide to keep code (VB or C#) along with the XAML in the same .xaml file. This is analogous to an in-line ASP.NET approach.

My point here is to keep in mind familiar concepts and patterns about .NET and Visual Studio as they will appear quite often while learning WPF. Recognizing them will help speed up the learning curve.

ASP.NET 2.0 Gridview

2006-03-28T09:51:00.000-06:00

I have been working with ASP.NET 2.0 on a variety of projects. When using the new Gridview control I have found that it does not support custom paging (as the datagrid did in ASP.NET 1.x). That's too bad, the first time I really want to use this facility and it is gone....

Visual Studio 2005 Missing Windows

2006-01-24T10:09:00.000-06:00

As I was debugging with Visual Studio 2005 I wanted to display the Immediate window (old habits die hard). When I looked for it in as a Debug|Windows menu item it was not there. I searched around menu items some and could not find it.

Instead I used CTL+ALT+I to access (display) it.

The same issue occurred when I wanted to access (display) the Exceptions window. I had to use CTL+ALT+E to access (display) it.

I wonder if this was by Visual Studio 2005 design or not; in any case these 2 windows are available....

ASP.NET 2.0 Changing SiteMap files

2006-01-23T13:10:00.000-06:00

I have been testing out navgation in ASP.NET 2.0, especially the sitemap feature.

I wanted to dynamically change sitemaps and found that it can be done as follows:

First define a few different sitemap files (i.e. x.sitemap, y.sitemap) within your project (i.e. Company1SiteMap, Company2SiteMap).

Then in the web.config file add the following entries:

<siteMap defaultProvider="Company1SiteMap" enabled="true">
<providers>
<add
name="Company1SiteMap"
type="System.Web.XmlSiteMapProvider"
siteMapFile="~/x.sitemap" />

<add
name="Company2SiteMap"
type="System.Web.XmlSiteMapProvider"
siteMapFile="~/y.sitemap" />
</providers>
</siteMap>

If a siteMapPath control is used on a form without specifing a siteMapProvider then the default provider is used which by default is a project file named web.sitemap. The default is changed (in this case to x.sitemap) by the web.confg entry:

<siteMap defaultProvider="Company1SiteMap" enabled="true">

The sitemap file defined by the Company1SiteMap <providers> entry is now the default sitemap for the project.

To define other sitemaps for the project, add entries in the <providers> section as shown in the above web.config entries.

To dynamically change the sitemap used by a sitemappath control just set the SiteMapProvider propery of the control with the name of the entry that points to the .sitemap file that is desired:

(Assume a sitemap control on the form named SiteMapPath1)Me.SiteMapPath1.SiteMapProvider = "Company2SiteMap" 'will use y.sitemap

Now, the SiteMapPath1 sitemappath control will use the sitemap file defined by the entry named Company2SiteMap (y.sitemap)

I tested this by changing the sitemap from the default (x.sitemap) to y.sitemap in a button click event and it worked like a champ.

ASP.NET 2.0 and Crystal Reports

2006-01-17T12:40:00.000-06:00

After a long rest I am back blogging.

Recently I have been spending a lot of time with Visual Studio 2005 exploring both ASP.NET and traditional Windows Forms projects.

I have a client in a medium sized company that has struggled with report distribution off and on for sometime. Having a small IT staff they wanted easy desktop installation along with “pretty” report printing capability from the client.

We discussed using Visual Studio 2003 and Crystal Reports with the Crystal Report Viewer control. Actually, a while back I did a small prototype and had many issues; finally we gave up and moved on to other projects.

Enter Visual Studio 2005. I decided to give it a try. In less than one hour I had a simple Crystal Report being displayed on a ASP.NET 2.0 web form. First, I populated a dataset with data for the report using ADO.NET (nothing special here). I created a rather simple Crystal Report using the Crystal Report wizard. Next, I bound the Crystal report to the dataset. Finally, I used the Crystal Report viewer control on a Web form to show the Crystal Report in the browser and provide formatted printing capability. It worked with no difficulty.

The two cool things about the process were using a 1) dataset as a data source for the crystal report (as opposed to having crystal do the data population) and 2) Adobe Reader is used to display the report when the client decides to print it at the browser; this lets a client choose the printer they want to use for printing (along with all the other printing goodies) and prints a formatted report (i.e. real page breaks etc) or for that matter export to a different format (word, pdf, excel). Since most desktop’s these days have Adobe Reader this technique for printing works like a champ. The biggest item however was that I had no problems doing this on an ASP.NET 2.0 page whatsoever; everything worked as advertised.

This is one possible solution for providing well formatted printed reports from a browser.

The client loved it and has begun to deploy various reports using this approach.

A few more VS 2005 Windows Forms features

2005-08-15T10:32:00.000-05:00

I have recently been using Beta 2 of Visual Studio 2005, looking at Windows Forms development.

I have discovered a few items that really help with Windows Forms development.

First, buttons have a new property AutoEllipsis; if your button text does not fit within the boundaries of the button, an ellipsis is automatically added.

In the project properties, you can "enable XP visual styles". What this does is allow your forms to have an XP look and feel (move the mouse over a button and see the effect)

TechEd 2005

2005-06-16T15:40:00.000-05:00

I was a proctor for the hands-on labs last week at TechEd in Orlando. There were over 800 computers with various labs available for TechEd attendees to try the latest Microsoft software.

MCT's from around the world were chosen to proctor the labs. I was flattered to be selected. I met many MCt's from all over the globe in addition to being able to talk with many attendees.

It was a very, very cool and worthwhile experience.

More Windows Goodies

2005-05-18T14:05:00.000-05:00

I have tried out a few new cool Windows features.

You can now make your status bar entry for your program flash using the Flash method.
In VB code Me.Flash(). One place this could come in handy is to notify a user when an asynchronous operation has completed, perhaps a Web service call or using one of the new asynchronous data retrieval techniques in ADO.NET 2.0.

Another cool feature is the new resource editor and the accessing of resources. Visual Studio 2005 really makes it easy to place strings, icons, images etc into a resource file as the resource editor has been vastly improved. Simply open project properties and select the Resource tab. The resource editor will appear. Icons and Images are now easily added as resource entries. For example, just select images from the Categories dropdown at the top of the resource editor. Then, drag an image (i.e. a BMP file) from the file explorer into the resource editor. Give it a name (i.e. pic1)

Also add a string entry; select String from the Categories dropdown and add an entry giving the string a name and value. Now the cool part, you only need one line of code to access the value or the image from the resource file. Suppose you added a resource string named test. In a code window, type something like:

Dim s as string = My.Resources.test ‘Access the string
Picturebox1.image = My.Resources.pic1 ‘Access the image

Resources are now available from My.Resources. This is also true for images, icons etc. This makes resource values even easier to use!!

Click Once Technology - Visual Studio 2005

2005-05-03T10:50:00.000-05:00

I attended a day of .NET on Saturday 4/30 (Kudos to CNUG for sponsoring this great event). All talks that I attended were very helpful.

There was a talk given by Chris Mayo, a Microsoft Evangelist, on Click Once Technology with Visual Studio 2005. For the last PDC I wrote the lab for Click Once Technology using VB.NET Whidbey, so I had seen this technology before and was somewhat familiar with it. However, what I saw on Saturday was much more complete and impressive. It is a huge improvement over One Touch Deployment. One of the cool things is that you can actually set up your debugging environment to simulate the availability/unavailability of permissions for your application. This feature will really help developers make sure of the permissions that are needed by their applications before deployment.

More Whidbey Windows Cool Features

2005-04-13T14:19:00.000-05:00

When I teach .NET development classes I always try to talk about "quick hits" that can be used to make an application have richer functionality or a nicer UI.

In a Whidbey Windows Forms project, for “the add existing” item option, there are several forms that can be added, including an about form and a splash screen form. Both of these forms have a pleasing UI (which can be changed) and also include logic to display associated project information. For example, the about form has logic to populate information like the product name, version and copyright from the assembly. The splash screen has a nice UI and also fills in the version number, application name and copyright from the assembly. Of course you can always add change the UI and add your own information.

The cool thing is that there is a new project property (an application property) called splash screen where you can select a form in your project to be the splash screen. This form is displayed automatically when the project starts up. The only issue that I have seen with it is that it disappears rather quickly. I have not found a way to change the length of time that the designated splash screen will stay visible.

For the about form, you will have to display that yourself, perhaps as a menu item entry.

In any event, now when writing a windows forms project it is easy to add a splash screen and an about box with a minimum of effort.

Unhandled Exceptions for Whidbey Beta 1 Windows Programs

2005-04-11T14:45:00.000-05:00

I have some XML files that I needed to process so I decided to write a Whidbey Windows forms program to display them. One of the first things I discovered is that when you create a windows forms project, in the project you get an folder named myproj. If you open this folder you will see a file myevents.vb among others.

Double-click to open this file in code view. You will see a class for the application. In this class you can add events that have application scope. One of the events that can be added is the unhandled exception event. Simply add code here to handle exceptions that are not handled within the application code itself. You could do this sort of thing using Visual Studio .NET but it was up to you to hook up the events etc. With Whidbey you just open this file, and place your exception handling code in the unhandled event.

Really a time saver!!

More ASP.NET 2.0

2005-03-10T17:40:00.000-06:00

I have continued to experiment with ASP.NET 2.0 using MS Visual Studio 2005 Beta1. One cool thing that I have noticed is that now you can easily have pages built with different languages in the same project; one aspx (with code page) in VB and another in C#.

When you create a new Web site in VS 2005 you are asked for the ProjectType (VB, C# or J#). Pick one, let’s say VB, and then create the site. You get a page named Default.aspx (notice the page name change from Visual Studio 2003) and a code file named Default.aspx.vb. Now add a new page (Web Site Add New Item). In the Add New Item Dialog box, there is a drop down where at the bottom you choose the language for the page being added. Choose C# and you get a page named Default2.aspx and a code page named Default2.aspx.cs. This results in the project having pages (with associated code pages) written in different languages, one in C# and one in VB.

This is possible because of partial classes and the compilation model for them in ASP.NET 2.0. On the first visit to a page, that page (aspx) in-line code (partial class) and the associated (aspx.vb or aspx.cs) code file (partial class) are compiled using the selected language as specified on the Page declarative (@ Page Language="VB...).

Here is one difference between ASP.NET 2.0 and ASP.NET 1.x; in ASP.NET 2.0 the page declarative Language= attribute affects both the associated code file and the aspx page – they are partial classes that together comprise the class for the page; if language=VB then both the code page and aspx page (in-line code) have to be VB. One part of a partial class is not compiled with one language and the other part of a partial class compiled with a different language.

For ASP.NET 1.x the Language= attribute affects only in-line code for the aspx page, not the associated code page. So, in ASP.NET 1.x using VS 2003 you could have an C# project (All code pages compiled with C# into the .dll in /Bin when you do a build), but in any particular aspx page you could change the Page Language= attribute to VB and have VB.NET in-line code for that page.

So, your aspx page in-line code would be in VB.NET and the associated code page would be C#. When you build the project using VS 2003 all code pages are compiled to a single dll using the language specified for the project. The ASP.NET 1.x compilation model compiles aspx pages as they are visited, "Hooking" them up with the associated precompiled .dll. The aspx pages themselves are compiled on the first visit using the language specified in the Page Language= attribute on the Page declarative.

So the short of it is, for ASP.NET 1.x the Language= attribute of the Page declarative controls the language for in-line code compilation of the aspx page only, while for ASP.NET 2.0 Language= attribute controls the language used for compilation of both the aspx page and the associated code file. Also, for ASP.NET 2.0 it is easy to have pages with different languages (in-line and code ) residing in the same Web site.

ASP.NET 2.0

2005-03-04T10:17:00.000-06:00

I have been working with ASP.NET 2.0 Master Page feature. It is pretty easy too work with. After getting a simple one to work (one master and one content page), I assumed that the architecture underneath was based on inheritance, sort of like Inherited Windows Forms. Well, after some research and experimentation I found that this feature is not based on inheritance as is Windows Forms; instead it uses a merge technique.

Actually what seems to happen is that a master page is compiled to its own dll, content pages that use the master page are compiled to their own dlls. A merge process takes place to contruct the final page that is ultimately sent back to the browser. No matter how many content pages reference a particular master, there is only one dll for that master.

A lot of this can been seen by constructing a simple example (one master and two content pages that reference the master), then run one of the content pages with debugging. The code for each page, master and content, can then be found in C:\WINDOWS\Microsoft.NET\Framework\v2.0.40607\Temporary ASP.NET Files. You can see the actual code (VB or C#) generated. Also, you can use ILDASM to look at the dlls that are generated.

My First Blog Entry

2005-01-07T14:20:00.000-06:00

For the last several years I have been a trainer and developer solely using Microsoft technologies. My emphasis has been with .NET. During my travels, whether it is in the classroom or on a development project I sometimes run into code snippets and experiences that I find useful. I hope to share them here, as well as general thoughts on development and teaching experiences.

Also, it appears that 2005 will be a very exciting year for .NET developers with the release of new tools and technologies by Microsoft. I hope to be able to comment on those here as well. Actually, I was lucky enough to do some work with the .NET Compact Framework 2.0 a while back and was very impressed with its new controls.

A Happy New Year to all.