Programming Features

ArrayList to object[] and versa

2009-07-30T00:22:00.000-07:00

A simple way to perform the conversion:

object[] tmp = new object[3]{1,2,3};

 
// to ArrayList
ArrayList arrayList = ArrayList.Adapter(tmp);


// to array
object[] tmp1 = arrayList.ToArray();

The CSS Sprites Creator

2009-07-24T07:28:00.000-07:00

In order to decrease the traffic and website loading time you can use CSS sprites.
The Sprite Creator 1.0 is a nice tool for upload an image and select areas of the image to create the css for that sprite.

The Singleton pattern

2009-06-28T10:54:00.000-07:00

The singleton pattern is a design pattern that is used to restrict instantiation of a class to one object.
This is useful when exactly one object is needed to coordinate actions across the system.

C++ implementations:

Static singleton:

#include "iostream"

template <class T> 
class Singleton
{
    static T _instance;   
public:

   ~Singleton(){ }
    Singleton(){ }

    T& GetInstance() {
        return _instance;
    }

private:
    Singleton(Singleton&);
    Singleton& operator=(Singleton&);
};
template <class T> 
T Singleton<T>::_instance;
 
class MyData
{
public:
    void Execute(){std::cout<<"Execute..."<<std::endl;}
    MyData(){std::cout<<"Constructor..."<<std::endl;}
};
 
void main()
{
    Singleton<MyData> singleton1;
    singleton1.GetInstance().Execute();

    Singleton<MyData> singleton2;
    singleton2.GetInstance().Execute();
 
    Singleton<int> singleton3;
    singleton3.GetInstance() = 5;
    std::cout<<singleton3.GetInstance()<<std::endl;
}

Static function singleton:

template <class T> 
class Singleton
{
public:
   ~Singleton(){ }
    Singleton(){ }

    T& GetInstance() {
        static T instance;   
        return instance;
    }
 
private:
    Singleton(Singleton&);
    Singleton& operator=(Singleton&);
};

Dynamic singleton:
Unlike the static singletons, the dynamic is not thread safe.
You can use critical section as synchronization mechanism.

template <class T> 
class Singleton
{
    static T* _instance;   
public:
   ~Singleton(){ }
    Singleton(){ }

    T& GetInstance() {

        if(!_instance)
            _instance = new T();
        return *_instance;
    }

private:
    Singleton(Singleton&);
    Singleton& operator=(Singleton&);
};

template <class T> 
T* Singleton<T>::_instance=0;

C# implementation:

        public class Singleton<T> where T : class, new()
        {
            private static T _instance = null;

            static Singleton()
            {
                _instance = new T();
            }

            public static T Instance
            {
                get
                {
                    return _instance;
                }
            }
        }

        class MyData 
        {
            public void Execute() { Console.WriteLine("Execute..."); }
        }

        [STAThread]
        static void Main()
        {
            Singleton<MyData>.Instance.Execute();
        }

The static constructor for a class executes at most once in a given application domain.
It's used to initialize any static data, or to perform a particular action that needs performed once only and it is called automatically before the first instance is created or any static members are referenced.

Double-Checked Locking Singleton (lazy initialization):

    internal sealed class Singleton<T> where T : class, new()
    {
        private static T _instance = null;
        private static object _syncObj = new object();

        private Singleton()
        {
            // your implementation
        }

        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (_syncObj)
                    {
                        if (_instance != null)
                            return _instance;
                        _instance = new T();
                    }
                }

                return _instance;
            }
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            Singleton<StringBuilder>.Instance.Append("Some text");
        }
    }

The double-checked locking optimization is designed to reduce the overhead of acquiring a lock by first testing the locking criterion.
Lazy initialization avoids initializing a value until the first time it is accessed.

The C# preprocessor directives

2009-06-20T07:24:00.000-07:00

Unlike the C/C++ the C# compiler does not have a separate preprocessor.
Basicaly preprocessor directives are instructions to the C# compiler to perform some action during compilation.

#if, #else, #elif and #endif - commonly used to evaluate conditional code sections:

#define DEBUG
using System;
public class MyClass
{
public static void Main()
{
 #if (DEBUG)
    Console.WriteLine("DEBUG is defined");
 #elif (VC_V7)
    Console.WriteLine("VC_V7 is defined");
 #else
    Console.WriteLine("DEBUG and VC_V7 are not defined");
 #endif
}
}

#define lets you define a symbol, such that, by using the symbol as the expression passed to the #if directive, the expression will evaluate to true.

#undef lets you undefine a symbol, such that, by using the symbol as the expression in a #if directive, the expression will evaluate to false.

#warning/#error lets you generate a warning/error from a specific location in your code:

#define DEBUG
public class MyClass
{
public static void Main()
{
   #if DEBUG
   #warning DEBUG is defined
   #endif
}
}

#line lets you modify the compiler's line number and (optionally) the file name output for errors and warnings.

#region lets you specify a block of code that you can expand or collapse when using the outlining feature of the Visual Studio Code Editor.

#region MyClass definition
public class MyClass
{
  public static void Main()
  {
  }
}
#endregion

Stopwatch – a way to measure elapsed time

2009-06-01T23:12:00.000-07:00

If you need to measure elapsed time of your function or code section you can use Stopwatch object.

According to MSDN:

A Stopwatch instance can measure elapsed time for one interval, or the total of elapsed time across multiple intervals. In a typical Stopwatch scenario, you call the Start method, then eventually call the Stop method, and then you check elapsed time using the Elapsed property.

     System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();

     watch.Start();

     // Your Implementation

     watch.Stop();

     Console.WriteLine(watch.Elapsed.ToString());

File.ReadAllText and File.WriteAllText

2009-05-31T09:03:00.000-07:00

If you are looking for an easy way to work with files the: File.ReadAllText and File.WriteAllText are the answer.

File.ReadAllText Method ppens a text file, reads all lines of the file, and then closes the file.

File.WriteAllText Method creates a new file, writes the specified string to the file, and then closes the file. If the target file already exists, it is overwritten.

Shared Memory

2009-05-09T12:31:00.000-07:00

Shared Memory is an efficeint way of exchanging data between programs running at the same time. One process will create an area in RAM which other processes can access.

WinAPI remarks:
After a Shared Memory object is created, the size of the file must not exceed the size of the file Shared Memory; if it does, not all of the file contents are available for sharing.
A shared file mapping object will not be destroyed until all processes that use it close their handles to it by using the CloseHandle function.

A simple example of Writer/Reader processes.
First process creates a Shared Memory; the second reads messages from it.

SharedMemoryHandler.h

#include<windows.h>

class SharedMemoryHandler
{
public:
    SharedMemoryHandler(void* pObj, int length);
    ~SharedMemoryHandler(void);

    bool Read();
    bool Write();
 
private:
    bool Load();
    bool Unload();
    SharedMemoryHandler(void);
    SharedMemoryHandler& operator=(SharedMemoryHandler&);
private:
    PVOID        m_pObj;
    int          m_length;

    PVOID        m_pBuf;
    HANDLE        m_hMutex;
    HANDLE        m_hMapFile;
};

SharedMemoryHandler.cpp

#include "SharedMemoryHandler.h"
#include <tchar.h>

//___________ create unique mutex name ___________
static LPWSTR mutexName=_T("SharedMemoryHandler_Mutex");
static LPWSTR sharedMemoryName=_T("SharedMemoryHandler_SharedMemory");
 
SharedMemoryHandler::SharedMemoryHandler(void* pObj, int length)
:m_hMutex(0), m_hMapFile(0), m_pBuf(0), m_pObj(pObj), m_length(length)
{
    Load();
}

SharedMemoryHandler::~SharedMemoryHandler(void)
{
    Unload();
    CloseHandle( m_hMutex );
    CloseHandle( m_hMapFile );
 
    m_length = 0;
    m_hMutex = m_hMapFile = m_pBuf = m_pObj = 0;
}

bool SharedMemoryHandler::Load()
{
    //__________ lock with mutex ____________
    if((m_hMutex = CreateMutex(NULL, FALSE, mutexName))==0)
    {
        return false;
    }

    //_____ wait till someone unlock it ___
    WaitForSingleObject( m_hMutex, INFINITE );

    // _____________ create shared memory __________
    m_hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, m_length, sharedMemoryName); 

    if (m_hMapFile == 0 || m_hMapFile == INVALID_HANDLE_VALUE) 
    { 
        //_____ unlock _____
        ReleaseMutex(m_hMutex);
        return false; 
    }

    //______________ load shared memory ________________
    m_pBuf = MapViewOfFile(m_hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, m_length);   

    if (m_pBuf == 0) 
    { 
        //_____ unlock _____
        ReleaseMutex(m_hMutex);
        return false;
    }

    //_____ unlock _____
    ReleaseMutex(m_hMutex);

    return true;
}

bool SharedMemoryHandler::Read()
{
    //__________ lock with mutex ____________
    if((m_hMutex = CreateMutex(NULL, FALSE, mutexName))==0)
    {
        return false;
    }

    //_____ wait till someone unlock it ___
    WaitForSingleObject( m_hMutex, INFINITE );
 
    ZeroMemory( m_pObj, m_length );
    CopyMemory(m_pObj, m_pBuf, m_length);
 
    //_____ unlock _____
    ReleaseMutex(m_hMutex);

    return true;
}

bool SharedMemoryHandler::Write()
{
    //__________ lock with mutex ____________
    if((m_hMutex = CreateMutex(NULL, FALSE, mutexName))==0)
    {
        return false;
    }

    //_____ wait till someone unlock it ___
    WaitForSingleObject( m_hMutex, INFINITE );

    ZeroMemory( m_pBuf, m_length );
    CopyMemory(m_pBuf, m_pObj, m_length);

    //_____ unlock _____
    ReleaseMutex(m_hMutex);

    return true;
}

bool SharedMemoryHandler::Unload()
{
    //_______________ get mutex handler ________________

    if((m_hMutex=CreateMutex(NULL, FALSE, mutexName))==0)
    {
        return false;
    }

    //____ wait till someone unlock it __
    WaitForSingleObject( m_hMutex, INFINITE );

    // ____ destroy shared memory ______
    if (!UnmapViewOfFile(m_hMapFile)) 
    { 
        //_____ unlock _____
        ReleaseMutex(m_hMutex);
        return false; 
    }

    //_____ unlock _____
    ReleaseMutex(m_hMutex);
    return true;
}

