Due to flexibility in creating reports with some tools in the .NET framework , using PrintDocument() class in creating reports is fading out. But sometimes you don’t have a choice but to use it. For instance creating reports without any predefined data source or generating reports where needed columns are determined at runtime.

In this post we will go through creating a report using the PrintDocument. Our datasoure will also come from a listview which contains a list of file types and their sizes from an indexed drive. When using the report document everything is drawn to the report interface, thus you draw a string, an image,a line. the difficulty in here also is, you yourself determine at runtime where your text, lines and images should be positioned

To start with, first drag a PrintPreviewDialog control on your form. The control is named “PrintPreview1”.

Then go to the code view and create  your procedure below.

Private Sub detaildisksreport_PrintPage(ByVal sender As Object, ByVal e As System.Drawing.Printing.PrintPageEventArgs)
        Dim linesPerPage As Single = 0
        Dim yPos As Single = 0
        Static count As Integer = 0
        Dim x, y, c, i As Integer
        Dim leftMargin As Single = e.MarginBounds.Left
        Dim topMargin As Single = e.MarginBounds.Top

        ‘declaring fonts to use in your reports
        Dim backFont As New Font("Arial", 10, FontStyle.Italic)
        Dim HeaderFont As New Font("Arial", 20, FontStyle.Bold)
        Dim normfont As New Font("Times New Roman", 18, FontStyle.Regular)

        ‘ Calculate the number of lines per page.
        linesPerPage = e.MarginBounds.Height / normfont.GetHeight(e.Graphics)

        ‘x determines the horizontal positions whiles y determines the vertical position

        ‘ Drawing an image on top of the report
        Dim b As Rectangle
        Dim pic As New Rectangle(40, 5, pic1.Width + 40, pic1.Height + 40)
        e.Graphics.DrawImage(pic1.Image, pic)

        ‘drawing a line around the image
        b = New Rectangle(40, 5, pic1.Width + 40, pic1.Height + 40)
        e.Graphics.DrawRectangle(Pens.Black, b)

        linesPerPage = e.MarginBounds.Height / normfont.GetHeight(e.Graphics)
        linesPerPage = linesPerPage – 5

        ‘ Drawing our report titles
        x = 190
        y = pic1.Height + 70

        e.Graphics.DrawString("DETAIL DRIVE REPORT", HeaderFont, Brushes.Black, x, y)

        y += 40
        x = 25
        e.Graphics.DrawString(" FOLDERS ON DRIVE :  " & Me.cmbCat.SelectedItem.ToString.ToUpper, HeaderFont, Brushes.Black, x, y)
        y += 40
        x = 10
        e.Graphics.DrawString("REPORT GENERATED ON " & Now.ToLongDateString.ToUpper, HeaderFont, Brushes.Black, x, y)
        y += 10
        x = 5

        e.Graphics.DrawLine(Pens.Black, 5, y + 30, 820, y + 30)
        x = 10
        y += 60
        c = y

        e.Graphics.DrawString("FOLDER NAME", HeaderFont, Brushes.Blue, x, y)
        x += 260

        e.Graphics.DrawString("NUMBER OF FILES", HeaderFont, Brushes.Blue, x, y)
        x += 330

        e.Graphics.DrawString("FOLDER SIZE", HeaderFont, Brushes.Blue, x, y)

        e.Graphics.DrawLine(Pens.Black, 5, y + 30, 820, y + 30)

        x = 33
        y = c + 40

        i = 0
        ‘adding the content to the report
        For i = count To Me.LsvCDs.Items.Count – 1

            Dim len As Integer
            If LsvCDs.Items.Item(i).SubItems(0).Text.Length > 25 Then
                len = 25
            Else
                len = LsvCDs.Items.Item(i).SubItems(0).Text.Length
            End If

            e.Graphics.DrawImage(Me.SmallImages.Images(0), 15, y + 2)

            e.Graphics.DrawString(Me.LsvCDs.Items.Item(i).SubItems(0).Text.Substring(0, len), normfont, Brushes.Blue, x, y)
            x += 400
            e.Graphics.DrawString(Me.LsvCDs.Items.Item(i).SubItems(1).Text, normfont, Brushes.Blue, x, y)
            x += 220
            e.Graphics.DrawString(Me.LsvCDs.Items.Item(i).SubItems(2).Text, normfont, Brushes.Blue, x, y)

            ’setting the y value to point to the next line
            ‘reseting the x value to the margin
            y += 30
            x = 33

            ‘checking to see if the current page is full
            If y + normfont.Height > e.PageSettings.PaperSize.Height Then
                count = i + 1
                e.HasMorePages = True
                Return

            End If
        Next

        count = 0
        e.HasMorePages = False
    End Sub

Also add the code below to a button click event and you are good to go.

   1: Dim pd As New PrintDocument()

   2: 'adding the print method created to the printdocument printpage event

   3: AddHandler pd.PrintPage, AddressOf disksreport_PrintPage

   4:  

   5: 'passing the print doucument to the PrintPreviewDialog

   6: PrintPreview1.Document = pd

   7: PrintPreview1.ShowDialog()

Below are sample interfaces, using printDocument to generate reports

This is the first in series of posts called the “Extensibility Series.”  This series will cover writing design-times for WPF & Silverlight custom controls for the WPF & Silverlight Designer for Visual Studio 2010 that target .NET 4.0 and Silverlight 3 and 4.  I will use the term Designer for the rest of this article.

Normally in a series you start with a simple example and article.  For this series I need to start with a level 300-400 example because this article and code is for the Development Tools Ecosystem Summit presentation that Mark Boulter and I did.

The presentation was on how to write a design-time assembly that could be shared between WPF and Silverlight custom controls.

Part I of this post covers Feedback and Rating control, design-time assembly discovery, loading and metadata creation.

Part II of this post will cover the control design-time code. (coming after Thanksgiving break)

The code in this post is C#.  (Yes… Karl is now a member of the dark side, but will remain faithful to the bright side.)  The example code is C#.  I will post VB.NET example code after the Thanksgiving break.

Tutorial Breadcrumb Trail

When you open the source code solution, be sure to open your Task List window so that you can view and walk the step by step tutorial breadcrumb trail I’ve added to the solution.  When you click on each TODO you’ll be taken to that section of code.

Background

For the purpose of this article and the code, our fictitious company name is, Cider Controls.  The first control we have ready for release is our WPF & Silverlight Feedback control.  The Feedback control contains our Rating control that allows a value to be selected at run-time using the mouse.  Our assignment is to write a design-time for Visual Studio 2010 for this control.

Note: Setting the rating value at design-time is probably something the control does not actually need.  However, it serves its purpose by illustrating how to use the extensibility features of the Designer.

WPF & Silverlight Feedback Control

The blue text is the Header property.  This property is of type Object.  Developers can supply simple text or use nested XAML to create any type of Header they want.

The text under the Header is the CommentHeading property which is a String.

The TextBox is bound to the Comment property which is a String.

The . . . . . is the Rating control.  This is bound to the Value property which is an Integer.

The CornerRadius property binds to the Border control in the control template.

The Submit Button is enabled when the Value is greater than zero and the Comment is not empty or null.

Required Design-Time Features

• Support both the WPF & Silverlight versions of the Feedback control
• Set control value at design-time using a context menu
• Set control value at design-time using the Rating control in an adorner
• Set control value at design-time using the Rating control is the properties window
• Set all control properties in the properties window
• Provide a Category Editor for the properties window that allows editing the Feedback control properties assigned to the Custom category

Features

Menu Action

The Feedback Value property is zero. 

Adorner

After the Feedback Value property has been set, both the control and adorner display the value.

Inline Value Editor

Inline Value editor uses the Rating control just like the Feedback control and adorner.

Category Editor

Design-time XAML

Notice the Feedback Header that takes XAML.  You could easily add a Grid or StackPanel and then display and image and text if you wanted.

<cc:Feedback
    HorizontalAlignment="Left" Grid.Column="1"
    VerticalAlignment="Top" Height="176" Width="304"
    CommentHeading="Write a design time for your control today."
    CornerRadius="10"
    Padding="3"
    BorderBrush="DarkGray"
    BorderThickness="3"
    Background="WhiteSmoke" Value="3" Margin="12,24,0,0">

    <cc:Feedback.Header>
        <TextBlock
            Foreground="Blue" FontSize="16" FontWeight="Bold"
            Text="Control Design Time Example" />
    </cc:Feedback.Header>

</cc:Feedback>

Design-Time Assembly Locating

Writing a design-time for a control is actually pretty simple and the code tends to be small blocks since each individual feature you add is almost self-contained.

There are two complicated pieces, metadata loading and Toolbox installation. 

Simplified:  Metadata loading is the design-time process that Visual Studio uses to discover and associate your design-time code with your control so that the Designer will run it at design-time when you want it to.

I’ll cover Toolbox installation in my next Extensibility Series post.

These two can be complicated because there are different ways to do both, some can involve the registry, some involve multiple assemblies and both depend on a naming convention.  In other words, when you first look at this, you’ll think there are a number of moving parts, but after you’ve done this a few times, you’ll have it down.

Design-Time Load Scenarios

