Today I came across a problem with Visual Studio 2008 installation program. The following error occurred when I tried to add/remove Visual Studio components via control panel:
A selected drive is no longer valid

This error occurs after installation of Visual Studio 2008 SP1 (Service Pack 1), so you can no longer add or remove components of the install.

In order to fix this error, you have two choices:

1. Uninstall SP1 via control panel, add necessary components to non-SP install, then apply SP1 again.

2. Locate and install required component manually. I was looking to add SQL Server Express Edition to my install. I found it at “\WCU\SSE\SQLEXPR.EXE” in Visual Studio 2008 installation folder (unpacked .ISO). This should work for other components accordingly.

I had to add file management capability to one of my projects and encountered a serious issue. AjaXplorer FAQ says the following:

How can I filter some file extensions, both for display/download and for upload?

>> [...]&fileTypes=*.doc;*.jpg;*.gif&fileTypeDescription=My%20Type%20Description&[...]

However, the above method in not secure.

In AjaXplorer customization, if you need to *really* filter out files based on file extension, you have to customize the storage plugin. In my case “access.fs”, class.fsAccessDriver.php script. I wrote the following code to accomplish this task:

 
if($fancyLoader) $userfile_name = SystemTextEncoding::fromUTF8($userfile_name);
 
//Filtering code here
if ( !preg_match('/.*.(avi|flv|mpeg|mpg|wmv|divx)$/i', $userfile_name, $matches) )
 
 
 
{
$errorMessage="You can upload video files only";
break;
 
 
}

This code will filter files on the server side and generate pop-up error if extension is not permitted. Furthermore, it works with non-flash uploader.

5 simple steps to improve speed of your old VS 2008 bro

1. Install Visual Studio 2008 Service Pack 1. Download it here: http://www.microsoft.com/downloads/details.aspx?FamilyId=FBEE1648-7106-44A7-9649-6D9F6D58056E&displaylang=en
2. Remove unnecessary imported namespaces via “Project Properties”, “References tab”. Such imports significantly slow down the IDE.
3. Change your project compilation to x86 only, if you don’t need x64. This will improve compilation speed. “Project Properties”, “Compile” tab, “Advanced Compile Options”.
4. Install .NET Framework updates via Windows Update.
5. Defragment your hard disk.

These four simple steps will make your Visual Studio 2008 fly!

If you want to group your class / component / control properties into categories, such as Accessibility, Appearance, Behavior, Data, Design, etc., it’s very easy to accomplish. All you need is to put System.ComponentModel.Category attribute on top of a property:

 
    <Category("CoolCategory")> _
    Private categorizedPropertyValue As String
    Public Property CategorizedProperty() As String
        Get
            Return categorizedPropertyValue
        End Get
        Set(ByVal value As String)
            categorizedPropertyValue = value
        End Set
    End Property

[Category("CoolCategory")]
private string categorizedPropertyValue;
public string CategorizedProperty {
    get { return categorizedPropertyValue; }
    set { categorizedPropertyValue = value; }
}

When displayed in a PropertyGrid control, your property will appear in a new category (”CoolCategory” in this example). This feature is compatible with any .NET language, including VB.NET and C#.

Get images from scanner, webcam or any other type of imaging device

Here’s the class that I wrote to extract images from various imaging devices via VB.NET and C#.

WIA (Windows Image Acquisition) supports the following types of devices:

• Scanners
• Digital Cameras
• Webcams

The class correctly communicates with Windows Image Acquisition Library (WIALib), releases all COM objects used and allows you to select between single image or multiple images acquisition.