First process:

#include "stdafx.h"
#include <conio.h>
#include "SharedMemoryHandler.h"

struct Message
{
    char msg[256];
};

int _tmain()
{
    Message msg = {0};
    strcpy(msg.msg, "Writer process message!");

    SharedMemoryHandler smh(&msg, sizeof(msg));
 
    smh.Write();
    _getch();

    return 0;
}

Second process:

#include "stdafx.h"
#include "SharedMemoryHandler.h"

struct Message
{
    char msg[256];
};

int _tmain()
{
    Message msg = {0};
    SharedMemoryHandler smh(&msg, sizeof(msg));

    smh.Read();
    printf("%s\n", msg.msg);

    return 0;
}

How to startup your application automatically when a Window starts

2009-05-09T03:12:00.000-07:00

One way to execute your process each time a Windows starts is to add your application's path to the registry.
When Windows starts it's executes all applications which registered at HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run path.

You can create installer for your application and create relevant registry key, or you can do this from code:

Main application:

int main()
{
    const wchar_t appKey[] = TEXT("My_StartUp_Application");
    const wchar_t appPath[] = TEXT("D:\\StartUpApplication\\debug\\StartUpApplication.exe");

    StartUpApplication startUpApp;
    startUpApp.Set(appKey, appPath);

  return 0;
}

StartUpApplication.h

class StartUpApplication
{
public:
    StartUpApplication(void);
    ~StartUpApplication(void);
 
    bool UnSet(const wchar_t* key);
    bool Set(const wchar_t* key, const wchar_t* appPath);
    bool GetAppPath(const wchar_t* key, wchar_t* appPath);

private:
    StartUpApplication(StartUpApplication&);
    StartUpApplication& operator=(StartUpApplication&);
};

StartUpApplication.cpp

#include "StartUpApplication.h"
#include <windows.h>
 
static const wchar_t* _startupPath = __TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run");

StartUpApplication::StartUpApplication()
{
}
StartUpApplication::~StartUpApplication(void)
{
}

bool StartUpApplication::Set(const wchar_t* key, const wchar_t* appPath)
{
    if(!key || !appPath)
        return false;

    HKEY hKey;

    if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, _startupPath, 0, KEY_ALL_ACCESS, &hKey))
        return false;

    long retVal = RegSetValueEx(hKey, key, 0, REG_SZ, (BYTE*)appPath, (wcslen(appPath)+1)*sizeof(TCHAR));

    return ( (ERROR_SUCCESS == retVal) && (ERROR_SUCCESS == RegCloseKey(hKey)) );
}

bool StartUpApplication::UnSet(const wchar_t* key)
{
    HKEY hKey;

    if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, _startupPath, 0, KEY_ALL_ACCESS, &hKey))
        return false;

    return ( (ERROR_SUCCESS == RegDeleteValue(hKey, (LPCWSTR)key)) && (ERROR_SUCCESS == RegCloseKey(hKey)) );
}

bool StartUpApplication::GetAppPath(const wchar_t* key, wchar_t* appPath)
{
    HKEY hKey;
 
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _startupPath, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
        return false;

    DWORD dwType = REG_SZ, dwSize = MAX_PATH;
 
    long retVal = RegQueryValueEx(hKey, (LPCWSTR)key, NULL, &dwType, (LPBYTE)appPath, &dwSize);
 
    return ( (ERROR_SUCCESS == retVal) && (ERROR_SUCCESS == RegCloseKey(hKey)) );
}

How to receive OS notifications about windows shutdown/logoff

2009-05-09T02:02:00.000-07:00

To create a process which must detect windows shutdown or log-off actions to perform necessary clean-up operations you can use many features.

One of them is to create Windows Service.
Another way is to subscribe to the system events notifications.

WinAPI provides a SetConsoleCtrlHandler function which able to add a callback for the calling process.

#include <windows.h>

HANDLE hEvent;

BOOL WINAPI ShutDownHandler(DWORD dwCtrlType)
{
    switch( dwCtrlType )
    {
        case CTRL_SHUTDOWN_EVENT:

        case CTRL_LOGOFF_EVENT: 

        case CTRL_CLOSE_EVENT: 
            SetEvent(hEvent);
            return TRUE;

        default:
            return FALSE;
    }
}
 
void main()
{
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    SetConsoleCtrlHandler(ShutDownHandler, true);
 
    // your implementation
 
    WaitForSingleObject(hEvent,INFINITE); 
 
    // your clean-up

    CloseHandle (hEvent);
}

Force application not to appear at taskbar

2009-05-08T09:37:00.000-07:00

#include <windows.h>
 
int _tmain(int argc, _TCHAR* argv[])
{
    HWND hwnd;
    wchar_t pszNewWindowTitle[MAX_PATH]={0};

    GetConsoleTitle(pszNewWindowTitle, sizeof(pszNewWindowTitle));
    hwnd = FindWindow(NULL, pszNewWindowTitle);

    if(hwnd)
        ShowWindow(hwnd, SW_HIDE);

    // Your Code..

    return 0;
}

How to force thread to perform context switch

2009-05-03T12:22:00.000-07:00

What is a context switch?
A context switch is an action performed by operating systems to switch from one process/thread to another.
Basically, during application execution the operating system provides a CPU time for each thread.
While thread is executed its state is loaded into CPU registers.
By the time comes to execute a new thread, current's thread data is stored back in process's stack and a new process's state is loaded into CPU registers.

You can cause context switch by calling:

C/C++

Sleep(0);

System.Threading.Thread.Sleep(0);

How to prevent current event's propagation

2009-05-02T11:03:00.000-07:00

Think about next scenario:

Create a table.
Each row shows information on click.
Each column shows information on click.
Each column can contain additional clickable tags.

The implementation:

    <table>
        <tr onclick="alert('row');">
            <td onclick="alert('td');">
                <span onclick="alert('td');" style="color:blue;" >
                    Click here!
                </span> 
                &nbsp; td section
            </td>
        </tr>
    </table>

That is because when method is called by any EventListener the event will cease propagating through the tree.

To prevent the propagation after “Click here!” text click use following code:

    <table>
        <tr onclick="alert('row');">
            <td onclick="alert('td');">
                <span onclick="spanClick(event);" style="color:blue;" >
                    Click here!
                </span> 
                &nbsp; td section
            </td>
        </tr>
    </table>

<script>
function spanClick(e)
{    
    alert('span');
    if(!e) var e = window.event;
    try{e.cancelBubble = true; return;}catch(e){} // IE
    try{e.stopPropagation(); return;}catch(e){}   // FireFox
}

Raise custom exceptions

2009-05-02T01:08:00.000-07:00

The SQL exception handling is a very powerful feature.
Yet, you must use it carefully.

It's important to understand that the "Catch" blocks swallows exceptions and application's Data Access Layer gets no information regarding SQL errors during execution.
Therefore it can take allot of time to understand if there was error at all!

In cases when it's crucial to notify calling application about execution crushes you can use RAISERROR routine.

RAISERROR – able to generate system defended as well as custom errors.

BEGIN TRY
    RAISERROR ('Error raised in TRY block.', -- Message text.
               16, -- Severity.
               1 -- State.
               );
END TRY

BEGIN CATCH
    DECLARE @ErrorMessage NVARCHAR(4000);
    DECLARE @ErrorSeverity INT;
    DECLARE @ErrorState INT;
 
    SELECT 
        @ErrorMessage = ERROR_MESSAGE(),
        @ErrorSeverity = ERROR_SEVERITY(),
        @ErrorState = ERROR_STATE();

    RAISERROR (@ErrorMessage, -- Message text.
               @ErrorSeverity, -- Severity.
               @ErrorState -- State.
               );
END CATCH;

GET vs POST methods

2009-04-29T21:51:00.000-07:00

a very nice post GET vs POST.

Initializing your assembly's information

2009-04-29T13:23:00.000-07:00

Each assembly you build has usable information such as company name, copyright, version and etc...
The way to modify it is to right click on your assembly project, under Application section choose Assembly Information.

Interfaces vs. abstract Classes

2009-04-29T10:49:00.000-07:00

Both interfaces and abstract classes provide a set of behavior patterns for derived types.

Interface able to inherit from multiple interfaces while class can inherit only from one class and many interfaces.
Abstract class can provide implementation for non abstract methods/properties while interface can't.
Abstract classes can to contain variables while interfaces can't.
Interface cannot provide access modifier for methods while abstract classes can.

General AJAX from scratch

2009-04-29T08:36:00.000-07:00

AJAX stands for Asynchronous JavaScript and XML.

By using AJAX you can:

Make requests to the server without reloading the page

Parse and work with XML documents

A lot of websites use AJAX to improve user’s experience.

Here is a small AJAX object example which making requests to a WebService:

AjaxObject.js:

function AjaxObject()
{
    this.responseText = '';
    this.httpRequest = null;
    this.method = 'GET';    // GET (Query String) or POST
    this.async = true;      // true - asynchronous, false - synchronous
    this.params = {};       // request params
    this.Callback = null;   // callback function
 
    this.CreateHttpRequest = function() {

        try { return new XMLHttpRequest(); }catch(e){}
        try { return new ActiveXObject("Msxml2.XMLHTTP"); }catch(e){}
        try { return new ActiveXObject("Microsoft.XMLHTTP"); }catch(e){}

        return null;
    }

    // initialize http request 
    if( !(this.httpRequest = this.CreateHttpRequest()) ) {

        alert("XMLHttpRequest not supported");
        return;
    }
 
    this.AddParam = function(key, value) {
 
        this.params[key]=value;
    }
 
    this.CreateRequestParams = function() {
 
        var Params = new Array();

        for(var item in this.params) {
            var param = item + "=" + encodeURIComponent(this.params[item]); 
            Params.push(param);
        }
 
        return Params.join("&");
    }

    this.Execute = function(url) {
 
        if(!this.httpRequest) {
            alert('unable to create HTTP request!');
            return null;
        }
 
        var self = this;
        this.httpRequest.onreadystatechange = function() {
 
            if(self.httpRequest.readyState == 4 && self.httpRequest.status == 200) {                   

                self.responseText = self.httpRequest.responseText;

                if ( self.Callback ){ 
                    self.Callback(self.responseText); 
                }
            }
        }

        this.httpRequest.onerror = function() {alert('http request error!'); return null;}
        this.httpRequest.onload = function() {}// add your implementation

        this.httpRequest.open(this.method, url + (this.method!='GET' ? '' : '?' + this.CreateRequestParams()), this.async); 

        this.httpRequest.setRequestHeader("Accept-Encoding", "gzip, deflate");    
        this.httpRequest.setRequestHeader("Content-type", "application/x-www-form-urlencoded");         
 
        this.httpRequest.send( this.method!='POST' ? null : this.CreateRequestParams());

        if(!this.async) {

            if(self.httpRequest.readyState == 4) {
                if(self.httpRequest.status == 200)
                    return this.httpRequest.responseText;  
                else {
                    alert('Http response error!');
                    return null;
                }
            }
        }
    }
}