• WPF Custom Control Designer – (single design assembly)
• Silverlight Custom Control Designer – (single or two design assemblies)
• Code Sharing for WPF & Silverlight controls (five design assemblies)

Note:  You can use other techniques for reducing the number of assemblies when doing multi-platform design-times, but they can lead to bugs and confusion due to platform mixing and won’t be discussed here.

For this post I’ll only cover the, “Code Sharing for WPF & Silverlight controls” scenario.  The techniques that I’ll describe here are used in Microsoft production code and simplify code sharing.  In future posts I’ll cover the other design-time load scenarios and techniques.

Design-Time Assembly Naming and Location

Looking closely at the above table, you’ll see a naming pattern.  The control assembly can be named whatever the control author wants.  Typically you’ll see the vendor name followed by the product and possibly version number.

The design-time assemblies must be named according to the above table in order for Visual Studio to load them.

For metadata loading Visual Studio loads the .dll’s in the above order.  Meaning .VisualStudio.Design. qualified .dll’s will load second and overwrite metadata in the .Design dll.

The “*” represents optional additional name text that the design-time assembly author can add.  Normally this is not used.  This provides a way to ship additional design assemblies that follow the above naming convention.  (See next paragraph.)

When the metadata is loaded there is one more consideration that is taken into account.  The version number of the Microsoft.Windows.Design.Extensibility.dll or Microsoft.Windows.Design.Interaction.dll that the design-time assembly is compiled against will be compared to those versions on the target machine.

For readability I’ll use MWD in place of Microsoft.Windows.Design.Extensibility.dll in the next short section.

The Design.*.dll nomenclature allows for multiple design assemblies fitting a pattern such as “foo.Design.*.dll”, one for each version of the MWD interface.  Zero or one assembly fitting a pattern will load:

• If the MWD version referenced by the design-time assembly has a different major version number than the user’s machine MWD version, then the design-time assembly will not load and is bypassed.
• If more than one design-time assembly is compatible with the user’s machine MWD version, the Designer loads the version compiled against the highest MWD version that is less than or equal to the user’s machine MWD version.

For instance, if the user’s machine MWD version is 4.1.3.0 and there are 4 design-time assemblies matching the pattern “foo.design*.dll”, each compiled against the below MWD versions, the designer reacts as follows:

• 3.0.1.0: Will not load.  Incompatible API version.
• 4.0.1.0: Would load if there were not a higher matching version, but since 4.1.1.0 exists it does not load 
• 4.1.1.0: Version loaded as it is closest to the current version number without exceeding it
• 4.3.0.0: Will not load in the Designer as it was built against a newer version of the MWD’s

Metadata and Design Code

The design-time assembly does not have to actually have any design time code in it.  In fact as you’ll see shortly, the two design-time assemblies that our solution has that follow the above naming convention only serve as shims between Visual Studio 2010 and our common WPF and Silverlight design-time assembly that does all the work.

WPF

The below screen shot pictures the WPF run-time custom control folder and contents.

The below screen shot pictures the contents of the \Design\ subfolder.

In the above image, CiderControls.WPF.VisualStudio.Design.dll is the assembly that Visual Studio will discover and load the design-time metadata from. 

CiderControls.Common.VisualStudio.Design.dll is in this folder because it is referenced by CiderControls.WPF.VisualStudio.Design.dll.

CiderControls.WPF.dll is in this folder because it is referenced by the common design-time assembly CiderControls.Common.VisualStudio.Design.dll.

Silverlight

The below screen shot pictures the Silverlight run-time custom control folder and contents.

The below screen shot pictures the contents of the \Design\ subfolder.

In the above image, CiderControls.Silverlight.VisualStudio.Design.dll is the assembly that Visual Studio will discover and load the design-time metadata from. 

CiderControls.Common.VisualStudio.Design.dll is in this folder because it is referenced by CiderControls.Silverlight.VisualStudio.Design.dll.

CiderControls.Silverlight.VisualStudio.Design.Types.dll is in this folder because it is referenced by CiderControls.Common.VisualStudio.Design.dll and CiderControls.Silverlight.VisualStudio.Design.dll. 

The above two file references are not a project references but a file or binary references.  When this reference is added, the browse button is used to browse to the CiderControls.Silverlight.dll and the reference added to the file.

CiderControls.Silverlight.dll is in this folder because it is referenced by CiderControls.Silverlight.VisualStudio.Design.Types.dll.

CiderControls.WPF.dll is in this folder because it is referenced by the common design-time assembly CiderControls.Common.VisualStudio.Design.dll.

Note: CiderControls.Silverlight.dll and CiderControls.Silverlight.VisualStudio.Design.Types.dll are the only two assemblies that actually reference Silverlight, the remaining assemblies are all WPF assemblies.

Design Subfolder

In both of the above series of images, the \Design subfolder is under the \Bin\Debug folder for each custom control assembly.  During development, the best way to populate the \Design subfolder is to set up a Post-build event.  Now your design-time test projects only need to reference the design-time assembly and Visual Studio will automatically load your design-time assembly for you.

For the CiderControls.WPF.VisualStudio.Design.dll project I’m using the following Post-build event command line:

    xcopy "$(TargetDir)*.*"   "$(SolutionDir)\CiderControls.WPF\Bin\Debug\Design" /S /I /Y

For the CiderControls.Silverlight.VisualStudio.Design.dll project I’m using the following Post-build event command line:

    xcopy "$(TargetDir)*.*"   "$(SolutionDir)\CiderControls.Silverlight\Bin\Debug\Design" /S /I /Y

WPF Metadata Loading

Visual Studio locating your correctly named design-time assembly is step one.  That assembly must also decorated with the ProvideMetadata attribute:

  [assembly: ProvideMetadata(typeof(RegisterMetadata))]

The ProvideMetadata constructor requires that a type be passed in.  That type must implement the IProvideAttributeTable interface.

IProvideAttributeTable interface has a single read-only property AttributeTable that returns an AttributeTable.

Below is the RegisterMetadata class that is in the CiderControls.WPF.VisualStudio.Design project.

using CiderControls.Common.VisualStudio.Design.Registration;
using CiderControls.WPF.VisualStudio.Design;
using Microsoft.Windows.Design.Metadata;

[assembly: ProvideMetadata(typeof(RegisterMetadata))]

namespace CiderControls.WPF.VisualStudio.Design {

  internal class RegisterMetadata : IProvideAttributeTable {

    AttributeTable IProvideAttributeTable.AttributeTable {
      get {
        CiderControlsAttributeTableBuilder builder =
            new CiderControlsAttributeTableBuilder(new WPFTypeResolver());
        return builder.CreateTable();
      }
    }
  }
}

Within the AttributeTable property we instantiate the CiderControlsAttributeTableBuilder class that derives from AttributeTableBuilder.  AttributeTableBuilder provides the CreateTable method. 

The CiderControlsAttributeTableBuilder is located in the “platform neutral” CiderControls.Common.VisualStudio.Design assembly.

The WPFTypeResolver is passed into the CiderControlsAttributeTableBuilder constructor.  This class allows the “platform neutral” CiderControls.Common.VisualStudio.Design assembly to resolve WPF types in our run-time control assembly by referring to them with platform neutral TypeIdentifiers.  The WPFTypeResolver is located in the CiderControls.WPF.VisualStudio.Design project.

The CiderControlsAttributeTableBuilder is the platform neutral class that does all the heavy lifting for creating the required AttributeTable; also know as our metadata.

Below is the WPFTypeResolver class that is in the CiderControls.WPF.VisualStudio.Design project.  The GetPlatformType method takes a platform neutral TypeIdentifier and returns a platform specific type.

using System;
using CiderControls.Common.VisualStudio.Design.Infrastructure;
using CiderControls.Common.VisualStudio.Design.Registration;
using Microsoft.Windows.Design.Metadata;

namespace CiderControls.WPF.VisualStudio.Design {

  internal class WPFTypeResolver : RegistrationTypeResolver {

    public override Type GetPlatformType(TypeIdentifier id) {
      switch (id.Name) {

        case Constants.STR_CIDERCONTROLSFEEDBACK:
          return typeof(CiderControls.Feedback);

        case Constants.STR_CIDERCONTROLSRATING:
          return typeof(CiderControls.Rating);
      }

      throw new ArgumentOutOfRangeException("id.Name", id.Name, message...);
    }
  }
}

Silverlight Metadata Loading

Visual Studio locating your correctly named design-time assembly is step one.  That assembly must also decorated with the ProvideMetadata attribute:

  [assembly: ProvideMetadata(typeof(RegisterMetadata))]

The ProvideMetadata constructor requires that a type be passed in.  That type must implement the IProvideAttributeTable interface.

IProvideAttributeTable interface has a single read-only property AttributeTable that returns an AttributeTable.

Below is the RegisterMetadata class that is in the CiderControls.Silverlight.VisualStudio.Design project.

using CiderControls.Common.VisualStudio.Design.Registration;
using CiderControls.Silverlight.VisualStudio.Design;
using Microsoft.Windows.Design.Metadata;

[assembly: ProvideMetadata(typeof(RegisterMetadata))]

namespace CiderControls.Silverlight.VisualStudio.Design {