Downloadable package contains actual library that can be used with any of your projects and two demo projects (VB.NET and C#).

If you don’t want to download source code, you can copy it from the code box below.

WIA Wrapper Library, VB.NET Version

Imports System.Drawing
Imports System.Runtime.InteropServices
Imports WIALib
Imports System.IO
 
Public Class ImageRetriever
 
    Public Function RetriveImages(ByVal selectionMode As ImageSelectionMode) As List(Of Bitmap)
 
        Dim comObjects As New List(Of Object)
 
        'Create WIA COM objects
 
        'Manager
        Dim manager As WiaClass = Nothing
        comObjects.Add(manager)
 
        'Devices collection
        Dim devices As CollectionClass = Nothing
        comObjects.Add(devices)
 
        'Root device
        Dim rootDevice As ItemClass = Nothing
        comObjects.Add(rootDevice)
 
        'Collection
        Dim pictures As CollectionClass = Nothing
        comObjects.Add(pictures)
 
        'Image
        Dim pictureItem As ItemClass = Nothing
        comObjects.Add(pictureItem)
 
        manager = New WiaClass()
 
        devices = TryCast(manager.Devices, CollectionClass)
 
        'Retrieve all devices
        If (devices Is Nothing) OrElse (devices.Count = 0) Then
            DisposeComObjects(comObjects)
            Throw New AcquisitionException("No devices found.")
        End If
 
        Dim UISelection As Object = System.Reflection.Missing.Value
 
        'WIA dialog, allows user to select a device
        rootDevice = DirectCast(manager.Create(UISelection), ItemClass)
 
        If rootDevice Is Nothing Then
            Throw New AcquisitionException("No device selected.")
        End If
 
        'WIA dialog, allows user to select a picture.
 
        Dim flag As WiaFlag = WiaFlag.SingleImage
        If selectionMode = ImageSelectionMode.Multiple Then flag = WiaFlag.UseCommonUI
 
        pictures = TryCast(rootDevice.GetItemsFromUI(flag, WiaIntent.ImageTypeColor), CollectionClass)
        If pictures Is Nothing Then
            DisposeComObjects(comObjects)
            Throw New AcquisitionException("No pictures selected.")
        End If
 
        Dim bitmapList As New List(Of Bitmap)
 
        For Each picture As Object In pictures
 
            Dim filePath As String = Path.GetTempFileName
            pictureItem = DirectCast(Marshal.CreateWrapperOfType(picture, GetType(ItemClass)), ItemClass)
            pictureItem.Transfer(filePath, False)
 
            bitmapList.Add(Image.FromFile(filePath))
 
            'Release COM object
            Marshal.ReleaseComObject(picture)
 
        Next
 
        Return bitmapList
 
        DisposeComObjects(comObjects)
 
    End Function
 
    Private Sub DisposeComObjects(ByVal objects As List(Of Object))
        For Each comObject In objects
            If comObject IsNot Nothing Then
                Marshal.ReleaseComObject(comObject)
            End If
        Next
    End Sub
 
End Class
 
Public Class AcquisitionException
    Inherits Exception
 
    Public Sub New(ByVal message As String)
        MyBase.New(message)
    End Sub
 
End Class
 
Public Enum ImageSelectionMode
    One = 0
    Multiple = 1
End Enum

WIA Wrapper Class, CSharp version

 
using System.Drawing;
using System.Runtime.InteropServices;
using WIALib;
using System.IO;
 
 
public class ImageRetriever
{
 
 
    public List<Bitmap> RetriveImages(ImageSelectionMode selectionMode)
    {
 
        List<object> comObjects = new List<object>();
 
        //Create WIA COM objects
 
        //Manager
        WiaClass manager = null;
        comObjects.Add(manager);
 
        //Devices collection
        CollectionClass devices = null;
        comObjects.Add(devices);
 
        //Root device
        ItemClass rootDevice = null;
        comObjects.Add(rootDevice);
 
        //Collection
        CollectionClass pictures = null;
        comObjects.Add(pictures);
 
        //Image
        ItemClass pictureItem = null;
        comObjects.Add(pictureItem);
 
        manager = new WiaClass();
 
        devices = manager.Devices as CollectionClass;
 
 
        //Retrieve all devices
        if ((devices == null) || (devices.Count == 0)) {
            DisposeComObjects(comObjects);
            throw new AcquisitionException("No devices found.");
        }
 
 
        object UISelection = System.Reflection.Missing.Value;
 
 
        //WIA dialog, allows user to select a device
        rootDevice = (ItemClass)manager.Create(UISelection);
 
 
 
        if (rootDevice == null) {
            throw new AcquisitionException("No device selected.");
        }
 
        //WIA dialog, allows user to select a picture.
 
        WiaFlag flag = WiaFlag.SingleImage;
        if (selectionMode == ImageSelectionMode.Multiple) flag = WiaFlag.UseCommonUI; 
 
 
        pictures = rootDevice.GetItemsFromUI(flag, WiaIntent.ImageTypeColor) as CollectionClass;
        if (pictures == null) {
            DisposeComObjects(comObjects);
            throw new AcquisitionException("No pictures selected.");
        }
 
        List<Bitmap> bitmapList = new List<Bitmap>();
 
        foreach (object picture in pictures) {
 
            string filePath = Path.GetTempFileName;
            pictureItem = (ItemClass)Marshal.CreateWrapperOfType(picture, typeof(ItemClass));
            pictureItem.Transfer(filePath, false);
 
            bitmapList.Add(Image.FromFile(filePath));
 
            //Release COM object
 
            Marshal.ReleaseComObject(picture);
        }
 
 
        return bitmapList;
 
 
 
        DisposeComObjects(comObjects);
    }
 
    private void DisposeComObjects(List<object> objects)
    {
        foreach (var comObject in objects) {
            if (comObject != null) {
                Marshal.ReleaseComObject(comObject);
            }
        }
    }
 
}
 
 
public class AcquisitionException : Exception
{
 
    public AcquisitionException(string message) : base(message)
    {
    }
 
}
 
public enum ImageSelectionMode
{
    One = 0,
    Multiple = 1
}

Downloadable version

Download full package

]]> http://johnwilliams.eu/2009/09/use-wia-to-retrieve-images-from-scanner-digital-camera-or-webcam-using-vbnet-and-csharp/feed/ http://johnwilliams.eu/2009/09/strict-vb-net/ http://johnwilliams.eu/2009/09/strict-vb-net/#comments Thu, 17 Sep 2009 08:21:05 +0000 admin http://johnwilliams.eu/?p=241