By using AjaxObject declaration you can create JavaScript object for performing AJAX requests.
AjaxObject object able to make GET/POST request, add method parameters, receive encoded response and execute the task synchronously/asynchronously.

Test.html:

<html>
<head>
    <title></title>
    <script language="javascript" src="AjaxObject.js" type="text/javascript"></script>
</head>

<body>
    <form id="form1">
    <div style="">
        <input type="button" value="Go" onclick="AjaxTestCall();"/>
        <textarea id="output_area" style="height: 200px; width: 650px;" cols="20" rows="2" name=""></textarea>
    </div>
    </form>
</body>

<script type="text/javascript">

function AjaxTestCall()
{
    //__________ Web Service _____________
    var url = "http://localhost:34965/www/WebService.asmx/HelloWorld";
 
    var output = document.getElementById('output_area');
    output.innerHTML = '';

    //____________synchronous Get request example____________________
    var ajaxObj1 = new AjaxObject();
    ajaxObj1.async = false; 
    var result = ajaxObj1.Execute(url);

    if(result)
        output.innerHTML +='GET, Synchronics request: ' + result + '\r\n';

 
    //____________asynchronous Get request example___________________
    var ajaxObj2 = new AjaxObject();
    ajaxObj2.Callback = function(result){ 

      if(result)
        output.innerHTML +='GET, Synchronics request: ' + result + '\r\n';
    }
    ajaxObj2.Execute(url);


    url = "http://localhost:34965/www/WebService.asmx/GetUserInfo";
    //____________synchronous POST request example____________________
    
    var ajaxObj3 = new AjaxObject();
    ajaxObj3.async = false; 
    ajaxObj3.method = 'POST';
    ajaxObj3.AddParam('nameName', 'David');
    var result = ajaxObj3.Execute(url);

    if(result)
        output.innerHTML +='GET, Synchronics request: ' + result + '\r\n';
 

    //____________asynchronous POST request example________________

    var ajaxObj4 = new AjaxObject();
    ajaxObj4.method = 'POST';
    ajaxObj4.Callback = function(result){ 

      if(result)
        output.innerHTML +='POST, Synchronics request: ' + result + '\r\n';
    }
    ajaxObj4.AddParam('nameName', 'David');
    ajaxObj4.Execute(url);
}

</script>
</html>

A Web Service implementation WebService.cs:

using System;
using System.Web;
using System.Collections;
using System.Web.Services;
using System.Web.Services.Protocols;

[WebService(Namespace = "http://localhost:34965/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class WebService : System.Web.Services.WebService {
 
    public WebService ()
    {

    }

    [WebMethod]
    public string HelloWorld() {
        return "Hello World";
    }

    [WebMethod]
    public string GetUserInfo(string nameName)
    {
        return nameName + " Information: David Libinson...";
    }
}

To allow http requests to a Web Service add following code you’re Web.config:

   <webServices>
      <protocols>
        <add name="HttpGet"/>
        <add name="HttpPost"/>
      </protocols>
    </webServices>

How to causes the linker to search for static library

2009-04-29T01:15:00.000-07:00

A static library is a file (.lib) that contains functions, classes, or resources that an external program can use to complement its functionality.

The following pragma causes the linker to search for the ws2_32.lib WinSocket library while linking:

#pragma comment(lib, "ws2_32.lib")

The following pragma causes the linker to search for the OpenGL libraries while linking:

#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glut32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "glaux.lib")

How to disable compiler warnings

2009-04-29T01:01:00.001-07:00

Use "#pragma warning" macro to disable compilation warnings:

#include <windows.h>

#pragma warning(disable: 4786)

void _tmain()
{
    ...
}

Pointer vs. Reference

2009-04-29T00:11:00.000-07:00

Both pointer and reference are data items that contain an address.
They avoid the copying of objects (pass by reference to a function) and reduce stack resources.

    int var = 20;
    int& varRef = var;
    varRef += 5;
 
    int var = 20;
    int* varPtr = &var;
    *varPtr += 5;

Still there are some differences:

Reference must point a variable on creation.
Reference can point only to one variable during its lifetime.
Unlike pointers reference cannot point to NULL.

class AB
{
    int a;
    char b;
};
 
...

void foo(AB* ab){}
 
void foo(AB& ab){}

Use reference if want to make sure that you are working with real object (not NULL).
Prefer using pointers if you need to perform integer arithmetic on address.

Loading DLL at run-time

2009-04-27T13:59:00.000-07:00

I used the previous post's DLL to execute function.

Here is an example of loading DLL at run-time:

#include <windows.h>

// pointer to function declaration
typedef void (*pMyFirstExportedFunction)(void);

int _tmain(int argc, _TCHAR* argv[])
{
    // map the DLL into current process memory space
    HINSTANCE hLib = LoadLibrary(TEXT("MyFirstDLL.dll"));

    if(!hLib) 
    {
        printf("Unable to load MyFirstDLL.dll...\n");
        return -1;
    }

    pMyFirstExportedFunction MyFirstExportedFunction = 0;
 
    // get function's address
    if( !(MyFirstExportedFunction = (pMyFirstExportedFunction)GetProcAddress(hLib, "MyFirstExportedFunction")) )
    {
        printf("Unable to load 'MyFirstExportedFunction' function from MyFirstDLL.dll.");
        return -1;
    }
 
    // execute the function
    MyFirstExportedFunction();

    // release the library
    FreeLibrary(hLib);

    return 0;
}

The most useful ANSI predefined macros

2009-04-27T04:38:00.000-07:00

__FILE__ - The name of the current source file.

__LINE__ - The line number in the current source file.

__TIME__ - The most recent compilation time of the current source file.

__DATE__ - The compilation date of the current source file.

Unmanaged DLL from scratch

2009-04-26T12:52:00.000-07:00

What is a DLL?
Dynamic-link library (DLL) is a shared library which can be mapped into process memory space at run-time.

Why to use it?

Versioning - it is easy to maintain the application versions by simply replacing old modules with new ones.

Modularity - by using DLLs it is easy to separate project into independent units which can perform different unique roles.

Code reuse - one code implementation can be exploited on different processes.

One of the great advantages of DLLs is that it is possible to use them in most popular programming languages such as: VB, Delphi, C\C++, .Net and etc...
Unfortunately, DLLs are platform dependant.

Allot of organization prefer using DLLs for implementing their logical units.
A GUI parts of application can be changed rapidly (MFC, WinForms, WPF) while logical implementations can remain unchanged.

Let's get started:
If you are using MS Visual Studio 6, open a new project and choose "Win32 Dynamic-Link Library", Give your project a name and click "OK" button:

Choose "An empty DLL project" option and click Finish button.

If you are using MS Visual Studio 2005/2008, open a new project and choose "Visual C++" under Project Types and "Win32 Console Application" under Templates, Give your project a name and click "OK" button:

Click next button, Choose "DLL" at Application type section, "Empty project" at Additional options and click "Finish" button:

Now create header and implementation files.
Give them same name as you gave to your project:

Next step is to enable DLL to export functions and resources.

Write the following code in MyFirstDLL.h file that you created:

#ifdef MYFIRSTDLL_EXPORTS
    #define MYFIRSTDLL_API __declspec(dllexport)
#else
    #define MYFIRSTDLL_API __declspec(dllimport)
#endif

__declspec keyword specifies that an instance of a given type is to be stored with a Microsoft-specific storage-class attribute dllexport and dllimport.

The dllexport and dllimport storage-class attributes are Microsoft-specific extensions to the C and C++ languages.
They enable you to export and import functions, data, and objects to and from a DLL.
In most cases you'll need only to export stuff from your DLL.

Write MYFIRSTDLL_API before each function that you want to be exported :

MYFIRSTDLL_API void MyFirstExportedFunction(void);

Now it is time to write an implementation:

Add following code to your MyFirstDLL.cpp file:

#include<stdio.h>
#include<windows.h>

#define MYFIRSTDLL_EXPORTS

#include "MyFirstDLL.h"

void MyFirstExportedFunction(void)
{
    printf("This is my first function exported from DLL!");
}
 
BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                   )
{
    switch (ul_reason_for_call)
    {
        case DLL_PROCESS_ATTACH:

        case DLL_THREAD_ATTACH:

        case DLL_THREAD_DETACH:

        case DLL_PROCESS_DETACH:
            break;
    }
    return TRUE;
}

In order to export your functions it is important to define MYFIRSTDLL_EXPORTS before including MyFirstDLL.h definitions.

The DllMain function is the entry point into a dynamic-link library. The function is called when processes and threads are initialized and terminated, or upon calls to the LoadLibrary and FreeLibrary functions.

ul_reason_for_call Indicates why the DLL entry-point function is being called.

Make your function implementation and build the project.
Here it is, your DLL is ready!

In order to see the exported interface I'll use the Dependency Walker:

As you can see, the ?MyFirstExportedFunction@@YAXXZ function name is not the same we gave it.
That because of Name Mangling.

The name mangling is a process that makes it possible to have two functions with the same name in C++ as long as they have different arguments (overloaded functions).Since C++ is a type safe language and fairly strict about types, it implements name mangling.

To prevent the mangling add extern "C" declaration:

#ifdef MYFIRSTDLL_EXPORTS
    #define MYFIRSTDLL_API __declspec(dllexport)
#else
    #define MYFIRSTDLL_API __declspec(dllimport)
#endif
 extern "C"
{
    MYFIRSTDLL_API void MyFirstExportedFunction(void);
};