  internal class RegisterMetadata : IProvideAttributeTable {

    AttributeTable IProvideAttributeTable.AttributeTable {
      get {
        CiderControlsAttributeTableBuilder builder =
          new CiderControlsAttributeTableBuilder(new SilverlightTypeResolver());
        return builder.CreateTable();
      }
    }
  }
}

Within the AttributeTable property we instantiate the CiderControlsAttributeTableBuilder class that derives from AttributeTableBuilder.  AttributeTableBuilder provides the CreateTable method. 

The CiderControlsAttributeTableBuilder is located in the “platform neutral” CiderControls.Common.VisualStudio.Design assembly.

The SilverlightTypeResolver is passed into the CiderControlsAttributeTableBuilder constructor.  This class allows the “platform neutral” CiderControls.Common.VisualStudio.Design assembly to resolve Silverlight types in our run-time control assembly by referring to them with platform neutral TypeIdentifiers.  The SilverlightTypeResolver is located in the CiderControls.Silverlight.VisualStudio.Design project.

The CiderControlsAttributeTableBuilder is the platform neutral class that does all the heavy lifting for creating the required AttributeTable; also know as our metadata.

Below is the SilverlightTypeResolver class that is in the CiderControls.Silverlight.VisualStudio.Design project.  The GetPlatformType method takes a platform neutral TypeIdentifier and returns a platform specific type.

using System;
using CiderControls.Common.VisualStudio.Design.Infrastructure;
using CiderControls.Common.VisualStudio.Design.Registration;
using CiderControls.Silverlight.VisualStudio.Design.Types;
using Microsoft.Windows.Design.Metadata;

namespace CiderControls.Silverlight.VisualStudio.Design {

  internal class SilverlightTypeResolver : RegistrationTypeResolver {

    public override Type GetPlatformType(TypeIdentifier id) {
      switch (id.Name) {

        case Constants.STR_CIDERCONTROLSFEEDBACK:
          return SilverlightTypes.FeedbackControlType;

        case Constants.STR_CIDERCONTROLSRATING:
          return SilverlightTypes.RatingControlType;

      }

      throw new ArgumentOutOfRangeException("id.Name", id.Name, message...);
    }
  }
}

This assembly, CiderControls.Silverlight.VisualStudio.Design is a WPF assembly.  Notice that we are not directly returning a Silverlight type by using the typeof method.  Instead we are returning a type that is located in the CiderControls.Silverlight.VisualStudio.Design.Types assembly and is exposed by static properties in the SivlerlightTypes class below.

The CiderControls.Silverlight.VisualStudio.Design.Types assembly has a project reference to the Sivlerlight controls run-time assembly.

using System;

[assembly:
  System.Runtime.CompilerServices.InternalsVisibleTo("CiderControls.Silverlight.VisualStudio.Design")]

[assembly:
  System.Runtime.CompilerServices.InternalsVisibleTo("CiderControls.Common.VisualStudio.Design")]

namespace CiderControls.Silverlight.VisualStudio.Design.Types {

  internal class SilverlightTypes {

    public static readonly Type FeedbackControlType = typeof(CiderControls.Feedback);
    public static readonly Type RatingControlType = typeof(CiderControls.Rating);
  }
}

I’ve made use of the Friend Assemblies feature that allows all my classes in the solution to be internal.  For VB.NET they will all be scoped as Friend.

Silverlight Type Resolution

By now you understand that the CiderControlsAttributeTableBuilder is “platform neutral” and is located in the CiderControls.Common.VisualStudio.Design assembly.

You know that the SiverlightTypeResolver will be pass into the CiderControlsAttributeTableBuilder constructor.  CiderControlsAttributeTableBuilder is the same class that the WPFTypeResolver will be passed into also.

When the CiderControlsAttributeTableBuilder needs to resolve a type it will pass a platform neutral TypeIdentifier to one of the TypeResolvers, they in turn will return a platform specific type.

For Silverlight only, the SiverlightTypeResolver will use the SilverlightTypes class to perform the actual type resolution.

While this seems confusing at first, it is the best way to allow Silverlight types to be resolved in a platform neutral fashion and without polluting a WPF assembly with Silverlight types.

Metadata Building

CiderControlsAttributeTableBuilder does the heavy lifting and is responsible for creating the AttributeTable required by Visual Studio.  This code is platform neutral, meaning it returns an AttributeTable for WPF or Silverlight without having to directly reference the run-time assembly controls inside its code.

For the below code, I left the comments in place to make reading a large section of code much easier.  The comments inline explain what is going on.

You’ll notice how the WPFTypeResolver and the SiverlightTypeResolver are used in this code.  The module level variable _registrationTypeResolver holds a reference to the TypeResolver that is used to resolve platform specific types using the platform neutral TypeIdentifier.

using System;
using System.ComponentModel;
using CiderControls.Common.VisualStudio.Design.Controls;
using CiderControls.Common.VisualStudio.Design.Infrastructure;
using Microsoft.Windows.Design.Features;
using Microsoft.Windows.Design.Metadata;
using Microsoft.Windows.Design.PropertyEditing;
using Microsoft.Windows.Design;

//
// This should be in AssemblyInfo.cs - declaring here to make it obvious
//

[assembly:
  System.Runtime.CompilerServices.InternalsVisibleTo("CiderControls.WPF.VisualStudio.Design")]

[assembly:
  System.Runtime.CompilerServices.InternalsVisibleTo("CiderControls.Silverlight.VisualStudio.Design")]

namespace CiderControls.Common.VisualStudio.Design.Registration {

  //TODO  5 - CiderControlsAttributeTableBuilder

  /// <summary>
  /// Platform neutral class that builds platform specific metadata
  /// </summary>
  internal class CiderControlsAttributeTableBuilder : AttributeTableBuilder {

    // allows for Platform specific Types to be used without directly referencing Silverlight
    private RegistrationTypeResolver _registrationTypeResolver;

    //TODO  6 - registrationTypeResolver resolves the platform specific Types in the platform neutral
    //          metadata builder
    public CiderControlsAttributeTableBuilder(RegistrationTypeResolver registrationTypeResolver) {
      _registrationTypeResolver = registrationTypeResolver;

      AddFeedbackControlAttributes();
      AddRatingControlAttributes();
    }

    /// <summary>
    /// Builds Feedback control metedata
    /// </summary>
    private void AddFeedbackControlAttributes() {

      //TODO  7 - Resolve the Platform specific Feedback control from the platform neutral
      //          TypeIdentifier
      Type feebackType = _registrationTypeResolver.GetPlatformType(MyPlatformTypes.Feedback.TypeId);

      //TODO  9 - Using the above feedbackType, create platform specific metadata for the Feedback
      //          control the below code adds features, catetory editor, inline editor, type converter
      //          and assigns a Category to each Feedback control property

      AddTypeAttributes(feebackType,
          new FeatureAttribute(typeof(FeedbackControlInitializer)),
          new FeatureAttribute(typeof(FeedbackControlContextMenuProvider)),
          new FeatureAttribute(typeof(FeedbackControlAdornerProvider))
          );

      AddCategoryEditor(feebackType,
          typeof(FeedbackControlCategoryEditor));

      AddMemberAttributes(feebackType,
          Constants.STR_CORNERRADIUS,
          new CategoryAttribute(Constants.STR_COMMON));

      // since the below Header property is of type object, it requires this
      // StringConverter to enable editing of simple string values in the properties window.
      AddMemberAttributes(feebackType,
          Constants.STR_HEADER,
          new CategoryAttribute(Constants.STR_CUSTOM),
          new TypeConverterAttribute(typeof(StringConverter)));

      AddMemberAttributes(feebackType,
          Constants.STR_VALUE,
          new CategoryAttribute(Constants.STR_CUSTOM),
          PropertyValueEditor.CreateEditorAttribute(typeof(RatingSelectorInlineEditor)));

      AddMemberAttributes(feebackType,
          Constants.STR_COMMENT,
          new CategoryAttribute(Constants.STR_CUSTOM));

      AddMemberAttributes(feebackType,
          Constants.STR_COMMENTHEADING,
          new CategoryAttribute(Constants.STR_CUSTOM));

    }

    /// <summary>
    /// Builds Rating control metedata
    /// </summary>
    private void AddRatingControlAttributes() {

      //TODO  7.1 - Resolve the Platform specific Rating control from the platform neutral
      //            TypeIdentifier
      Type ratingType = _registrationTypeResolver.GetPlatformType(MyPlatformTypes.Rating.TypeId);

      //TODO  9.1 - Using the above ratingType, create platform specific metadata for the Rating
      //            control the below code keeps the Rating control from appearing in the
      //            Choose Items dialog after the CiderControls.WPF or CiderControls.Siverlight
      //            assembly is added.
      //
      // this is only done for illustration, there is no actual reason to keep the Rating control
      // out of the Choose Items dialog.
      AddTypeAttributes(ratingType,
          new ToolboxBrowsableAttribute(false)
          );
    }

    private void AddTypeAttributes(Type type, params Attribute[] attribs) {
      base.AddCallback(type, builder => builder.AddCustomAttributes(attribs));
    }