Sometimes VB.NET is considered less powerful than C#. This isn’t true, all .NET languages have equal abilities.
The only difference is that VB.NET allows too many liberties in default configuration.

Old VB Compatibility Namespace

The first unnecessary thing consists of imported Visual Basic 6 Compatibility Namespace (Microsoft.VisualBasic). If you wish to become a true .NET programmer, you have to remove it. For almost every VB6 function there’s a replacement in .NET Framework. If you won’t use old compatibility functions, it will become possible to convert your code to other .NET languages without any problem.
So go ahead and remove it via Project, “ProjectName Properties“, “References” tab.

Remove VB Compatibility Namespace

Compile Options. Warning Configurations.

In VB.NET, there’s no even a warning in regard to implicit type conversion, late binding or object assumption by default. This may lead to potential errors or low performance of the code.

If you want fast and reliable code, you have to change “None” at least to “Warning” or even “Error“.

The first three entries of configuration are the most important. They can be changed via “Project“, “ProjectName Properties“, “Compile” tab.

Regedit Open Key

Unfortunately, there’s no command-line switch to open a specific key in Windows Registry Editor. However, the task can be achieved via LastKeyvalue of Applets key. If you need to open a hive in regedit, you can use C# and VB.NET code located below.

Regedit Open Hive

using Microsoft.Win32.Registry;
using Microsoft.Win32;
using System.IO;
 
public class RegEditKeyOpener
{
 
	public void Open(string keyPath)
	{
		using (RegistryKey regeditKey = Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Applets\\RegEdit", true)) {
			//Example: My Computer\HKEY_CURRENT_USER\Software\WinRAR SFX
			regeditKey.SetValue("LastKey", keyPath);
			Process.Start("regedit");
		}
 
	}
 
}