Build the project and check the exported interface.
That is your first DLL!

Use initializer for static variables such arrays, structures and unions instead of memset

2009-04-25T06:58:00.000-07:00

Please answer me this:
How many of you use next type of action to reset your variable before use?

typedef struct _A
{
    int        x;
    char       y;
    char*      z;
}A;
 
void main()
{
    A a;
    ZeroMemory(&a, sizeof(a));

    // Or:

    int arr[50];
    memset(arr, 0, sizeof(arr));
}

The truth is that we can perform same action without using additional functions such as memset or ZeroMemory (a macro which uses memset function)!

C language allows ordinary variables, structures, unions and arrays to be given initial values in their definitions.
C++ allows the initializer for an automatic member variable of a union or structure type to be a constant or non-constant expression.

The initializer is preceded by an equal sign (=).

Example:

void main()
{
    A a={0};
    A a1 = {20, 'Z', "some string"};

    int arr[50]={50};
}

Handling Windows Services (the unmanaged way)

2009-04-24T15:19:00.000-07:00

The Win API provides set of function which allows handling Windows Services.
Here is a small class for managing local services:

WindowsServiceHandler.h

#include <windows.h>
 
class WindowsServiceHandler
{
public:
 
enum ServiceStatus {
    WS_ERROR                = -1,
    WS_STOPPED              = 0x00000001,
    WS_START_PENDING        = 0x00000002,
    WS_STOP_PENDING         = 0x00000003,
    WS_RUNNING              = 0x00000004,
    WS_CONTINUE_PENDING     = 0x00000005,
    WS_PAUSE_PENDING        = 0x00000006,
    WS_PAUSED               = 0x00000007
};
 
public:
    WindowsServiceHandler(void);
    virtual ~WindowsServiceHandler(void);
 
    virtual bool Stop(coname);
    virtual bool Start(const char* serviceName);
    virtual bool Restart(const char* serviceName);
    virtual bool QueryStatus(const char* serviceName, ServiceStatus& status);

private:
    SC_HANDLE    m_hManager;st char* serviceN
 
private:
    WindowsServiceHandler(WindowsServiceHandler&);
    WindowsServiceHandler& operator=(WindowsServiceHandler&);
};

WindowsServiceHandler.cpp

#include "WindowsServiceHandler.h"

WindowsServiceHandler::WindowsServiceHandler(void)
:m_hManager(0)
{
    m_hManager = OpenSCManager(                   
        NULL,                   // machine (NULL == local)     
        NULL,                   // database (NULL == default)         
        SC_MANAGER_ALL_ACCESS); // access required                    
}
 
WindowsServiceHandler::~WindowsServiceHandler(void)
{
    CloseServiceHandle(m_hManager); 
    m_hManager = 0;
}

bool WindowsServiceHandler::Stop(const char* serviceName)
{
    if(!m_hManager || !serviceName)
        return false;

    SC_HANDLE hService = 0;

    if (0 == (hService = OpenService(m_hManager, TEXT(serviceName), SERVICE_ALL_ACCESS))) {
        return false;
    }
 
    SERVICE_STATUS status = {0};
 
    if (!ControlService(hService, SERVICE_CONTROL_STOP, &status)) {
        return false;
    }

    while(QueryServiceStatus(hService, &status))        
    {                    
        if (status.dwCurrentState == SERVICE_STOP_PENDING)                                       
            Sleep(10);                    
        else                
            break;                
    }                
 
    return (status.dwCurrentState == SERVICE_STOPPED);
}

bool WindowsServiceHandler::Start(const char* serviceName)
{
    if(!m_hManager || !serviceName)
        return false;
 
    SC_HANDLE hService = 0;

    if (0 == (hService = OpenService(m_hManager, TEXT(serviceName), SERVICE_ALL_ACCESS))) {
        return false;
    }
 
    if(!StartService(hService, 0, NULL)) {
        return false;
    }
 
    SERVICE_STATUS status = {0};
 
    while(QueryServiceStatus(hService, &status))        
    {                    
        if (status.dwCurrentState == SERVICE_START_PENDING)                       
            Sleep(10);                    
        else                
            break;                
    }                
 
    return (status.dwCurrentState == SERVICE_RUNNING);  
}

bool WindowsServiceHandler::Restart(const char* serviceName)
{
    return (Stop(serviceName) && Start(serviceName));
}
 
bool WindowsServiceHandler::QueryStatus(const char* serviceName, ServiceStatus& status)
{
    if(!m_hManager || !serviceName) {
        status = ServiceStatus::WS_ERROR;
        return false;
    }

    SC_HANDLE hService = 0;

    if (0 == (hService = OpenService(m_hManager, TEXT(serviceName), SERVICE_ALL_ACCESS))) {
        status = ServiceStatus::WS_ERROR;
        return false;
    }

    SERVICE_STATUS sStatus = {0};
 
    if(!QueryServiceStatus(hService, &sStatus)) {
        status = ServiceStatus::WS_ERROR;
        return false;
    }

    status = (ServiceStatus)sStatus.dwCurrentState;
    return true;
}

main.cpp


#include "WindowsServiceHandler.h"
#include <iostream>

using namespace std;
 
void main()
{
    char serviceName[] = "MSSQL$SQLEXPRESS";
 
    WindowsServiceHandler serviceHandler;
    WindowsServiceHandler::ServiceStatus status;
 
    cout<<"status..."<<endl;
    serviceHandler.QueryStatus(serviceName, status);
    cout<<"Service is running: "<<(status==WindowsServiceHandler::ServiceStatus::WS_RUNNING?"true":"false")<<endl;

    cout<<"stop..."<<endl;
    serviceHandler.Stop(serviceName);
    serviceHandler.QueryStatus(serviceName, status);
    cout<<"Service is running: "<<(status==WindowsServiceHandler::ServiceStatus::WS_RUNNING?"true":"false")<<endl;

    cout<<"start..."<<endl;
    serviceHandler.Start(serviceName);
    serviceHandler.QueryStatus(serviceName, status);
    cout<<"Service is running: "<<(status==WindowsServiceHandler::ServiceStatus::WS_RUNNING?"true":"false")<<endl;

    cout<<"restart..."<<endl;
    serviceHandler.Restart(serviceName);
    serviceHandler.QueryStatus(serviceName, status);
    cout<<"Service is running: "<<(status==WindowsServiceHandler::ServiceStatus::WS_RUNNING?"true":"false")<<endl;
}

Handling registry entities manualy

2009-04-22T13:57:00.000-07:00

In order to export registry entity manually, type regedit command in “Run” command prompt,
Go to the desired key, right click on it and choose “Export” option:

Give a name to file and click save button.

Open the created file:

Windows Registry Editor Version 5.00
[HKEY_CURRENT_USER\Software\MyWindowsApplication]
"Version"="1.0"
"xPosition"=dword:00000234
"yPosition"=dword:00000176

You can update the Values and update the registry by double-clicking on the updated file!

Saving application’s settings in Registry

2009-04-22T13:17:00.000-07:00

The Windows Registry is a data storage which holds information about the operating system and software/hardware configurations.
It has a tree-like structure which based on key/value settings.
Keys are represented as folder (value holders) and values can store different value types:

Many applications use Registry to store application's configurations such as version, screen location, paths and etc...

The registry can be edited manually by running regedt executable:

The Registry is split into a number of logical sections. Each section has its own purpose and responsibilities.

A C# Example: The application saves version and Form's screen location in registry.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using Microsoft.Win32;
 
namespace MyWindowsApplication
{
    public partial class Form1 : Form
    { 
        private string appConfigPath = "Software\\MyWindowsApplication";
        public Form1()
        {
            InitializeComponent();
        }
 
        protected override void OnClosing(CancelEventArgs e)
        {
             base.OnClosed(e);

             RegistryKey key = Registry.OpenSubKey(appConfigPath, true);
             if (key == null)
                Registry.CurrentUser.CreateSubKey(appConfigPath);

             key.SetValue("Version", "1.0", RegistryValueKind.String);
             key.SetValue("xPosition", this.DesktopLocation.X, RegistryValueKind.DWord);
             key.SetValue("yPosition", this.DesktopLocation.Y, RegistryValueKind.DWord);
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
 
            RegistryKey key = Registry.CurrentUser.OpenSubKey(appConfigPath);
 
            if (key != null)
            {
                this.Text = (string)key.GetValue("Version");

                Point point = new Point(
                    (int)key.GetValue("xPosition"),
                    (int)key.GetValue("yPosition"));

                this.DesktopLocation = point;
            }
        }
    }
}

The Dependency Walker

2009-04-21T12:42:00.000-07:00

Dependency Walker is a utility that scans any 32-bit or 64-bit Windows module (exe, dll, ocx, sys, etc.) and builds a hierarchical tree diagram of all dependent modules.

For each module found, it lists all the functions that are exported by that module, and which of those functions are actually being called by other modules. Another view displays detailed information about each file including a full path to the file, base address, version numbers, machine type, debug information, and more.

Dependency Walker runs on Windows 95, 98, Me, NT, 2000, XP, 2003, and Vista.

You can find it at:

Microsoft Visual Studio 6:
C:\Program Files\Microsoft Visual Studio\Common\Tools\DEPENDS.EXE

Microsoft Visual Studio 2005:
C:\Program Files\Microsoft Visual Studio 8\Common7\Tools\Bin\Depends.Exe

Or you can download it from http://www.dependencywalker.com

What is vshost.exe file do?

2009-04-20T03:53:00.000-07:00

Many of you may seen that when you run your .Net application in DEBUG mode
The "Windows Task Manager" shows .vshost.exe instead of your executable name:

So what is it vshost.exe, and why we need it?

vshost.exe is a hosting process feature that improves debugging performance, enables partial trust debugging, and enables design time expression evaluation:

The hosting process files contain vshost in the file name and are placed in the output folder of your project.

Cascading Style Sheets Compressors

2009-04-18T12:09:00.000-07:00

CSS Compressors:

http://www.csscompressor.com/

http://www.cssdrive.com/index.php/main/csscompressor/

http://www.blumentals.net/csstool/tour.php

Speeding up your web site roles.

2009-04-18T11:46:00.000-07:00

A list of best practices for speeding up your web site.

Jesse Hansen's JavaScript Compressor

2009-04-18T11:07:00.000-07:00