    private void AddCategoryEditor(Type type, Type editorType) {
      base.AddCallback(type, builder =>
         builder.AddCustomAttributes(CategoryEditor.CreateEditorAttribute(editorType)));
    }

    private void AddMemberAttributes(Type type, string memberName, params Attribute[] attribs) {
      base.AddCallback(type, builder => builder.AddCustomAttributes(memberName, attribs));
    }
  }
}

The last three methods are helper methods that make the metadata code cleaner and easier to read.

In the next Part II of this article, I’ll tie the above attributes to each of the design-time features.

Downloads

Source Code Download

PowerPoint Slides from the Development Tools Ecosystem Summit Presentation

Online Documentation Status

Almost all of MSDN and most examples you’ll see on the Internet use the interfaces from Visual Studio 2008.  When you see IRegisterMetadata used in an example, you know you’re looking at old code.  Overtime this will change, new examples will be posted and MSDN updated.

Remember IRegisterMetadata has been replaced with IProvideAttributeTable in Visual Studio 2010.  Most of old the code and the substance of the example or documentation you are viewing is probably correct and good to learn from.  You just need to be aware that you are looking at older code and that example won’t compile under Visual Studio 2010.

More Information Links

MSDN: WPF Designer Extensibility  (This is the best extensibility reference.)

WPF and Silverlight Designer Extensibility Samples

Ning Zhang’s Blog: Silverlight Design Time: Toolkit October 2009 Release Update

How to Write Silverlight Design Time for All Designers: Visual Studio 2008, Blend 2; Blend 3, and Visual Studio 2010

Close

Hope each of you have a wonderful Thanksgiving. 

I’m going out to sea again to write code for a week.  You can follow my cruise Tweets @kdawg02.

Have a great day,

Just a grain of sand on the worlds beaches.

As if you need “another” reason to start running Visual Studio 2010 Beta2, here is another for all the cross platform .NET Line of Business application developers.

Silverlight 3 & 4 Library assemblies can be referenced in .NET 4.0 applications and used. 

The above WPF application has a file reference also known as a binary reference (as opposed to a project reference) to the BusinessEntities.Silverlight.dll and has instantiated the Customer class and used it for the DataContext for the above MainWindow.

How To Do It

The steps are simple, but you need to follow the workflow to avoid issues.

1.  Your Silverlight Library can’t have any “Silverlight specific” code in it.  I have been able to share my own framework code (Ocean) and business entities without any issues. 

Now that Silverlight 4 has shipped and IDataErrorInfo has been added this enables entity sharing between Silverlight and WPF much easier since you no longer have to implement this interface youself just to get code compatibility with your business objects.

2.  Set up a file reference (as opposed to a project reference) between the .NET 4.0 project and your Silverlight 3 or 4 class library .dll.  In the add reference dialog, use the Browse button to locate the target .dll.

3.  If you have the Silverlight 3 or 4 library in the same solution as the consuming .NET 4.0 project(s) it is important that you establish the correct project dependencies and build order.  By default, Visual Studio will not alter your project build order when a file reference is make.

In our case, we need the project build order to look like the below image.

To establish the above build order, switch to the Dependencies tab, select the other solution projects that depend on the Silverlight 3 or 4 class library and check the Silverlight 3 or 4 library as pictured below.

A Few Thoughts

If you have never used file reference projects in your solution a few things in the user experience are slightly different. 

IntelliSense

If you edit the Silverlight 3 or 4 class library, don’t expect those changes to be picked up by the .NET 4.0 project(s) until after you build.  This means, if you added a property or method in the code editor, IntelliSense in the .NET 4.0 project won’t “list it” until you build the solution.

Build Order

Its easy to overlook manually setting the project dependencies to ensure the correct build order since for all other projects you have ever created Visual Studio did this for you.

Also, don’t overlook this step after adding a new project to an existing solution that you’ve already set the build order on.

Clean Solution

If you have the Silverlight 3 or 4 class library in the solution and you clean the solution, the library assembly .dll will be removed from output folder.  This will cause Visual Studio to add some errors to your Error List since it can no long find the referenced assembly.  After building the solution, these errors will be removed from the Error List.

So… if you clean your solution and send it to someone like on a blog post, developers that open your solution will see these errors.  Again, build and all is well.

Service References

Now that you can put your business entities in a Silverlight 3 or 4 class library and your .NET 4.0 service, business and data layers can consume those entities, take full advantage of service reference dialog Advanced settings.  Advanced button is located in the lower left corner of the Add Service Reference dialog.

I have had issues with the Add Service Reference feature when trying to get it to reuse my existing types.  So I always elect to help the wizard and specifically select the assemblies that contain my business entities as I’ve done in the below image.

Note:  The project download does not have a service reference, the below image is from another project.

I love this feature because it allows me to use my business entities that have code in them in all the layers of my application without any duplication of code.  This also easily enables entity sharing between Silverlight 3 OR 4 and WPF.

Download

The project source code can be downloaded from my SkyDrive.

Source Code (97KB)

Close

Hope you like the new developer productivity capabilities of Visual Studio 2010.

Have a great day,

Just a grain of sand on the worlds beaches.

A long time feature request has been added to Visual Basic 10 that ships with Visual Studio 2010; decorating an Event as NonSerialized.

In prior versions of Visual Basic developers had to implement a Custom Event or another workaround when their types needed to expose an Event and they had to be Serializable.  C# had this capability, now Visual Basic does too!

A very common scenario is a class that implements INotifyPropertyChanged and must also be Serializable. 

Visual Basic developers can now decorate the Event with the NonSerialized attribute.  The compiler does the rest for you.

Imports System.ComponentModel

<Serializable()>
Public Class Customer
    Implements INotifyPropertyChanged

#Region " INotifyPropertyChanged Serializable "

    'New VB 10 feature!
    <NonSerialized()>
    Public Event PropertyChanged(
                  ByVal sender As Object,
                  ByVal e As System.ComponentModel.PropertyChangedEventArgs) _
                  Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

    Protected Sub OnPropertyChanged(ByVal strPropertyName As String)
        If Me.PropertyChangedEvent IsNot Nothing Then
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(strPropertyName))
        End If
    End Sub

#End Region

End Class

Have a great day,

Just a grain of sand on the worlds beaches.

I have a strange fascination with hybrids.  Combining old and new technologies in bizarre and interesting ways.   Why must developers make “the choice” between a web or native technology? It would be great to build applications that would increase or decrease in features depending on the platform they were run on.

Do you have a Winforms application that you’d like to host in a web browser?  There’s an interesting technique you can use to do this enabled by .net Framework 3.5.

The .net framework provides the ability to create WPF web applications (commonly called XBAP).  WPF has the ability, in turn, to host Winforms. 

Security

It appears that in order to do this effectively, it’s necessary to deploy your XBAP application as a “Full Trust” application.

The code

To use this, create an XBAP project, then a page a “WinformHost” control on it.   The XAML could look like this:

<Page x:Class="Page1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Page1">
    <DockPanel LastChildFill="True">
        <Button Name="Button1"  DockPanel.Dock="Bottom"  >This is a WPF Button</Button>
        <WindowsFormsHost Name="WinformHost"   />
    </DockPanel>
</Page>

Then, create some code to instantiate your winform and show it on the Winform host:

Class Page1

Here’s the subroutine:

Public NotInheritable Class WinformToUserControl

Interesting bits and pieces

We found that in order for the items inside the control to scale properly, the AutoScaleMode property on the Winform must be set to Dpi instead of the default, which is Font.  I have a feeling this is because Dpi is the mode preferred for WPF, but I am uncertain.

In the sample WinformToUserControl class I found it better to contain the Winform inside a panel rather than exposing the Winform directly.  It seemed to make it more stable.  Feel free to experiment with taking it off.

Gotchas

As of time of writing, Firefox on my Windows 7 64 bit machine steadfastly refuses to run xbap.  It appears the “Windows Presentation Foundation” addin has not been automatically installed.  I have no idea how to install it.  There’ appears to be no information about how to do so.  So if you have it, good for you.  If you don’t….try re-installing the .net framework 3.51 (which didn’t work for me…)

I do know there was some controversy about this addin being temporarily blacklisted by Mozilla due to security concerns last month, but that’s all over now isn’t it?  

Download

You can download a sample project here.

Links

• I didn’t use anything from this project, but you might find it interesting MdiWindowManager
• StackOverflow post on Embedding winforms in usercontrols

Hi Friends, Walk-in interviews for jobs – 14/11/09 and 15/11/09 – Nov 14/15 – Sat/sun.

Hot Walkins [Sourced by Company HR Directly]:

Walkin Interviews at TOP companies of India – November 14/15 2009 (nov 14th/15th – sat/sun)

More Walkins ? http://jumbowalkin.com

Good luck and a great weekend!

I have this awesome little ADO.NET code generator called .netSavant.  It analyzes your stored procedures and generates an optimized wrapper class that encapsulates the logic for execution.  After using it myself for quite some time, I thought, oddly, that I could make a little extra cash from the endeavor.  Heh, sadly I was wrong.  Dispite a lot of interest, few people were interested in paying $50 for a visual studio addin that saved a LOT of time and buggy code.  Wierd, but whatever.