Imports Microsoft.Win32.Registry
Imports Microsoft.Win32
Imports System.IO
 
Public Class RegEditKeyOpener
 
Public Sub Open(ByVal keyPath As String)
Using regeditKey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software\Microsoft\Windows\CurrentVersion\Applets\RegEdit", True)
'Example: My Computer\HKEY_CURRENT_USER\Software\WinRAR SFX
regeditKey.SetValue("LastKey", keyPath)
Process.Start("regedit")
End Using
 
End Sub
 
End Class

There’s a secret - entire .NET application connectivity is limited to 2 connections per server by default. This is a good thing to protect servers from overloading and to encourage developer consciousness, but every benefit can have a dark side as well. If you need to override this limit for some reason, you can use the following code. Don’t forget to add a reference to System.Configuration assembly in your project.

{
System.Net.Configuration.ConnectionManagementElement managerElement = new System.Net.Configuration.ConnectionManagementElement();
managerElement.MaxConnection = 15;
System.Net.ServicePointManager.DefaultConnectionLimit = 15;
}

Dim managerElement As New System.Net.Configuration.ConnectionManagementElement
managerElement.MaxConnection = 15
System.Net.ServicePointManager.DefaultConnectionLimit = 15

Let’s learn how to work with .NET Registry Classes in several simple steps.

Preparation

Let’s prepare nice environment for our registry work. Open your copy of Visual Studio 2008 and create new console application.

Registry namespace import

Open your application’s code. Add “using Microsoft.Win32;” and “using Microsoft.Win32.Registry;” to the top. If you’re in VB, add Imports Microsoft.Win32.Registry and Imports Microsoft.Win32 . It doesn’t matter what class will you use and default start-up class can be used.

A bit of theory

In .NET, registry manipulations can be achieved via Registry class and corresponding RegistryKey class.

The keys are separated into 7 main categories. CurrentUser and LocalMachine are the most often used ones. A key can be open as writable or read-only. Each RegistryKey may contain SubKeys and Values.

Here’s a full list of root keys: ClassesRoot, CurrentConfig, CurrentUser, DynData, LocalMachine, PerformanceData, Users.

Using these classes, you can create, enumerate and delete new keys. Additionally, you can enumerate, retrieve and assign key values.

First trick - enumerate the keys

Enough theory. Let’s get down to business. In this part, we’ll enumerate key names of software that belongs to current user.

{
    using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey("Software")) {
 
        foreach (var subKeyName in softwareKey.GetSubKeyNames()) {
            Console.WriteLine(string.Format("Key: {0}", subKeyName));
 
        }
    }
}

Using softwareKey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software")
 
For Each subKeyName In softwareKey.GetSubKeyNames()
Console.WriteLine(String.Format("Key: {0}", subKeyName))
Next
 
End Using

Upon execution of the above code, console window should be populated with various entries.

Our own registry key

We can create a registry key for our own software. It can be used to store various settings.

//Open the software key of the current user. Must be opened as writable.
{
    using (RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey("Software", true)) {
 
        //Attempt to open our key if it's already created. Open as writable.
        RegistryKey ourRegistryKey = softwareKey.OpenSubKey("MyCalculator", true);
        //If it's not there, attempt to create it
        if (ourRegistryKey == null) ourRegistryKey = softwareKey.CreateSubKey("MyCalculator"); 
 
        //Read current data of "MyPath" value
        Console.WriteLine(string.Format("My path: {0}", ourRegistryKey.GetValue("MyPath")));
        //And assign the new one
 
        ourRegistryKey.SetValue("MyPath", Application.StartupPath);
    }
}

'Open the software key of the current user. Must be opened as writable.
Using softwareKey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software", True)
 
'Attempt to open our key if it's already created. Open as writable.
Dim ourRegistryKey As RegistryKey = softwareKey.OpenSubKey("MyCalculator", True)
'If it's not there, attempt to create it
If ourRegistryKey Is Nothing Then ourRegistryKey = softwareKey.CreateSubKey("MyCalculator")
 