A JavaScript compression is one of many ways to improve performance of your Website.
Check out Jesse Hansen's JavaScript Compressor

How to make bootable USB Flash Stick

2009-04-17T11:00:00.000-07:00

BootFlashDOS is a small utility that will format and make DOS bootable your USB Flash Stick.

Your object’s residents and Garbage Collection generations

2009-04-17T09:36:00.000-07:00

The .Net garbage collector divides managed heap memory in to 3 parts(generations).

All new heap allocated objects are placed on generation 0.
When generation 0 section is full the garbage collector moves the reachable (not disposed) objects into generation 1 heap area and if it's full also then garbage collector will scan generation 1, reclaiming memory for unreachable objects and promoting reachable objects to generation 2.

Generation 0 - usually 128 - 256 KB
Generation 1 - usually up to 2MB
Generation 2 - usually 10 MB or larger

Use System.GC.GetGeneration function to define generation residents of your object.

Writing messages to the trace listeners.

2009-04-17T04:09:00.000-07:00

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            System.Diagnostics.Debug.WriteLine("Hello Debug World!");
            Console.ReadKey();
        }
    }
}

Sending strings to the debugger for display

2009-04-17T03:34:00.000-07:00

OutputDebugString - Sends a string to the debugger for display.

#include "stdafx.h"
#include "windows.h"

int _tmain(int argc, _TCHAR* argv[])
{
    OutputDebugString(_T("Application started...\n"));

    int i = 0, j = 2;
 
    OutputDebugString(_T("Variables declaration finished...\n"));
 
    getchar();
    return 0;
}

Other Debugging Functions.

Saving application's events/errors in Windows Event log

2009-04-16T15:04:00.000-07:00

EventLog object lets you access or customize Windows event logs, which record information about important software or hardware events.

Example:

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace EventLogger
{
    class Program
    {
        private string _appSource = "APPLICATION_LOG";
        private string _appLogName = "MY_EVENT_LOG";
        private EventLog _logHandle = null;
 
        static void Main(string[] args)
        {
            Program obj = new Program();
            obj.WriteEvent("Hello World!");
        }

        public Program()
        {
            try
            {
                // Create the source, if it does not already exist.
                if (!EventLog.SourceExists(_appSource))
                {
                    EventLog.CreateEventSource(_appSource, _appLogName);
                }
 
                // Create an EventLog instance and assign its source.
                _logHandle = new EventLog();
                _logHandle.Source = _appLogName;
            }
            catch { }
        }

        public void WriteEvent(string msg)
        {
            _logHandle.WriteEntry(msg, EventLogEntryType.Information);
        }
 
        public void WriteError(string msg)
        {
             _logHandle.WriteEntry(msg, EventLogEntryType.Error);
        }
 
        public void WriteError(Exception exp)
        {
            StringBuilder msg = new StringBuilder();

            while (exp != null)
            {
                msg.AppendLine(exp.Message);
                msg.AppendLine(exp.StackTrace);
                exp = exp.InnerException;
            }

            WriteError(msg.ToString());
        }

        public void WriteError(Exception exp, string errorMsg)
        {
            StringBuilder msg = new StringBuilder(errorMsg);
 
            while (exp != null)
            {
                msg.AppendLine(exp.Message);
                msg.AppendLine(exp.StackTrace);
                exp = exp.InnerException;
            }
 
            WriteError(msg.ToString());
        }
    }
}

The output:

3 ways of getting .aspx file name at run-time

2009-04-15T13:22:00.000-07:00

        System.IO.Path.GetFileName(Request.PhysicalPath);

        System.Web.VirtualPathUtility.GetFileName(Request.RawUrl)

        string sPath = System.Web.HttpContext.Current.Request.Url.AbsolutePath;
        System.IO.FileInfo oInfo = new System.IO.FileInfo(sPath);
        string sRet = oInfo.Name;

typeof & instanceof

2009-04-15T05:45:00.000-07:00

JavaScript operators:

The instanceof operator returns true if the specified object is of the specified object type:

function HelloPrinter()
{
    this.Print = function(){
        alert('Hello');
    }
}
 
var printer = new HelloPrinter();
printer.Print();

alert(printer instanceof Date);         // false
alert(printer instanceof Object);       // true
alert(printer instanceof String);       // false
alert(printer instanceof HelloPrinter); // true

The typeof operator returns a string indicating the type of the unevaluated operand. operand is the string, variable, keyword, or object for which the type is to be returned:

var myFun = new Function("5+2")
var shape="round"
var size=1
var today=new Date()

typeof myFun == 'function'   
typeof shape == 'string'
typeof size == 'number'
typeof today == 'object'
typeof dontExist == 'undefined'

PInvoke Visual Studio Add-in

2009-04-15T01:38:00.001-07:00

PInvoke Visual Studio Add-in - Find and contribute PInvoke signatures.