So, with mixed feelings I killed the project.  It simply cost too much money to maintain the website and merchant account for a product that only sold a handful of licenses over the 18-24 months.

I’m left wondering what to do with the project.  There are a few options:

1. Create a codeplex project
2. Host the source code myself
3. Release the addin as freeware (no source code)
4. Release the addin as freeware with sponsorship (uhg, gross right?) (no source code)
5. Leave the project inactive and move on to other exciting technologies

I’m wondering if I really want to spend more effort supporting the project as a whole, though with so much time invested, its hard to walk away from it.  Part of me would like to see more people use .netSavant, if only to justify the time I spent creating it.  I’d also like the challenge of updating some of the methodology used to generate the source code, and possibly provide some extensibility points to enhance the analysis features that it supports.

Perhaps some day .netSavant will be resurrected in a better form.  Until that time, thanks for your interest and support.

Joshua

For retrieving maxrequest length from web.config use following function:

public int GetMaxLength()
{
HttpRuntimeSection httpRuntime =
(HttpRuntimeSection)ConfigurationManager.GetSection("system.web/httpRuntime");
return httpRuntime.MaxRequestLength;
}

Me he andado matando con esto… pero al final lo encontré… funciona solo con .net, no jala con versiones vb 6 (bendito Dios jajaja)

Dim fm As FormCollection
fm = Application.OpenForms

For i As Integer = 0 To fm.Count – 1

Dim f As Form
f = fm.Item(i)

Next

… con eso basta…
PD solo se opbtienen los forms de la aplicación de la cual se llama…

The best kept secret in Redmond, WA are the new T4 Preprocess Text Templates that shipped in Visual Studio 2010 Beta1 and Beta2.  In just a few minutes you’ll be in the know and using them.

Background – Condensed

T4 = text template transformation toolkit

T4 templates have been available since Visual Studio 2005 and are part of DSL (Domain Specific Languages) documentation.

In Visual Studio 2010 the templates are MUCH easier to use because they are preprocessed.  When you save your T4 template, it is compiled.  The T4 template is now “processed” at compile time.  This was not the case in previous releases.

Your compiled template is just another type in an assembly that you can now instantiate and call its single method, TransformText.  The only run-time requirement to use T4 templates is the .NET 2.0 Framework.

Prerequisites

• Visual Studio 2010
• T4 Editor Plug In 
  • Visual Studio 2010 does not provide any editing assistance when editing T4 templates (.tt files).  You can search the Internet for T4 Editor and you’ll find some information and products.
  • I’m currently using the Tangible T4 Editor (free) that you can get on the Visual Studio Gallery here: 
    • http://visualstudiogallery.msdn.microsoft.com/en-us/60297607-5fd4-4da4-97e1-3715e90c1a23
    • The editor is an Alpha version, has a few limitations but I was able to author the below template in a few minutes.

Our Scenario

We have been tasked with creating some code that we can pass data fields to and that code will create a VB.NET property.  This code will be part of a larger program that is fed information and creates class files.

Before T4 Preprocessed templates we had several options available to us.  Write code to spit out the required property, buy a 3rd party product, use CodeDom, etc.

Since we just installed Visual Studio 2010 Beta2, we are going for the productive, inexpensive, simple and out of the box solution, T4 Preprocessed Text Template.

Our Test Bench

This simple application simulates the data harness that will ultimately feed our T4 template and consume its output.  Set a few data fields and press Generate Code.

Code Generation – It’s all about the data

Code generation requires metadata to drive the output.  With the new T4 templates, getting metadata into your T4 template is a simple matter of a partial class.  The members in the partial class are available at design time and run-time.  I know this seems so simple, but T4 did not always work this way.  Now you have full design time strong typing and instant compile time verification of your template and code.

To keep this example as simple as possible, I’ve exposed the metadata directly as properties and passed values for them in the constructor of our Partial Class PropertyTemplate.  For simple scenarios this totally fine.  For a larger or multi-language code generation applications, a better solution is to expose the metadata through an Interface.  The Interface type can contain metadata and helper methods that can be used in your T4 template.

Kathleen Dollard and I have spoken a good bit about this and think using Interfaces for metadata and helper methods makes the most sense.  I’m sure Kathleen will write more on this subject and I know I will.

In the below T4TemplateLibrary project you can see how I’ve set up the project.  I had to turn on “Show All Files” to see the hidden file, “PropertyTemplate.vb” below the “PropertyTemplate.tt” file.

Open the hidden “PropertyTemplate.vb” file up and you will see the type of code you and I used to have to write to generate code.  Now T4 does it for us!

The below partial class is overly simple and exposes metadata that will be consumed by the T4 template.

Namespace My.Templates

  Partial Public Class PropertyTemplate

    Public Property PropertyName As String = String.Empty
    Public Property BackingField As String = String.Empty
    Public Property TypeName As String = String.Empty
    Public Property IsShared As Boolean = False
    Public Property RaisePropertyChangedMethodName As String = String.Empty
    Public Property IsReadOnly As Boolean = False
    Public Property Scope As String = String.Empty
    Public Property IsSetterPrivate As Boolean = False

    Public Sub New(ByVal strScope As String, ByVal bolIsShared As Boolean,
                   ByVal bolIsReadOnly As Boolean, ByVal bolIsSetterPrivate As Boolean,
                   ByVal strPropertyName As String, ByVal strBackingField As String,
                   ByVal strTypeName As String, ByVal strRaisePropertyChangedMethodName As String)
      Me.Scope = strScope
      Me.IsShared = bolIsShared
      Me.IsReadOnly = bolIsReadOnly
      Me.IsSetterPrivate = bolIsSetterPrivate
      Me.PropertyName = strPropertyName
      Me.BackingField = strBackingField
      Me.TypeName = strTypeName
      Me.RaisePropertyChangedMethodName = strRaisePropertyChangedMethodName
    End Sub

  End Class

End Namespace

T4 Template

To add a T4 template to your project, select Add New Item, then type “preprocessed” in the search box.  Select the Preprocess Text Template.

If you used classic ASP, then T4 template editing is a skill you already have.  In classic ASP we used <% and <%=.  In T4 we use <# and <#=.  The reason for this change is so that T4 can be used to generate classic ASP and ASP.NET code.  If you didn’t have the joy of shipping classic ASP web sites, no worries.  15 minutes of trail and error and you’ll be fully qualified.

The below image shows the free Tangible T4 Editor Plug-In IntelliSense in action.  It provides IntelliSense for T4 directives and template specific constructs like <#.  It also colorizes the template code.  Colorizing makes editing the template much easier too.  One current limitation is that its IntelliSense engine does list member properties defined in the partial class for the template.

The below code block is the T4 template.  It has a language directive at the top followed by static text and code blocks.

<#@ template language="VB" #>

<#= Me.Scope #><#= IIF(Me.IsShared, " Shared","") #><#= IIF(Me.IsReadOnly, " ReadOnly", "") #> Property <#= Me.PropertyName #> As <#= Me.TypeName #>
    Get
        Return <#= Me.BackingField #>
    End Get
<# If Not Me.IsReadOnly Then #>
    <#= IIF(Me.IsSetterPrivate, " Private ","") #>Set(ByVal value As <#= Me.TypeName #>)
<# If String.IsNullOrEmpty(Me.RaisePropertyChangedMethodName) Then #>
        <#= Me.BackingField #> = value
<# Else #>
        <#= Me.BackingField #> = value
        <#= String.Format("{0}(""{1}"")", Me.RaisePropertyChangedMethodName, Me.PropertyName) #>
<# End If #>
    End Set
<# End If #>
End Property

<#=  is the same as the ASP Response.Write.  It writes the result of the expression into the template.  For example, if the Scope is Public, <#= Me.Scope #> would yield Public when the template is transformed at run-time.

<# is the beginning of a code block.  Notice how the IsReadOnly property is tested.  Basic on the result, an entire block of code can either run or be by-passed.  This feature is so cool when you bring loops from LINQ queries into the picture.

One thing you’ll notice is that all the code blocks are left justified.  Yes, this makes reading the template a little harder.  However, if you don’t do this, the resulting code will be indented the same amount as the code block indentation.

So what I do when editing my templates is to indent everything to make it easier to edit the template.  When I”m done, I go back and move the code to the left.

Run-Time Rendering of T4 Templates

Dim t As New PropertyTemplate(
    Me.cboScope.SelectedItem.ToString,
    Me.chkIsShared.IsChecked.Value,
    Me.chkIsReadOnly.IsChecked.Value,
    Me.chkIsSetterPrivate.IsChecked.Value,
    Me.txtPropertyName.Text,
    Me.txtBackingField.Text,
    Me.cboTypeName.SelectedItem.ToString,
    Me.cboRaisePropertyChangedMethodName.SelectedItem.ToString)

'How cool is this?  Instantiate, call a single method, get the code!
Dim strResult As String = t.TransformText

Instantiate the template, call the TransformText method.  Not very sexy, but powerful!

Download

Get Your T4 On Demo Application (33KB)

Alternate Download Site

Some corporate firewalls do not allow access to Windows Live Sky Drive. You can download the installer here. Remember to rename the file from .doc to .zip. This is a requirement of WordPress.

