ASHVIN'S TECHNICAL BLOG

Determine list of printers installed in C# (.Net Framework)

2010-04-25T11:27:00.000+04:00

1. Add System.Drawing library as reference.

2. Import the System.Drawing.Printing.

using System.Drawing.Printing;

3. PrinterSettings.InstalledPrinters is a string collection of the printer names installed on the machine

Example to output all printers on Console:


using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing.Printing;
using System.Windows.Forms;

namespace PrintersDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            for(int i = 0; i < PrinterSettings.InstalledPrinters.Count; i++)
            {
                Console.WriteLine(PrinterSettings.InstalledPrinters[i]);
            }

            Console.ReadLine();
        }
    }
}
  

JDeveloper: ORA-01882: timezone region found found

2010-04-25T11:11:00.000+04:00

When trying to deploy your web application using JDeveloper to the integrated WebLogic, if you get the following error:

(oracle.jbo.JboException) JBO-29000: Unexpected exception java.sql.SQLDataException, msg=ORA-01882: timezone region not found

then to resolve this issue,

1. Goto Application menu and select Project Properties

2. In the Project Properties window, On the left pane, select Run/Debug/Profile

3. On the right pane, Edit the Default configuration (or double click on Default)

4. In the Edit run configuration window, select Launch Settings

5. For 'Java option' text box, add -Duser.timezone="+04:00"

You will probably need to save and restart JDeveloper for the changes to take effect.

Command to launch Remote Desktop Connection

2010-04-24T18:12:00.000+04:00

Just type mstsc in the Run window or the command prompt window, and the Remote Desktop Connection window will pop up ...

GetDeviceVersion() in RAPI fix

2009-06-11T09:13:00.002+04:00

I have got a desktop application that determines the operating system's version of the device (I have used a Windows Mobile 5.0 device) connected to PC via ActiveSync. When calling the method GetDeviceVersion() exposed in the RAPI class in the OpenNETCF.Desktop.Communication library, the application crashes with the following exceptions:

When running the solution in Debug configuration:
System.NullReferenceException was unhandled
Message="Object reference not set to an instance of an object."

When running the solution in Release configuration:
System.AccessViolationException was unhandled
Message="Attempted to read or write protected memory. This is often an indication that other memory is corrupt."

When running the exe application:
Unhandled exception at 0x00000000 in XXXApplicationNameXXX.exe: 0xC0000005: Access violation reading location 0x00000000.

The solution to any of these issues is to PInvoke the method CeGetVersionEx() rather than the one provided in the RAPI class.

//PInvoke Declarations
[StructLayout(LayoutKind.Sequential,
    CharSet = CharSet.Unicode)]
public struct CEOSVERSIONINFO
{
    internal int dwOSVersionInfoSize;
    public int dwMajorVersion;
    public int dwMinorVersion;
    public int dwBuildNumber;
    public PlatformType dwPlatformId;
    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
    public string szCSDVersion;
}
 
[DllImport("rapi.dll", 
    CharSet = CharSet.Unicode, 
    SetLastError = true)]
internal static extern int 
    CeGetVersionEx(ref CEOSVERSIONINFO lpVersionInformation);

//PInvoke Call
CEOSVERSIONINFO osVersionInfo = new CEOSVERSIONINFO();
CeGetVersionEx(ref osVersionInfo);

Source: opennetcf

Adding the XML Declaration when calling DataSet.WriteXml(Stream stream) method

2009-05-28T14:15:00.001+04:00

using (DataSet ds = new DataSet())
{
//TODO: fill the ds with appropriate data
XmlTextWriter stream = new
XmlTextWriter(@"C:/xmltest.xml", Encoding.UTF8);
ds.WriteXml(stream);
stream.Close();
}

The above example attempts to write the content of the DataSet to an xml file using the DataSet.WriteXml method. The xml file doesn't contain the XML declaration.

Content of xml file:

<NewDataSet />

TIP: To include the XML declaration in the output file, call the method WriteStartDocument() on the stream object prior to the WriteXml() method call.

using (DataSet ds = new DataSet())
{
//TODO: fill the ds with appropriate data
XmlTextWriter stream = new
XmlTextWriter(@"C:/xmltest.xml", Encoding.UTF8);
stream.WriteStartDocument();
ds.WriteXml(stream);
stream.Close();
}

Content of xml file:

<?xml version="1.0" encoding="utf-8"?>
<NewDataSet />

Application Settings in .Net Framework

2009-05-24T20:12:00.006+04:00

The .Net Framework allows us to create and access values that persist from application session to application session. These values are called settings.For example, settings can be used to store user preferences, color scheme of application, or web server address used by the application.

Settings have four properties: Name (also used to access it at run-time), Type (represents type of setting), Value and Scope (can be either User or Application). A setting with Application scope represents a value that is used by the entire application regardless of the user, whereas a setting with User scope is more likely to be user-specific.

Application settings are read-only and values can be changed at design time, while User settings can be changed at run-time as well.

The Settings Editor in Visual Studio can be opened by double click Settings.settings under the Properties folder in Solution Explorer.

Loading settings at run-time

this.Title = Properties.Settings.Default.ApplicationName;

txtName.Text = Properties.Settings.Default.Name;

txtAddress.Text = Properties.Settings.Default.Address;

txtNationality.Text = Properties.Settings.Default.Nationality;

Saving user setings at run-time

Properties.Settings.Default.Name = txtName.Text;

Properties.Settings.Default.Nationality = txtNationality.Text;

Properties.Settings.Default.Address = txtAddress.Text;

Properties.Settings.Default.Save();

Download Example

Single Instance applications using WindowsFormsApplicationBase available in Microsoft.VisualBasic.dll

2009-05-14T21:46:00.003+04:00

Have you ever thought of using the WindowsFormsApplicationBase class (available in Microsoft.VisualBasic.dll) in a C# solution to implement a Single Instance application?

Actually, there are a number of ways to write Single Instance applications, such as Mutexes, Processes and so on and so forth. However, the WindowsFormsApplicationBase class provides a very elegant way to achieve the same result.

Click here, here and here for some cool examples and as such, I don't need to write any sample code and/or demo here ;-)

Smart Device CAB Project includes wrong localized resources

2009-04-21T09:26:00.003+04:00

http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=117453

When the projects in Visual Studion 2005 are compiled, different satellite assemblies are normally generated in different folders e.g. \obj\release\<%lang%>\ where <%lang%> can be fr, gb and pt, just to mention a few.

The INF file contents will also point to the different resource aseemblies for each resource. (though the name of these assemblies are same, the path are still different). However, I think the CabWiz.exe believes that all these assemblies are same (as they share the same name), and hence include the same assembly in the cab file for each different language.

The issue and workarounds described in the above link.

Run an application when device connects to PC via ActiveSync

2009-02-27T15:41:00.001+05:00

To run an application when a PDA device connects to the PC via ActiveSync, the AutoStartOnConnect registry key can be used. The key resides at HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\AutoStartOnConnect in the Windows Registry Editor.

When a device connects to the PC, ActiveSync enumerates all the string values under the AutoStartOnConnect key and attempts to launch the specified applications.

Similarly, the registry key HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows CE Services\AutoStartOnDisconnect can be used when a device is disconnected from the PC.

Coding Style: WaitCursor encapsulation

2009-02-04T13:46:00.001+05:00

Often during long processes, we need to display the WaitCursor to give feedback to the users. Changing the mouse cursor to WaitCursor, and then back to the default cursor may be achieved as follows:

1 // change to WaitCursor

2 Cursor.Current = Cursors.WaitCursor;

4 // DO SOMETHING

6 // change to default cursor

7 Cursor.Current = Cursors.Default;

Now, assume that an exception is thrown during the processing (i.e. DO SOMETHING), the cursor may never change back to the default state. Hence, we may need to use a try and finally block to ensure that the cursor is changed back when either the processing is successfully completed or an exception is thrown. The code will now be as follows:

1 // change to WaitCursor

2 Cursor.Current = Cursors.WaitCursor;

4 try

5 {

6 // DO SOMETHING

7 }

8 finally

9 {

10 // change to default cursor

11 Cursor.Current = Cursors.Default;

12 }

As changing the cursor to the busy state and back to the normal state is repeated in different methods, a further improvement would be to encapsulate this piece of functionality in a class. Then, a using statement can be used to handle the cursor states during processing.

23 /// <summary>

24 /// Handles wait cursor

25 /// </summary>

26 public class WaitCursor : IDisposable

27 {

28 public WaitCursor()

29 {

30 Cursor.Current = Cursors.WaitCursor;

31 }

33 public void Dispose()

34 {

35 Cursor.Current = Cursors.Default;

36 }

37 }

using (new WaitCursor())
{
  // DO SOMETHING
}

MCTS: .Net Framework 2.0 Windows Application achieved!

2008-12-01T21:30:00.002+05:00

Good evening everyone.

Today is indeed a special day for me, as I am going to have my first ever certification. I took the 70-526 Microsoft .NET Framework 2.0 – Windows-Based Client Development examination in the morning at the CTI Prometric Centre and I have passed with a score of 980 out of 1000.

I also completed the 70-536 Microsoft .NET Framework – Application Development Foundation examination last October (with a score of 947 out of 1000), so I am now a Microsoft Certified Technology Specialist: .NET Framework 2.0 Windows Applications.

Read more about the MCTS: .Net Framework 2.0 Windows Application here.

There are actually about 15,469 professionals worldwide with this certification, and working as a .NET developer for more than 2 years and spending a couple of months preparing for these two examinations, I am finally going to be one of them. Objective met!!!

Manually enable remote connections in SQL Server 2005

2008-11-25T08:53:00.007+05:00

The default configuration of the SQL Server 2005 doesn't allow remote connections. Hence, the error message "An error has occurred while establishing a connection to the server. When connecting to SQL Server 2005, this failure may be caused by the fact that under the default settings SQL Server does not allow remote connections. (provider: Named Pipes Provider, error: 40 - Could not open a connection to SQL Server)" when creating a new SQL Server database or connecting to an existing database in Visual Studio 2005 (VS2005).

To manually enable remote connections on the SQL Server,

1. Open the SQL Server Surface Area Configuration through Start menu.

2. Next, select Surface Area Configuration for Services and Connections.

3. On the left panel, expand the SQL Server instance -> Database Engine -> Remote Connections. Then, on the right panel, select Local and remote connections - Using TCP/IP only.

4. Also, make sure that the SQL Server Browser service is running.

5. Finally, restart the SQL Server instance. This can be done in the Services list under Administrative Tools in Control Panel.