PInvoke.net, meaning Platform Invoke, is a wiki used by around 50,000 .NET developers a month to find and contribute PInvoke signatures (also known as Declare statements in VB), type definitions, and any other information related to calling Win32, or other unmanaged APIs in managed code (languages such as C# or VB.NET).

PInvoke Visual Studio Add-in

2009-04-15T01:38:00.000-07:00

.NET Reflector

2009-04-15T01:33:00.000-07:00

.NET Reflector enables you to easily view, explore, browse, and analyze .NET assemblies.

Plug and Play Application in C#

2009-04-14T15:25:00.000-07:00

What Is Plug and Play Application?

Plug and Play is a technology that lets applications and moduls (Dlls for instance) work together automatically.
A user can simply add a new module ("plug it in") and begin working ("begin playing"). This should be possible even while the Application is running, without restarting it.

How it works?

First you need to create a Class Library project for modules interface (IPluggableModule)
Than create another Class Library for each new module. All modules must inherit from IPluggableModule interface.
Create a folder C:\\MyModules (a place for all modules).

Use my demo ConsoleApplication1.Program to test the result.
Each time you copy a dll module you created, it will load it and execute its action

PluggableModulesInterface project:

namespace PluggableModulesInterface
{
    public interface IPluggableModule
    {
        void Execute();
    }
}

PluggableModuleA project:

using System;
using System.Collections.Generic;
using System.Text;
using PluggableModulesInterface;
 
namespace PluggableModules
{
    public class PluggableModuleA: IPluggableModule
    {
        string m_name=string.Empty;
        void IPluggableModule.Execute()
        {
            // Module A execute implementation
            Console.WriteLine("Module A execute implementation");
        }
    }
}

Test project:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Threading;
using PluggableModulesInterface;
 
namespace ConsoleApplication1
{
    class Program
    {
        static string App_Modules_Path = "C:\\MyModules";
        static bool isRunning = true;
        static int Time_Out = 300; 

        static void Main()
        {
            // load existing moduls
            LoadExistingModules();

            // start the watcher thread, load a new moduls
            Thread watcherThread = new Thread(new ThreadStart(RunWatcher));
            watcherThread.Start();
 
            // start the performer thread, execute moduls each 5 seconds
            Thread performerThread = new Thread(new ThreadStart(ExecuteModules));
            performerThread.Start();
 
            while(isRunning);
        }

        private static void RunWatcher()
        {
            FileSystemWatcher modulesWatcher = new FileSystemWatcher();
            modulesWatcher.Path = App_Modules_Path;
 
            modulesWatcher.Filter = "*.dll";
            modulesWatcher.NotifyFilter = NotifyFilters.FileName;
 
            modulesWatcher.Created += new FileSystemEventHandler(OnCreated);
            modulesWatcher.Deleted += new FileSystemEventHandler(OnCreated);

            // Begin watching.
            modulesWatcher.EnableRaisingEvents = true;

            Console.ReadKey();
        }
 
        private static void OnCreated(object source, FileSystemEventArgs e)
        {
            LoadAssembly(e.FullPath);
        }

        private static void OnDeleted(object source, RenamedEventArgs e)
        {
            PluggableModulesHandler<Type> modulesHandler = PluggableModulesHandler<Type>.Instance;
            for (int i = 0; i < modulesHandler.Count; ++i)
            {
                if (modulesHandler[i].Name == e.Name)
                    modulesHandler.Remove(modulesHandler[i]);
            }
        }
 
        private static void LoadAssembly(string fileName)
        {
            try
            {
                int counter = 0;
                while (!CanLoad(fileName) == true && counter < 5)
                {
                    System.Threading.Thread.Sleep(Time_Out); counter++;
                }
 
                System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFile(fileName);

                foreach (Type type in assembly.GetTypes())
                {
                    Type moduleInterface = type.GetInterface("PluggableModulesInterface.IPluggableModule");

                    if (moduleInterface != null)
                    {
                        // add the object to the collection
                        PluggableModulesHandler<Type>.Instance.Add(type);
                    }
                }
            }
            catch (Exception exp)
            {
                // log it
            }
        }

        private static void ExecuteModules()
        {
            try
            {
                while (isRunning)
                {
                    PluggableModulesHandler<Type> modulesHandler = PluggableModulesHandler<Type>.Instance;

                    for (int i = 0; i < modulesHandler.Count; ++i)
                    {
                        IPluggableModule module = (IPluggableModule)Activator.CreateInstance(modulesHandler[i]);
                        module.Execute();
                    }
                    Thread.Sleep(5 * 1000);
                }
            }
            catch(Exception exp)
            {
                // log it
            }
        }
 
        private static void LoadExistingModules()
        {
            DirectoryInfo dir = new DirectoryInfo(App_Modules_Path);
            FileInfo[] files = dir.GetFiles("*.dll");
 
            foreach (FileInfo file in files)
            {
                LoadAssembly(file.DirectoryName + "\\" + file.Name);
            }
        }
 
        private static bool CanLoad(string fileName)
        {
            try
            {
                if (File.Exists(fileName))
                {
                    FileStream stream = File.Open(fileName, FileMode.Open);
                    stream.Dispose();
                }
                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}

Using Reflection to create class instance from DLL for a specific interface

2009-04-14T14:51:00.000-07:00

An interface:

public interface IPluggableModule
{
    void Execute();
    string Name { get; set;}
}

public class PluggableModuleA: IPluggableModule
{
    string m_name=string.Empty;

    void IPluggableModule.Execute()
    {
        // Module A execute implementation
        Console.WriteLine("Module A execute implementation");
    }

    string IPluggableModule.Name
    {
        get
        {
            return "PluggableModuleA";
        }
        set
        {
            m_name = value;
        }
    }
}

The loader:

private static void LoadAssembly(string fileName)
{
    try
    {
        System.Reflection.Assembly assembly = System.Reflection.Assembly.LoadFile(fileName);

        foreach (Type type in assembly.GetTypes())
        {
            Type moduleInterface = type.GetInterface("IPluggableModule");

            if (moduleInterface != null)
            {
                IPluggableModule module = (IPluggableModule)Activator.CreateInstance(type);

                module.Execute(); // 
            }
        }
    }

    catch (Exception exp)
    {
        // log it
    }
}

Synchronized collection class

2009-04-14T12:11:00.000-07:00

Provides a thread-safe collection that contains objects of a type specified by the generic parameter as elements.

public class PluggableModulesHandler<T>
{
    private static List<T> m_moduls = null;
    private static PluggableModulesHandler<T> m_instance = null;
    private static object syncObj = new object();

    private PluggableModulesHandler()
    {
        m_moduls = new List<T>();
    }

    public static PluggableModulesHandler<T> Instance
    {
        get
        {
            if (m_instance == null)
            {
                lock (syncObj)
                {
                    if (m_instance == null)
                        m_instance = new PluggableModulesHandler<T>();
                }
            }
            return m_instance;
        }
    }
 
    public void Add(T obj)
    {
        lock (syncObj)
        {
            m_moduls.Add(obj);
        }
    }

    public void Remove(T obj)
    {
        lock (syncObj)
        {
            m_moduls.Remove(obj);
        }
    }

    public T this[int index]
    {
        get 
        { 
            lock (syncObj) 
            { 
                return m_moduls[index]; 
            } 
        }
    }

    public int Count 
    { 
        get 
        {
            lock (syncObj) 
            {
                return m_moduls.Count; 
            } 
        } 
    }
}

static void Main()
{
    PluggableModulesHandler<string>.Instance.Add("Module A");
    PluggableModulesHandler<string>.Instance.Add("Module B");
    PluggableModulesHandler<string>.Instance.Add("Module C");

    Console.WriteLine("Number of modules: " + PluggableModulesHandler<string>.Instance.Count);
    Console.WriteLine("Modules:\n");

    for (int i = 0; i < PluggableModulesHandler<string>.Instance.Count; ++i)
    {
        Console.WriteLine(PluggableModulesHandler<string>.Instance[i]);
    }
}

NET Framework 3.5, 3.0 equivalent: SynchronizedCollection(T) Class

The way to receive command line arguments for the current process

2009-04-14T09:20:00.000-07:00

    string[] args = System.Environment.GetCommandLineArgs();

window.showModalDialog and Postbak problem

2009-04-14T08:25:00.000-07:00

According to MSDN, A modal dialog box retains the input focus while open. The user cannot switch windows until the dialog box is closed.

A strange bug (or feature) takes place when you make a postback inside modal dialog box:
after the postback, a page is duplicated to in a new browser window.

Solution is to add <base target='_self' /> inside the HEAD tag:

<head runat="server">

    <title></title>

    <base target='_self' />

</head>

When you use window.showModalDialog to show content which resident inside MasterPage container or you need to add a base tag dinamicly use:

this.Page.Header.Attributes.Add(new LiteralControl("<base target='_self' />"));

in Page_Load method.

Free online image editors

2009-04-13T10:53:00.000-07:00

http://www.sumopaint.com/app/
http://www.pixlr.com/editor/
http://fotoflexer.com/app/

Identity insert/update workarounds

2009-04-13T09:05:00.000-07:00

Many times during my work I needed to insert specific identity number or update an existing identity column.

Here are some solutions:

Let’s create a test table:

CREATE TABLE [dbo].[Configuration]
(
        [Id] [int] PRIMARY KEY IDENTITY(1,1) NOT NULL,
        [Key] [nvarchar](50) NOT NULL,
     [Value] [nvarchar](max) NOT NULL,
        [Description] [nvarchar](max) NULL,
)

Insert some values:

INSERT INTO [Configuration]([Key], [Value], [Description])
                    VALUES('Application_Thread_Timeout' ,'2000' ,'')
 

INSERT INTO [Configuration]([Key], [Value], [Description])
                VALUES('Application_Path' ,'http://progfeatures.blogspot.com' ,'')

Here is what happens if I’ll try to insert a new config key with Id = 1000:

INSERT INTO [Configuration]([Id], [Key], [Value], [Description])
                    VALUES(1000,'Application_Log_BackUp_File' ,'SomeName' ,'')
 

-----------------------------------------------------------------
Msg 544, Level 16, State 1, Line 2
Cannot insert explicit value for identity column in table 'Configuration' when IDENTITY_INSERT is set to OFF.

The solution is to use IDENTITY_INSERT keyword:

SET IDENTITY_INSERT [Configuration] ON

INSERT INTO [Configuration]([Id], [Key], [Value], [Description])
                 VALUES(1000,'Application_Log_BackUp_File' ,'SomeName' ,'')

SET IDENTITY_INSERT [Configuration] OFF

How to update Identity:

Unfortunately we cannot update existing identity
without some tricks.

First trick is to save the relevant row in temporary variable,
delete the real row, and then insert the temporary row with new identity:

DECLARE @Configuration TABLE 
(

    [Id] int,
    [Key] nvarchar(50),
    [Value] nvarchar(max),
    [Description] nvarchar(max)
)

INSERT INTO @Configuration Select 1000, [Key], [Value], [Description] FROM [Configuration]
    WHERE [Configuration].[Key] LIKE 'Application_Thread_Timeout'
 
-- Now @Configuration contains the desired row
SELECT * FROM @Configuration

DELETE FROM Configuration 
    WHERE [Configuration].[Key] LIKE 'Application_Thread_Timeout'


SET IDENTITY_INSERT [Configuration] ON

   -- Insert a temp row with a new identity (1000)
   INSERT INTO [Configuration]([Id], [Key], [Value], [Description])
                   Select [Id], [Key], [Value], [Description] FROM @Configuration

SET IDENTITY_INSERT [Configuration] OFF

SELECT * FROM Configuration

Another trick to update Identity:

Right click on the table in the "Object Explorer"
Select "Design" option
Select the identity row and set the "Is Identity" property to false

Now you can insert/update the way you like.

Exception handling in SQL

2009-04-12T11:13:00.000-07:00

Many modern languages such as C++, Java, C#, Ada and many others contains Exception handling mechanism.
It designed to handle the occurrence of special conditions that change the normal flow of execution.

Why should use we Exception handling in SQL?

Exceptions handling mechanism can handle errors generated in stored procedures and triggers. It can be very useful for Transactions.

Here are some examples:

A divide-by-zero error:

BEGIN TRY
SELECT 1/0;
END TRY
BEGIN CATCH
SELECT
   ERROR_NUMBER() AS ErrorNumber,
   ERROR_SEVERITY() AS ErrorSeverity,
   ERROR_STATE() AS ErrorState,
   ERROR_PROCEDURE() AS ErrorProcedure,
   ERROR_LINE() AS ErrorLine,
   ERROR_MESSAGE() AS ErrorMessage;
END CATCH

Call a stored procedure which selects values from unexisting table:


CREATE PROCEDURE SP_SelectUsers
AS
 select Users.name from Users
GO

BEGIN TRY
 exec SP_SelectUsers
END TRY
BEGIN CATCH
  SELECT
     ERROR_NUMBER() AS ErrorNumber,
     ERROR_SEVERITY() AS ErrorSeverity,
     ERROR_STATE() AS ErrorState,
     ERROR_PROCEDURE() AS ErrorProcedure,
     ERROR_LINE() AS ErrorLine,
     ERROR_MESSAGE() AS ErrorMessage;
END CATCH

TRY…CATCH block inside a transaction:


-- insert values to unexisting table:
CREATE PROCEDURE SP_InsertTaskValue
AS
  INSERT INTO Tasks values('some value')
GO

BEGIN TRANSACTION;

BEGIN TRY
  exec SP_InsertTaskValue
END TRY
BEGIN CATCH
   SELECT
      ERROR_NUMBER() AS ErrorNumber,
      ERROR_SEVERITY() AS ErrorSeverity,
      ERROR_STATE() AS ErrorState,
      ERROR_PROCEDURE() AS ErrorProcedure,
      ERROR_LINE() AS ErrorLine,
      ERROR_MESSAGE() AS ErrorMessage;

  IF @@TRANCOUNT > 0
      ROLLBACK TRANSACTION;
END CATCH;

IF @@TRANCOUNT > 0
  COMMIT TRANSACTION;

Unfortunately, Exceptions handling has its weaknesses.
Here are the conditions that unaffected by a TRY…CATCH construct:

Warnings or informational messages that have a severity of 10 or lower.
Errors that have a severity of 20 or higher that stops the SQL Server Database Engine task processing for the session.
Attentions, such as client-interrupt requests or broken client connections.
When the session is ended by a system administrator by using the KILL statement.
Compile errors, such as syntax errors, that prevent a batch from running.
Errors that occur during statement-level recompilation.

Set variables with the SELECT statement

2009-04-12T10:11:00.000-07:00

An alternative way to set variables:


DECLARE @Year int, @Month nvarchar(10), @Day nvarchar(10)

SELECT @Year = 2008, @Month = 'April', @Day = 'Friday'

SELECT @Year as Year, @Month as Month , @Day as Day

Year        Month      Day
----------- ---------- ----------
2008        April      Friday

DECLARE @Id int, @UserName nvarchar(15), @Password nvarchar(15)

SELECT @Id = Id
  ,@UserName = UserName
  ,@Password = Password
FROM Users

SELECT @Id ,@UserName ,@Password
FROM Users

Ho to modifying global configuration settings for the current server

2009-04-12T07:23:00.000-07:00

If you need to modify global configuration settings such as: maximum server memory",
"remote login timeout", "user maximum connections" and many others, you can use
sp_configure stored procedure.

Basically sp_configure updates the sys.sysconfigures view which contains one row for each
configuration option set by a user. sysconfigures contains the configuration options that
are defined before the most recent startup of SQL Server, plus any dynamic configuration
options set since then.

You can run sp_configure without params to see all configuration key names.
*The list of all configuration options.

Example:

Let's say that I would like to limit the maximum number of simultaneous user connections allowed on an instance of SQL Server. Therefore I need to use the "user connections option is an advanced setting. If you are using the sp_configure system stored procedure to change the setting, you can change user connections only when show advanced options is set to 1 (*The setting takes effect after the server is restarted).

The "user connections" option is an advanced setting. In order to change it you need to set "show advanced options" to 1.

sp_configure 'show advanced options', 1;
RECONFIGURE WITH OVERRIDE

Then run:

sp_configure 'user connections', 255
RECONFIGURE WITH OVERRIDE

Restart SQL Server for this change to take effect.

Another way of see and change user connections:

1. In Object Explorer, right-click a server and click Properties.
2. Click the Connections node.
3. Under Connections, in the Max number of concurrent connections box, type or select a value to set the maximum number of users that are allowed to connect simultaneously to the instance of SQL Server.
4. Restart SQL Server.

TRANSACTIONS and Data Integrity

2009-04-11T14:24:00.000-07:00

That's not secret that all information system applications depend on data, and it's crucial for developers to keep it reliable and valid.

TRANSACTION is a mechanism for keeping Data Integrity and, stands for "Everything or Nothing" principal.
It have the following properties: atomic, consistent, isolated, and durable (ACID).

Atomic - Either all of the operations in the transaction succeed or none of the operations persist.

Consistent - If the data are consistent before the transaction begins, then they will be consistent after the transaction finishes.

Isolated - The effects of a transaction that is in progress are hidden from all other transactions.

Durable - When a transaction finishes, its results are persistent and will survive a system crash.

TRANSACTION means that only if every part of operation succeeds then a transaction can be committed, or it can be rolled back if any statement fails.

When to use a TRANSACTION?

Wheel it's important to use it whenever an operation must perform multiple modify actions (Insert, Update or Delete) spatially when one action depends on other.

Example:


CREATE PROCEDURE SP_TransactionTest
(
@UserName nvarchar(20)
,@Password int
,@TaskId int
)
AS
BEGIN
BEGIN TRANSACTION;

UPDATE Users
SET UserName = @UserName, Password = @Password
Where TaskId = @TaskId

INSERT INTO Tasks(TaskName)
VALUES ('Some Value')

IF @@ROWCOUNT > 0 AND @@ERROR = 0
BEGIN
COMMIT TRANSACTION
SELECT 1
END

ELSE
BEGIN
ROLLBACK TRANSACTION
SELECT 0
END
END

Prefer using IDENT_CURRENT over @@Identity and SCOPE_IDENTITY

2009-04-11T09:18:00.000-07:00

When you look at IDENT_CURRENT, @@Identity and SCOPE_IDENTITY it seams that they do same job.
All three functions return last-generated identity values. However each of these functions differ.

IDENT_CURRENT returns the last identity value generated for a specific table in any session and any scope. The function returns NULL when the function is invoked on an empty table or on a table that has no identity column.

@@IDENTITY returns the last identity value generated for any table in the current session, across all scopes.

SCOPE_IDENTITY returns the last identity value generated for any table in the current session and the current scope.

Here is a simple example:

Think about next scenario:
My application must perform an update action each time when a new user created in the system.
When new user is inserted into Users table its trigger executes and makes insert into Tasks table.

code:


CREATE TABLE Users
(
 Id int IDENTITY(5,1) NOT NULL,
 UserName nvarchar(15) NOT NULL,
 Password nvarchar(15) NOT NULL
)

GO
CREATE TABLE Tasks
(
Id int IDENTITY(1,1) NOT NULL,
TaskName nvarchar(50) NOT NULL
)

GO
CREATE TRIGGER Users_Trigger
ON Users AFTER INSERT
AS
BEGIN

INSERT INTO Tasks(TaskName)
   VALUES (IDENT_CURRENT('Users'))

END

a test query:

 INSERT INTO Users(UserName,Password)
VALUES ('DavidLibinson','111111')

SELECT @@Identity as '@@Identity'

SELECT SCOPE_IDENTITY() as 'SCOPE_IDENTITY'

SELECT IDENT_CURRENT('Tasks') as 'IDENT_CURRENT'

The result:

 (1 row(s) affected)
@@Identity
---------------------------------------
1

(1 row(s) affected)
SCOPE_IDENTITY
---------------------------------------
5

(1 row(s) affected)
IDENT_CURRENT
---------------------------------------
1

When you use IDENT_CURRENT it always returns the last identity value generated for a specific table in any session and any scope!

*Failed statements and transactions can change the current identity for a table and create gaps in the identity column values. The identity value is never rolled back even though the transaction that tried to insert the value into the table is not committed.

How to create GUID in MS SQL

2009-04-11T06:05:00.000-07:00

NewID - function creates a unique value of type uniqueidentifier.

Example:

select NewID()
------------------------------------
6D4C17C3-5EBD-4261-B05C-BA1A88852F38

(1 row(s) affected)

sp_help and sp_helptext

2009-04-11T03:19:00.000-07:00

Some times during the development process you need to see a definitions, dependencies or source code of user-defined rules (such as stored procedures, functions, views, tables, etc...).
From my experience I can tell that sometimes it takes allot of time to find it.

Fortunately, MS SQL provides a very useful stored procedures which can help us!

sp_help - Provides information about a database object, a user-defined data type, or a data type.

Syntax

sp_help [ [ @objname = ] name ]

Arguments

[@objname =] name

You can write object name, select it and use ALT+F1 shortcut to see it's definition.

___________________________________________________________

sp_helptext - Displays the definition (source text) of a user-defined rule, default, unencrypted Transact-SQL stored procedure, user-defined Transact-SQL function, trigger, computed column, CHECK constraint, view, or system object such as a system stored procedure.

Syntax

sp_helptext [ @objname = ] 'name'

Arguments

[ @objname = ] 'name'

You can add sp_helptext to shortcut list: go to Tools -> Options, Environment -> Keyboard.
Type sp_helptext near to CTRL+F1, press OK button and restart the Microsoft SQL Server Management Studio.

How to kill user processes

2009-04-11T02:50:00.000-07:00

KILL function is commonly used to terminate a process that is blocking other important processes with locks, or a process that is executing a query that is using necessary system resources. System processes and processes running an extended stored procedure cannot be terminated.

In order to kill user process we must know it's session ID (spid).

Use sp_who stored procedure to find information about current Microsoft® SQL Server™ users and processes.

kill 51

The foundation stones of Object-Oriented Programming

2009-04-10T12:04:00.001-07:00

Allot of people in software engineering don't know what Object-Oriented Programming stands for.

Here are basic principles of OOP:

Encapsulation

Inheritance

Polymorphism

Generic programming

Encapsulation is the hiding of the internal mechanisms and data structures of a software component behind a defined interface, in such a way that users of the component only need to know what the component does, and cannot make themselves dependent on the details of how it does it. The purpose is to achieve potential for change: the internal mechanisms of the component can be improved without impact on other components, or the component can be replaced with a different one that supports the same public interface.

Inheritance is a way to form new classes using classes that have already been defined. The new classes, known as derived classes, take over (or inherit) attributes and behavior of the pre-existing classes, which are referred to as base classes. It is intended to help reuse existing code with little or no modification.

Polymorphism allows values of different data types to be handled using a uniform interface. The concept of parametric polymorphism applies to both data types and functions.

Generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters. This approach permits writing common functions or types that differ only in the set of types on which they operate when used, thus reducing duplication.

Win32 Serial Communication Programming

2009-04-10T05:56:00.000-07:00

Allot of embedded systems (Windows Ce, Windows Embedded) provide an API for working with Serial Communication protocols such as RS232, RS422 and RS485.

Initial steps for creating synchronies connection:

At first we must open communications port.
It can be made by using CreateFile function which can create a handle to a communications resource, such as the serial port (COM1 for example).

Next we need to set a Baud rate. Baud rate is a measure of how fast data are moving between systems that use serial communication (most modern embedded systems transmitting at 115,200 baud and higher).
SetCommState function configures a communications device according to the specifications in a device-control block.

In addition it is necessary to sets the time-out parameters for all read and write operations our communications device (we don't want to wait for response forever!).
SetCommTimeouts - is the right function for this.

Now you can send and receive data!
In many applications developers preferred not to close a handle after one transition.
Single handle can be used for multiple I/O transitions.

Here is a simple class for synchronies serial communications:

SerialAPI.h

#include <windows.h>
class SerialAPI
{
public:
   SerialAPI(int portNumber);
   virtual ~SerialAPI(void);
  
   virtual bool    Write(const void *buf,int length);
   virtual bool    Read(void *buf,int length);
   virtual bool    SetBaudRate(int rate);   
   virtual bool    SetTimeout(int timeoutMs);
   virtual bool    Connect();
   virtual bool    Disconnect();

   inline bool        IsConnected()const{return m_isConnected;}
   inline HANDLE    GetHandle()const{return m_handle;}

private:
   TCHAR    m_portNumberName[15];
   bool    m_isConnected;
   HANDLE    m_handle;

private:   
   SerialAPI(SerialAPI&);
   SerialAPI& operator=(SerialAPI&);

};

SerialAPI.cpp

#include "SerialAPI.h"
#include <stdio.h>


SerialAPI::SerialAPI(int portNumber)
{   
   _stprintf(m_portNumberName,_T("COM%d:"),portNumber);
   Connect();
}

SerialAPI::~SerialAPI(void)
{
   Disconnect() ;
}

bool SerialAPI::Write(const void *buf, int length)
{
   DWORD bufLength    = length, bytesWritten = 0;

   if (!WriteFile(m_handle, (LPVOID)buf, bufLength, &bytesWritten, 0) || length != bytesWritten)
       return false;
   return true;
}

bool SerialAPI::Read(void *buf,int length)
{
   DWORD bufLength    = length, bytesRead    = 0;

   if (!ReadFile(m_handle, (LPVOID)buf, bufLength, &bytesRead, 0) || length != bytesRead)
       return false;
   return true;
}

bool SerialAPI::SetBaudRate(int rate)
{
   DCB PortDCB;
   PortDCB.DCBlength = sizeof(DCB);

   if (!GetCommState (m_handle, &PortDCB))
       return false;

   PortDCB.BaudRate = (DWORD)rate;         

   if (!SetCommState(m_handle, &PortDCB))
       return false;

   return true;
}

bool SerialAPI::SetTimeout(int timeoutMs)
{
   COMMTIMEOUTS CommTimeouts;

   if (!GetCommTimeouts(m_handle, &CommTimeouts))
       return false;

   CommTimeouts.ReadTotalTimeoutConstant    = timeoutMs;   
   CommTimeouts.WriteTotalTimeoutConstant    = timeoutMs;   

   if (!SetCommTimeouts(m_handle, &CommTimeouts))
       return true;
}

bool SerialAPI::Connect()
{
   if (m_isConnected)
       return false;

   m_handle = CreateFile (m_portNumberName,        // Pointer to the name of the port
                     GENERIC_READ | GENERIC_WRITE,    // Access (read-write) mode
                     0,                            // Share mode
                     NULL,                            // Pointer to the security attribute
                     OPEN_EXISTING,                // How to open the serial port
                     0,                            // Port attributes
                     NULL);                        // Handle to port with attribute to copy

   if (m_handle == INVALID_HANDLE_VALUE)
       return false;

   m_isConnected = true;

   return true;
}

bool SerialAPI::Disconnect()
{
   if (m_isConnected)
   {
       if (!CloseHandle(m_handle))
           return false;

       m_handle = INVALID_HANDLE_VALUE;
   }

   m_isConnected = false;

   return true;
}

Asynchronous read operations on StandardOutput

2009-04-09T15:47:00.000-07:00

Requirement:

An application must perform Anti-Virus scan for all newly downloaded files.
In order to make sure that files are not infected, the application can use N number of Anti-Virus software applications by using their API.

To learn about how to redirect process standard output/input read my previos post "Redirecting process standard output/input".

To start asynchronous read operations, you must redirect the StandardOutput stream of a Process, add your event handler to the OutputDataReceived event, and call BeginOutputReadLine.

Example:

public class Scanner{

   private static object _syncOutput = new object();

   public void Scan()
   {
        Process process = new Process();
        process.StartInfo.Arguments = "C:\\GridView_Example.zip";
        process.StartInfo.FileName = "F:\\ESET NOD32 Antivirus\\ecls.exe";
        process.StartInfo.WorkingDirectory = "F:\\ESET NOD32 Antivirus\\";

        // must be set to false to perform redirect actions
        process.StartInfo.UseShellExecute = false;  
        process.StartInfo.CreateNoWindow = true;
        process.StartInfo.RedirectStandardOutput = true;
        process.StartInfo.RedirectStandardError = true;
 
        process.OutputDataReceived += new DataReceivedEventHandler(OutputHandler);

        if (process.Start())
        {
                process.BeginOutputReadLine();
                process.WaitForExit();
        }
        process.Close();
   }

   private static void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine)
   {
       if (!string.IsNullOrEmpty(outLine.Data))
       {
          lock (_syncOutput)
          {
              Console.WriteLine("Output: " + outLine.Data);
          }
       }
   }
}

Redirecting process standard output/input

2009-04-09T12:35:00.000-07:00

In my experience I needed to write an application which executed Microsoft DOS commands.
In addition the application had to analyze DOS command's output.

So basically the idea was to get a handle of command's console window, insert input and read command's output.

Fortunately, System.Diagnostics namespace offers allot of system handle classes:
System.Diagnostics.Process and System.Diagnostics.ProcessStartInfo

string command = "ping";
string arguments = "http://progfeatures.blogspot.com";

System.Diagnostics.Process process = new Process();

process.StartInfo.FileName = "cmd";
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardInput = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;

if (process.Start())
{
     process.StandardInput.WriteLine(command + " " + arguments);
     process.StandardInput.Close();
     process.WaitForExit(this.MaxTimeOut);
     AnalyzeResult(process.StandardOutput.ReadToEnd());
}         
process.Close();

When a Process writes text to its standard stream, that text is typically displayed on the console. By redirecting the StandardOutput stream, we can manipulate or suppress the output of a process.

ProcessStartInfo.RedirectStandardOutput Property:
Gets or sets a value that indicates whether the output of an application is written to the Process.StandardOutput stream.


private void AnalyzeResult(string output)
{
    Console.WriteLine(output);
    // any action...
}

Output result:

Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

G:\ConsoleApplication1\bin\Debug>ping http://progfeatures.blogspot.com

Pinging blogspot.l.google.com [209.85.227.191] with 32 bytes of data:

Reply from 209.85.227.191: bytes=32 time=115ms TTL=242
Reply from 209.85.227.191: bytes=32 time=109ms TTL=242
Reply from 209.85.227.191: bytes=32 time=109ms TTL=242
Reply from 209.85.227.191: bytes=32 time=109ms TTL=242

Ping statistics for 209.85.227.191:
Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
Minimum = 109ms, Maximum = 115ms, Average = 110ms

Running processes from my application

2009-04-09T10:27:00.000-07:00

A simple way of running executables from C# application:

System.Diagnostics.Process process = new System.Diagnostics.Process();

process.StartInfo.Arguments = "";
process.StartInfo.FileName = "calc";
process.StartInfo.WorkingDirectory = "C:\\WINDOWS\\system32\\";
process.StartInfo.UseShellExecute = true;
 
if (process.Start())
   process.WaitForExit();

process.Close();

10 Tips for Writing High-Performance Web Applications

2009-04-09T09:00:00.000-07:00

Useful performance tips and tricks for ASP.NET:

Tip 1—Return Multiple Resultsets
Tip 2—Paged Data Access
Tip 3—Connection Pooling
Tip 4—ASP.NET Cache API
Tip 5—Per-Request Caching
Tip 6—Background Processing
Tip 7—Page Output Caching and Proxy Servers
Tip 8—Run IIS 6.0 (If Only for Kernel Caching)
Tip 9—Use Gzip Compression
Tip 10—Server Control View State

debugger - The JavaScript debugging.

2009-04-08T23:11:00.000-07:00

Many Web developers adding alert() snippets at strategic points in the Client-side code.
Sometimes we use these prompts to see the values of certain variables as the code progresses.
This process can take allot of time to replace the alert from section to section and reloading the page each time.

In order to do debug a Client-side scripts you can use the "debugger" keyword to invoke the Microsoft Script Debugger or Microsoft Visual Studio programmatically in the script code.

First you must disable the "Disable Script Debugging" in the Internet Explorer properties under "Advanced" section:

Insert keyword debugger in a place where debugging process should take place:

function PerformLogin(){

            debugger
             if(document.getElementById('iframeHolder'))
                     return true;

               return false;
}

And when an execution will hit the debugger point, a miracle will take place:

Programming Code formatting and highlight tool for my Blog

2009-04-08T15:25:00.000-07:00

A great tool for posting well-formatted programming code:

CopySourceAsHtml - is an add-in for Microsoft Visual Studio 2005/2008 that allows you to copy source code, syntax highlighting, and line numbers as HTML.

After downloading and installing the CopySourceAsHtml select, the relevant area of the code.
If it's a client-side code (.HTML, .ASPX, .JS, etc…) click on "Copy As Html" in the "Edit" section.

For a server-side code simply select a code and use right-mouse click to select the "Copy As Html" menu option:

Client-side Id of a Web Server Controls

2009-04-07T22:35:00.000-07:00

I think that it will be fair enough to say that each Web application must perform “client side” validations before making a post-back with a new input to Server.
In many cases when we use “Web Server Controls” the final control's ID is not the same as we gave it on the Server(especially when we use Master Pages and Web User Controls).

The ClientID value is often used to programmatically access the HTML element rendered for a control in client-side script.

Example:

Server-side:

<asp:Content ID="Content1" ContentPlaceHolderID="PlaceHolder1" Runat="Server">

    <asp:TextBox ID="TXT_UserName" runat="server"></asp:TextBox>

    <asp:Button ID="BTN_LogIn" runat="server" OnClientClick="return PerformLogin();" />

    <script type="text/javascript">

        function PerformLogin(){

            if(document.getElementById('TXT_UserName').value!='')

                return true;

            return false;

    </script>

</asp:Content>

Client-side result:

<input id="ctl00_PlaceHolder1_TXT_UserName" type="text" name="ctl00$PlaceHolder1$TXT_UserName"/>

<input id="ctl00_PlaceHolder1_BTN_LogIn" type="submit" onclick="return PerformLogin();" value="" name="ctl00$PlaceHolder1$BTN_LogIn"/>

As you can see, ASP.NET automatically generates a unique ClientID value for each server control on a page.
The ClientID value is generated by concatenating the ID value of the control and the UniqueID value of its parent control.

Use .ClientID property to get the real control’s Client-side ID:

function PerformLogin(){

            if(document.getElementById('<%=TXT_UserName.ClientID%>').value!='')

                return true;

            return false;

"foreach" iterating over an Enum

2009-04-07T12:46:00.000-07:00

The enum keyword is used to declare an enumeration, a distinct type consisting of a set of named constants.

In order to iterate over Enumeration (set of constants) we can use next functions:


enum Days { Sunday, Monday, Tuesday, Wednesday };

class Program
{
    static void Main()
    {
            Array daysValue = Enum.GetValues(typeof(Days));
            foreach (int i in daysValue)
                Console.WriteLine(i);

            string[] daysName = Enum.GetNames(typeof(Days));
            foreach (string str in daysName)
                Console.WriteLine(str);
    }
}

atexit - A way to perform tasks after the main function

2009-04-06T13:18:00.000-07:00

In many cases programmers face a situation where application must perform task/s after the main function.

For instance:

Memory/Resource Deallocation

Messaging/Notifications

Resource/s Updates

atexit - Processes the specified function at exit.

int atexit( void(__cdecl *func )( void ) );

Parameters:

func
Function to be called.

Return Value
atexit returns 0 if successful, or a nonzero value if an error occurs.

Accounting to MSDN:
Successive calls to atexit create a register of functions that are executed in last-in, first-out (LIFO) order.
The functions passed to atexit cannot take parameters.
atexit use the heap to hold the register of functions.
Thus, the number of functions that can be registered is limited only by heap memory.

An example:

void foo()
{
  printf("Hello World after the main function!");

}

void main()
{
   ---
    atexit(foo);
}

If you need to perform actions on DLL use _onexit which is a Microsoft extension.