Get Your T4 On Demo Application (33KB)

Links

Gareth Jones blog  Gareth works on the DSL Team at Microsoft and works with the Microsoft T4 product.

Kathleen Dollard’s blog Kathleen has been doing code generation for a very long time and is an industry expert in this space.

Kathleen Dollard’s work blog post on why T4 Templates are the best thing since sliced bread.

Oleg Sych very nice blog post on T4 Preprocessed Text Templates

Pablo Galiano T4 Preprocessing Part 1

Pablo Galiano T4 Preprocessing Part 2

Close

There is a fair amount of information on Visual Studio 2005/2008 T4 templates.  When reading these blog posts, magazine articles and MSDN Documentation, keep in mind that the new T4 templates do not have wide spread documentation yet.  Most of what you will find is applicable to editing of the templates and directives used in the templates.  Beyond that, just filter the information and you’ll stay on course.

Visual Studio 2010 T4 Preprocessed Text Templates are a great tool for your toolbox.  Hope to see you use the best kept secret in Redmond.

Have a great day,

Just a grain of sand on the worlds beaches.

I have updated the project templates Visual Studio 2010 Beta2 Sample Data Project Templates. 

The Silverlight template needed an update to the .proj file.

Please download the templates from the above post.

Sorry for the problem.

Close

Have a great day,

Just a grain of sand on the worlds beaches.

I was working on a post for T4 Preprocessed Text Templates (I’ll post it tonight) and found a bug in the XAML Power Toys for Visual Studio 2010 Beta2 Cider Designer grid parsing code. 

Chances are you won’t hit it, but I did so I’ve corrected the code and posted a new update.  The code didn’t properly handle a null value in the CheckBox.Content property.  I’ve correct it and added additional null checks.

Please visit this page XAML Power Toys for Visual Studio 2010 Beta2 Cider Designer and get the latest version v1.0.1.

You can go to the above page, download the install files and install overtop as it will remove the previous version and install the new one.

Sorry for the bug. 

Close

Hope you use and enjoy XAML Power Toys for Visual Studio 2010 Beta2 for Cider.

Have a great day,

Just a grain of sand on the worlds beaches.

The WPF and Silverlight Designer for Visual Studio 2010 shares several new design time (d:) properties and design time MarkupExtensions with Expression Blend 3 that provide necessary information for the WPF and Silverlight Designer to deliver a great editing experience.

I have explained the d:DesignData MarkupExtension in detail in this blog post:  Visual Studio 2010 Beta2 Sample Data Project Templates.

In this post I’ll cover the d:DataContext property and the d:DesignInstance MarkupExtension.

d:DataContext

d:DataContext gives developers the ability to set a design time d:DataContext that is separate and independent of the run-time DataContext property.

This feature solves the problem of developers wanting to set their DataContext programmatically but also wanting design time data.

All d: properties are ignored during compilation and are not part of any run-time assemblies.

d:DesignInstance

Purpose:  Provides a design time shape to the d:DataContext its applied to.

Example:  In the below snippet the Person class is the shape provided by d:DesignInstance to the Grid’s d:DataContext.

<Grid d:DataContext="{d:DesignInstance local:Person}">

Note: In the above example, the Person class is actually a faux type (fake or substitute type).  This faux type enables types that are not creatable to be created and their properties exposed as a shape.  See the below section on creating creatable types.

Usage:  So, now that the d:DataContext has shape, what can I do with it?

The shape is used by the new Binding Builder to expose the properties of the type in d:DataContext.  You can see in the below image, the four properties exposed by the Person class.

The Binding Builder is opened by clicking or right clicking on the Property Marker in the Properties Window.  The Property Marker is the icon to the right of the property name.  The Binding Builder is a GUI for editing bindings in WPF and Silverlight.  This is a super feature

The Cider Team has a great explanation of the new features on WindowsClient.net that you can read here: Setting Up Visual Studio for WPF and Silverlight Development.  There is an article and video.

You can read additional Cider Team Online material here:  WPF and Silverlight Designer for Visual Studio 2010.  We are in the process of adding many more articles.  While the material is initially geared for developers coming from other platforms to WPF or Silverlight, it has a lot of great information even for the seasoned XAML Head.  Yea, I said it.  I’m a XAML Head too and proud of it.  (LOL)

Without d:DesignInstance, d:DesignData or d:Source applied to a CollectionViewSource the Binding Builder would have no way to determine shape and provide a list of properties.

Note:  If d:DataContext is not set, but DataContext is set and has a created type assigned to it, this will also supply shape that the Binding Builder can use for listing properties.

Creating Creatable Types

 <Grid d:DataContext="{d:DesignInstance local:Person, IsDesignTimeCreatable=True}">

d:DesignInstance provides a technique for creating a non-faux type.  Setting the property IsDesignTimeCreatable to True on the d:DesignInstance MarkupExtension enables this.

Links

MSDN d:DesignInstance Walkthrough

Video showing d:DesignData and d:DesignInstance can be viewed from this blog post:  Visual Studio 2010 Beta2 Sample Data Project Templates.

The above post also has source code for sample data templates.  There four of the templates are tutorial walkthroughs on this topic and sample data.

The two .xaml files in the DesignInstance Samples folder are the walkthroughs.  You can create this project in VB.NET or C# by using one of the below templates when creating your project.

• VB WPF Application DesignData Sample – VB.NET Sample WPF Application that demonstrates consuming sample data.
• CS WPF Application DesignData Sample – C# Sample WPF Application that demonstrates consuming sample data.

Close

Hope you find d:DesignInstance and d:DesignData Sample Data in Visual Studio 2010 Beta2 a productive feature for your application development.

Have a great day,

Just a grain of sand on the worlds beaches.

To get to this Options dialog, use the Tools menu, selected Options, select Text Editors, select XAML, select Miscellaneous.

MarkupExtension IntelliSense and Editing

The most requested feature for the WPF & Silverlight XAML Editor was MarkupExtension IntelliSense.  This feature has been added to Visual Studio 2010 Beta2.

In addition to IntelliSense you also get some entry helpers.

1.  When you type a { (left curly brace) Visual Studio will automatically insert the } (right curly brace) for you. 

You can disable this feature by un-checking the above option, “Closing braces for MarkupExtensions.”

2.  When you press the SPACEBAR inside {} (curly braces) Visual Studio will automatically insert a comma for you to the left of the space added by pressing the SPACEBAR. 

You can disable this feature by un-checking the above option, “Commas to separate MarkupExtension parameters.”

Toolbox Auto-Population

Visual Studio 2010 Beta2 now adds all Custom Controls and UserControls in the Solution to the Toolbox when you build the solution.  Control’s are added to a separate Toolbox tab for each project. 

You can disable this feature by un-checking the above option, “Automatically populate toolbox items.”

How Auto-Population Works

When you build a project, its corresponding tab in the Toolbox is cleared and then all types that derive from FrameworkElement are added to the Toolbox tab for that project.  (see Fine Print below for more details)

When you build the solution, all projects Toolbox tabs are updated as explained above.

If you want to prevent an item from appearing in the Toolbox during the Auto-Population processing decorate the class with the System.ComponentModel.DesignTimeVisible attribute and pass False in the constructor.

The following code snippet shows the DesignTimeVisible attribute decorating the CustomView UserControl.  The CustomView UserControl will not appear in the Toolbox.

Imports System.ComponentModel

<DesignTimeVisible(False)>
Public Class CustomerView
    Inherits UserControl

End Class

Fine Print

To appear in the Auto-Population Toolbox process a type must derive from FrameworkElement and:

1.  Are public and have a default public or internal constructor or are internal and have either a default public or internal constructor

3.  Types deriving from Window or Page are ignored

4.  FrameworkElements in other .exe projects are ignore

5.  Internal classes will only be displayed when the active designer is for an item in the same project

6.  Friend Assemblies are not taken into account for Toolbox Auto-Population

Close

Have a great day,

Just a grain of sand on the worlds beaches.

Current Version 1.0.1, Last Update 28 October 2009

These last few weeks I’ve been writing control designers for Visual Studio 2010 Beta2 WPF and Silverlight controls.

Turns out this is much easier than I expected and is a lot of fun too!

This application is an example for writing a globalized WPF & Silverlight platform neutral control designer.  Both WPF & Silverlight applications use the same Design library.  You can check out the source code to see how this is done.  This source code is in VB.NET.  Later this week, I’ll be posting another full featured article and code example in C# and VB.NET for writing a platform neutral control designer for WPF & Silverlight custom controls.  The project also includes two controls you can use in your projects.  (Yes, Karl now speaks C#.  Took about 2 days to pick it up.  Still have to lookup some syntax but pretty fluent now.)

I must give credit where credit is due.  I got a good bit of feedback and suggestions from my teammates on the Cider Team (WPF & Silverlight Designer Team).  Thanks Mark, Zhanbo, Bin, Pav, Marco, Ben  and Ray.  My great friend Josh Smith also came over one day for some pair programming activities.  Thanks Josh!

For those that care, the above designer is an MVVM application that is completely data driven from the ViewModel.

Grid Layout Tool

The Grid Layout Tool provides an abstract view of the selected Grid control in the designer that enables editing the Rows and Columns of the selected Grid.