Build setup project and msi file using command-line

2008-11-21T08:36:00.002+05:00

Command build the VS2005 deployment (or setup) project and create the msi file:

"C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\devenv.exe" SOLUTIONNAME.sln /Build "Release" /project SETUPPROJECTNAME.vdproj /projectconfig "Release"

ArgumentException Column does not belong to table

2008-11-14T10:12:00.002+05:00

When using ADO.Net, I got the following error:

Column does not belong to table . A simple fix will be to check if the column exists before accessing the column in the table. This can be done as follows:

if (row.Table.Columns.Contains(ColumnName))

{

// proceed here

}

Code Snippets: Monitor class for thread-safety

2008-10-27T16:55:00.009+05:00

Code Snippets is an interesting in-built feature of Visual Studio 2005. Code snippets are normally used in the Code Editor by first typing a shortcut (short name or alias), and then pressing TAB key. The code snippet shortcut/alias will then expand into a programming construct. This can make writing program code quicker, easier and more reliable.

To use the code snippets, use any of the follwing ways:

1. Right click in Code Editor and select the Insert Code Snippet menu command,
2. Activate the code snippet list by typing CTRL + K followed by X.

The Code Snippets Manager, found under the Tools menu, allows us to manage code snippets (add/remove) that will be available to insert into the code. It can also be accessted by CTRL K, followed by B.

The code snippets are stored as XML in .snippet files, and any user-defined snippet can be easily imported through the Code Snippets Manager and used during coding.

As a example, I will write a code snippet in order to use the Monitor.Enter and Monitor.Exit methods for thread-safe code (as we already have the 'lock' code snippet in VS2005) as shown below:

try

    System.Threading.Monitor.Enter(obj);

    // do some work here

finally

    System.Threading.Monitor.Exit(obj);

>>> Create the code snippet and store it as monitor.xml

<?xml version="1.0" encoding="utf-8" ?>

<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">

  <CodeSnippet Format="1.0.0">

    <Header>

      <Title>monitor</Title>

      <Shortcut>monitor</Shortcut>

      <Description>Code snippet to use Monitor class for thread-safety</Description>

      <Author>Ashvin Gunga</Author>

      <SnippetTypes>

        <SnippetType>Expansion</SnippetType>

      </SnippetTypes>

    </Header>

    <Snippet>

      <Declarations>

        <Literal>

          <ID>expression</ID>

          <ToolTip>Expression to evaluate</ToolTip>

          <Default>AnObject</Default>

        </Literal>

      </Declarations>

      <Code Language="csharp">

        <![CDATA[

try

          System.Threading.Monitor.Enter($expression$);

          //TODO: Enter your code here

          $selected$ $end$

          finally

          System.Threading.Monitor.Exit($expression$);

          }]]>

      </Code>

    </Snippet>

  </CodeSnippet>

</CodeSnippets>

>>> Use the Code Snippets Manager and import the monitor.snippet file under My Code Snippets

>>> Now, in the code, type monitor and press TAB. The monitor shortcut is expanded to:

try

    System.Threading.Monitor.Enter(AnObject);

    //TODO: Enter your code here

finally

    System.Threading.Monitor.Exit(AnObject);

Downloads
Visual Studio 2005 Code Snippets can be downloaded here.

Load data from XML file into Crystal Reports

2008-10-25T10:00:00.018+04:00

In this post, I will demonstrate how we can display data found in an XML file in a Crystal Report in C# using .NET Framework. It is easier to understand the whole thing when there is no need to write code for database (such as Oracle, Access or SQL) access or adapter or connection objects.

Pre-requisite: Crystal Reports installed on the machine, along with Visual Studio 2005.

1. The first thing is to create a new Windows Application (here I've named it XmlToCrystalReports) in VS2005.

2. I will add an Employees.xml file to the project, under a DATA folder. The xml file will contain data about employees.

Right click on the Windows Application in the Solution Explorer. Select Add -> Add New Item. Choose XML File in the Add New Item form, name it Employees.xml and select Add..

3. Populate the xml file with test data.

<?xml version="1.0" encoding="utf-8" ?>

<Employees>

  <Employee>

    <Id>1</Id>

    <Name>John</Name>

    <Position>Team Leader</Position>

    <Experience>6</Experience>

  </Employee>

  <Employee>

    <Id>2</Id>

    <Name>Frank</Name>

    <Position>Analyst Programmer</Position>

    <Experience>3</Experience>

  </Employee>

  <Employee>

    <Id>3</Id>

    <Name>Michael</Name>

    <Position>Senior Analyst Programmer</Position>

    <Experience>5</Experience>

  </Employee>

  <Employee>

    <Id>4</Id>

    <Name>Thomas</Name>

    <Position>Senior Analyst Programmer</Position>

    <Experience>4</Experience>

  </Employee>

  <Employee>

    <Id>5</Id>

    <Name>Alan</Name>

    <Position>Trainee Analyst Programmer</Position>

    <Experience>0.5</Experience>

  </Employee>

</Employees>

4. Next, I will add a Crystal Report to the project.

Right click on the Windows Application in the Solution Explorer. Select Add - Add New Item.

Choose Crystal Report, name it EmployeesReport.rpt, and select Add.

The Crystal Reports Gallery pops up. I will leave the default options and select OK.

The Standard Report Creation Wizard is shown, along with a list of available data sources. Under Project Data -> .NET Objects, double click on XmlToCrystalReports.MainForm.

The ADO.NET form is shown. Browse and select the Employees.xml file created earlier and choose Finish.

And we are back in the Standard Report Creation Wizard. The Employee table is now shown under the Available Data Sources tree. Select the Employee table, move it to the right under the Selected Tables tree and choose Next.

Now, we will need to select the appropriate fields to be displayed in the crystal report. So, move all the fields under the Fields to Display tree on the right and select Finish.

The EmployeesReport.rpt is added to the project and shown in the designer, with a pre-defined layout.

5. Format the crystal report to meet your needs (example, change font size, add title in header)

6. The Solution Explorer will now be as follows:

7. Now to view the report when the application runs, we will need to add a Crystal Report Viewer to the main form. The Crystal Report Viewer component is available in the Toolbox under Crystal Reports.

We can hide the Group Tree found on the left by setting the DisplayGroupTree to false in the Properties Window.

8. The last step is during form load, we will need to (1) load the XML file into a dataset, (2) create an EmployeesReport instance and set the data source to the dataset created, and (3) set the ReportSource of the crystal viewer to the instance of the EmployeesReport.

private void Form1_Load(object sender, EventArgs e)

    DataSet dsEmployees = new DataSet();

    dsEmployees.ReadXml(@"DATA\Employees.xml");

    EmployeesReport report = new EmployeesReport();

    report.SetDataSource(dsEmployees);

    crystalReportViewer1.ReportSource = report;

9. Run the application, and (if everything is ok) the Crystal Reports Viewer will display the employee displays found the the xml file.

Dotfuscate

2008-10-24T22:52:00.013+04:00

Introduction
The Microsoft .NET compiler converts the C# source code into Microsoft Intermediate Language (MSIL). However, with the use of a good decompiler tool and a few mouse clicks, any person can revert this .NET compiled code to its original C# source code. Hence, we need to protect the source code, including the 'trade secrets and logic' from attackers, especially when distributing the libraries/executables to third parties. A viable solution is the use of an Obfuscation Tool such as the .NET Dotfuscator (or simply, Dotfuscator).

The definition of 'obfuscate' is 'to confuse' or 'to make obscure or unclear', and that's exactly what an obfuscator tool will do. The Obfuscator will apply behavior preserving transformations on the code so that the functionality is preserved but the readability or understandability of the code is drastically reduced. The aim is to confuse observers while giving a consistent behavior to the Runtime Environment.

Main strategies of an obsfuscator
Compaction
The entire application is analysed and unused members are identified and removed from the obfuscated assembly. This is called the Compaction process. The unused members include unused classes, methods, instance variables and design time metadata, just to name a few. For example, a common library may offer a lot of functionalities but only a few are used in the application. So, these unused methods can be safely removed. Compacted programs also tend to load faster and run using less memory.

Overload Induction
The obfuscator renames all program identifiers to small, meaningless names. The Overload Induction mechanism works by identifying colliding set of methods across inheritance hierarchies and renaming such sets according to some enumeration (e.g. the alphabet). This method determines all opportunities for name reuse and hence, you may find more than 30% of ALL methods renamed to a single letter 'a'. Another advantage is the final program size of the obfuscated code is reduced by approximately 10% as there is heavy reuse of identify names.

String Encryption
Another interesting feature is the implementation of the runtime decrypted string encryption. An encryption algorithm is applied to all string literals and constants so as to make reverse-engineering even harder. This is very useful to hide hardcoded SQL strings, usernames and passwords that may be found in the code. Also, a decryption algorithm is inserted in the obfuscated code and later called at runtime to get back the original string literals.

Control Flow obfuscation
Control Flow obfuscation is yet another strong form of code protection. Here the flow of the program is changed so that the link between the original code and the obfuscated code breaks. It also ensures that no bug is introduced. For example, a for loop statement may be transformed into a while loop, a switch statement may be converted to a nested if statement and go to statements and labels may be introduced, just to name a few. This in turn transform the neat logic and flows in the original source code into a 'spaghetti-like' code to confuse the readers and any reverse engineering tool.

Assembly Linking
Multiple input assemblies are also combined into one or more output assemblies.

PreEmptive Solutions Dotfuscator flavors
There are currently two different version of the Dotfuscator: Professional Edition and Community Edition. The Community Edition is an entry level obfuscator and is included in Visual Studio 2005 Pro. The Professional Edition provides superior protection to foil decompilation, size reduction to conserve memory and improve load times, incremental obfuscation to release patches, watermarking to track pirates and so on and so forth.

Simple Dotfuscator Demonstration
1. Create your project in VS2005. Here, I shall use a simple application that print numbers 1 to 100.

using System;

using System.Collections.Generic;

using System.Text;

namespace DotfuscateDemo

    class Program

        private double unUsedDouble;

        /// <summary>

        /// Gets or sets the un used double.

        /// </summary>

        /// <value>The un used double.</value>

        public double UnUsedDouble

            get { return unUsedDouble; }

            set { unUsedDouble = value; }

        /// <summary>

        /// Main method

        /// </summary>

        /// <param name="args"></param>

        public static void Main(string[] args)

            Print1ToN(100);

            Console.ReadLine();

        /// <summary>

        /// Print1s to N.

        /// </summary>

        /// <param name="nValue">The n value.</param>

        private static void Print1ToN(int nValue)

            for (int i = 1; i <= nValue; i++)

                Console.WriteLine(i);

2. Build your project to get the assemblies that needs to be dotfuscated.

3. In Visual Studio 2005, open the Dotfuscator Community Edition found under Tools menu.

4. On the 'Select Project Type' screen, select the 'Create New Project' option.

5. Now we are ready to dotfuscate the project asssembly.

Select the Input tab on the Dotfuscator main window.

Select the option 'Browse and add assemblies to list' (this is an open folder icon) and add the project assembly.

6. There are other features available in the different tabs on the window and many of them may also be disable if you using the Community Edition. To keep this example simple, I will go directly to the dotfuscation process.

7. Now its time to save the project using Save Project under File menu. The solution is saved as an xml file.

8. The final step is to kick off the obfuscation process. This is done by selecting the Build Project option (play icon).

9. Once the build is completed, a Build Statistics is shown giving summary details of the obfuscated code changes.

10. You can now find the dotfuscated assemblies in a folder named Dotfuscated at the location where you saved the project xml file.

Before obfuscation...
After obfuscation...
Worth noting facts about Dotfuscator
A command line interface is available and thus, makes it suitable for integration into scripting environments or automated build processes.

ASP.NET code behind assemblies can be obfuscated using the Dotfuscator.

Dotfuscator will solely work on the compiled .NET assemblies and the original source code is never affected.

Dotfuscator is not a profiler (a very common misconception!!!).

Dotfuscator supports the Microsoft .NET Compact Framework.

And finally ...
Last but not least, it is important to know that obfuscation (or even encryption) is not 100% protected and secure. The only aim is to make the reverse engineering process extremely time consuming and painful so that it's not worth the effort and hence, stopping any potential attacker.

References
Microsoft .NET Support Team Blog
Preemptive Solutions
The Dotfuscator Solution

Hide ListView border in .NET Compact Framework

2008-10-23T16:40:00.000+04:00

To disable (or hide) the border of a ListView control in .NET Compact Framework,

1. Declare the following PInvoke methods...

#region PInvoke Declarations
const int GWL_STYLE = -16;
const int WS_BORDER = 0x00800000;
const int SWP_NOSIZE = 0x1;
const int SWP_NOMOVE = 0x2;
const int SWP_FRAMECHANGED = 0x20;
 
[DllImport("coredll.dll")]
private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
 
[DllImport("coredll.dll")]
private extern static void SetWindowLong(IntPtr hwnd, int nIndex, int dwNewLong);
 
[DllImport("coredll.dll")]
private static extern bool SetWindowPos(IntPtr hwnd, IntPtr hWndInsertAfter,
    int x, int y, int cx, int cy, int uflags);
#endregion

2. Write a ShowListViewBorder method...

/// <summary>
/// Shows the list view border.
/// </summary>
/// <param name="handle">The handle.</param>
/// <param name="showBorder">if set to <c>true</c> [show border].</param>
private void ShowListViewBorder(IntPtr handle, bool showBorder)
{
    int style = GetWindowLong(handle, GWL_STYLE);
    if (showBorder)
    {
        style |= WS_BORDER;
    }
    else
    {
        style &= ~WS_BORDER;
    }
    SetWindowLong(handle, GWL_STYLE, style);
    SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_FRAMECHANGED);
}