'Read current data of "MyPath" value
Console.WriteLine(String.Format("My path: {0}", ourRegistryKey.GetValue("MyPath")))
'And assign the new one
ourRegistryKey.SetValue("MyPath", Application.StartupPath)
 
End Using

“Advanced” technique. Register our software for start up with Windows.

Here’s how we can add our software to the automatic start-up list of the current user. Startup path must be quote-wrapped.

{
    RegistryKey autoStartKey = Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Run", true);
    autoStartKey.SetValue("MySoftwareName", string.Format("{0}{1}{0}", "\"", Application.ExecutablePath));
}

Dim autoStartKey As RegistryKey = Registry.CurrentUser.OpenSubKey _
("Software\\Microsoft\\Windows\\CurrentVersion\\Run", True)
autoStartKey.SetValue("MySoftwareName", String.Format("{0}{1}{0}", """", Application.ExecutablePath))

If you want to register start-up for all users, simply replace Registry.CurrentUser.OpenSubKey in the above code with Registry.LocalMachine.OpenSubKey. Note that administrative permission will be needed for system-wide changes.

Now you’re familiar with some basic and even advanced registry manipulation techniques.

This time I’m going to name 5 most common reasons of errors in .NET programming.

This is something that experienced programmer should avoid.  Let’s proceed.

Incorrect multithreading

Most of developers want to enhance their applications with multithreading capabilities. For some projects such enhancements are beneficial, however, they might be a burden for others. Furthermore, poorly written multi-threading code can lead to unexpected results and runtime errors.

Some controls and classes are not thread-safe. This means that you have to invoke them via the same thread, that originally created them. Good examples of thread-unsafe items would be WebBrowser control and System.Windows.Forms.Clipboard class. Even if they work at some time, such classes may crash in the process, if you haven’t considered thread safety carefully.

Null Reference error

System.NullReferenceException is considered to be hard to debug. At the same time, it’s a common filth that makes life more difficult for amateurs.

This exception occurs due to fact that object reference hasn’t been assigned to an instance of an object. Every time there’s a chance that object can be Null (Nothing in Visual Basic), you should check whether the reference is set:

{
object myObject = new object();
if (myObject != null) {
 
}
else {
//Do some stuff with the object
 
}
//Don't use the object in order to avoid NullReferenceException
 
}

Dim myObject As New Object
If myObject IsNot Nothing Then
 
'Do some stuff with the object
 
Else
 
'Don't use the object in order to avoid NullReferenceException
 
End If

Alternatively,  if (myObject == null) (If myObject Is Nothing in VB) can be used.

Missing DDL’s and other types of files

Every time you reference a class library you have to make sure that the assembly will exist either in GAC (Global Assembly Cache) or the same directory where original assembly resides.

It is a good practice to set “Copy Local” property of each assembly you’ve referenced to True. This property can be accessed via project properties, “References” tab.

Never forget to include important application files into resources or content section. Such files should be also included into installation packages.

Inappropriate exceptions handling

You should NEVER use “Try-Catch” block to CONCEAL an exception. Such actions would lead to almost untraceable errors. If an exception occurs in some part of the code, you should find a proper way to handle it. Keep in mind that exception handling also consumes large amount of processor’s time. If known exception occurs somewhere in your code, you should fix it, not hide. For example, use  System.IO.File.Exists function to check whether the file exists and don’t use FileNotFoundException handling for that. In real life, it is inappropriate to treat fire alarm as something normal. A similar approach should be used for .NET applications if you want to make them stable.

Unclear code and missing comments

Debugging is one of the most important parts of application development cycle. If you write unclear code, debugging can become difficult.

Separate your code into classes, subs and functions. Good object-oriented model is a guarantee of painless development cycle. Use regions and namespaces where appropriate. Commenting will make life easier for you and for other developers, who might need to work with your code.