The above image is the Grid Layout Tool that allows you to:

• Move (reorder) rows and columns
• Move (reorder) multiple rows and columns (when multi-selected with CTRL+click)
• Insert row or column before or after any row or column
• Delete row or column
• Set all row or all columns sizes using the TextBoxes at the top.  Enter value and press ENTER.
• Set individual row or column size by clicking the text value the Azure row or column headers and then editing them.  Enter value and press ENTER.
• To set size to auto type “a” or “auto” and press ENTER.
• Designer is updated real time as you make your changes.
• Clicking the “Save” button commits the changes into one Undo Transaction.
• Clicking the “Cancel” button cancels all changes and puts the designer back in its original state.

Menu Options

This menu is only available when you have selected a GRID control in the WPF or Silverlight designer.

Chainsaw – Leaves Alignment

The chainsaw will remove all Margins, MinHeights, MinWidths and from CheckBox, RadioButton, Label, TextBlock will remove height and widths and on TextBox will remove height.  Will set all Grid Rows to Auto.  Will remove Name and x:Name if enabled.

Use this command if you do not have styles defined that determine layout for your form.  (see video)

Chainsaw – Clears Alignments

The chainsaw will remove all HorizontalAlignments, VerticalAlignments, Margins, MinHeights, MinWidths and from CheckBox, RadioButton, Label, TextBlock will remove height and widths and on TextBox will remove height.  Will set all Grid Rows to Auto.  Will remove Name and x:Name if enabled.

Use this command is you have a styles defined that determines layout for your form.  (see video)

Modify Control Tags on Create

If this option is checked the following controls will be affected when you create the control using the ToolBox.

StackPanel and Grid – Alignments and Name cleared  (note: when the StackPanel is created inside a GroupBox or Expander, the tag modifications are ignored and overridden by the designer.)

TextBox, TextBlock, Label, CheckBox, RadioButton – smaller sizes than the Visual Studio defaults and Named is cleared.  The smaller sizes widths were 120, now 80, except TextBox which is 100.  You can play around with control creation to see if this makes sense for you.

Modify Control Tags and Chainsaw Clears Name

If you want control names cleared by the Chainsaw or the control Modify Control Tags on Create feature check this menu option.  To turn off name clearing, uncheck this menu option.

Video

PLEASE view this short tutorial video.  You will get a full and quick understanding of this great feature.

This video is on my SkyDrive.  Silverlight Streaming is being discontinued and won’t let me upload any more video files.  Like many others, I’m trying to find an alternate location to host all my training videos.  Relocating and re-pointing all my videos will be a huge PIA.  Any suggestions for hosting would be greatly appreciated.

The below video can be downloaded and viewed.  Click the link to be taken to my SkyDrive.

  XAML Power Toys 2010 Beta2 for Cider Tutorial Video (13 minutes)

Downloads – Visual Studio 2010 Beta2 ONLY

This software will not work in the final release of Visual Studio 2010.  That includes RC/RTM releases.  I will release a new version when RC (release candidates) are published.

Remember – Please build your projects before attempting to create forms, ViewModels or using the Field List.

Please set your Control Defaults after installing, new options have been added.

Download now comes from my Windows Live Sky Drive.

Microsoft employees please read this:

If you are using the final Beta2 release these links and this software will work for you.

If not please  email me and I’ll send you an internal drop location you can get this software from.  (Just look me up in the Global address book.)

XAML Power Toys 2010 for Cider – for Visual Studio 2010 Beta2 v1.0.1 Release (459 KB)

XAML Power Toys 2010 for Cider – for Visual Studio 2010 Beta2 v1.0.1 Source Code not required (85 KB)

Alternate Download Site

Some corporate firewalls do not allow access to Windows Live Sky Drive.  You can download the installer here.  Remember to rename the file from .doc to .zip.  This is a requirement of WordPress.

XAML Power Toys 2010 for Cider – for Visual Studio 2010 Beta2 v1.0.1 Release (459 KB)

Your Feedback

I can’t not over emphasize the the importance and the weight of your feedback on this block post.  My team (Cider Team that delivers the WPF & Silverlight Designer) is eager to hear from customers on features you need in the WPF & Silverlight Designer and XAML Editor.

Close

Hope you use and enjoy XAML Power Toys for Visual Studio 2010 Beta2 for Cider.

Have a great day,

Just a grain of sand on the worlds beaches.

This post is the home page for XAML Power Toys for Visual Studio 2010 Beta2.  Please post all comments and suggestions for this version on this post.

XAML Power Toys for Visual Studio 2010 has all the same features as XAML Power Toys for Visual Studio 2008 except as noted below.  Please use the XAML Power Toys for Visual Studio 2008 page as a reference for how the the features work.  Please download this version of the software below.

During development of XAML Power Toys for Beta2 I ran into some bugs that are being corrected for the final release of Visual Studio 2010.  As a result I had to cut a few features for this release.

The below image displays the menu for XAML Power Toys for Visual Studio 2010 Beta2.  Users of the 2008 version will notice the “Group Into” submenu is gone; the “Tools” submenu is gone and that “Create ViewModel for Class” is displayed in the this submenu but it shouldn’t.

The bottom line is, submenus are broken in Beta2 and there is no known workaround.

Notice I have moved “Set Control Defaults” and “About” features from the “Tools” submenu to this submenu.

The other grayed out menu options are not enabled because no XAML was selected when the screen shot was taken.  All features on this menu work as advertised.  “Create ViewModel for Class” just displays here in error and will never be enabled.  It does work correctly in the C# and VB.NET Code Windows.

The good news is, the above software has been updated and works great in Visual Studio 2010 Beta2.

When the final release of Visual Studio 2010 is public I will release a new version without these limitations.

Downloads – Visual Studio 2010 Beta2 ONLY

Remember – Please build your projects before attempting to create forms, ViewModels or using the Field List.

Please set your Control Defaults after installing, new options have been added.

Download now comes from my Windows Live Sky Drive.

Download XAML Power Toys for Visual Studio 2010 Beta2 v5.1.0001 Release Installer (809 KB)

Download XAML Power Toys for Visual Studio 2010 Beta2 v5.1.0001 Source Code not required (594 KB)

Alternate Download Site

Some corporate firewalls do not allow access to Windows Live Sky Drive.  You can download the installer here.  Remember to rename the file from .doc to .zip.  This is a requirement of WordPress.

Download XAML Power Toys for Visual Studio 2010 Beta2 v5.1.0001 Release Installer (809 KB)

Visual Studio 2010 Beta2 Known Issues

The below issues are known, being worked on and will be fixed for the RC/RTM milestone.

1.  Can’t Add Menu inside an AddIn

This problem was first reported on MS Connect. 

https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=462766&wa=wsignin1.0

The workaround for this bug is to set the “Embod Interop Types” property to False for the “Microsoft.VisualStudio.CommandBars 8.0 Reference”

2.  Submenus keep repeating

When adding a submenu to a menu you have added in an AddIn, the submenus will repeat the entire menu tree instead of just showing the submenu items.

This is why I had to remove the “Group Into” submenu and features.  The submenus were simply unusable.

3.  Setup project “Client Framework” problems

When I first compiled the Setup project for this release, upon installation I kept getting a message that I had to install the .NET 4.0 Framework.  Obviously the full .NET framework was installed on the machine.

The only way I could get the message to not show up when running the Setup.exe, was to remove all references to the “Client Framework” within the solution.

Remember, in Visual Studio 2010 Beta2 all WPF and Class Library projects will by default target the “.NET 4.0 Client Framework.”  This is a good thing as it makes application distribution and installation easier for customers of your applications.

However, in this Beta2 release, to get the files to install from the output of the Setup project I had to remove all references to the “Client Framework.”

Close

Hope you use and enjoy XAML Power Toys for Visual Studio 2010 Beta2.

Have a great day,

Just a grain of sand on the worlds beaches.

At the request of a XAML Power Toys user I have updated XAML Power Toys for Visual Studio 2008 to version v5.0.0.01.

This update adds one new feature and corrects the v5 known issue.

The ViewModel creation window now allows selecting the name of the method that is used to raise the  PropertyChanged event.  You can thank Ted Warring for the suggestion.  Awesome Ted, appreciate the feedback and feature suggestion.

ViewModel Creator Gets New Feature

The ViewModel creator tool makes building a ViewModel class a snap.  This feature is sensitive to C# and VB.NET and will create the correct code for you.

The yellow highlight indicates the new feature added in v5.0.0.1.  You can now select or type in the name of the method that will be called when raising a PropertyChanged event.

This name value is also used if you selected the Implement INotifyPropertyChanged option.

This name feature enables you to use any name in your ViewModel base classes and have the generated code us it.

As always, you can download XAML Power Toys for Visual Studio 2008 here:

http://karlshifflett.wordpress.com/xaml-power-toys/

Close

Hope you use and enjoy XAML Power Toys for Visual Studio 2008.

Have a great day,

Just a grain of sand on the worlds beaches.

In .NET 4.0 WPF text rendering has been greatly improved.

However this new feature is not enabled by default.

You can read the complete feature write up on the WPF Text Blog.

