Search results for 'app:weblogs' matching tag 'CSharp'

Your Application Title in .NET

DeborahK — Mon, 27 Aug 2012 05:00:00 GMT

You would think that giving an application a title and later retrieving that title would be a straightforward thing to do in VB.NET or C#. But it turns out to be a little complex, especially to find the appropriate place to enter the title then to write the appropriate code to retrieve that title.

First, enter the title of the application.

In C#:

Find the project in Solution Explorer.
Double-click on the Properties node under the project in Solution Explorer.
Select the Application tab.
Click the Assembly Information button.
Enter the desired title into the provided dialog.

In VB:

Find the project in Solution Explorer.
Double-click on the My Project node under the project in Solution Explorer.
Select the Application tab.
Click the Assembly Information button.
Enter the desired title into the provided dialog.

Second, write the code to retrieve that title. In this example, the title is provided as an ApplicationName property.

In C#:

/// <summary>
/// Gets the name of the application.
/// </summary>
/// <value></value>
/// <remarks></remarks>
public static string ApplicationName
{
    get
    {
        var entryAssembly = Assembly.GetEntryAssembly();
        var applicationTitle = ((AssemblyTitleAttribute)entryAssembly.GetCustomAttributes(typeof(AssemblyTitleAttribute), false)[0]).Title;
        if (string.IsNullOrWhiteSpace(applicationTitle))
        {
            applicationTitle = entryAssembly.GetName().Name;
        }
        return applicationTitle;
    }
}

In VB:

''' <summary>
''' Gets the name of the application.
''' </summary>
''' <value></value>
''' <remarks></remarks>
Public Shared ReadOnly Property ApplicationName() As String
    Get
        Dim applicationTitle = My.Application.Info.Title
        If String.IsNullOrWhiteSpace(My.Application.Info.Title) Then
            applicationTitle = My.Application.Info.AssemblyName
        End If
        Return applicationTitle
    End Get
End Property

The C# code defines a static property for the application name. Its getter first determines the entry assembly, which is the first executable that was executed. So even if this property is in a library component, if the application was launched with a WinForms or other UI component, the entry assembly is the UI component and not the library. If the code needs the currently executing assembly, replace GetEntryAssembly with GetExecutingAssembly.

The C# code then uses GetCustomAttributes to obtain the AssemblyTitleAttribute from the assembly to then retrieve the title.

If for some reason the title attribute was not set, the code uses the GetName method to retrieve the name of the entry assembly and uses the retrieved name.

The VB code uses the My namespace to retrieve the application title. The My namespace provides a very nice shortcut to the application's title attribute. If for some reason the title attribute was not set, the code uses the AssemblyName, also provided within the My namespace.

In both languages, the application title is "Acme Customer Management" as defined in the Assembly Information dialog.

Use this technique any time you want to define the application title in the assembly information and retrieve it for display or logging.

Enjoy!

Visual Studio toolbar

bill — Wed, 07 Mar 2012 06:00:00 GMT

The beta of Visual Studio 11 is causing a lot of feedback around the grey shade icons. The use of colour or not has also brought to the forefront the UI for colour-blind people. So I thought I’d post a picture of my toolbar, along with some links to see the page as seen by those with colour-blindness...

My toolbar:

Colour-blind filter web site: http://colorfilter.wickline.org/

This post on the above site:
http://colorfilter.wickline.org/?a=1;r=;l=0;j=1;u=msmvps.com/blogs/bill/archive/2012/03/07/visual-studio-toolbar.aspx;t=p

VB Quark #7 : Optional Parameters and Dates

bill — Wed, 09 Nov 2011 06:00:00 GMT

Hopefully you already know VB has full support for Optional parameters, both declaring them and calling them, but did you know you can use Dates as Optional parameters ?

   Public Sub AddNewCustomer(customer As Customer,
                             Optional dateAdded As Date = Nothing)
      If dateAdded = Nothing Then dateAdded = Now

VB has had this support for Optional parameters in place for the last decade or so in .NET and for years before that back in the COM versions of VB.

In the last release of .NET (VS 2010), C# finally got support for Optional parameters, so the above in C# would look like:

     public void AddNewCustomer(Customer customer,
                           DateTime dateAdded = default(DateTime))
      {
         if (dateAdded == default(DateTime)) dateAdded = DateTime.Now;

The Nothing in the VB declaration is the same as default(DateTime) in C#, which equates to the theoretical Gregorian date of 1/1/0001.

But what if you want to specify a default date ? Well because VB supports date literals, in VB you can, but in C# you can’t. In VB you can write any date literal for the optional parameter value. For example, you might have some legacy database support, and when the date is unknown you want to use the equivalent of an OLE Date’s zero value:

Public Sub AddNewCustomer(customer As Customer,
Optional dateAdded As Date = #12/30/1899#)

When the VB compiler compiles this, it adds a System.Runtime.CompilerServices.DateTimeConstantAttribute to the parameter information with the default value stored as an Int64 (the number of ticks). C# actually sees the optional value in the above example and will use it. That is both VB and C# can call the code taking advantage of the optional value for the date parameter, but only VB let’s you define that value.

Displaying Dates in VS 2010

bill — Tue, 08 Nov 2011 06:00:00 GMT

From time to time there’s discussion about the way dates are displayed in the Visual Studio IDE for Visual Basic. Typically dates are shown using VB’s date literal syntax of #MM/dd/yyyy# which is the standard US format. For people outside of the USA this can be confusing or ambiguous at times. The good news is Visual Studio allows you to easily add your own display formatter.

Simply create a new class library project, add the following attribute to your AssemblyInfo file:

<Assembly: DebuggerDisplay("Date: {ToString(""s"")} kind={Kind}", Target:=GetType(DateTime))>

And then just copy the assembly to your Visualizers directory, eg:
My Documents\Visual Studio 2010\Visualizers

I added the Kind property to the display so as you can easily see if the Date is a local date, UTC or unspecified.

I've attached a sample project. Enjoy

Setting up Separate Visual Studio Instances

DeborahK — Sun, 23 Oct 2011 05:00:00 GMT

You can open Visual Studio multiple times, but each environment has the same settings. With Visual Studio 2010 and experimental instances, you can now have entirely different instances of Visual Studio with different settings.

If you open up Visual Studio 2010 and make the font larger or install specific extensions, those settings are used every time you open Visual Studio. This assumes that you want to work with Visual Studio the same way every time you use it. But you may have scenarios where this is not the case.

Say you want to set up your Visual Studio with one set of settings for your daily work and a different set when you do demos to your team or user group. Or you want one set of settings when you work on an ASP.NET application and a different set when you work on Windows Forms. Or one set when you work with client x and another set when you work with client y.

To support these scenarios, Visual Studio 2010 provides a feature called "experimental instances". Experimental instances allow you to set up multiple instances of Visual Studio with completely different settings, options, and extensions.

To set up an experimental instance, create a short cut to Visual Studio. Include with the path, the option /RootSuffix XXX, where XXX is any name you want to give to your alternate instance.

For example:

"C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe" /RootSuffix Demo

This sets up a new instance of Visual Studio called Demo. You can create any number of these new instances, just give them unique names.

The following is a screen shot for my demo instance:

Use this technique any time you want to set up multiple instances of Visual Studio.

Enjoy!

Opening Visual Studio From the Task Bar

DeborahK — Sun, 23 Oct 2011 05:00:00 GMT

If you use Visual Studio often, you probably pinned it to the task bar so you can quickly access it. Here is a tip for opening Visual Studio from the task bar using the keyboard.

First, count the position of Visual Studio in the task bar. Mine is in position #10.

Hold down the Windows Key + Alt + # of the item. On my system, this is Windows Key + Alt + 10. Then use the arrow keys to select the desired project.

Use this technique any time you want to launch Visual Studio from the Task Bar using the keyboard.

Enjoy!

VB Windows Phone Toolkit Aug 11 sample

bill — Fri, 19 Aug 2011 05:00:00 GMT

The Silverlight Windows Phone Toolkit August 2011 (7.1 SDK) doesn't contain a working VB sample. If you try to load the VB sample that does ship, you’ll get hundreds of errors. So I put together the VB sample that should have shipped.

Download the VB Windows Phone Toolkit samples

Enjoy

Oh, and Thanks to Nick Randolph for confirming the SDK doesn’t contain a working example.

Silverlight Validation: Resource File

DeborahK — Tue, 03 May 2011 05:00:00 GMT

Resource files are a great way to manage strings, especially if you need to support multiple languages. This post demonstrates how to use a resource file with the validation attributes used by Silverlight and WCF RIA Services.

NOTE: This post is part of a set of validation posts which starts here and it uses the sample code from this prior post.

In this prior post, the code example demonstrated how to use the single property validation attributes available in Silverlight and WCF RIA Services. For example, to validate that a first name is entered and does not exceed 20 characters, the attributes look like this:

[Required(ErrorMessage="Please enter a first name.")]
[StringLength(20, ErrorMessage = "First name cannot exceed 20 characters.")]
public string FirstName { get; set; }

Notice how the validation error messages are hard-coded strings. This poses a challenge if you need to localize your application.

A better option is to add the strings to a resource file. The trick here is that the resource file needs to exist both on the server (in the Class Library project if you are using WCF RIA with your own business layer) and on the client (in the Silverlight project). This is done by a process called linking.

1) In the Class Library project containing your business layer, add a resource file (Add | New Item | Resources File).

I added mine to a Resources folder in the project.

NOTE: If you are not using your own business layer on the server, you can add the resource file directly to the Web project instead.

2) Enter a name for each string along with the string values. Optionally add a comment.

3) Set the Access Modifier for each resource string to Public.

The result should look something like this:

4) In the Silverlight project, link to that resource file by selecting Add | Existing Item and then clicking on Add As Link in the Add Existing Item dialog.

5) In the Silverlight project, link also to the associated Designer.cs file.

NOTE: The Add Existing Item dialog allows multiple selection. So you could link both the rex file and the Designer/cs file in one step.

6) Modify the attribute parameters in the business layer Class Library project to reference the resource file instead of using hard-coded strings. Be sure to add a using for the resource file's namespace:

using InStepValidationExample.BL.Resources;

[Required(ErrorMessageResourceType = typeof(ValidationErrorResources),
ErrorMessageResourceName = "FirstNameRequired")]
[StringLength(20,
ErrorMessageResourceName = "FirstNameLength",
ErrorMessageResourceType = typeof(ValidationErrorResources))]
public string FirstName { get; set; }

Instead of setting the ErrorMessage parameter to a hard-coded string, this code sets the ErrorMessageResourceType parameter to the type of the resource file (which is the resource file name). The ErrorMessageResourceName parameter specifies the name that you defined for the associated resource string in the resource file.

7) Now for the tricky part. By default, Visual Studio requires that the two resource files be in the same namespace. If they aren't, the application won't find the resources.

For example, if you use the Silverlight Business Application template, you can see that it puts the resource file in the BizApp.Web project under a Resources folder. The resources are then in the BizApp.Web.Resources namespace.

To access the resources from the BizApp Silverlight project, the file is put in a folder hierarchy with a Web folder and then a Resources folder so the resulting namespace is again BizApp.Web.Resources.

In the example for this post, however, the resources are in a Class Library in a business layer separate from the Web project:

The namespace of the resources in the business layer is InStepValidationExample.BL.Resources. The namespace of the resources in the Silverlight project is InStepValidatoinExample.SL.Resources.

So if you run the application at this point, it will crash with a "TargetInvocationException occurred" message. If you look at the exception detail it says "Could not find any resources appropriate for the specified culture or the neutral culture..." Basically, it cannot find the resource file.

Luckily, we know the secret handshake required to get this to work:

7a) Right-click on the Silverlight project and select Unload Project.

7b) Right-click on the Silverlight project again and select to edit the project file.

7c) Add a <LogicalName> element to the <EmbeddedResource> element in the project file and set it to the namespace and resource name. Mine looked like this:

<ItemGroup>
<EmbeddedResource Include="..\InStepValidationExample.BL\Resources\ValidationErrorResources.resx">
    <Link>Resources\ValidationErrorResources.resx</Link>
    <LogicalName>
InStepValidationExample.BL.Resources.ValidationErrorResources.resources
     </LogicalName>
</EmbeddedResource>
</ItemGroup>

7d) Close the project file.

7e) Right-click on the Silverlight project and select Reload Project.

Now when you run, it should find your resource file.

Use a resource file any time you want better management of your strings, especially if you plan to localize your application.

Enjoy!

Silverlight/WCF RIA Validation: Metadata Class

DeborahK — Tue, 03 May 2011 05:00:00 GMT

Data annotation attributes are a great way to add single property validation to your Silverlight/WCF RIA application. But what if you don't want to inject attributes all over your business classes? The purpose of a metadata class is to have a place for all of these attributes external from the business class.

NOTE: This post is part of a set of validation posts which starts here and it uses the sample code from this prior post.

If your Silverlight application uses WCF RIA services and your own business objects, then you can set attributes on your business object properties to define single-attribute validation.

In this prior post, the code example demonstrated how to use the single property validation attributes available to validate that a last name is entered and does not exceed 20 characters, the attributes look like this:

[Required(ErrorMessage = "Please enter a last or family name.")]
[StringLength(20, ErrorMessage = "Last name cannot exceed 20 characters.")]
public string LastName { get; set; }

If you don't want these attributes in your business classes, you can instead create a metadata file and store all of the attributes there.

1) Right-click on your business object's Class Library project and add a new class (Add | New Item | Class).

In this example, the class was called Student. So the metadata class is named StudentMetadata.cs.

2) In this new class, add any of the business object properties and associated attributes.

Note that the property names defined in the metadata class must exactly match the property names in the original class.

In C#:

using System.ComponentModel.DataAnnotations;

namespace InStepValidationExample.BL
{
internal sealed class StudentMetadata
{

   /// <summary>
   /// Private to ensure this class is not instantiated.
   /// </summary>
   private StudentMetadata()
   {}

[Required(ErrorMessage = "Please enter a last or family name.")]
[StringLength(20, ErrorMessage = "Last name cannot exceed 20 characters.")]
public string LastName { get; set; }
}
}

In VB:

TBD

3) Associate the metadata class with its original class using a MetadataType attribute on the original class definition. This attribute associates the original business object class with the metadata class.

In C#:

namespace InStepValidationExample.BL
{
    [MetadataType(typeof(StudentMetadata))]
    public class Student
    {
     ...
    }
}

In VB:

TBD

When you run the application, the validation should work as before:

Use this technique any time you want attributes on your business object properties, but want to define these attributes external from the business object classes.

Enjoy!

Silverlight/WCF RIA Single Property Validation

DeborahK — Sun, 01 May 2011 05:00:00 GMT

When you identify the validation scenarios for your application, you will find that some only require basic single property validation. Examples:

Ensure that a first name is entered.
Ensure that the first name is not longer than 20 characters
Ensure that the age is between 16 and 120.
Ensure that the email address is valid.

NOTE: This post is part of a set of validation posts which starts here and it uses the sample code from this prior post.

Each of these requirements can be handled by Silverlight's single field validation using property attributes.

When you use WCF RIA Services and your own set of business objects, these attributes are set in the business layer on the business object properties. WCF RIA Services then automatically generates a copy of your business object properties with their attributes on the client for use with Silverlight.

Silverlight performs the validation when the user leaves the field AND before the data is submitted to the server. If there is a validation error, the data is not submitted to the server and a validation error appears.

Each of the simple validation attributes are discussed below.

Required Field Validation

Use the Required attribute to mark a property as required. For example, if the first name is required, the first name property is adorned as follows:

[Required()]
public string FirstName { get; set; }

If you make this change and run the sample application (from this prior post), the first name field is automatically validated. Clear the field and you will see this:

Silverlight's built-in validation automatically kicks in and you see the default required validation error message.

NOTE: You can modify the Silverlight XAML to specify the ValidatesOnNotifyDataErrors property as part of the binding expression. However, this is not necessary. The default value of this property is true, so the validation errors are reported by default.

If you don't like the error message, you can change it by setting one of the named parameters of the Required attribute:

[Required(ErrorMessage="Please enter a first name.")]
public string FirstName { get; set; }

The message then appears as shown below:

Use required field validation any time you want to ensure that the user enters a value into a Silverlight control.

String Length Validation

Often times the data entered on a page in Silverlight will get stored to a database where a maximum field size is defined. It is helpful for the users to be aware of this maximum before attempting to submit the data to the server.

For example, if the first name is set to a maximum of 20 characters in the database, you can set the StringLength attribute as follows:

[Required(ErrorMessage="Please enter a first name.")]
[StringLength(20, ErrorMessage = "First name cannot exceed 20 characters.")]
public string FirstName { get; set; }

Use string length validation any time you want to ensure that the user does not enter more data than can be stored in the database table or any other time that a string length cannot exceed a maximum value.

Range Validation

When entering numbers, often times the value must be limited to a specific range of values. For example, in this application the age must be between 16 and 120.

[Range(16, 120,
ErrorMessage="Please enter your age. You must be 16 or older.")]
public int Age { get; set; }

This results in the following:

NOTE: The Range attribute has overloads with parameters that are integers or doubles. To validate other types (such as decimal), you need to use the Range overload that takes a type as the first parameter and string values to convert to the defined type. For example:

[Range(typeof(Decimal),"0", "40000")]
public decimal TuitionPaid{ get; set; }

Use range validation any time you want to validate user entry to a range of numeric values.

Regular Expression Validation

Regular expression validation allows you to perform pattern matching on the entered value. For example, an email address must match a specific pattern with a local part of the address followed by an at sign (@) followed by a domain name. The Regular Expression attribute could look like this:

[Regular(@"^(?("")("".+?""@)|" +
      @"(([0-9a-zA-Z]((\.(?!\.))|" +
      @"[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))" +
      @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|" +
      @"(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$",
      ErrorMessage="Please enter a valid email address")]
public string Email { get; set; }

NOTE: Replace "Regular" above with "RegularExpression". For whatever reason, the entire string was blocked in this post if the word "Expression" appeared above.

Other properties that could use a regular expression include phone numbers, social security numbers, and any other entry that must match a specific pattern.

You can find more information on regular expressions here.

Use regular expressions any time you want to validate a user's entry based on pattern matching.

For more complex validation scenarios, see this prior post.

Enjoy!

EDIT 5/2/11: Corrected typographical errors. Corrected the regular expression, which did not paste into the post correctly.