3. Call the ShowListViewBorder...

ShowListViewBorder(window.lvwDetails.Handle, false);

'Beautify' C# source code in VS2005

2008-10-05T22:44:00.004+04:00

Many times I have been asked whether it is possible to 'beautify' the C# source code in Visual Studio 2005. The answer is yes, we can.

In VS2005, the Format Document command found in the Edit -> Advanced Menu is available. The keyboard shortcut is:

Ctrl-k, Ctrl-d

(i.e. press ctrl, k and d keys simultaneously)

Before Format Document command...

public class Divider

public static double Divide(int divident, int divisor)

try{return divident / divisor;}

catch (Exception ex){

throw ex;

public static void Main() { try

{Divider.Divide(30, 0);}

catch (Exception ex)

{Debug.WriteLine(ex.StackTrace);

After Format Document command...

public class Divider

    public static double Divide(int divident, int divisor)

        try { return divident / divisor; }

        catch (Exception ex)

            throw ex;

    public static void Main()

try

        { Divider.Divide(30, 0); }

        catch (Exception ex)

            Debug.WriteLine(ex.StackTrace);

Tip: Another way to achieve the same result is to first find the last closing bracket in the source and then delete it, and finally re-type it.

You can also check out the other interesting features available on the Edit -> Advanced menu:

Null-coalescing operator in .NET Framework

2008-09-28T20:28:00.003+04:00

The post Declaring variables as nullable in c# describes how nullable value types can be declared used in C#.

.NET Framework also provides the ?? operator, called the null-coalescing operator, and its primary use is to define a default value for a nullable value types as well as reference types. It returns the left-hand operand if it is not null; otherwise it returns the right operand.

As an example, if the following code is run, the intValue will be 1, since nullInt is null.

Nullable<int> nullInt = null;

int intValue = nullInt ?? 1;

Walkthrough EQATEC Tracer

2008-09-25T15:59:00.010+04:00

1: Create application in .NET

I have written a simple test application, TestEqatecTracer, to play with the new tool EQATEC .NET Tracer (which I mentioned in the previous post). In the TestEqatecTracer application,

- names are populated in a list structure,
- list is then sorted using the List.Sort() ,
- finally, the list is sorted by the last character using SortByLastCharacter Comparer class.

using System;
using System.Collections.Generic;
using System.Text;
 
namespace TestEqatecTracer
{
    public class SortByLastCharacter : IComparer<string>
    {
        #region IComparer<string> Members
 
        public int Compare(string x, string y)
        {
            if (string.IsNullOrEmpty(x) || string.IsNullOrEmpty(y))
                return 0;
            else
                return x[x.Length - 1].CompareTo(y[y.Length - 1]);
        }
 
        #endregion
    }
 
    public class Program
    {
        static void Main(string[] args)
        {
            List<string> names = new List<string>();
            names.Add("John");
            names.Add("Frank");
            names.Add("Andy");
            names.Add("Brain");
 
            Console.WriteLine("Initial names: ");
            PrintNames(names);
            Console.WriteLine();
 
            Console.WriteLine("Names sorted: ");
            names.Sort();
            PrintNames(names);
            Console.WriteLine();
 
            Console.WriteLine("Names sorted by last character: ");
            names.Sort(new SortByLastCharacter());
            PrintNames(names);
            Console.WriteLine();
 
            Console.ReadLine();
        }
 
        private static void PrintNames(List<string> names)
        {
            if (names != null)
            {
                foreach (string name in names)
                    Console.WriteLine(name);
            }
        }
    }
}

2. Instrumentation Process

Now open the EQATEC Tracer tool. In the Instrumentor tab, browse and locate the assemblies of the application. The drag and drop feature can also be used.

The list of all assemblies in the selected folder will be shown in the Assembly List.

Select the assemblies that will be analysed in the list shown, and start the instrumentation process by selecting the "Instrument currently selected assemblies" button and a modified version of the assemblies will be then generated. The instrumentation process injects trace statements in the assemblies.

3. Select methods to trace

Click the flash icon to launch the modified application. The application view will then change to the Viewer tab.

After connecting to the application, the Control tree is populated with the classes and methods of the assemblies. Select ones that needs to be traced by checking the boxes.

The LocalHost represents the local machine. If the application is a device application, then the IP address of the device should be entered.

4. View trace results

Now connect to the application using the "Play" button.

And the trace will be shown in the Trace Viewer.

25/09/2008 15:51:18 (1) enter Program.Main ( String[], )
25/09/2008 15:51:18 (1) enter+leave Program.PrintNames ( List`1[System.String], )
25/09/2008 15:51:18 (1) enter+leave Program.PrintNames ( List`1[System.String], )
25/09/2008 15:51:18 (1) enter+leave SortByLastCharacter..ctor ()
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Andy", "Brain", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 11, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "John", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 0, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Andy", "John", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 11, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "John", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 0, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "John", "Andy", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( -11, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "John", "Frank", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 3, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "John", "John", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 0, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "John", "John", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 0, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "Andy", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( -11, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "Andy", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( -11, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "Brain", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 0, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "Andy", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( -11, )
25/09/2008 15:51:18 (1) enter SortByLastCharacter.Compare ( "Brain", "Brain", )
25/09/2008 15:51:18 (1) leave SortByLastCharacter.Compare ( 0, )
25/09/2008 15:51:18 (1) enter+leave Program.PrintNames ( List`1[System.String], )

EQATEC Tracer

2008-09-25T08:53:00.002+04:00

Another free developer tool has been released yesterday - the EQUATEC Tracer.

Here's the email extract from the EQATEC development team:

We're happy to announce the release of yet another development tool, the EQATEC Tracer.

In summary, the tracer will show how your .NET code is executed live. It's great for debugging and no source code changes are needed: just point the tracer to your app, run the modified code, and start watching the trace output. It's that simple.

The tracer is useful for all .NET developers, but especially for those doing embedded development in .NET Compact Framework: it allows you to enable in-target-debugging during development or at customer sites - a situation where a traditional debugger isn't an option. Letting the tracer add trace-instructions to all methods and turn them on/off at runtime can easily save many, many days of work, so you can spend your time on the fun and interesting parts instead of adding endless trace-messages.

Some functional highlights include:

- Add trace to any .NET apps - no source code changes needed
- Enable tracing at runtime for all method calls, parameters, exceptions etc
- Works with both .NET Compact Framework and the full .NET Framework
- Very low overhead when tracing is turned off
- View trace output from PC or device remotely over network connection
- On the fly enabling and disabling of trace instructions
- Trace each thread in a separate window

The EQATEC Tracer can be downloaded here under BSD license terms.

CommaDelimitedStringCollection class in .NET Framework

2008-09-23T11:33:00.003+04:00

One simple but yet very interesting and useful class in .NET Framework that allows the creation of comma separated string from a list of string items is the CommaDelimitedStringCollection. This class is found in the System.Configuration namespace. So, we can stop reinventing the wheel each time we need such a collection, and instead, make use of this ready-made class.

Sample code...

CommaDelimitedStringCollection sites = new CommaDelimitedStringCollection();

sites.Add("www.yahoo.com");

sites.Add("www.google.com");

sites.AddRange(new string[] { "moiashvin-tech.blogspot.com", "www.lexpress.mu" });

Console.WriteLine(sites.ToString());

Output...
www.yahoo.com,www.google.com,moiashvin-tech.blogspot.com,www.lexpress.mu

100% code coverage - good but not preeminent

2008-09-21T14:29:00.011+04:00

I was configuring TestDriven.NET on my machine, and the idea of writing a few lines about code coverage popped in my mind. There have been continuous debates and discussions about this particular topic in the past years and thousands of words have already been written by experts in the field. Everyone can have a different opinion about testing, and more importantly code coverage (as this is what the post is all about), and so do I.

We, programmers (irrespective of the programming language that we use), have one common goal in our respective objectives - to write good quality code. And by good quality code, I mean code that implements correctly the desired functionality, is in line with industry (or corporate) standards while following the appropriate coding guidelines, uses constraint resources of the environment and infrastructures in an optimal way and is easily maintainable, just to mention a few. Last but not least, another feature of the good quality code is also 'bug free' code.

The testing phase in a software development life cycle ensures that the code is well-tested using an appropriate strategy. Different types of tests, such as unit tests, integration tests and system tests, just to name a few, are conducted. Once the tests are completed, code coverage reports are usually produced.

"Testing never proves the absence of faults, it only shows their presence." - Edsger Dijkstra

What is code coverage? Code coverage tells us how much of our code have we tested. It gives helpful information about the part of the code that has been exercised, and hence, a complete new perspective to the testing paradigms. However, the toughest task is to be able to correctly interpret the code coverage results (or say, reports). And that's where development teams and programmers often make their first mistake.

Many professionals in the software development field believe that a 100% code coverage means that the application is bug free. Hold on. Take a moment and give this a second thought. Are you indeed such a believer?

According to me, 100% code coverage is good but not preeminent. Not preeminent? Yes, I believe there is nothing extraordinary with a 100% code coverage. Does the 100% coverage guarantee that all the tests have been done in the right way? Does it guarantee that the selected test cases and test data are indeed correct? Does it guarantee that we haven't missed any corner case? What about a missing functionality in the code, will the 100% coverage identify it? The answers are a big NO. This is neither the Test Driven Development nor the code coverage fault. It's a failing of the way the results are interpreted. The focus should be more on the test strategies, scenarios and data rather than on the code coverage.

Let me give a very basic example. I have a static Divide() method in the Divider class that accepts a dividend and divisor and returns the quotient.

using System;

using System.Collections.Generic;

using System.Text;

namespace CodeCoverageTests

    public class Divider

        public static double Divide(int divident, int divisor)

            return dividend / divisor;

I will use the DividerTest class to test this Divide() method using the NUnit tool.

using System;

using System.Collections.Generic;

using System.Text;

using NUnit.Framework;

namespace CodeCoverageTests

    [TestFixture]

    public class DividerTest

        [Test]

        public void TestDivide()

            Assert.AreEqual(10.0, Divider.Divide(30, 3), "Incorrect division.");

When run, the test is passed successfully.

And more importantly, the code coverage shows a 100% figure.

With this figure, it gives the impression that this is really a good piece of work, with tests passed succesfully, and above all, a code coverage of 100%.

Ladies and Gentlemen: Don't be fooled by the coverage report. That's how Andrew Glover expressed himself in his article “In pursuit of code quality: Don’t be fooled by the coverage report”.

Call the method Divide() with 0 as the divisor and the program will throw a DivisionByZero exception. This is just a simple example to show how wrong one can be when assuming that a piece of code with 100% code coverage is bug free.

Code coverage is a very good indicator of how various sections of the code were tested. It is here to work as a complement, not the primarily indicator, for the overall code quality picture.

Netbeans free DVD distribution program suspended indefinitely

2008-09-18T19:45:00.003+04:00

Extract of the email from Netbeans Webmaster...

I regret to inform you that the DVD distribution program has been suspended indefinitely as we evaluate options to simplify the distribution of NetBeans software.

Since August 30th, 2005, NetBeans.org has shipped more than 225,000 CDs & DVDs to developers around the world through this initiative! During this period, NetBeans has experienced explosive growth as a download, media kit, and a community. To stay ahead of this encouraging trend we are looking into ways to effectively satisfy increasing demand for NetBeans software worldwide. Please bear with us.

In the interim, we are offering the same great contents of NetBeans IDE 6.1 ML DVD Starter Kit as an ISO image that you are free to download and burn. Alternatively, visit our download page for installer bundles as lightweight as 18MB. In the near future we also hope to offer our downloads via mirrors and bittorrent ...

Logon failed for user MACHINENAME/ASPNET

2008-09-15T21:20:00.008+04:00

Some weeks back, everything was working fine with the login MYCOMPUTER/ASPNET on the SQL Express Server.

I formatted my machine recently and during 're-installation' of the operating system, I used a MACHINENAME instead of the default MYCOMPUTER.

Then, I run the aspnet_regiis command and it seems to me that the user MACHINENAME/ASPNET has been created and is also being used as login onto the database.

The client application throws the following exception:

System.Data.SqlClient.SqlException: Cannot open database "XXXDATABASEXXX.MDF" requested by the login. The login failed.
Login failed for user 'MACHINENAME\ASPNET'.
at System.Data.SqlClient.SqlInternalConnection.OnError(SqlException exception, Boolean breakConnection)
at System.Data.SqlClient.TdsParser.ThrowExceptionAndWarning(TdsParserStateObject stateObj)
... ... ... ...

... ... ... ...

The database should now be configured to recognise this new MACHINENAME/ASPNET user.

I tried to replace the MYCOMPUTER/ASPNET user with MACHINENAME/ASPNET user in the database properties but can't find the MACHINENAME/ASPNET user in the available list of users. Any reason for that???

Anyways, instead of losing precious time finding the right way, the following SQL statement will create the user on the database and allow successful login. Just you have to make sure that the appropriate permissions are set once the user has been created.

USE [XXXDATABASEXXX.MDF]
CREATE USER [MACHINENAME\ASPNET] FOR LOGIN [MACHINENAME\ASPNET]
GO

Don't forget to change XXXDATABASEXXX and MACHINENAME to the appropriate names on your machine...

Predicates: List.Find() method

2008-09-12T08:50:00.010+04:00

When it comes to searching an element in a list in C#, it seems easier to write a for loop, and iterate over the elements until the desired element is found. In other words, a linear or sequential search.

As an example, a LocationVO has two members: Code and Description.

public class LocationVO

    private string code;

    /// <summary>

    /// Gets or sets the code.

    /// </summary>

    /// <value>The code.</value>

    public string Code

        get { return code; }

        set { code = value; }

    private string description;

    /// <summary>

    /// Gets or sets the description.

    /// </summary>

    /// <value>The description.</value>

    public string Description

        get { return description; }

        set { description = value; }

The list declaration would be as follows:
List<LocationVO> locations = new List<LocationVO>();

And the linear search would be:

/// <summary>

/// Finds the business location.

/// </summary>

/// <param name="code">The code.</param>

/// <returns></returns>

public LocationVO FindLocation(string code)

    if (locations != null)

        for (int i = 0; i < locations.Count; i++)

            if (locations[i].Code = code)

                return locations[i];

    return null;

Predicates
An more elegant way is to use the List.Find() method. This method uses a predicate that defines the search criteria. If an element has to be searched by using another criteria (e.g. using the description property rather than the code one), it would be better to write another predicate rather than duplicating the linear search algorithm in the source code.
/// <summary>

/// Finds the location using predicate.

/// </summary>

/// <param name="code">The code.</param>

/// <returns></returns>

public LocationVO FindLocationUsingPredicate(string code)

    LocationVO vo = locations.Find(delegate(LocationVO curr)

        return curr.Code == code;

});

    return vo;

The List.FindAll() method is yet another interesting method that returns all instances matching the search criteria.

No setter for KeyChar property in KeyPressEventArgs class

2008-08-07T20:25:00.008+04:00

Have you ever tried to set the property KeyChar of the KeyPressEventArgs class? At least, we should be able to do that when looking at the tooltip documentation.

However, no matter how much you struggle, it will never compile. The reason is simple - a minor mistake in the documentation for the KeyChar property. KeyChar has only the getter and NO SETTER.

Drawing rotated text in .Net Compact Framework

2008-08-06T22:36:00.008+04:00

To draw rotated text in applications targeting mobile devices, the LogFont class in the .Net Compact Framework exposes the desired methods. Read more on MSDN here.

Subversion Repository on Windows

2008-08-03T20:49:00.004+04:00

While installing and configuring Subversion for a second time on my machine (yes, a second time since I had to format my pc some weeks back), I thought about writing a post with the steps. But the good thing is there is already a very very very good article that gives a Step-by-Step instructions for running a Subversion repository under Windows, and it covers the downloads, installation, configuration and usage. Click here.

... And you can find a lot more articles here as well.

Nokia N95 MAC Address

2008-07-29T22:24:00.001+04:00

To check the MAC address of the WLAN adapter for phones running on the S60 operating systems (for example, the Nokia N95), type the following code in the standby mode:

*#62209526#

The MAC address of some phone can also be obtained on the label under the battery.

Synchronize Timezone for Windows Mobile 5.0 devices in C# and .Net Compact Framework

2008-07-28T20:21:00.007+04:00

Synchronize Timezone for Windows Mobile 5.0 devices in C# and .Net Compact Framework

Many forums on the web have the issue of timezone synchronization for the WM5.0 devices posted and unanswered. Changing the timezone information on a Windows Mobile 5.0 device is not as straight forward as a Windows CE 5.0 one. The latter keep all the different timezones in the device registry, while the former has the timezones in a file on its file system.

To correctly change current timezone for applications in C# running on the Windows Mobile 5.0 platform, the PInvoke calls can be used. To make life easier, I would recommend the OpenNETCF library as it already wraps the PInvoke calls and their complexity in managed classes.

In the OpenNETCF.Win32 namespace, the TimeZoneCollection class exposes the Initialize() method that loads an array of timezone structures into memory. The Initialize() method of the TimeZoneCollection class uses the PInvoke call

[DllImport("citydb")]

extern static IntPtr ClockGetTimeZoneDataByOffset(int nOffset);

to get all the different timezones available on the device.

Once all the different timezones have been loaded, it is easy to loop through the collection and pick up the appropriate timezone and then call the SetTimeZoneInformation() method found in the DateEx class within the same namespace.

However, when the TimeZoneCollection is instantiated and initialized, a native exception is thrown on the device, similar to the following:

TimeZoneCollection tzc = new TimeZoneCollection();

tzc.Initialize();

Chris Tacke mentioned about a bug in the OpenNETCF code in his blog, and to get over this exception, the PInvoke definition must be changed so that it accepts a second parameter that is a ref int (the original only has one parameter, which is incorrect). Hence, the PInvoke definition will be as follows:

[DllImport("citydb")]

extern static IntPtr ClockGetTimeZoneDataByOffset(int nOffset, ref int fix);

If you need further information or still having problems, please do not hesitate to let me know.

Last but not the least, talking about the real synchronization, my application's server tier already handled all the complexity (i.e. determining the correct time, and timezone for the device and providing the timezone bias), so I just had to set the timezone and time correctly using the provided bias.

N95 Barcode Reader

2008-07-26T14:14:00.012+04:00

Nokia N95 allows creation, sharing and scanning of barcodes. Yes barcodes!!!

1. Create the barcode
The barcode can be created by using different kind of generators. And there are many free online generators as well. For example, here or here. I will use the Nokia's Mobile Codes service.

The barcode below is one for this blog's url http://moiashvin-tech.blogspot.com:

These barcodes can also be used in websites, emails, or documents and at the same time protect the data from spambots.

2. Reading the barcode

Now to read the barcode, there are various readers available for the S60 mobile phones. For example, Kaywa Reader, Glass Reader, UpCode Reader and Semacode Reader, just to name a few.

Here, I will use the Nokia Barcode Reader that comes with the mobile phone by default.

Updated on 30/Jul/08:
Why is this needed? A comment posted from one of the nokia forums:

Actually this is a massive usage in Japan that is spreading across the globe. In Japan you find adverts, posters, magazines etc with them and more commonly, every businessman has one on his business card so the recipient can scan it straight into the phone!

For a real practical situation, imagine this:
You see poster for a gig you are interested in. The poster has a QR code (2D barcode), you scan it and the resulting link takes the phone browser straight to a secure site where you buy tickets!

It really does have a lot of potential. It is also useful if you want to view a web page on your phone to save typing in a long address. I have a firefox plugin which generates the barcode for the page you are on when you hover over a status bar icon. You can then scan that straight off the screen for future use on your phone!

Source: http://www.allaboutsymbian.com/

C# 3.0 Object and Collection Initializers

2008-07-26T13:51:00.001+04:00

In this article, I will talk about Object and Collection Initializers in C# 3.0.

Object initializers let us assign values to any accessible fields or properties of an object at the time of creation without having to explicitly invoke a constructor.

When using .Net 2.0, to initialize an instance of a User, we would (1) either overload the constructors, (2) or create an instance first and assign values accordingly.

User oldUser = new User();

oldUser.UserId = "OUSR";

oldUser.UserName = "Old User";

oldUser.UserEmail = "old.user@somewhere.com";

oldUser.UserLevel = 3;

Now, with C# 3.0 and .NET 3.5, we will be able to initialize the object by creating the instance and assigning the values to the properties in a single statement. Using this new syntax, the code will look like:

User test = new User { UserId = "NUSR", UserName = "New User",

 UserEmail = "new.user@anywhere.com", UserLevel = 3};

Similarly, if we had to create a list of users in .NET 2.0, we would first create the list and then add the users one by one.

User oldUser = new User();

oldUser.UserId = "OUSR";

oldUser.UserName = "Old User";

oldUser.UserEmail = "old.user@somewhere.com";

oldUser.UserLevel = 5;

User newIser = new User();

newIser.UserId = "NUSR";

newIser.UserName = "New User";

newIser.UserEmail = "new.user@anywhere.com";

newIser.UserLevel = 3;

List<User> users = new List<User>();

users.Add(oldUser);

users.Add(newIser);

And now, with C# 3.0 and .NET 3.5, this can be achieved in just one single statement:

List<User> users = new List<User> {

    new User { UserId = "OUSR", UserName = "Old User",

        UserEmail = "old.user@somewhere.com", UserLevel = 5},

    new User { UserId = "NUSR", UserName = "New User",

        UserEmail = "new.user@anywhere.com", UserLevel = 3}

};

C# 3.0 Automatic Properties

2008-07-26T12:46:00.003+04:00

The C# 3.0 has a very interesting feature: Automatic Properties.

So far, with C# 2.0 and Visual Studio 2005, we have enjoyed the 'Right-Click --> Refactor --> Encapsulate Field' option to automatically generate properties in the classes. And hence, as an example, a User class will look like:

    public class User

        private string userId;

        /// <summary>

        /// Gets or sets the user id.

        /// </summary>

        /// <value>The user id.</value>

        public string UserId

            get { return userId; }

            set { userId = value; }

        private string userName;

        /// <summary>

        /// Gets or sets the name of the user.

        /// </summary>

        /// <value>The name of the user.</value>

        public string UserName

            get { return userName; }

            set { userName = value; }

        private string userEmail;

        /// <summary>

        /// Gets or sets the user email.

        /// </summary>

        /// <value>The user email.</value>

        public string UserEmail

            get { return userEmail; }

            set { userEmail = value; }

        private int userLevel;

        /// <summary>

        /// Gets or sets the user level.

        /// </summary>

        /// <value>The user level.</value>

        public int UserLevel

            get { return userLevel; }

            set { userLevel = value; }

Now, with C# 3.0, the User class will look as follows:

    public class User

        /// <summary>

        /// Gets or sets the user id.

        /// </summary>

        public string UserId { get; set; }

        /// <summary>

        /// Gets or sets the user name.

        /// </summary>

        public string UserName { get; set; }

        /// <summary>

        /// Gets or sets the user email.

        /// </summary>

        public string UserEmail { get; set; }

        /// <summary>

        /// Gets or sets the user level.

        /// </summary>

        public int UserLevel { get; set; }

When the code is compiled, the compiler will automatically generate the appropriate fields when encountering the empty get and/or set blocks. However, note that these automatic properties are normally used in situations where no body is in the get or set blocks.

And, going one step further, the compiler generated code for these automatic properties is as follows:

LINQ - Restriction Operator 'where'

2008-07-26T11:58:00.002+04:00

The .NET Framework 3.5 version extends the .NET Framework 2.0 and 3.0 versions. One of the new features is the Language-Integrated Query (LINQ) and this extends powerful query capabilities to the C# language syntax (and VB as well) in the form of standard easily-learned query patterns.

A very simple program that displays the odd digits in LINQ:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace TestLinQ

    class Program

        static void Main(string[] args)

           // declare an array of integers

           int[] digits = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

           // find all odd digits

           var oddDigits = from n in digits where n % 2 == 1 select n;

           // display all odd digits

           foreach(var x in oddDigits)

              Console.WriteLine(x);

This is indeed my first LINQ experience ;-), more precisely with the restriction operation 'where' ...

Projects targeting .NET Compact Framework 1.0 require version 1.1 of the .NET Framework, which is not detected on this machine.

2008-07-16T21:09:00.002+04:00

I tried to compile a C# solution, containing one Smartphone 2003 .NET Compact Framework 1.1 project, in Visual Studio 2005 and got the following error:

Projects targeting .NET Compact Framework 1.0 require version 1.1 of the .NET Framework, which is not detected on this machine.

This has been explained on the MSDN page here.

Apparently, the .NET Framework 1.1 was not installed on my machine. This framework can be downloaded here.

One thing worth noting is that having the .NET Framework 2.0 is not sufficient to build the .NET Framework 1.1 projects. We need to get it installed on the machine first!

Determine if a computer is 32-bit or 64-bit Microsoft Windows XP

2008-07-12T23:44:00.005+04:00

There are different ways to determine a computer is running a 32-bit or 64-bit Microsoft Windows operating system. In this post, I will talk only for the Windows XP Professional operating system.

Right-click My Computer --> Select Properties --> In General tab,

for a 32-bit version, the operating system will appear as "Microsoft Windows XP Professional Version " (e.g. 2002) under the System section and,

for a 64-bit version, the operating system will appear as "Microsoft Windows XP Professional x64 Edition Version ".

More information here.

Troubleshooting the Realtek HD Audio Sound Manager

2008-07-12T21:18:00.005+04:00

Following a full format of my machine, I have re-installed the Realtek HD Audio Sound Manager. The rear speakers and front panel mic jack wasn't working for some reasons and it seems there was no easy way to fix this problem - no obvious configuration in the Sound Manager panels, the devices were working properly on the Device Manager, the installation of latest drivers doesn't change anything... and many other users having the same problem on the internet technical forums.

However, I have solved this issue months back when first installing the drivers, and I have solved it once again for a second time. So, if you having the same problem, try the following:

1. Open the Realtek HD Audio Sound Manager and click the Connector Settings option;

2. Check (or select) the Disable front panel jack detection.

And, it works!!

Embed image in HTML message in .NET Framework

2008-07-06T15:12:00.005+04:00

Adding an image to an email message in .NET Framework is quite simple by using the attachment features. However doing so, the receiver of the email will have to explicitly open the image (or download it first) when opening the message.

An alternative way would be to use an HTML-formatted message and embed the image in the message. In this way, as the receiver opens the message, the image will appear automatically.

How is it achieved in .NET Framework? Very simple.

1. Create an email message, setting the from address, to address and subject text accordingly.
2. Create an html body, and use the img tag to embed the image. Set the content id (cid) in the src attribute correctly.
3. Create an alternative view for the html message.
4. Create linked resource object for the image to be embedded. Set the content id.
5. Add the newly created linked resource object to the html alternative view.
6. Add the alternative view to the email message.
7. Set the IsBodyHtml property to true.

8. Send the email message using SmtpClient (not in this post).

HelloWorld example illustrating Globalization feature in .NET Framework

2008-07-05T21:18:00.008+04:00

In this simple example, I will illustrate globalization feature of .NET Framework via the ResourceManager and the CultureInfo classes.

Step 1: Create a console application. Under the Properties folder, there exists one resource file, namely Resources.resx.

Open the file and add a new entry:

HelloTest > Hello World. Welcome to my blog.

Step 2: Now, right click the Properties folder and add a new resource file using the Add -> Add New Item. Name it as Resources.it.resx.

Open the newly created resource file and add a new entry:

HelloTest > Ciao mondo. Benvenuto al mio blog.

Step 3: Repeat Step 2, by adding a new resource file. Name it Resources.fr.resx and add a new entry:

HelloTest > Bonjour monde. Bienvenue à mon blog.

So far,

Step 4: Instantiate the ResourceManager class. Use the GetString() method to get the correct text to be displayed based on the desired culture.

The ResourceManager picks up the correct text for the culture.

Output:

Registration and Persistance of Custom Culture in .NET Framework

2008-07-05T20:22:00.010+04:00

Writing the previous post about Creating a Custom Culture in .NET Framework, one question came in my mind: where the information about this new custom culture is stored on the computer? what the register method does with the CultureAndRegionInfoBuilder instance? And after some research work, I have got the needed details.

Registration of Custom Culture
The registration process, when calling the Register() method, does the following:

1. An .nlp file is created. This file contains all information defined in the CultureAndRegionInfoBuilder instance.

2. Next, the .nlp file is stored in the %WINDIR%\Globalization system directory on the computer (i.e. C:\WINDOWS\Globalization\). Hence, the culture information will still be available when the computer is restarted at a later time.

Note: Since the .nlp file is stored in a system directory, to register a custom culture you must have administrative priviledges on the computer.

3. The final step is the preparation of the .NET Framework to search the %WINDIR%\Globalization system directory the next time there is a request to create a new custom culture. An InvalidOperationException will be thrown if an attempt to register a culture more than once is made.

Persistance of Custom Culture
Another interesting feature about the CultureAndRegionInfoBuilder is its ability to write an XML representation of the object to a specified file. This can be achieved using the Save() method.

// save the new culture
// for instantiation of the infoBuilder object, see previous post
infoBuilder.Save("c:/en-mu.xml");

Creating a Custom Culture in .NET Framework

2008-07-05T19:38:00.005+04:00

Another interesting topic on cultures in .NET Framework is creating a custom culture. This is very useful if the predefined cultures in .NET Framework or the underlying windows operating system do not provide the required information.

The CultureAndRegionInfoBuilder class allows the creating of custom cultures from scratch or based on existing cultures.

For instance, if we try to create a CultureInfo object for "en-MU", an exception is thrown.

CultureInfo muCultureInfo = new CultureInfo("en-MU");

I will now create this custom "en-MU" culture by using the existing cultures.

Step 1: Add a reference to sysglobl.dll in the project. This library can be found in the Microsoft .NET folder (e.g. C:\Windows\Microsoft.NET\Framework\v2.0.50727\).

Step 2: Add the namespaces System and System.Globalization

using System;
using System.Globalization;

Step 3: Create an instance of the CultureAndRegionInfoBuilder

CultureAndRegionInfoBuilder infoBuilder
= new CultureAndRegionInfoBuilder("en-MU", CultureAndRegionModifiers.None);

The CultureAndRegionModifiers.None is used since the custom culture is a specific one. More information about the CultureAndRegionModifiers enumeration here.

Step 4: To keep the new custom culture simple, I will use a combination of the existing en-GB and fr-FR cultures. Hence, in this step, the culture and region details will be loaded in the new culture.

CultureInfo frCulture = new CultureInfo("fr-FR");
CultureInfo gbCulture = new CultureInfo("en-GB");
infoBuilder.LoadDataFromCultureInfo(frCulture);
infoBuilder.LoadDataFromRegionInfo(new RegionInfo(gbCulture.LCID));

Step 5: The new custom culture is now ready. However, additional details can be further changes to have more precise information.

For example,

infoBuilder.CultureEnglishName = "Mauritius";
infoBuilder.CurrencyEnglishName = "Mauritian Rupees";
infoBuilder.TwoLetterISORegionName = "MU";
infoBuilder.NumberFormat.CurrencySymbol = "Rs";

Step 6: Register the new custom culture on the local computer and makes the culture available to the application(s).

infoBuilder.Register();

Now, the culture "en-MU" can be successfully instantiated.

CultureInfo muCultureInfo = new CultureInfo("en-MU");

Note: To unregister the custom culture, the Unregister() method can be used.

CultureAndRegionInfoBuilder.Unregister("en-MU");

Cultures in .NET Framework

2008-07-05T12:36:00.016+04:00

The .NET Framework provides the CultureInfo class in System.Globalization namespace that allows manipulation and retrieval of information about the cultural context in which an application is running.

First of all, it is important to elaborate on the different culture categories available. The cultures in .NET can be grouped into three categories:

1. Invariant Culture
This culture category is culture-insensitive and is used as a default culture when consistency is desired.

2. Neutral Culture
A neutral culture is associated with a language but has no relationship to countries or regions. For example, the English spoken in UK is different from that spoken in the US. English (en), French (fr) and Spanish (sp) are examples of neutral cultures. This culture category will be designated by the first two characters in the CultureInfo class of .NET. If only the two letters are specified, they will be the Neutral class.

3. Specific Culture
This category is the most precise and is represented by a neutral culture, a hyphen, and then a specific culture abbreviation. For instance, in "fr-FR", fr is the neutral culture (French) and FR represents the specific culture (France).

CultureInfo in .NET Framework
The current culture information can be obtained via the CurrentCulture property of the executing thread's CurrentThread property.

CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;

Enumerating all available cultures
To get hold of all the different cultures available, the following code can be used:

CultureInfo[] cultures = CultureInfo.GetCultures(CultureTypes.AllCultures);

The GetCultures() method accept the CultureTypes enum as an input parameter.

Windows XP Regional Options
Go to Control Panel --> Regional and Language Options --> Regional Options Tab

RegionInfo in .NET Framework
CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
RegionInfo regionInfo = new RegionInfo(cultureInfo.LCID);

C# Form Keyboard Events - KeyPreview property

2008-07-02T10:52:00.001+04:00

If you encounter a situation where you want your C# form to see the key events that happen on its controls, then set the Form.KeyPreview property to true.

We have been working on one of the Symbol devices, namely, WT4090 and there was the need to close the form when the user presses the ESC button. The KeyDown event is triggered correctly as long as the form is without any control, and once a control is added, the KeyDown event stopped being triggered. The solution was to set:

Form.KeyPreview = true

Remarks from MSDN
When this property is set to true, the form will receive all KeyPress, KeyDown, and KeyUp events. After the form's event handlers have completed processing the keystroke, the keystroke is then assigned to the control with focus. For example, if the KeyPreview property is set to true and the currently selected control is a TextBox, after the keystroke is handled by the event handlers of the form the TextBox control will receive the key that was pressed. To handle keyboard events only at the form level and not allow controls to receive keyboard events, set the KeyPressEventArgs.Handled property in your form's KeyPress event handler to true.

You can use this property to process most keystrokes in your application and either handle the keystroke or call the appropriate control to handle the keystroke. For example, when an application uses function keys, you might want to process the keystrokes at the form level rather than writing code for each control that might receive keystroke events.

Source: here

Working with event logs

2008-06-27T13:07:00.008+04:00

The .Net Framework provides the EventLog class in the System.Configuration namespace that allows us to create and manage log entries. In this article, I will describe how this can be achieved in just a few lines of codes.

a) Creating an Event Log

The EventLog class allows us to create an event log. Here are a couple of overloaded constructors available, but here, I am going to use the simplest one by providing a name for the log only. Also, to use the event log, the Source property needs to be specified and a message needs to be written as well.

Next, to write an entry, I will use the WriteEntry method, by giving the message and the entry type.

If the code is executed, the new event log will be visible in the Windows Event Viewer.

b) Deleting an Event Log

c) Getting existing event logs

Event Viewer and event logs in Windows XP

2008-06-27T11:13:00.002+04:00

The Event Log Service in Windows XP records application, security and system events in its Event Viewer. Here an event is any significant occurence in an application and/or system that requires notification to the users. The event logs allow us to obtain information about hardware, software or any system components, identify and diagnose current system problems or even assist in prediction of potential system problems.

Event Logs in Windows XP

1. Application log
2. Security log
3. System log

Viewing the Event Logs in XP

Start --> Control Panel --> Performance and Maintenance --> Administrative Tools --> Event Viewer

For more information about Event Viewer and event logs, read the nice article How to view and manage event logs in Event Viewer in Windows XP here.

Coming next: Event Logs in .Net 2.0

YouTube for Mobile

2008-06-21T20:27:00.006+04:00

YouTube for Mobile is a mobile application that will allow you to browse and watch YouTube videos from your handset. I have tried it on my Nokia N95, and it works great.

the main features ...
- browse by popular videos (most viewed, top rated, featured), related videos or keyword search;
- sign into your YouTube account and access your own videos, subscriptions and favourites;
- upload videos from the mobile phone to YouTube directly;
- Similar look and feel of the YouTube website version;
- supported phones are Nokia's N73, N95, E65, 6110, 6120 and Sony Ericsson's K800 and W880

some other facts ...
- applicant has been written in java;
- works best with 3G coverage (and my home MyT connection as well);
- video is in .3gp format and of lower quality than the video on the YouTube website;
- supported phones are Nokia's N73, N95, E65, 6110, 6120 and Sony Ericsson's K800 and W880;

YouTube installation ...
To install the YouTube application, use your mobile phone and go to

m.youtube.com/app

and follow the instructions to download and install YouTube on the phone. Upon successful completion, the YouTube icon will appear on the applications menu.

the sound issue on Nokia phones ...
For Nokia devices, you must have the Warning Tones enabled in your phone's settings to hear audio in YouTube. This setting can be found in "Profiles" > "Current Profile" > "Personalize" > "Warning Tones."

snapshots...

Launch YouTube Mobile Client from Menu ...

YouTube Mobile Client is launched, and enters the Home menu ...

Search a video on YouTube ...

Video presented with small thumbnail and related descriptive information ...

Video starts with same look and feel as YouTube.com ...

Additional options available ...

Logon YouTube using my account ...

View my videos ...

Closing the application ...

further information...
here and here.

Declaring variables as nullable in C#

2008-06-11T20:31:00.003+04:00

Nullable variables can be declared if you want to determine whether a value has been assigned or not.

Two ways:

1. Use Nullable type
Nullable b = null;

2. Use C# shorthand notation
bool? b = null;

Launch a program on a device remotely from the desktop using RAPI Start

2008-06-11T16:36:00.005+04:00

Pre-requisites:
1. Windows Mobile Developer Power Toys is installed on your pc. This can be downloaded here.

2. Microsoft ActiveSync is installed on your pc. This can be downloaded here.

3. Device is connected to the pc via ActiveSync.

4. The program to be launched has already been deployed on the device.

Procedure:
To launch a program on a device remotely via command-line,

1. Open Command Prompt Window

2. Go to *installation path of Windows Mobile Developer Power Toys*\RAPI_Start

cd C:\Program Files\Windows Mobile Developer Power Toys\RAPI_Start

3. Type rapistart *path of program on device to be launched enclosed between double quotes (see example below)*

Example:
rapistart "\Program Files\HelloWorldApplication\HelloWorldApplication.exe"

.Net Compact Framework and OpenNetCF

2008-06-09T19:30:00.009+04:00

The slides of a small presentation I made on .Net Compact Framework and OpenNetCF...

Tip: Remove the hidden .svn folders

2008-05-06T20:20:00.006+04:00

Are you using subversion as your source code repository? Do you want to delete all the .svn hidden folders inside your project folder? Last year, I got the solution I required from Jon Galloway's blog @ here

Initialization code for log4net in c# web service project

2008-05-06T19:46:00.006+04:00

log4net is the .NET version of the Java logger, log4j. I have used it in both .NET Full and .NET CF Framework projects. Now, I have developed a sample web service and successfully configured the application to use log4net. The one tricky part is to correctly tell the application to load the configuration settings when it starts.

The initialization code can be put in the the web project's Global.asax.cs:

The Application_Start method is called automatically when the web service is loaded, and thus, it is the ideal place to initialize the log4net environment.

More info on log4net

Creating shortcut for Add/Remove Programs window

2008-05-02T11:24:00.003+04:00

Here's a cool tip to directly open the Add/Remove Programs window without going through the Control Panel window.

Type control appwiz.cpl in the Run command window and click OK.

In my case, I needed a shorcut the desktop to the Add/Remove Programs and here are the basic steps:

1. Right-click on the desktop
2. Select New -> Shortcut
3. In the Create Shorcut window, enter control appwiz.cpl and click Next.
4. In the Select a Title for the program, enter a descriptive name and click Finish.

And if the shortcut icon is a big ugly, then you can change it as well from the shortcut properties window.

Escape ampersand (&) character in C#

2008-05-02T10:59:00.008+04:00

Problem
Set the Text property of a Label with a string literal having ampersand (&) characters. When the application is run, the ampersand character is not displayed in the label.

The default behaviour of Labels interprets ampersand characters (&) in the Lanel control's Text property as an access key prefix character, and not as a character literal.

Solution
To escape the ampersand character, I will suggest two ways.

1. Use double ampersand. However, this modifies the original string literal, which you probably don't want.

2. Set the Label.UseMnemonic Property to false (since by default, value for the UseMnemonic property is true).

More information on Label.UseMnemonic Property on MSDN

Removing InstallState files after uninstallation

2008-05-01T23:44:00.000+04:00

Once everything from the previous post is working, one potential problem that can be encountered is that INSTALLSTATE files are not removed after uninstallation of a .NET Framework 2.0-based application. This is an issue related to custom actions and the following article from Microsoft gives a very good description of the exact problem:

An .installstate file is not removed after you uninstall a .NET Framework 2.0-based application

Since the Workarounds suggested in the article didn't make much sense to me, I have found another way to solve it.

Solution
the same custom action (that was initially used for Install custom action) to the Uninstall custom action.

Then, Override the Uninstall method in the installer class and make sure it calls the base Uninstall method.

Update application config file during installation process

2008-05-01T23:07:00.005+04:00

I was looking for sample code snippet(s) in the MSDN Library that allow the application's configuration file to be modified during the installation process. I've found the following article:

Redirecting an Application to Target a Different XML Web Service During Installation

That's exactly what I needed and it just took me just a couple of minutes to code it in C#.

I think it won't be a big deal to complete the last part ... :-) Is it?

SetCompatibleTextRenderingDefault must be called before the first IWin32Window object is created in the application.

2008-05-01T12:53:00.006+04:00

SetCompatibleTextRenderingDefault must be called before the first IWin32Window object is created in the application.

Problem Description
I encountered this error when attempting to start a project's exe file compiled under the Release configuration.

Analysis & Observations
The exe file compiled under the Debug configuration started without any problem and there were no error messages or exceptions.

Starting the Release version from Visual Studio (though F5 - start debugging), it worked fine as well.

The Main() function had the Application.SetCompatibleTextRenderingDefault method call in the second line before the Load method call. So, this should be working fine.

The application configuration file has been renamed deployed.

When starting the exe, the process shows for a second in the Task Manager and then disappears (which is not what I expected).

There is no pragma code or conditional compilation sections in the code that may not execute when running in Release Mode.

Problem Cause
After all these observations and some further investigation in the code, I have finally found the real problem. The MainFormController is a singleton and had a Form as an instance member. This form was being instantiated when the class was being loaded in the memory, well before the Application.SetCompatibleTextRenderingDefault and Load method calls.

Solution
I have changed the code to lazy initialization of the form, and thus, the form will be instantiated only when it is requested for the first time. Wohoooooo.

Extracting string literals from Enum

2008-04-30T16:55:00.004+04:00

public enum Users { Anonymous, Trainee, Developer, TeamLeader, Manager, Administrator}

A simple way to extracting the string constants from enum:

Type userType = typeof(Users);

// get names of users as string
string[] user = Enum.GetNames(userType);

// enum to string
string anonymous = Users.Anonymous.ToString();

// string to enum
Users manager = (Users)Enum.Parse(typeof(Users), "Manager", true);

Tip: Open partial class for a form in code view

2008-04-29T15:24:00.005+04:00

When creating a partial class for a Form in Visual Studio, the "View Designer" button (or option) is shown. Also, opening (e.g. double click) the partial class for the form not only opens a blank form in the IDE but may also destroy the original one. However, for the Form.Designer.cs partial class, this "View Designer" option is not shown.

Is it possible to tell the VS IDE not to show the "View Designer" button for these partial classes?
Yes, one way you could tell the IDE not to show the form in the designer is to use the DesignerCategory Attribute.

[System.ComponentModel.DesignerCategory("code")]
public partial class MainForm
{
....

Steps to reproduce:
1. Create a new windows application.
2. Add a new class named PartialMainForm.cs
3. Add the partial keyword in front of the "class Form1" declaration in the added class.
4. Save everything.
5. Double click the PartialMainForm.cs file in the Solution Explorer.
6. A blank form appear.

Scroll Listbox Programmatically

2008-04-01T13:44:00.001+04:00

String literals can be added to a ListBox control by using the Items.Add method. However, the ListBox control doesn't scroll automatically. One way to achieve this is to use the TopIndex property. This property determines the first entry to be visible in the ListBox.

Make the first entry visibile at the top of the ListBox:
this.listbox1.TopIndex = 0;

Show the last string of the control visible at the bottom of the ListBox (the last entry visible):
this.listbox1.TopIndex = this.listbox1.Items.Count - 1;

Windows Firewall window using firewall.cpl

2008-03-09T20:26:00.003+04:00

If you want to go to the Windows Firewall window, the normal way would be Start -> Control Panel -> Security Center -> Windows Firewall.

But a faster way is: Start -> Run and type firewall.cpl and then OK

And here it is ...

Tip: Immediate Window on Visual Studio

2008-02-12T20:56:00.000+04:00

Here is a quick tip to have the Immediate Window on Visual Studio 2005

1. Go to Command Window
If you can't find it, go to
View -> Other Windows -> Command Window
OR simply,
Ctrl + Alt + A

2. Type Immed in the Command Window

-> The Immediate Window appears!

Free Online Barcode Generator

2008-01-10T18:14:00.000+04:00

Here's a free online barcode generator:

Free Online Barcode Generator

Add vertical rule in VS2005 IDE

2008-01-10T15:03:00.000+04:00

Here is a cool tip that allows you to have a vertical rule (or say line) after 100 characters in VS IDE:

1. Close Visual Studio 2005 (if open)
2. Start regedit
3. Open the key HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\Text Editor
4. Create a new string named "Guides" and assign the value "RGB(128,0,0) 100".

5. Now open Visual Studio and see the vertial rule.

Detect the presence of network connection

2007-11-06T09:55:00.001+04:00

A simple way to detect the presence of network connection in a device (managed code):

Log4net and .Net Compact Framework 1.0

2007-10-24T22:13:00.001+04:00

Log4net, part of the Apache Logging Services project, can be a very helpful tool to log statements to different output targets. One of the features of log4net is the support for multiple frameworks. This post is just an extract from the Apache site that highlights the major differences of the compact version of log4net.

Microsoft .NET Compact Framework 1.0

* Assembly attributes
The .NET Compact Framework 1.0 does not support retrieving assembly level attributes, therefore all log4net configuration attributes were removed from the .NET Compact Framework 1.0 version of log4net.

For Smart-device applications, the log4net system can be configured by passing the location of the log4net configuration file to the log4net.Config.XmlConfigurator.Configure(FileInfo) method in the entry point of the application.

For example:

// Uncomment the next line to enable log4net internal debugging
// log4net.Util.LogLog.InternalDebugging = true;

// This will instruct log4net to look for a configuration file
// called config.log4net in the root directory of the device
log4net.Config.XmlConfigurator.Configure(new FileInfo(@"\config.log4net"));

// This will shutdown the log4net system
log4net.LogManager.Shutdown();

* Notification events
The .NET Compact Framework 1.0 does not support notification events during the application shutdown, therefore log4net cannot automatically hook the application shutdown notification.

Applications will need to programmatically shutdown the log4net system during the application's shutdown using the log4net.LogManager.Shutdown() method in order to prevent losing logging events. See the code above for an example.

* FileSystemWatcher
The .NET Compact Framework 1.0 does not support the System.IO.FileSystemWatcher class. As a result, the XmlConfiguratorAttribute.Watch property and the XmlConfigurator.ConfigureAndWatch methods are not available. Watching changes to the log4net configuration file is not supported on the .NET Compact Framework 1.0.

* UserName
The .NET Compact Framework 1.0 does not support the System.Security.Principal.WindowsIdentity class. This is used to capture the current thread's user identity. Therefore the LoggingEvent.UserName property will return the value "NOT AVAILABLE".

* Identity
The .NET Compact Framework 1.0 does not support the System.Security.Principal.IPrincipal interface. This is used to capture the current thread's user identity. Therefore the LoggingEvent.Identity property will return the value "NOT AVAILABLE".

* Environment variables
The .NET Compact Framework 1.0 does not support retrieving environment variables, therefore it's not possible to substitute environment variables in parameter values when using the .NET Compact Framework 1.0 version of log4net.

* Serialization
The .NET Compact Framework 1.0 does not support serialization, therefore none of the log4net classes in the .NET Compact Framework 1.0 version are serializable.

* LoggingEvent.Domain
The .NET Compact Framework 1.0 does not support AppDomain functionality. The friendly name for the current AppDomain is stored in the LoggingEvent.Domain property and is accessed using the %a pattern of the PatternLayout. On the .NET Compact Framework 1.0 this value is generated by taking the file name for the application's primary module.

Click here to visit the page directly.

Use of BeginUpdate() and EndUpdate() when populating ListView/TreeView

2007-09-28T19:38:00.000+04:00

Often a listview control in C# needs to be populated with large amount of data (bulky operations, for example, adding 1000 items). For every item added in the Listview, the control will redraw itself, thus greatly reduce the overall performance.

However, using the two methods BeginUpdate() and EndUpdate() while performing these bulk operations gives significant advantage. A call to BeginUpdate() can be made before adding/deleting/clearing items. This will stop any paint messages being sent or processed. Once the operation is done, the EndUpdate() can then be called.

I have logged the time taken of the above code (i.e. adding 1000 items in a ListView for each button click) with and without the BeginUpdate/EndUpdate method calls using a test application.

The use BeginUpdate() and EndUpdate populates the control with a constant duration and much better performance. Amazing, isn't it?

Write C# code for both full .NET Framework and .NET Compact Framework

2007-09-20T11:33:00.000+04:00

Introduction
C# is fully supported on both the full .NET Framework and .NET Compact Framework and there are many times when a piece of code could have been used on both the "full framework" and "compact framework. A simple example would be the Business Logic as this would normally be the same in an enterprise project, whether the solution would be deployed on any of these platforms. I have attempted to write a simple application that addresses this issue, and I am sure there exist other ways to do this - google.com is a faithful friend :).

The Visual Studio Solution: FrameworkApps
There are three projects in the solution, and they are:

1. BusinessLogic, a class library project, that implements the business logic;
2. DesktopApp, a desktop application on the full .net framework platform;
3. DeviceApp, a device application on the .net compact framework platform.

The BusinessLogic.cs file is used by both the desktop and device application. Thus, any source files hould be added as links to the projects, to avoid duplicate source files.

Here is a snapshot of the project structure:

Conditional compilation
Conditional branching of the code at compile time is used to determine the code to be compiled during the compilation process. To achieve this, go to the desktop project properties and under the Build tab add a new "Conditional compilation symbol", say FULL_FRAMEWORK.

Implementation
Project: BusinessLogic
Source file: BusinessLogic.cs

Project: DesktopApp
Source file: Form.cs

Project: DeviceApp
Source file: Program.cs

Output
Set DesktopApp as the startup project and run the application:

Set DeviceApp as the startup project and run the application:

Hope it helps.

Automatic generation of XML Documentation in C# with GhostDoc

2007-09-10T18:14:00.001+04:00

Writing XML comments while coding in C# can be a tedious task at times. By installing GhostDoc, a free Visual Studio add-in, you can automate this process and get some additional minutes to concentrate on the code :-)

What does GhostDoc do?
GhostDoc simply gives you a quick means of adding some comments to your classes/methods while you are using the editor to code in C#, by guessing a suitable (and meaningful) comments and thus, automates the process.

Note: GhostDoc assumes that the code follows Microsoft's Design Guidelines for Class Library Developers.

GhostDoc also includes options that allow you to modify existing rules and add additional rules that determine what kind of comments should be generated. Sounds exciting, isn't it?

What doesn't GhostDoc do?
GhostDoc doesn't do miracles...

GhostDoc is not a tool for creating the complete documentation for a given source file in one go. It can only document one member at a time, and you always have to check and, if necessary, correct the automated comments in order to meet match your preferred documentation.

Installation
Download it from http://www.roland-weigelt.de/ghostdoc/

Usage
While coding in the Visual Studio editor, right click on the class name, method, etc and select "Document this".

Give it a try!

Millisecond component on .NET Compact Framework

2007-09-06T11:17:00.000+04:00

One of the differences between full .NET Framework and .NET Compact Framework relates to the Time Intervals. The value returned from System.DateTime.Now is specific only to seconds, not milliseconds. Thus, the milliseconds component of the DateTime, usually expressed between 0 and 999 (in the full framework) will always be 0 on a compact framework platform.

Recommendation

Microsoft recommends the use of the TickCount property available in the Environment class in order to get a more precise time span measurement. This property returns the amount of time in milliseconds that has passed since the last time the computer was started.

http://msdn2.microsoft.com/en-us/library/system.environment.tickcount(vs.80).aspx

Hope it helps.

Optimal size of column headers in listview

2007-09-03T20:12:00.000+04:00

When using a ListView in C# and the View property is set to View.Details, you probably want to set the width of the columns in the listview to an optimal size, without any … in the columns.

Problem
If the column text strings does not fit the column width (set at design time), three dots (...) will be displayed at run time, as shown below.

Aim
Display the text fully in the column, and get rid of the ...

Solutions??

For one moment, you may think of finding the length of the longest string in the column and assign it to the width of the column header. But wait, the length would be in terms of number of characters, whereas the width of the column should be in pixels. So, this will not work, unless you use a utility function to convert the length of the text (taking into consideration the font being used) and calculate it in terms of pixel. Yes it is possible :-) but you won't see it in this post!

Correct Solution
At runtime, set the Width of the ColumnHeader to:

a) -1 to adjust the width of the longest item in the column (without taking into consideration the column heading).

hdrCountry.Width = -1;
hdrName.Width = -1;

Now, the text in the columns is displayed correctly, but not the heading of the first column.

b) -2 to autosize width of the column, taking into consideration the column heading.

hdrCountry.Width = -2;
hdrName.Width = -2;

Now, it works fine. Hope it helps.

Drawing a filled rectangle on a windows form

2007-08-27T16:54:00.000+04:00

This is quite straight-forward. Override the OnPaint() method with the following code:

And it's done. A filled rectangle will be painted at the top of the form.

The code is in the overridden OnPaint() method so that each time the form is resized/obscurred by another form, the content will be re-painted automatically. Also, it is a good practice to call the Dispose methods of objects that consume system resources heavily (e.g. Brush and Graphics objects).

Cradle a device emulator and access the internet

2007-08-02T17:18:00.000+04:00

Pre-requisites:
Visual Studio 2005 is installed.
Microsoft ActiveSync 4.0 or later is installed.
An internet connection is available.

Often a device emulator attempts to connect to the internet via the pc and the following message is encountered: Cannot Connect - Unable to connect: You have no modem entries created, and no network card present.

Here is a simple walkthrough, with some tips, describing how an emulator can be launched from Visual Studio, cradle it via ActiveSync and access a web page on the internet (obviously, provided that the PC is connected to the net).

Step 1: Launch an emulator (say Pocket PC 2003 SE Emulator)

a) Start Visual Studio 2005.

b) Go to the Device Emulator Manager (Tools -> Device Emulator Manager)
A list of available emulators will be displayed in the Device Emulator Manager window.

c) To start the emulator, right click PC 2003 SE Emulator and select Connect.
The Emulator will start.

Step 2: Attempt to browse a web page via Internet Explorer

a) Launch Internet Explorer (Start -> Internet Explorer) from the Device Emulator and your web page url, say enter www.google.com.

The error message will be displayed: Cannot Connect - Unable to connect: You have no modem entries created, and no network card present.

Step 3: Cradle the emulator

The emulator must be cradled (as it would have been the case for a physical device) and connect it to the PC via ActiveSync.

a) To cradle the emulator, go to the Device Emulator Manager in Visual Studio (Tools -> Device Emulator Manager).

b) Right click on the connected emulator, and select Cradle.
The emulator will now be cradled and connected to ActiveSync.

Step 4: Access the web page (repeat step 3)
The Internet Explorer on the emulator will successfully browse to the web page.

Great, isn't it?

Skip 'blue' welcome screen on Windows XP

2007-07-22T10:33:00.000+04:00

If you are using Windows Xp and want to get rid of the blue "Welcome" screen that shows up at startup (prompting you to select the correct user account and enter the password, if any), then this post can be useful :-) One reason for turning off this feature is that you can turn on your PC, and come back after some minutes and you are right on the desktop (ready for use). However, please bear in mind that although you are the sole user of the system, it is not recommended to do so as it simply means you are disabling the basic security feature that the operating system provides. So, be careful!

Pre-requisite:

You have currently logged on windows as Administrator and have admin rights.

Steps
1. Click Start and then select Run,
2. In the Run window, type control userpasswords2, and then click OK button,

A User Accounts windows pops up.

3. Clear the "Users must enter a user name and password to use this computer" check box, and then click Apply.

You will be requested for the username and password of the account you wish to automatically logon as for following reoots of your system.

4. In the Automatically Log On window, type the required information and click OK to close the window.
5. Finally click OK to close the User Accounts window.

At any later stage, you can activate this security feature by following the same steps but recheck the box, at step 3.

Setting transparent color to control's BackColor property

2007-07-13T20:02:00.000+04:00

Using C# with .Net Framework 2.0, an attempt to assign a color from the System.Drawing.Color struct to the BackColor property of a window’s control, say a System.Windows.Forms.TextBox, will compile and run successfully.

Snippet 1:
textBox1.BackColor = Color.Cyan;

However, a problem arises when any transparent color (e.g. #00FEF2D4) is assigned to the BackColor property. Upon execution, a runtime exception will be thrown (see below).

Snippet 2:
textBox1.BackColor = ColorTranslator.FromHtml("#00FEF2D4");

On msdn, the following explanation is given:
The BackColor property does not support transparent colors unless the SupportsTransparentBackColor value of System.Windows.Forms.ControlStyles is set to true.

Using the control’s SetStyle() method, this SupportsTransparentBackColor value can be changed. The problem now is that SetStyle() is declared as a protected method and thus, only the control’s class or any child class can call this method.

A quick solution
A possible solution is to create a class inheriting from the control’s class. For example, a TransparentTextBox class can inherit from the System.Windows.Forms.TextBox. Now, the protected SetStyle() method is accessible and the SupportsTransparentBackColor value can be set to true. The ideal place to call the SetStyle() method will be in the constructor of this new class after the InitializeComponent() method calls.

It’s done. Now, as an instance of TransparentTextBox can be created and any transparent color can be set.

Snippet 3:
transparentTextBox1.BackColor = ColorTranslator.FromHtml("#00FEF2D4");

One major concern: do we really want to subclass all controls that probably will need a transparent color? Think...

Hello World

2007-07-13T19:59:00.001+04:00

Hello World! Welcome to my new blog - ASHVIN"S TECHNICAL BLOG.

I started a personal blog Ashvin Gunga last year. Then, the idea to have another blog where I can share fwd emails popped in my mind. So, I created another one - FWDs - early this year. Weeks back I thought why not a technical blog - a blog where I can share anything I want related with technology, computing and programming. Now, it's up. I am writing my first post!

Another post that I wrote on my personal blog and talks about the start of this new blog: Ashvin's Technical Blog