The scenario where you get the most payback for using this feature is with text that is sized 15pt and below.

Line of Business forms containing TextBlocks, Labels, CheckBoxes, RadioButtons, Buttons and TextBoxes will have FontSizes below 15pt and will receive the most benefit of this new feature.

The feature is enabled by placing the “TextOptions.TextFormattingMode” attached property on the UI Element or on a parent UI Element.

<TextBlock Text=".NET 3.5 rendering" />

<TextBlock Text=".NET 4.0 improved rendering" TextOptions.TextFormattingMode="Display" />

The below XAML demonstrates how to have all text rendering use the new text rendering feature by placing the “TextOptions.TextFormattingMode” attached property on the Window.

In the below example, all child controls of the Window will use the new text rendering.

<Window x:Class="MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="350" Width="525"
    TextOptions.TextFormattingMode="Display">
    <Grid>

        <TextBlock Text="Inherited the .NET 4.0 improved rendering" />

    </Grid>
</Window>

Visual Studio 2010 Beta2 and .NET 4.0 have a lot of new goodness, go check it out!

Have a great day,

Just a grain of sand on the worlds beaches.

Silverlight 3 application demonstrating Sample Data.

Displaying Sample Data in the WPF and Silverlight Designer for Visual Studio 2010 Beta2 is now very easy with the design time DesignData markup extension.

The below video is a complete tutorial for using Sample Data in your WPF and Silverlight applications.  Please take a view few minutes to view it.

The Sample Application templates have many comments in them, walking you through Sample Data.  Please take a few minutes and review the projects created by the Sample Application Templates.

Beta2 Template Information

For Beta2, you need to use these templates to consume sample data in your projects.  The reason is the winfx.targets file for was not updated with the Sample Data Build Actions in time for Beta2.

These project files have been modified to include the DesignData Build Action for the Sample Data files.  All Sample Data files must have their Build Action set to DesignData in the properties window.

These templates will not be required for the final version of Visual Studio 2010.

There are really two templates.

1.  <Language> <Platform> Empty Application – this template consists of an empty project file and the added Build Action DesignData.

2.  <Language> <Platform> Sample Application – this template consists of a sample application that has sample data files and a UserControl that demonstrates how to consume the sample data.  It also includes the added Build Action DesignData.

WPF Templates

VB WPF Application DesignData – Empty VB.NET WPF Application template with sample data support.

VB WPF Application DesignData Sample – VB.NET Sample WPF Application that demonstrates consuming sample data.

CS WPF Application DesignData – Empty C# WPF Application template with sample data support.

CS WPF Application DesignData Sample – C# Sample WPF Application that demonstrates consuming sample data.

Silverlight Templates

VB SL Application DesignData – Empty VB.NET SL Application template with sample data support.

VB SL Application DesignData Sample – VB.NET Sample SL Application that demonstrates consuming sample data.

CS SL Application DesignData – Empty C# SL Application template with sample data support.

CS SL Application DesignData Sample – C# Sample SL Application that demonstrates consuming sample data.

Sample Application Template Usage

The WPF and Silverlight sample application template creates an application complete with sample data files, entity classes, a UserControl consuming the sample data files and

xmlns:d – How To Easily Add The d: Namespace

All design time properties live in a design time namespace that is part of this schema: http://schemas.microsoft.com/expression/blend/2008.

Examples of design time properties are, d:DesignWidth, d:DesignHeight, d:DesignInstance, d:DesignData, d:DataContext, d:Source.

In order to use the d: properties you must have a xmlns declaration in your XAML.  In Visual Studio 2010 there is a very easy way to add it to a Window, UserControl or Page .xmal file.

If you select the root control, you’ll see a Root Size Mode button displayed in the lower right hand corner.  Clicking this button changes the size mode of your root container from Auto to Fixed or from Fixed to Auto.

If the d: namespace has not been added to the root control yet, clicking this button will do it for you.  In addition to the d: namespace, mc: is added and the mc:Ignorable is added also.

I have modified each of the starter templates below to automatically add this for you.  However, as you add new Windows, Pages or UserControls, those templates may not have the d: namespace declarations, so the above trick comes in handy.

Adding a New Sample Data File

Open an existing Sample Data project or Create a new project using one of the Sample Data templates.

Add a resource dictionary to the project naming it <my entity class name>SampleData.xaml.

For example:  Customer sample data file would be named, “CustomerSampleData.xaml”

The the file properties as pictured below:

Build Action: DesignData

Copy to Output Directory: Do not copy

Custom Too:  <blank>

Editing a New Sample Data File

This is an example of a single instance sample data file.

<local:Customer
    xmlns:local="clr-namespace:WPFApplication2"
    Age="21" Email="jim@hotmail.com"
    FirstName="Jim" LastName="Smith" />

Sample Data files allow you to construct your objects in XAML.  You can set the required properties as illustrated above.

The below code illustrates how to create a collection of items in a sample data file.

<local:Customers xmlns:local="clr-namespace:WPFApplication2">
    <local:Customer
        Age="21" Email="jim@hotmail.com"
        FirstName="Jim" LastName="Smith" />
    <local:Customer
        Age="22" Email="jane@hotmail.com"
        FirstName="Jane" LastName="Smith" />
</local:Customers>

The above Customers class derives from the Generic List of Customer.

Consuming Sample Data in WPF

<!-- DataGrid Sample-->
<Grid d:DataContext="{d:DesignData Source=/SampleData/PeopleSampleData.xaml}"
      Grid.Row="1" Margin="7">
    <DataGrid ItemsSource="{Binding}"/>
</Grid>

Sample Data is exposed through the d:DataContext design time property.  Design time properties are not compiled into your applications.

In WPF this is how you start at the root, navigate to SampleData folder and get the xaml file.

Consuming Sample Data in Silverlight

<!-- DataGrid Sample-->
<Grid d:DataContext="{d:DesignData Source=../SampleData/PeopleCollectionSampleData.xaml}"
      Grid.Row="1" Margin="7">
    <data:DataGrid ItemsSource="{Binding}"/>
</Grid>

In Silverlight you have to ../ up to the root, then navigate to SampleData folder and get the xaml file.

Slight difference between WPF and Silverlight.

Video

PLEASE view this short tutorial video.  You will get a full and quick understanding of this great feature.

This video link supports right click, save as…

  Sample Data Tutorial Video (22 minutes)

Installing Templates Using The Download

For VB.NET copy the download to:

C:\users\<your user name>\Documents\Visual Studio 2010\Templates\ProjectTemplates\Visual Basic

Unzip the download in this folder.  You should have 4 zip files in the folder.  You are ready to go.

For C# copy the download to:

C:\users\<your user name>\Documents\Visual Studio 2010\Templates\ProjectTemplates\Visual C#

Unzip the download in this folder.  You should have 4 zip files in the folder.  You are ready to go.

Downloads

After downloading one or both template downloads, you’ll need to rename the file extension from .doc to .zip.  This is a requirement of WordPress.com.

Requires:  Visual Studio 2010 Beta2

Silverlight Templates require:  Silverlight 3

VB.NET Project Templates (61KB) (updated 10-28-2009)

C# Project Templates (58KB) (updated 10-28-2009)

Installing Templates From Within Visual Studio 2010 Beta2

The sample data templates are also be individually available on the Visual Studio Code Gallery.

To use a single template open the New Project Dialog and select the Online Templates tab at the bottom left.  You can browse all available templates or search for “design” and all the templates will be listed.

Close

Hope you use and enjoy Sample Data in Visual Studio 2010 Beta2.

Gentle reminder, please watch the above video too.

Have a great day,

Just a grain of sand on the worlds beaches.

In previous posts, how to run MySQL scripts and add local users and groups with net command in VB.NET, it did not catch any errors from the child processes running.

In this post, you will see how easy it is to catch those error messages.

Download code (PDF) here.

In this example, it will display message "Process Completed" or the "Error message" in a label on the GUI.

Here is the code snippet:
Private Sub RunTheCommand(ByVal TheCommand As String, ByVal TheArguments As String)
     Try
          Dim proc As New Process
          Dim err As String = ""
          'Clear any messages in the GUI.
          lblError.Text = ""

          proc.StartInfo.FileName = TheCommand
          proc.StartInfo.Arguments = TheArguments

          'StartInfo.UseShellExecute must be False when StartInfo.RedirectStandardError = True.
          'Otherwise when reading the stream from StandardError will throw an exception.
          proc.StartInfo.UseShellExecute = False
          proc.StartInfo.RedirectStandardError = True
          'Don’t show command prompt window.
          proc.StartInfo.CreateNoWindow = True
          'Start process
          proc.Start()
          'Read the error stream (synchronously) first to the end before
          'waiting for the child process to exit – to avoid a deadlock.
          err = proc.StandardError.ReadToEnd
          proc.WaitForExit()
          proc.Close()

          'Display errors on the GUI if any
          If err = "" Then
               lblError.Text = "Process Completed"
          Else
               lblError.Text = err
          End If

     Catch ex As Exception
          MessageBox.Show(Err.Description, "Process Error", _
               MessageBoxButtons.OK, MessageBoxIcon.Error)
     End Try
End Sub

Happy Coding