For Those Who Matter

Install / Uninstall .NET Windows Service [C#]

2012-01-11T06:55:00.001-08:00

Install service using InstallUtil.exeTo install or uninstall windows service (which was created using .NET Framework) use utility InstallUtil.exe. This tool can be found in the following path (use appropriate framework version number).C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exeTo install .NET service run command similar to this (specify full path to your service).InstallUtil.exe "c:\myservice.exe"To uninstall .NET service use the same command with parameter /u.InstallUtil.exe /u "c:\myservice.exe"Install service programmaticallyTo install service programmatically using C# see the following class ServiceInstaller in c-sharpcorner.com article.

EBCIDIC vs ASCII

2011-12-22T10:41:00.000-08:00

Mainframes use the EBCDIC code set, while PCs use the ASCII codeset. The codeset refers to how the alphabet is coded internally in the computer. Each letter of the alphabet is represented by a value, and the EBCDIC and ASCII codesets assign different values to the alphabet. For example, the letter A is represented by the hexadecimal (hex) value 41 (65 decimal) in the ASCII codeset, and by the hex value C1 (193 decimal) in the EBCDIC code set.

In SQL, you can use "COLLATE SQL_EBCDIC037_CP1_CS_AS" to hint the SQL to use EBCDIC system to compare. The collate hint should be applied to the left of a comparision. For example,

If 'A' COLLATE SQL_EBCDIC037_CP1_CS_AS > 'a'
Print 'ok';

If 'A2222' COLLATE SQL_EBCDIC037_CP1_CS_AS Between 'Aaaaa' And 'A0000'
Print 'ok';

X509 certificate - Key distribution and authentication (how it works)

2011-01-17T06:23:00.000-08:00

These technologies use an X.509 certificate hierarchy with public-key cryptography to accomplish two tasks- Key Distribution and User Authentication.

Here is a simplified version of how this works: A public/private keypair (usually RSA) is generated by a CA. All private keys must be safeguarded by their owner against compromise. Public keys are incorporated into a certificate, which is a binding between an X.500 hierarchical name identity and a public key. Public keys (and likewise, certificates) do not need to be protected from disclosure to unauthorized parties (a.k.a. compromise), and can be distributed with software or by insecure electronic means, such as web sites, information servers, etc.

A user wishing to acquire an X.509 certificate also creates a keypair, safeguarding his private key. The public key is incorporated into a "certificate request", which is usually an email message to the CA requesting identity verification and the issuance of a certificate.

If approved, the CA returns to the user a certificate, signed by the CA. A signed certificate is simply the user's public key and X.509 identity encrypted with the CA's private key. Anyone who has access to a copy of the CA's certificate can verify the authenticity of the user's certificate by decrypting the user's certificate with the public key contained in the CA's certficate. Again, the actual implementation is more complicated, but here is a simplified version of how two entities perform mutual authentication: Both the client and server have valid copies of the issuing CA's certificate. A client informs the server that it wishes to mutually authenticate, so the parties exchange certificates Each party verifies the authenticity of the certificate by decrypting the infomation in the certificate with the public key of the CA. The server can then send some value to the client, encrypted with the public key of the client. Only the client can decrypt the ciphertext and read the value. The client performs a transformation of the value, and encrypts the result with the public key of the server and returns this information. Once the parties are satisfied as to the identity of the other party, it is possible to establish a secure connection between the client and server by negotiating a session key and security. Globus (and therefore, Condor) do not perform this final step of establishing a secure connection because of cryptographic export controls.

ASP.net permissions to root certificate store

2011-01-16T14:21:00.000-08:00

Generally you give permissions to A certificate. I use a method like this to find the custom made cert and grant permissions. If you are using a cert issued by a public entity like Verisign, Thawte, etc, this is probably unnecessary.

FindPrivateKey.exe My LocalMachine –n "CN=" ...will find certificates on the local machine in the personal store for a particular issuer.

Note: If FindPrivateKey is not on your local machine, download the WCF samples, including the FindPrivateKey tool, at http://www.microsoft.com/downloads/details.aspx?FamilyId=2611A6FF-FD2D-4F5B-A672-C002F1C09CCD&displaylang=en

FindPrivateKey returns the location of the private key for the certificate, similar to

"C:\Documents and Settings\All Users\Application Data\Microsoft\Crypto\RSA\Machinekeys\4d657b73466481beba7b0e1b5781db81_c225a308-d2ad-4e58-91a8-6e87f354b030". Run the following command line to assign read only access permissions to the process identity of the ASP.NET/WCF Service

cacls.exe "C:\Documents and Settings\All Users\Application Data\Microsoft\Crypto\RSA\Machinekeys\4d657b73466481beba7b0e1b5781db81_c225a308-d2ad-4e58-91a8-6e87f354b030" /E /G "NT AUTHORITY\NETWORK SERVICE":R NOTE: If you are running Microsoft Windows® XP, give the certificate permissions for the ASPNET identity instead of the NT Authority\Network Service identity, because the IIS process runs under the ASPNET account in Windows XP.

Certificates are viewable from the MMC snap in for Certificates. Open MMC, choose File --> Add/Remove Snap in, click the add button and choose certificates. From here you will need to choose the appropriate store (usually Computer Account - Local Computer for ASP.NET items) to manage and then you can view/admin the certs.

Please take a good hard look at the different command line options, and make sure that you have a clear understanding of what certificates are and how they work before granting any permissions.

create test certificate

2011-01-13T18:56:00.000-08:00

http://blog.functionalfun.net/2008/05/how-to-create-server-certificate-for.html

http://www.devproconnections.com/article/security-development/working-with-certificates.aspx

How to debug and send certificates in .net
http://www.kerrywong.com/2006/12/01/using-x509-certificate-with-web-service-in-aspnet/

How can I start the Certificate Manager on Windows XP?

2011-01-13T13:34:00.001-08:00

The certificate manager is implemented as a Management Console Snap-in Control (MSC) file. The application can be started as certmgr.msc

Below is a list of other management console Snap-in controls. They are all in \Windows\System32

You can start them from the start menu, by clicking on 'run' and then entering the desired command, e.g. certmgr.msc.

How browser verify SSL certificate

2011-01-12T12:27:00.000-08:00

What is browser compatibility?

The certificate that you purchase to secure your web site must be digitally signed by another certificate that is already in the trusted store of your user's web browsers. By doing this, the web browser will automatically trust your certificate because it is issued by someone that it already trusts. If it isn't signed by a trusted root certificate, or if links in the certificate chain are missing, then the web browser will give a warning message that the web site may not be trusted.

So browser compatibility means that the certificate you buy is signed by a root certificate that is already trusted by most web browsers that your customers may be using. Unless otherwise noted, the certificates from all major certificate providers listed on SSL Shopper are compatible with 99% of all browsers. For more details about a specific certificate provider, see SSL Certificate Compatibility.

How does ASP.NET know a session has been authorized?

2010-12-31T12:13:00.000-08:00

The server looks for an authentication cookie. If it fails to find the authentication cookie, the user is redirected to the configured logon page (Login.aspx), as specified by the LoginUrl attribute of the forms element.

The FormsAuthentication class creates the authentication cookie automatically when the FormsAuthentication.SetAuthCookie or FormsAuthentication.RedirectFromLoginPage methods are called.

If your application is configured to use cookieless forms authentication and the FormsAuthentication.RedirectFromLoginPage method is being used, then the FormsAuthenticationModule class automatically sets the forms authentication ticket in the URL.

Show CONNECTION tab in IE

2010-11-23T07:23:00.000-08:00

[HKEY_CURRENT_USER\Software\Policies\Microsoft\Internet Explorer\Control Panel]"ConnectionsTab"=dword:00000000

OR

[HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Internet Explorer\Control Panel]"ConnectionsTab"=dword:00000000

Creating/Using a Microsoft Data Link (.udl) File

2010-09-16T09:34:00.000-07:00

To create a .udl file:

1. Create an empty text file with the extension .udl.

2. From Windows Explorer, double-click on your new file to open the Data Link

3. In the Data Link Properties dialog box, enter the connection information that is required to open an ADO Connection object.

4. Click OK to save the .udl file with the information that you entered.

Sample Code That Shows How to Reference the File

The following sample code shows you how to reference the file in the ConnectionString property of a Connection object. It requires that you reference the Microsoft ActiveX Data Objects Library.

Dim obConnection As New ADODB.Connection
obConnection.ConnectionString = "File Name=c:\mydir\myfile.udl"
obConnection.Open

Note: You can also refer to the .udl file in the Visual Basic DataEnvironment tool.

Register WCF with IIS

2010-09-01T07:38:00.000-07:00

In order to host a WCF service in IIS, WCF should be registered correctly with IIS. If you install .Net 3 (or 3.5) after IIS this will happen automatically; however, if you install IIS on a system which already containz .Net 3 then a manual registration for WCF is needed as explain by (http://msdn.microsoft.com/en-us/library/aa751792.aspx)

You need to run command prompt as administrator, and run the following command -

"%windir%\Microsoft.NET\Framework\v3.0\Windows Communication Foundation\ServiceModelReg.exe" -r -y

Convert Excel to DataSet

2010-07-13T11:16:00.000-07:00

public static DataSet ConvertExcelToDataSet(string sFileFullPath, string sSheetName, string tableName, bool bCleanupTable)
{
OleDbConnection conn = null;

try
{
sFileFullPath = GetFileFullPath();

DataSet oDataSet = new DataSet();

string dsn = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + sFileFullPath + @";Extended Properties=""Excel 8.0;HDR=" + (bCleanupTable ? "NO" : "YES") + @";IMEX=1""";
conn = new OleDbConnection(dsn);
conn.Open();
OleDbDataAdapter adapter = new OleDbDataAdapter("SELECT * FROM [" + sSheetName + "$]", conn);

adapter.FillSchema(oDataSet, SchemaType.Source, tableName);

foreach (DataColumn column in oDataSet.Tables[tableName].Columns)
column.DataType = typeof(string);

adapter.Fill(oDataSet, tableName);

DataTable table = oDataSet.Tables[tableName];
if (bCleanupTable)
CleanupExcelData(table);

return oDataSet;
}
finally
{
if (conn != null)
conn.Close();
}
}

Microsoft Web Server Clustering

2010-06-23T12:42:00.000-07:00

WLBS (Windows NT Load Balancing Service) is used in Windows NT 4.0

NLB (Network Loading Balancing) is included in the Windows Server 2003 family, Windows 2000 Standard Server SP 3 and later, Windows 2000 Advanced Server, and Windows 2000 Datacenter Server.

Search Key Words in the Stored Procedures

2010-01-19T09:38:00.001-08:00

SELECT ROUTINE_NAME, ROUTINE_DEFINITION
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_DEFINITION LIKE '%keywords%'
AND ROUTINE_TYPE='PROCEDURE'

Visual Studio 2005 ToolBox not showing Reporting Services tools

2010-01-16T05:56:00.000-08:00

"Try rebuilding your toolbox items.

Locate the directory %USERPROFILE%\Local Settings\Application Data\Microsoft\VisualStudio\8.0 and delete the four (hidden) files: toolbox.tbd, toolbox_reset.tbd, toolboxIndex.tbd, toolboxIndex_reset.tbd. Start VS and open the toolbox (This will take a while). Note: You lose all user-added items from the toolbox.
"

ADO.NET Query Execution time is 10 times slower than via Query Analyzer

2009-11-25T10:34:00.000-08:00

Try cleaning out procedure cache and memory buffers in QA
DBCC DROPCLEANBUFFERS
DBCC FREEPROCCACHE

Doing so before you test your query in QA prevents usage of cached execution plans and previous results cache.

MS SQL DB - Make it Case Insensitive

2009-11-24T12:38:00.000-08:00

ALTER DATABASE MyDatabase
COLLATE SQL_Latin1_General_CP1_CI_AS

Run the CMD as a delegate user account

2009-10-08T07:58:00.001-07:00

runas /user:bnysecurities\zhangh cmd

Where does ASPState Database store data?

2009-10-02T07:42:00.000-07:00

The default when creating the ASPState database with the command line tool, aspnet_regsql, is for data to be stored in the tempdb rather than in the ASPState db.

For others similarly unenlightened as I was:

C:\>aspnet_regsql -S servername -E -ssadd -sstype t

is for the temdb option, and:

C:\>aspnet_regsql -S servername -E -ssadd -sstype p

is for the persistent option.

LARGEADDRESSAWARE and Visual Studio

2009-09-10T08:58:00.000-07:00

To make the application use more than 2G memory, you need use LARGEADDRESSAWARE indicator when compiling.

To make Visual Studio large address aware:

1.Be sure to backup devenv.exe
2.Using the Visual Studio command prompt, navigate to C:\Program Files\Microsoft Visual Studio 9\Common7\IDE\
3.execute the following command:
1: editbin /LARGEADDRESSAWARE devenv.exe

By doing above, your studio will be able to use more than 2G memory.

In addition, "editbin /LARGEADDRESSAWARE " can be used against any managed assemblies. It will enable the assemblies use more than 2G memory.

3GB Switch in Windows boot.ini

2009-09-10T08:35:00.000-07:00

http://www.maxi-pedia.com/3GB+switch+Windows+boot.ini+3+GB

The /3GB or 3GB switch in the boot.ini file lets you tune the use of memory and memory address space in your computer. The /3GB switch specifies the amount of memory for user-mode virtual address space. It is used to allocate more memory to applications and less memory to the operating system.

The /3GB switch increases the size of the user process address space from 2 GB to 3 GB.

This can improve performance of servers that run virtual-memory-intensive applications. That is for example database servers. A larger address space can improve a database server performance.

How does the /3GB switch work?
By default Windows provides applications with a flat 32-bit virtual address space that describes 4 gigabytes of virtual memory. In other words, regardless of the amount of physical memory in your system (RAM), 32-bit versions of Windows only use a virtual address space of 4 GB.

The address space is split so that 2 GB of address space is directly accessible to user-mode processes (applications, for example your Opera Browser and the other 2 GB is only accessible to kernel-mode processes (Windows operating system, drivers, etc.).

The 32-bit versions of Windows were later in their production cycles improved to provide applications with a 3 GB flat virtual address space, with the kernel and executive components using only 1 GB.

This is accomplished by adding the /3GB switch to the boot.ini file. Adding the /3GB switch to the boot.ini file will not increase the amount of physical RAM memory, the 3GB switch just tells the computer to allocate the existing memory space differently.

The 3GB boot.ini switch is often used on Windows Server 2003 which includes support for the 3GB startup switch.

What is the benefit of using the 3GB switch?
Depending on what software you run on your server, it might make sense to optimize the server memory usage. If for example you are running only a few memory extensive large applications that do not interact with the operating system but rather work on their own, you might want to consider implementing this switch.

The additional virtual address space that you give applications with the 3GB switch helps reduce the amount of memory fragmentation in the virtual address space.

What values can the /3GB switch take?
The switch can have any value between 2048 (2 GB) and 3072 (3 GB) megabytes. It needs to be expressed in decimal notation.

With the switch, Windows will use the remaining address space (4 GB minus the specified amount) as its kernel-mode address space.

How do I find out what boot.ini options my server uses?
You can see this in the boot.ini file, of course. Another more detailed way is to research registry settings. In this case, you would go to the Start menu, click Run, type REGEDIT, and hit ENTER.

Locate the following registry keys section:

HKLM\System\CurrentControlSet\Control\SystemStartOptions

How do I set the /3GB switch in Windows Server 2003?
Setting the /3GB switch for your server is very easy. Execute the following steps:

-> right-click My Computer
-> Properties
-> click the Advanced tab
-> click Settings in the Startup and Recovery area
-> click Edit in the System startup area

This will open the Windows boot.ini file in Notepad. See the following print screen:

Locate the [Operating Systems] section and add the /3GB switch to the end of the startup line that includes the /fastdetect. Now you can save the changes, close Notepad, and click OK to close all the open dialog boxes.

You need to restart the computer for the change to take effect.

Boot.ini file /3GB switch example
This is what your default boot.ini file before you make the change might look like. The timeout and partition and other parameters depend on your setup. Pay attention to the line with the /fastdetect.

[boot loader]timeout=10default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS[operating systems]multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Windows Server 2003, Enterprise" /fastdetectAnd, below you can find what the boot.ini file should look like after making the change.

[boot loader]timeout=10default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS[operating systems]multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Windows Server 2003, Enterprise" /fastdetectmulti(0)disk(0)rdisk(0)partition(1)\WINDOWS="Windows Server 2003, Enterprise with /3GB" /3GB /fastdetectMake sure you do not enter a typo in this file as it might result in being unable to start your computer.

Do I need to reboot the server after adding the /3GB switch?
Yes, the /3GB switch entered in the system’s boot.ini file and takes effect after a restart.

Which operating systems support the 3GB switch?
The /3GB switch applies to 32-bit systems only. The following is a list of operating systems that support the 3GB switch:

Windows Server 2003 Standard Edition
Windows Server 2003 Enterprise Edition
Windows Server 2003 Datacenter Edition
Windows 2000 Advanced Server
Windows 2000 Datacenter Server
This is a list of officially supported operating systems that can handle the 3GB switch. Other systems may or may not handle it well depending on the hardware and software configuration.

Can I use the /3GB switch on Windows XP?
Adding the 3GB switch to the boot.ini file in Windows XP SP1 can cause Windows not to start.

A supported fix is available from Microsoft, but it is only intended to correct the problem resulting from this specific setup. The solution to this problem is upgrade to the latest service pack. You can read more about this problem on the following Microsoft page:

Windows XP SP1 May Not Start with the /3GB or /USERVA Switch
http://support.microsoft.com/default.aspx?scid=kb;en-us;328269

Can I use the /3GB switch on Windows Server 2000?
The 3GB switch is officially supported on the 2000 Advanced Server. The official word is that it should not be used on Windows 2000 Server because it is unsupported and can cause application or operating system to crash.

Important warning
Any time you make a change to the boot.ini file, make sure that you have all your data backed up!

Are there any other boot.ini parameters that I should know about?
Yes, you might be interested in knowing about the /fastdetect switch: Fastdetect boot.ini switch.

The Data Execution Prevention DEP setting can be also implemented in your BOOT.INI file through the NOEXECUTE switch. See the noexecute DEP parameter in boot.ini page for more details.

Is my xp 32bit or 64 bit?

2009-09-10T08:19:00.001-07:00

Method 1
1. Click Start, click Run, type sysdm.cpl, and then click OK.
2. Click the General tab. The operating system appears as follows:
(For a 64-bit version operating system: Microsoft Windows XP Professional x64 Edition Version < Year> appears under System. For a 32-bit version operating system: Microsoft Windows XP Professional Version< Year> appears under System.) Note is a placeholder for a year.

Method 2
1. Click Start, click Run, type winmsd.exe, and then click OK.
2. In the details pane, locate Processor under Item. Note the value. (If the value that corresponds to Processor starts with x86, the computer is running a 32-bit version of the Windows operating system. If the value that corresponds to Processor starts with ia64 or AMD64, the computer is running a 64-bit version of the Windows operating system.)

.Net, 64bit and 32 bit

2009-09-10T07:22:00.000-07:00

Since .Net 2.0 was released, .Net started supporting 64bit programming.

'CorFlags.exe' is a tool for you to peek the information inside a PE. It can be used to check whether an assembly is targetting 32bit or 64bit.

Here's one sample query.

D:\Project\BookingSheet\BookingSheetUI\bin\Release>corflags bookingsheetui.exe

Version : v2.0.50727
CLR Header: 2.5
PE : PE32
CorFlags : 3
ILONLY : 1
32BIT : 1
Signed : 0

You can see that 32bit is set to 1 that means the exe is targetting 32bit.

You can use "corflags bookingsheetui.exe \32bit+" to enforce the assembly to target 32bit. You can also use "corflags bookingsheetui.exe \32bit-" to enforce the assembly not use 32bit.

An assembly that is targetting 32bit can also run at a 64bit WIN OS. It is called "WOW64".

Migrating a managed program involved unmanaged codes is more complicated.

Reactive Process Recycling

2009-08-25T13:15:00.000-07:00

Reactive process recycling occurs when a process is misbehaving or unable to serve requests.

Configuration settings that are related to this:

requestQueueLimit: Handles deadlock conditions. The DWORD value is set to the maximum allowed number of requests in the queue, after which the worker process is considered to be misbehaving. When the number is exceeded, a new process is launched and the requests are reassigned. The default is 5000 requests.

memoryLimit: Handles memory leak conditions. The DWORD value is set to the percentage of physical memory that the worker process can consume before it is considered to be misbehaving. When that percentage is exceeded, a new process is launched and the requests are reassigned. The default is 60%.

shutdownTimeout: Specifies the amount of time the worker process has to shut itself down gracefully (string value in hr:min:sec format). When the time out expires, the ASP.NET ISAPI shuts down the worker process. The default is "00:00:05".

Increase the memory limit

2009-08-25T12:46:00.000-07:00

1) Booting the OS into /3GB mode
2) Marking your assemblies as /LARGEADDRESSAWARE
3) There may not be a contiguous block of memory large enough to satisfy your allocation.
4) .NET imposes a 2GB object size limit, so trying to allocate an array larger than 2GB will fail.
5) The exe that will be published is first created in the obj\release or obj\debug directory, depending on if this is a release or debug build.
6) The postbuild is run before the .exe is copied to the bin\release\*.publish\publish version directory.
7) Postbuild commands: $(ProjectDir)postbuild.bat $(ProjectDir)obj\$(ConfigurationName)\$(TargetFileName) $(TargetPath)
8) Postbuild.bat file

echo off

call "%VS80COMNTOOLS%vsvars32.bat"

editbin /largeaddressaware %1

editbin /largeaddressaware %2

An Introduction to OLAP in SQL Server 2005

2009-08-19T07:36:00.000-07:00

http://www.devx.com/dbzone/Article/21410/0/page/3

•Determine the required dimensions (bys) and measures (target data) .
•Use Data Transformation Services to extract data from your source databases, transforming the data as needed, and loading the finished data into the cube.
•Use the BI Workbench's Analysis Services wizards to build the measures, dimensions, and schema.
•Provide cube browsers for your users so they can select and view reports. If necessary, write MDX queries or use automated tools, such as Excel Pivot Tables to query the cube.

try/catch/finally

2009-07-15T13:42:00.000-07:00

"try/catch/finally" is to handle unexpected exception so that the program will deterministic. But you have to be aware of that it only handle the codes that are in the block of "try".

How ASP.NET Works with IIS

2009-07-06T07:37:00.000-07:00

Svchost.exe is process that delivers Web publishing services (or in other words - iis). When an asp.net request comes, it will forward the request to asp.net working process - aspnet_wp.exe that is running under the account ASPNET.

DB schema design - char, varchar, nchar, nvarchar and text

2009-07-06T07:04:00.000-07:00

Database supplies mutilple field types to manage text data.

If the length of the data in a field is relatively fixed, you should use char.

If the length of the data varies, you should use varchar.

If the data is unicode (16 bits characters), you should nchar or nvarchar.

In old version, varchar and nvarchar can only hold chars no more than 8000 (?). In sql 2005 and future version, text, and ntext going to be replaced by varchar. (Image is replaced by varbinary(max)). Varchar(max) can hold 2(31) - 1 bytes or 2GB - 1 chars.

ODBC and OLE

2009-07-06T06:55:00.000-07:00

ODBC and OLE are both the utility for applications to connect to database. OLE is a native MS SQL server connector while ODBC is a general connector and can be used to connect to any Database that supports ODBC.

For performance reason, if you know you are connecting to MS SQL database, you can choose to use OLE as your connector.

WCF general

2009-07-02T08:51:00.000-07:00

From service developer point of view, here's some main points.

1)A service has to define a contract that is a interface. The contract defines the methods that are available for clients to use.

2)The interface has to be implemented of course.

3)In the service configuration file, you will define endpoint, binding and behaviors.

4)An endpoint defines the address, contract and binding. A binding defines the protocols, securities and so on. A behavior may define whether exception details should be sent to the client side when the service is in debug mode.

From a service client developer's point of view, the main points are:

1)Generate or define a proxy of the service.

2)Consume the service through the proxy.

3)In the client configuration file, you will define client and bindings. The client will include the definition of an end point and the binding will define the protocols used for the service.

WCF queue application

2009-07-01T10:38:00.000-07:00

First, MSMQ (microsoft message queue) has to be installed on the developer's machine.
If it is not there yet, it can be installed through "Control Panel". Choose add/remove programs and then choose add/remove windows component and check message queue.

If the queue runs locally, it is usually private queue.

Client side will still need a proxy. However, the codes have to be created manually since there's no contract between the client and the service. Each side interacts directly with the queue. The proxy still has the similar look as any other WCF's proxy.

The client posts message to queue through the proxy. The consumer side will dequeue the message and process it.

Creating a Partition View

2009-06-29T13:53:00.000-07:00

A partition view combines data from multiple tables into one. Partition view can take advantage existed indexes on the combined tables and only query table partition that contains the data and thus improves the searching efficiency.

To create a partition view, you just need add a CHECK constraint to the combined tables on a particular fields and therefore make sure there are no duplicate rows in the combined views.

IPhone 3G (8g, 16g and 32g)

2009-06-29T12:56:00.000-07:00

8G is only $99 that is $100 cheaper than 16g and $200 cheaper than 32g. However, the differences among the phones are not just the size of storage. 16G/32G has better camera and has video recording. They also have voice control and compass. 16G and 32G actually do no have much difference other than the storage size.

Questionnaire before buying a house

2009-03-21T11:12:00.000-07:00

http://www.criteriumhomeinspection.com/100questions.pdf
http://www.hud.gov/offices/hsg/sfh/buying/buyhm.cfm

Ten Common Database Design Mistakes

2007-11-14T08:35:00.001-08:00

Ten Common Database Design Mistakes
26 February 2007
by Louis Davidson
No list of mistakes is ever going to be exhaustive. People (myself included) do a lot of really stupid things, at times, in the name of "getting it done." This list simply reflects the database design mistakes that are currently on my mind, or in some cases, constantly on my mind.

NOTE:
I have done this topic two times before. If you're interested in hearing the podcast version, visit Greg Low's super-excellent SQL Down Under. I also presented a boiled down, ten-minute version at PASS for the Simple-Talk booth. Originally there were ten, then six, and today back to ten. And these aren't exactly the same ten that I started with; these are ten that stand out to me as of today.

Before I start with the list, let me be honest for a minute. I used to have a preacher who made sure to tell us before some sermons that he was preaching to himself as much as he was to the congregation. When I speak, or when I write an article, I have to listen to that tiny little voice in my head that helps filter out my own bad habits, to make sure that I am teaching only the best practices. Hopefully, after reading this article, the little voice in your head will talk to you when you start to stray from what is right in terms of database design practices.

So, the list:

Poor design/planning
Ignoring normalization
Poor naming standards
Lack of documentation
One table to hold all domain values
Using identity/guid columns as your only key
Not using SQL facilities to protect data integrity
Not using stored procedures to access data
Trying to build generic objects
Lack of testing
Poor design/planning
"If you don't know where you are going, any road will take you there" – George Harrison

Prophetic words for all parts of life and a description of the type of issues that plague many projects these days.

Let me ask you: would you hire a contractor to build a house and then demand that they start pouring a foundation the very next day? Even worse, would you demand that it be done without blueprints or house plans? Hopefully, you answered "no" to both of these. A design is needed make sure that the house you want gets built, and that the land you are building it on will not sink into some underground cavern. If you answered yes, I am not sure if anything I can say will help you.

Like a house, a good database is built with forethought, and with proper care and attention given to the needs of the data that will inhabit it; it cannot be tossed together in some sort of reverse implosion.

Since the database is the cornerstone of pretty much every business project, if you don't take the time to map out the needs of the project and how the database is going to meet them, then the chances are that the whole project will veer off course and lose direction. Furthermore, if you don't take the time at the start to get the database design right, then you'll find that any substantial changes in the database structures that you need to make further down the line could have a huge impact on the whole project, and greatly increase the likelihood of the project timeline slipping.

Far too often, a proper planning phase is ignored in favor of just "getting it done". The project heads off in a certain direction and when problems inevitably arise – due to the lack of proper designing and planning – there is "no time" to go back and fix them properly, using proper techniques. That's when the "hacking" starts, with the veiled promise to go back and fix things later, something that happens very rarely indeed.

Admittedly it is impossible to predict every need that your design will have to fulfill and every issue that is likely to arise, but it is important to mitigate against potential problems as much as possible, by careful planning.

Ignoring Normalization
Normalization defines a set of methods to break down tables to their constituent parts until each table represents one and only one "thing", and its columns serve to fully describe only the one "thing" that the table represents.

The concept of normalization has been around for 30 years and is the basis on which SQL and relational databases are implemented. In other words, SQL was created to work with normalized data structures. Normalization is not just some plot by database programmers to annoy application programmers (that is merely a satisfying side effect!)

SQL is very additive in nature in that, if you have bits and pieces of data, it is easy to build up a set of values or results. In the FROM clause, you take a set of data (a table) and add (JOIN) it to another table. You can add as many sets of data together as you like, to produce the final set you need.

This additive nature is extremely important, not only for ease of development, but also for performance. Indexes are most effective when they can work with the entire key value. Whenever you have to use SUBSTRING, CHARINDEX, LIKE, and so on, to parse out a value that is combined with other values in a single column (for example, to split the last name of a person out of a full name column) the SQL paradigm starts to break down and data becomes become less and less searchable.

So normalizing your data is essential to good performance, and ease of development, but the question always comes up: "How normalized is normalized enough?" If you have read any books about normalization, then you will have heard many times that 3rd Normal Form is essential, but 4th and 5th Normal Forms are really useful and, once you get a handle on them, quite easy to follow and well worth the time required to implement them.

In reality, however, it is quite common that not even the first Normal Form is implemented correctly.

Whenever I see a table with repeating column names appended with numbers, I cringe in horror. And I cringe in horror quite often. Consider the following example Customer table:

Are there always 12 payments? Is the order of payments significant? Does a NULL value for a payment mean UNKNOWN (not filled in yet), or a missed payment? And when was the payment made?!?

A payment does not describe a Customer and should not be stored in the Customer table. Details of payments should be stored in a Payment table, in which you could also record extra information about the payment, like when the payment was made, and what the payment was for:

In this second design, each column stores a single unit of information about a single "thing" (a payment), and each row represents a specific instance of a payment.

This second design is going to require a bit more code early in the process but, it is far more likely that you will be able to figure out what is going on in the system without having to hunt down the original programmer and kick their butt…sorry… figure out what they were thinking

Poor naming standards
"That which we call a rose, by any other name would smell as sweet"

This quote from Romeo and Juliet by William Shakespeare sounds nice, and it is true from one angle. If everyone agreed that, from now on, a rose was going to be called dung, then we could get over it and it would smell just as sweet. The problem is that if, when building a database for a florist, the designer calls it dung and the client calls it a rose, then you are going to have some meetings that sound far more like an Abbott and Costello routine than a serious conversation about storing information about horticulture products.

Names, while a personal choice, are the first and most important line of documentation for your application. I will not get into all of the details of how best to name things here– it is a large and messy topic. What I want to stress in this article is the need for consistency. The names you choose are not just to enable you to identify the purpose of an object, but to allow all future programmers, users, and so on to quickly and easily understand how a component part of your database was intended to be used, and what data it stores. No future user of your design should need to wade through a 500 page document to determine the meaning of some wacky name.

Consider, for example, a column named, X304_DSCR. What the heck does that mean? You might decide, after some head scratching, that it means "X304 description". Possibly it does, but maybe DSCR means discriminator, or discretizator?

Unless you have established DSCR as a corporate standard abbreviation for description, then X304_DESCRIPTION is a much better name, and one leaves nothing to the imagination.

That just leaves you to figure out what the X304 part of the name means. On first inspection, to me, X304 sounds like more like it should be data in a column rather than a column name. If I subsequently found that, in the organization, there was also an X305 and X306 then I would flag that as an issue with the database design. For maximum flexibility, data is stored in columns, not in column names.

Along these same lines, resist the temptation to include "metadata" in an object's name. A name such as tblCustomer or colVarcharAddress might seem useful from a development perspective, but to the end user it is just confusing. As a developer, you should rely on being able to determine that a table name is a table name by context in the code or tool, and present to the users clear, simple, descriptive names, such as Customer and Address.

A practice I strongly advise against is the use of spaces and quoted identifiers in object names. You should avoid column names such as "Part Number" or, in Microsoft style, [Part Number], therefore requiring you users to include these spaces and identifiers in their code. It is annoying and simply unnecessary.

Acceptable alternatives would be part_number, partNumber or PartNumber. Again, consistency is key. If you choose PartNumber then that's fine – as long as the column containing invoice numbers is called InvoiceNumber, and not one of the other possible variations.

Lack of documentation
I hinted in the intro that, in some cases, I am writing for myself as much as you. This is the topic where that is most true. By carefully naming your objects, columns, and so on, you can make it clear to anyone what it is that your database is modeling. However, this is only step one in the documentation battle. The unfortunate reality is, though, that "step one" is all too often the only step.

Not only will a well-designed data model adhere to a solid naming standard, it will also contain definitions on its tables, columns, relationships, and even default and check constraints, so that it is clear to everyone how they are intended to be used. In many cases, you may want to include sample values, where the need arose for the object, and anything else that you may want to know in a year or two when "future you" has to go back and make changes to the code.

NOTE:
Where this documentation is stored is largely a matter of corporate standards and/or convenience to the developer and end users. It could be stored in the database itself, using extended properties. Alternatively, it might be in maintained in the data modeling tools. It could even be in a separate data store, such as Excel or another relational database. My company maintains a metadata repository database, which we developed in order to present this data to end users in a searchable, linkable format. Format and usability is important, but the primary battle is to have the information available and up to date.

Your goal should be to provide enough information that when you turn the database over to a support programmer, they can figure out your minor bugs and fix them (yes, we all make bugs in our code!). I know there is an old joke that poorly documented code is a synonym for "job security." While there is a hint of truth to this, it is also a way to be hated by your coworkers and never get a raise. And no good programmer I know of wants to go back and rework their own code years later. It is best if the bugs in the code can be managed by a junior support programmer while you create the next new thing. Job security along with raises is achieved by being the go-to person for new challenges.

One table to hold all domain values
"One Ring to rule them all and in the darkness bind them"

This is all well and good for fantasy lore, but it's not so good when applied to database design, in the form of a "ruling" domain table. Relational databases are based on the fundamental idea that every object represents one and only one thing. There should never be any doubt as to what a piece of data refers to. By tracing through the relationships, from column name, to table name, to primary key, it should be easy to examine the relationships and know exactly what a piece of data means.

The big myth perpetrated by architects who don't really understand relational database architecture (me included early in my career) is that the more tables there are, the more complex the design will be. So, conversely, shouldn't condensing multiple tables into a single "catch-all" table simplify the design? It does sound like a good idea, but at one time giving Pauly Shore the lead in a movie sounded like a good idea too.

For example, consider the following model snippet where I needed domain values for:

Customer CreditStatus
Customer Type
Invoice Status
Invoice Line Item BackOrder Status
Invoice Line Item Ship Via Carrier
On the face of it that would be five domain tables…but why not just use one generic domain table, like this?

This may seem a very clean and natural way to design a table for all but the problem is that it is just not very natural to work with in SQL. Say we just want the domain values for the Customer table:

SELECT *FROM Customer JOIN GenericDomain as CustomerType ON Customer.CustomerTypeId = CustomerType.GenericDomainId and CustomerType.RelatedToTable = 'Customer' and CustomerType.RelatedToColumn = 'CustomerTypeId' JOIN GenericDomain as CreditStatus ON Customer.CreditStatusId = CreditStatus.GenericDomainId and CreditStatus.RelatedToTable = 'Customer' and CreditStatus.RelatedToColumn = ' CreditStatusId'
As you can see, this is far from being a natural join. It comes down to the problem of mixing apples with oranges. At first glance, domain tables are just an abstract concept of a container that holds text. And from an implementation centric standpoint, this is quite true, but it is not the correct way to build a database. In a database, the process of normalization, as a means of breaking down and isolating data, takes every table to the point where one row represents one thing. And each domain of values is a distinctly different thing from all of the other domains (unless it is not, in which case the one table will suffice.). So what you do, in essence, is normalize the data on each usage, spreading the work out over time, rather than doing the task once and getting it over with.

So instead of the single table for all domains, you might model it as:

Looks harder to do, right? Well, it is initially. Frankly it took me longer to flesh out the example tables. But, there are quite a few tremendous gains to be had:

Using the data in a query is much easier:
SELECT *FROM Customer JOIN CustomerType ON Customer.CustomerTypeId = CustomerType.CustomerTypeId JOIN CreditStatus ON Customer.CreditStatusId = CreditStatus.CreditStatusId
Data can be validated using foreign key constraints very naturally, something not feasible for the other solution unless you implement ranges of keys for every table – a terrible mess to maintain.
If it turns out that you need to keep more information about a ShipViaCarrier than just the code, 'UPS', and description, 'United Parcel Service', then it is as simple as adding a column or two. You could even expand the table to be a full blown representation of the businesses that are carriers for the item.
All of the smaller domain tables will fit on a single page of disk. This ensures a single read (and likely a single page in cache). If the other case, you might have your domain table spread across many pages, unless you cluster on the referring table name, which then could cause it to be more costly to use a non-clustered index if you have many values.
You can still have one editor for all rows, as most domain tables will likely have the same base structure/usage. And while you would lose the ability to query all domain values in one query easily, why would you want to? (A union query could easily be created of the tables easily if needed, but this would seem an unlikely need.)
I should probably rebut the thought that might be in your mind. "What if I need to add a new column to all domain tables?" For example, you forgot that the customer wants to be able to do custom sorting on domain values and didn't put anything in the tables to allow this. This is a fair question, especially if you have 1000 of these tables in a very large database. First, this rarely happens, and when it does it is going to be a major change to your database in either way.

Second, even if this became a task that was required, SQL has a complete set of commands that you can use to add columns to tables, and using the system tables it is a pretty straightforward task to build a script to add the same column to hundreds of tables all at once. That will not be as easy of a change, but it will not be so much more difficult to outweigh the large benefits.

The point of this tip is simply that it is better to do the work upfront, making structures solid and maintainable, rather than trying to attempt to do the least amount of work to start out a project. By keeping tables down to representing one "thing" it means that most changes will only affect one table, after which it follows that there will be less rework for you down the road.

Using identity/guid columns as your only key
First Normal Form dictates that all rows in a table must be uniquely identifiable. Hence, every table should have a primary key. SQL Server allows you to define a numeric column as an IDENTITY column, and then automatically generates a unique value for each row. Alternatively, you can use NEWID() (or NEWSEQUENTIALID()) to generate a random, 16 byte unique value for each row. These types of values, when used as keys, are what are known as surrogate keys. The word surrogate means "something that substitutes for" and in this case, a surrogate key should be the stand-in for a natural key.

The problem is that too many designers use a surrogate key column as the only key column on a given table. The surrogate key values have no actual meaning in the real world; they are just there to uniquely identify each row.

Now, consider the following Part table, whereby PartID is an IDENTITY column and is the primary key for the table:

PartID
PartNumber
Description

1
XXXXXXXX
The X part

2
XXXXXXXX
The X part

3
YYYYYYYY
The Y part

How many rows are there in this table? Well, there seem to be three, but are rows with PartIDs 1 and 2 actually the same row, duplicated? Or are they two different rows that should be unique but were keyed in incorrectly?

The rule of thumb I use is simple. If a human being could not pick which row they want from a table without knowledge of the surrogate key, then you need to reconsider your design. This is why there should be a key of some sort on the table to guarantee uniqueness, in this case likely on PartNumber.

In summary: as a rule, each of your tables should have a natural key that means something to the user, and can uniquely identify each row in your table. In the very rare event that you cannot find a natural key (perhaps, for example, a table that provides a log of events), then use an artificial/surrogate key.

Not using SQL facilities to protect data integrity
All fundamental, non-changing business rules should be implemented by the relational engine. The base rules of nullability, string length, assignment of foreign keys, and so on, should all be defined in the database.

There are many different ways to import data into SQL Server. If your base rules are defined in the database itself can you guarantee that they will never be bypassed and you can write your queries without ever having to worry whether the data you're viewing adheres to the base business rules.

Rules that are optional, on the other hand, are wonderful candidates to go into a business layer of the application. For example, consider a rule such as this: "For the first part of the month, no part can be sold at more than a 20% discount, without a manager's approval".

Taken as a whole, this rule smacks of being rather messy, not very well controlled, and subject to frequent change. For example, what happens when next week the maximum discount is 30%? Or when the definition of "first part of the month" changes from 15 days to 20 days? Most likely you won't want go through the difficulty of implementing these complex temporal business rules in SQL Server code – the business layer is a great place to implement rules like this.

However, consider the rule a little more closely. There are elements of it that will probably never change. E.g.

The maximum discount it is ever possible to offer
The fact that the approver must be a manager
These aspects of the business rule very much ought to get enforced by the database and design. Even if the substance of the rule is implemented in the business layer, you are still going to have a table in the database that records the size of the discount, the date it was offered, the ID of the person who approved it, and so on. On the Discount column, you should have a CHECK constraint that restricts the values allowed in this column to between 0.00 and 0.90 (or whatever the maximum is). Not only will this implement your "maximum discount" rule, but will also guard against a user entering a 200% or a negative discount by mistake. On the ManagerID column, you should place a foreign key constraint, which reference the Managers table and ensures that the ID entered is that of a real manager (or, alternatively, a trigger that selects only EmployeeIds corresponding to managers).

Now, at the very least we can be sure that the data meets the very basic rules that the data must follow, so we never have to code something like this in order to check that the data is good:

SELECT CASE WHEN discount < 0 then 0 else WHEN discount > 1 then 1…
We can feel safe that data meets the basic criteria, every time.

Not using stored procedures to access data
Stored procedures are your friend. Use them whenever possible as a method to insulate the database layer from the users of the data. Do they take a bit more effort? Sure, initially, but what good thing doesn't take a bit more time? Stored procedures make database development much cleaner, and encourage collaborative development between your database and functional programmers. A few of the other interesting reasons that stored procedures are important include the following.

Maintainability
Stored procedures provide a known interface to the data, and to me, this is probably the largest draw. When code that accesses the database is compiled into a different layer, performance tweaks cannot be made without a functional programmer's involvement. Stored procedures give the database professional the power to change characteristics of the database code without additional resource involvement, making small changes, or large upgrades (for example changes to SQL syntax) easier to do.

Encapsulation
Stored procedures allow you to "encapsulate" any structural changes that you need to make to the database so that the knock on effect on user interfaces is minimized. For example, say you originally modeled one phone number, but now want an unlimited number of phone numbers. You could leave the single phone number in the procedure call, but store it in a different table as a stopgap measure, or even permanently if you have a "primary" number of some sort that you always want to display. Then a stored proc could be built to handle the other phone numbers. In this manner the impact to the user interfaces could be quite small, while the code of stored procedures might change greatly.

Security
Stored procedures can provide specific and granular access to the system. For example, you may have 10 stored procedures that all update table X in some way. If a user needs to be able to update a particular column in a table and you want to make sure they never update any others, then you can simply grant to that user the permission to execute just the one procedure out of the ten that allows them perform the required update.

Performance
There are a couple of reasons that I believe stored procedures enhance performance. First, if a newbie writes ratty code (like using a cursor to go row by row through an entire ten million row table to find one value, instead of using a WHERE clause), the procedure can be rewritten without impact to the system (other than giving back valuable resources.) The second reason is plan reuse. Unless you are using dynamic SQL calls in your procedure, SQL Server can store a plan and not need to compile it every time it is executed. It's true that in every version of SQL Server since 7.0 this has become less and less significant, as SQL Server gets better at storing plans ad hoc SQL calls (see note below). However, stored procedures still make it easier for plan reuse and performance tweaks. In the case where ad hoc SQL would actually be faster, this can be coded into the stored procedure seamlessly.

In 2005, there is a database setting (PARAMETERIZATION FORCED) that, when enabled, will cause all queries to have their plans saved. This does not cover more complicated situations that procedures would cover, but can be a big help. There is also a feature known as plan guides, which allow you to override the plan for a known query type. Both of these features are there to help out when stored procedures are not used, but stored procedures do the job with no tricks.

And this list could go on and on. There are drawbacks too, because nothing is ever perfect. It can take longer to code stored procedures than it does to just use ad hoc calls. However, the amount of time to design your interface and implement it is well worth it, when all is said and done.

Trying to code generic T-SQL objects
I touched on this subject earlier in the discussion of generic domain tables, but the problem is more prevalent than that. Every new T-SQL programmer, when they first start coding stored procedures, starts to think "I wish I could just pass a table name as a parameter to a procedure." It does sound quite attractive: one generic stored procedure that can perform its operations on any table you choose. However, this should be avoided as it can be very detrimental to performance and will actually make life more difficult in the long run.

T-SQL objects do not do "generic" easily, largely because lots of design considerations in SQL Server have clearly been made to facilitate reuse of plans, not code. SQL Server works best when you minimize the unknowns so it can produce the best plan possible. The more it has to generalize the plan, the less it can optimize that plan.

Note that I am not specifically talking about dynamic SQL procedures. Dynamic SQL is a great tool to use when you have procedures that are not optimizable / manageable otherwise. A good example is a search procedure with many different choices. A precompiled solution with multiple OR conditions might have to take a worst case scenario approach to the plan and yield weak results, especially if parameter usage is sporadic.

However, the main point of this tip is that you should avoid coding very generic objects, such as ones that take a table name and twenty column names/value pairs as a parameter and lets you update the values in the table. For example, you could write a procedure that started out:

CREATE PROCEDURE updateAnyTable@tableName sysname,@columnName1 sysname,@columnName1Value varchar(max)@columnName2 sysname,@columnName2Value varchar(max)…
The idea would be to dynamically specify the name of a column and the value to pass to a SQL statement. This solution is no better than simply using ad hoc calls with an UPDATE statement. Instead, when building stored procedures, you should build specific, dedicated stored procedures for each task performed on a table (or multiple tables.) This gives you several benefits:

Properly compiled stored procedures can have a single compiled plan attached to it and reused.
Properly compiled stored procedures are more secure than ad-hoc SQL or even dynamic SQL procedures, reducing the surface area for an injection attack greatly because the only parameters to queries are search arguments or output values.
Testing and maintenance of compiled stored procedures is far easier to do since you generally have only to search arguments, not that tables/columns/etc exist and handling the case where they do not
A nice technique is to build a code generation tool in your favorite programming language (even T-SQL) using SQL metadata to build very specific stored procedures for every table in your system. Generate all of the boring, straightforward objects, including all of the tedious code to perform error handling that is so essential, but painful to write more than once or twice.

In my Apress book, Pro SQL Server 2005 Database Design and Optimization, I provide several such "templates" (manly for triggers, abut also stored procedures) that have all of the error handling built in, I would suggest you consider building your own (possibly based on mine) to use when you need to manually build a trigger/procedure or whatever.

Lack of testing
When the dial in your car says that your engine is overheating, what is the first thing you blame? The engine. Why don't you immediately assume that the dial is broken? Or something else minor? Two reasons:

The engine is the most important component of the car and it is common to blame the most important part of the system first.
It is all too often true.
As database professionals know, the first thing to get blamed when a business system is running slow is the database. Why? First because it is the central piece of most any business system, and second because it also is all too often true.

We can play our part in dispelling this notion, by gaining deep knowledge of the system we have created and understanding its limits through testing.

But let's face it; testing is the first thing to go in a project plan when time slips a bit. And what suffers the most from the lack of testing? Functionality? Maybe a little, but users will notice and complain if the "Save" button doesn't actually work and they cannot save changes to a row they spent 10 minutes editing. What really gets the shaft in this whole process is deep system testing to make sure that the design you (presumably) worked so hard on at the beginning of the project is actually implemented correctly.

But, you say, the users accepted the system as working, so isn't that good enough? The problem with this statement is that what user acceptance "testing" usually amounts to is the users poking around, trying out the functionality that they understand and giving you the thumbs up if their little bit of the system works. Is this reasonable testing? Not in any other industry would this be vaguely acceptable. Do you want your automobile tested like this? "Well, we drove it slowly around the block once, one sunny afternoon with no problems; it is good!" When that car subsequently "failed" on the first drive along a freeway, or during the first drive through rain or snow, then the driver would have every right to be very upset.

Too many database systems get tested like that car, with just a bit of poking around to see if individual queries and modules work. The first real test is in production, when users attempt to do real work. This is especially true when it is implemented for a single client (even worse when it is a corporate project, with management pushing for completion more than quality).

Initially, major bugs come in thick and fast, especially performance related ones. If the first time you have tried a full production set of users, background process, workflow processes, system maintenance routines, ETL, etc, is on your system launch day, you are extremely likely to discover that you have not anticipated all of the locking issues that might be caused by users creating data while others are reading it, or hardware issues cause by poorly set up hardware. It can take weeks to live down the cries of "SQL Server can't handle it" even after you have done the proper tuning.

Once the major bugs are squashed, the fringe cases (which are pretty rare cases, like a user entering a negative amount for hours worked) start to raise their ugly heads. What you end up with at this point is software that irregularly fails in what seem like weird places (since large quantities of fringe bugs will show up in ways that aren't very obvious and are really hard to find.)

Now, it is far harder to diagnose and correct because now you have to deal with the fact that users are working with live data and trying to get work done. Plus you probably have a manager or two sitting on your back saying things like "when will it be done?" every 30 seconds, even though it can take days and weeks to discover the kinds of bugs that result in minor (yet important) data aberrations. Had proper testing been done, it would never have taken weeks of testing to find these bugs, because a proper test plan takes into consideration all possible types of failures, codes them into an automated test, and tries them over and over. Good testing won't find all of the bugs, but it will get you to the point where most of the issues that correspond to the original design are ironed out.

If everyone insisted on a strict testing plan as an integral and immutable part of the database development process, then maybe someday the database won't be the first thing to be fingered when there is a system slowdown.

Summary
Database design and implementation is the cornerstone of any data centric project (read 99.9% of business applications) and should be treated as such when you are developing. This article, while probably a bit preachy, is as much a reminder to me as it is to anyone else who reads it. Some of the tips, like planning properly, using proper normalization, using a strong naming standards and documenting your work– these are things that even the best DBAs and data architects have to fight to make happen. In the heat of battle, when your manager's manager's manager is being berated for things taking too long to get started, it is not easy to push back and remind them that they pay you now, or they pay you later. These tasks pay dividends that are very difficult to quantify, because to quantify success you must fail first. And even when you succeed in one area, all too often other minor failures crop up in other parts of the project so that some of your successes don't even get noticed.

The tips covered here are ones that I have picked up over the years that have turned me from being mediocre to a good data architect/database programmer. None of them take extraordinary amounts of time (except perhaps design and planning) but they all take more time upfront than doing it the "easy way". Let's face it, if the easy way were that easy in the long run, I for one would abandon the harder way in a second. It is not until you see the end result that you realize that success comes from starting off right as much as finishing right.

WaitHandles - Auto/ManualResetEvent and Mutex

2007-11-14T08:34:00.001-08:00

Monitor.Wait/Pulse isn't the only way of waiting for something to happen in one thread and telling that thread that it's happened in another. Win32 programmers have been using various other mechanisms for a long time, and these are exposed by the AutoResetEvent, ManualResetEvent and Mutex classes, all of which derive from WaitHandle. All of these classes are in the System.Threading namespace. (The Win32 Semaphore mechanism does not have a managed wrapper in .NET 1.1. It's present in .NET 2.0, but if you need to use it before then, you could either wrap it yourself using P/Invoke, or write your own counting semaphore class.)

Some people may be surprised to learn that using these classes can be significantly slower than using the various Monitor methods. I believe this is because going "out" of managed code into native Win32 calls and back "in" again is expensive compared with the entirely managed view of things which Monitor provides. A reader has also explained that monitors are implemented in user mode, whereas using wait handles require switching into kernel mode, which is fairly expensive.

WaitHandle itself only exposes a few useful instance methods/properties:

WaitOne() - used to wait for the handle to be free/signalled. The exact meaning of this depends on the concrete type being used (Mutex, AutoResetEvent or ManualResetEvent).
Close()/Dispose() - used to release the resources used by the handle.
Handle - used to get the native handle being wrapped. Most developers won't need to use this.
In addition, it has two useful static methods which deal with sets of WaitHandles:

WaitAny() - used to wait for any of the handles in a set to be free/signalled.
WaitAll() - used to wait for all of the handles in a set to be free/signalled.
All of the WaitXXX() methods have overloads allowing you to specify a timeout and whether or not to exit the "synchronization domain". The default value is false. What is a synchronization domain, you ask? Well, it's to do with some automatic thread handling that .NET has to offer in the guise of Transactional COM+. Most .NET developers won't need to use this, but Juval Löwy has an article on the topic if you wish to find out more.

Auto/ManualResetEvent
The two "event" classes (which are entirely different from .NET events - don't get the two confused) come as a sort of pair, and are very similar. You can think of them like doors - when they're in the "signalled" (or "set") state they're open, and when they're in the "non-signalled" (or "reset") state, they're closed. A call to WaitOne() waits for the door to be opened so the thread can "go through it" in some sense. The difference between the two classes is that an AutoResetEvent will reset itself to the non-signalled state immediately after a call to WaitOne() - it's as if anyone going through the door closes it behind them. With a ManualResetEvent, you have to tell the thread to reset it (close the door) when you want to make calls to WaitOne() block again. Both classes can manually be set or reset at any time, by any thread, using the Set and Reset methods, and can be created in the signalled/set or non-signalled/reset state. (These methods return a boolean value saying whether or not they were successful, but the documentation doesn't state why they might fail.)

Here's some sample code which simulates 10 runners. Each runner is passed a ManualResetEvent which is initially non-signalled. When the runner completes the race, it signals the event. The main thread uses WaitHandle.WaitAny to wait for the first runner to finish, and uses the value returned by the method to say who won the race. It then uses WaitHandle.WaitAll to wait for everyone to finish. Note that if we'd used AutoResetEvent instead, we'd have to call Set on the event of the winner, as it would have been reset when we detected it being set with the call to WaitAny.

using System;
using System.Threading;

class Test
{
static void Main()
{
ManualResetEvent[] events = new ManualResetEvent[10];
for (int i=0; i < events.Length; i++)
{
events[i] = new ManualResetEvent(false);
Runner r = new Runner(events[i], i);
new Thread(new ThreadStart(r.Run)).Start();
}

int index = WaitHandle.WaitAny(events);

Console.WriteLine ("***** The winner is {0} *****",
index);

WaitHandle.WaitAll(events);
Console.WriteLine ("All finished!");
}
}

class Runner
{
static readonly object rngLock = new object();
static Random rng = new Random();

ManualResetEvent ev;
int id;

internal Runner (ManualResetEvent ev, int id)
{
this.ev = ev;
this.id = id;
}

internal void Run()
{
for (int i=0; i < 10; i++)
{
int sleepTime;
// Not sure about the thread safety of Random...
lock (rngLock)
{
sleepTime = rng.Next(2000);
}
Thread.Sleep(sleepTime);
Console.WriteLine ("Runner {0} at stage {1}",
id, i);
}
ev.Set();
}
}

Mutex
Whereas Auto/ManualResetEvent have a lot in common with using Monitor.Wait/Pulse, Mutex has even more in common with Monitor.Enter/Exit. A mutex has a count of the number of times it's been acquired, and a thread which is the current owner. If the count is zero, it has no owner and it can be acquired by anyone. If the count is non-zero, the current owner can acquire it however many times they like without blocking, but any other thread has to wait until the count becomes zero before they can acquire it. The WaitXXX() methods are used to acquire the mutex, and ReleaseMutex() is used by the owner thread to decrease the count by one. Only the owner can decrease the count.

So far, so much like Monitor. The difference is that a Mutex is a cross-process object - the same mutex can be used in many processes, if you give it a name. A thread in one process can wait for a thread in another process to release the mutex, etc. When you construct a named mutex, you should be careful about making assumptions as to whether or not you will be able to acquire initial ownership of it. Fortunately, there is a constructor which allows the code to detect whether the system has created a whole new mutex or whether it's used an existing one. If the constructor requested initial ownership, it will only have been granted it if it created a new mutex - even if the existing mutex can immediately be acquired.

Mutex names should start with either "Local\" or "Global\" to indicate whether they should be created in the local or global namespace respectively. (I believe that local is the default, but why take the risk? Make it explicit in the name.) If you create a mutex in the global namespace, it is shared with other users logged into the same machine. If you create a mutex in the local namespace, it is specific to the current user. Make sure you pick a suitably unique name so you don't clash with other programs.

To be honest, I think the principle use that mutexes will be put to in .NET is the one mentioned earlier - detecting that another instance of an application is already running. Most people don't need inter-process communication on this kind of level. The other use is to enable you to block until either one or all of a set of WaitHandles is released. For other purposes, where Monitor is good enough, I suggest using that - especially as C# has the lock statement specifically to support it. Here's an example of detecting a running application, however:

using System;
using System.Threading;

class Test
{
static void Main()
{
bool firstInstance;

using (Mutex mutex = new Mutex(true,
@"Global\Jon.Skeet.MutexTestApp",
out firstInstance))
{
if (!firstInstance)
{
Console.WriteLine ("Other instance detected; aborting.");
return;
}

Console.WriteLine ("We're the only instance running - yay!");
for (int i=0; i < 10; i++)
{
Console.WriteLine (i);
Thread.Sleep(1000);
}
}
}
}

Run the example in two different console windows - one will count to ten slowly; the other will abort after it detects that the other application instance is running. Note the using statement around the mutex: this should extend across the whole of the application's execution, otherwise another instance would be able to create a new mutex with the same name, after the old one had been destroyed. For instance, suppose you use a local variable without a using statement, like this:

using System;
using System.Threading;

class Test
{
static void Main()
{
bool firstInstance;

// Bad code - do not use!
Mutex mutex = new Mutex(true,
@"Global\Jon.Skeet.MutexTestApp",
out firstInstance);

if (!firstInstance)
{
Console.WriteLine ("Other instance detected; aborting.");
return;
}

Console.WriteLine ("We're the only instance running - yay!");
for (int i=0; i < 10; i++)
{
Console.WriteLine (i);
Thread.Sleep(1000);
}
}
}

In that case, you'd probably find that everything would work fine under debug, where the GC is very conservative about what it collects. When not running under the debugger, however, the GC can tell that the mutex variable isn't used after its initial assignment, so for the main duration of the app, it can be garbage collected at any time - and that destroys the mutex! The using statement shown earlier is only one way round this. You could make it a static variable instead, or use GC.KeepAlive(mutex); at the end of the method to make sure that the GC doesn't ignore the variable.

Working with Windows Service Using Visual Studio 2005

2007-11-14T08:33:00.001-08:00

http://aspalliance.com/1316_Working_with_Windows_Service_Using_Visual_Studio_2005#Page2

Calling __doPostBack in javascript

2007-01-02T08:40:00.001-08:00

Update: There is an existing .Net Framework method Page.GetPostBackEventReference that emits client-side script that initiates postback and also provides a reference to the control that initiated the postback event. It is well described in MSDN article “Generating Client-Side Script for Postback“. So my function should call

ctrl.Page.GetPostBackEventReference(ctrl) instead of
__doPostBack('" + UniqueIDWithDollars(ctrl) + @"','');

and in most cases GetPostBackEventReference can be used directly.

Original Post:

I've used a function to submit postback from my javascript by passing Id of the link server control as it was suggested in article “How postback works in ASP.NET”

//call the postback function with the right ID
__doPostBack('ControlId','');
and it worked fine for a while.

However when I moved the link to the User control, it stopped to work.

I recognized that I need to provide fully qualified Control.ClientId but it didn't work.
In debugger I found that when calling the __doPostBack(), ASP.NET generates ID with dollar - $ -separator, not underscore that is used in ClientID, e.g. 'userContol1$linkContol1'.

I found confirmation to this in ASP.NET Server Control - Design Time Support and .NET Development: PressButton Design and Server Control . Microsoft provides UniqueIDWithDollars internal method, that can be accessed through reflection.

However I found that it is simpler just to duplicate code in static function.

The working version of javascript function to __doPostBack :

public static bool RegisterFunctionToPostBack(string sFunctionName,Control ctrl)

{ //from http://www.xefteri.com/articles/show.cfm?id=18 How postback works in ASP.NET

if (HttpContext.Current.Request.Browser.JavaScript)

{
string sJS =" function " + sFunctionName + @"()

{

//call the postback function with the right ID

__doPostBack('" + UniqueIDWithDollars(ctrl) + @"','');

}";

sJS=JScriptHelper.JScript(sJS);

ctrl.Page.RegisterStartupScript(sFunctionName, sJS);

return true;

}

return false;

}

//from http://www.codeproject.com/aspnet/DesignTimeSupport.asp

public static string UniqueIDWithDollars(Control ctrl)

{

string sId = ctrl.UniqueID;

if (sId == null)

{

return null;

}

if (sId.IndexOf(':') >= 0)

{<

Garbage collection & weak references

2007-01-02T08:40:00.000-08:00

I have been reading parts of Inside C# (Vol 2) today. Specifically I've focused on the chapters concerning garbage collection and related subjects. Just reading those parts, I have to say that this book does a pretty good job of outlining some of the details that happen behind the scene. It describes how garbage collection is implemented in the framework and provides some examples to go along with it. Anyway, the part that I found interesting (I had heard about this briefly before) was how the runtime assigns objects on the heap to a generation. Currently with .Net 1.x, there are 3 generations that an object can be a part of. When garbage collection occurs, it “sweeps” the first generation (0), releasing the memory associated with those objects. If there isn’t enough memory available for the current operation, the garbage collector will sweep the next generation (1). It continues doing this until enough memory has been released to fulfill the current requirement. Granted, the garbage collector uses an algorithm to determine which objects to collect, etc… If an object survives a “sweep” operation, it’s generation is incremented. But the cool part to all of this is that newer objects are added to the lowest generation (0). So what this means is that typically, objects more local in scope are collected before/will have a shorter lifetime than objects of a less local scope.

Also, I was reading about weak references a little bit. I stumbled upon weak references when I was working with NAnt a while back. I never really found a resource to describe what the point of weak references is. This has all changed, thanks to this book :) So basically, you use weak references when you are using objects that are costly to instantiate/setup. Say you have your large object that the user has access to; the user switches to a different part of your application where the object isn’t needed. You can create a weak reference to that object and then proceed to dispose/destroy the strong reference to the object. If the user switches back to the original part of the application where that object would be used again, it’s possible to get back the strong reference by using the weak reference. Thus, you avoid the cost of setting up the object. Wow, that was a confusing sentence. The way that I think this all works is that you tell the runtime that you no longer need the object, making it available for garbage collection. A weak reference is like a pointer, pointing to where the object exists in memory. If later on, that object has not been collected, you can re-create the strong reference to it. The week reference class has a property called IsAlive to test if the object exists still or not. That’s my take on it, if I’m wrong please inform me...

The below is a sample usage.

...
WeakReference wa = null;
try
{
A a = new A();
wa = new WeakReference(a, false);
}
ca

Post a data file directly to your client

2007-01-02T08:39:00.000-08:00

Response.Clear();
System.IO.FileInfo oFileInfo = new System.IO.FileInfo(sFilePath);
Response.AddHeader("Content-Disposition", "attachment; filename=" + oFileInfo.Name);
Response.ContentType = sMimeType;
DocumentQry oQry = new DocumentQry() ;
using(new iDeal.Common.Utilities.SafeDisposer(oQry))
{
byte[] bFile = oQry.GetFile(sFilePath) ;
Response.BinaryWrite(bFile) ;
}

Query Active Directory using VB script

2007-01-02T08:38:00.000-08:00

'Global variables
Dim sCustomer
Dim sDomain
Dim oContainer
Dim OutPutFile
Dim FileSystem
'Initialize global variables
sCustomer = "Lehman Brothers"
sDomain = "DC=ideal,DC=qa,DC=local"
Set FileSystem = WScript.CreateObject("Scripting.FileSystemObject")
Set OutPutFile = FileSystem.CreateTextFile("cellphone.txt", True)
Set oContainer=GetObject("LDAP://OU=" & sCustomer & ",OU=Customers,OU=Phoenix Application," & sDomain)
'Enumerate Container
EnumerateUsers oContainer
'Clean up
OutPutFile.Close
Set FileSystem = Nothing
Set oContainer = Nothing
WScript.Echo "Finished"
WScript.Quit(0)
Sub EnumerateUsers(oCont)
Dim oUserInfo
For Each oUserInfo In oCont
Select Case LCase(oUserInfo.Class)
Case "user"
If (Not IsEmpty(oUserInfo.UserPrincipalName) and Not IsEmpty(oUserInfo.mobile)) Then
OutPutFile.WriteLine oUserInfo.UserPrincipalName & " ^ " & oUserInfo.mobile
End If
Case "organizationalunit"
EnumerateUsers oUserInfo
End Select
Next
End Sub

So which CLR will my app use

2007-01-02T08:37:00.000-08:00

So which CLR will my app use?

We have shipped several versions of .Net framework: 1.0, 1.1, and 2.0 is on the horizon. All of them are side by side, meaning, someone may be using 1.0 CLR, at the same time, someone else is using 1.1 CLR. In the same process, there can be only one CLR. Once CLR is loaded in the process, it cannot be unloaded.

So which CLR will my app use?

It depends on which .Net framework has installed, and which framework your app is built with.

The real component to determine which CLR to load is mscoree.dll, residing in %windir%\system32. When you install .Net framework, it will replace mscoree.dll if the existing one is older then the one it carries, and it will leave it alone if the existing one is newer. So we always have the latest mscoree.dll in %windir%\system32, even the corresponding .Net framework has been uninstalled. For this reason, mscoree.dll has to maintain very strict compatibility.

Because we always have the latest mscoree.dll, the following discussion is based on what newest .Net framework you have ever installed.

If only 1.0 is installed, then 1.0 CLR will always be used. 1.0 mscoree.dll is not side by side aware.

If 1.1 is installed, then the CLR you built with will be loaded. If you built your app with 1.0, then 1.0 CLR will be loaded. If you built your app with 1.1, then 1.1 CLR will be loaded. If the required CLR is not available in your machine, mscoree.dll will bring up a dialog and quit. This is so that your app won’t run under a different CLR that you did not test.

The thinking shifts in 2.0. In 2.0, mscoree.dll will try to use the CLR you built with first. If that CLR cannot be found, mscoree.dll will load 2.0 CLR to run your app. But if the CLR you built with is newer than (the currently installed) 2.0, mscoree.dll will bring up the same dialog and quit. The latter behavior is frequently seen in internal testing.

For apps built with interim release, mscoree.dll maps it to the closest officially released CLR. So 1.0 beta2+ will use 1.0 CLR. 1.1 beta will use 1.1 CLR.

Of course, you can use a config file to overwrite the default behavior.

http://msdn.microsoft.com/library/en-us/cpguide/html/cpconside-by-sideexecution.asp has more information.

The CLR's execution engine

2007-01-02T08:35:00.001-08:00

The CLR's execution engine

Let's start by taking a look at the basics of the CLR when it comes to executing code. The central file in this story is mscoree.dll (Component Object Runtime Execution Engine), which contains the execution engine. Well, that's not completely true actually. Mscoree is called the "startup shim" and is unique on the machine, regardless of the number of side-by-side installations of the .NET Framework (e.g. 1.0.3705, 1.1.4322, 2.0.x). You'll find the file in the system32 folder on your system. It's the task of the mscoree.dll file to hand over execution to a specific version of the CLR depending on a number of factors. Such an installation of a version of the CLR contains a bunch of files starting with mscor, such as:

mscorwks.dll - the workstation version of the CLR
mscorsvr.dll - the server version of the CLR (I'll talk about the workstation and server versions in a later post when talking about the garbage collector etc)
mscorlib.dll - contains a part of the System namespace of managed classes (e.g. System.Activator is in there, whileas System.Uri lives in the System.dll assembly); this file contains low-level functionality that has a close relationship with the CLR itself (e.g. code to support concepts such as application domains)
mscorjit.dll - the just-in-time compiler of the CLR to compile IL-code to native code at runtime
You can find all these files in the Microsoft.NET\Framework folders in your Windows directory. As you can have multiple different versions of the CLR on one machine, it's the job of the startup shim (which is not installed on a version-per-version basis) to load a specific version of the CLR and to hand over execution to that particular version.

NotesSQL 3.02j ODBC error 126 when adding DSN

2007-01-02T08:35:00.000-08:00

When trying to add a DSN via the MS ODBC Data Source Administrator I get the following errors:

"The setup routines for the Lotus NotesSQL Driver (*.nsf) ODBC driver could not be loaded due to system error code 126."

"Driver's ConfigDSN, Config Driver, or ConfigTranslator failed
Could not load the setup or translator library"

The Solution is:

make sure your enviornment path has both: C:\Lotus\Notes or C:\NotesSQL.

Or if you install NotesSql in other path, you need make sure those paths are inccluded in environmental path.

Disable address bar in Internet Explorer 7

2007-01-02T08:29:00.000-08:00

Problem - How to disable address bar in Internet Explorer
Environment – Internet Explorer 7

I searched our existing case database and found a similar case. Following are the summary of key points discussed in that case:
1. Address bar behaviour:
(a) the enabled address bar will show up in all user-initiated IE7 windows, as you cannot customize the user-initiated IE7 by disabling the enabled address bar.

(b) the enabled address bar will always show up in IE7 for script-opened window if window.open command does not specify anything.

(c) The disabled address bar will show up in a script-opened window even if window.open suppresses it under default internet-zone setting (i.e., “allow websites to open windows without address or status bar” is defaulted to ‘disabled’).

2. The address bar can be suppressed under the following circumstances:
(a) Via script-opened window (i.e., via window.open) provided if we use “toolbar=no” (we can just use this alone without specifying others)

(b) If we use “location=no” (without specifying the “fullscreen” flag together), and under the circumstance that IE7 setting “allow websites to open windows without address or status bar” is set to ‘enabled’.

PS: The latter setting is defaulted to ‘enabled’ under “intranet zone” or “trusted site” category.

3. The reason to force showing the address bar, under defaulted internet zone setting, is to alert end users about un-trusted location of website so users know when they have been redirected to a different website. This is by-design and is a given security implementation of Microsoft. The only ways out, as mentioned earlier, are at end-user’s discretion, to enable the “allow open windows without address bar…” flag in IE7 settings for script-opened windows or to add the website domain in to trusted zone.

Interface vs Abstract Class

2006-04-18T14:13:00.000-07:00

Class vs. interface
Some say you should define all classes in terms of interfaces, but I think recommendation seems a bit extreme. I use interfaces when I see that something in my design will change frequently.

For example, the Strategy pattern lets you swap new algorithms and processes into your program without altering the objects that use them. A media player might know how to play CDs, MP3s, and wav files. Of course, you don't want to hardcode those playback algorithms into the player; that will make it difficult to add a new format like AVI. Furthermore, your code will be littered with useless case statements. And to add insult to injury, you will need to update those case statements each time you add a new algorithm. All in all, this is not a very object-oriented way to program.

With the Strategy pattern, you can simply encapsulate the algorithm behind an object. If you do that, you can provide new media plug-ins at any time. Let's call the plug-in class MediaStrategy. That object would have one method: playStream(Stream s). So to add a new algorithm, we simply extend our algorithm class. Now, when the program encounters the new media type, it simply delegates the playing of the stream to our media strategy. Of course, you'll need some plumbing to properly instantiate the algorithm strategies you will need.

This is an excellent place to use an interface. We've used the Strategy pattern, which clearly indicates a place in the design that will change. Thus, you should define the strategy as an interface. You should generally favor interfaces over inheritance when you want an object to have a certain type; in this case, MediaStrategy. Relying on inheritance for type identity is dangerous; it locks you into a particular inheritance hierarchy. Java doesn't allow multiple inheritance, so you can't extend something that gives you a useful implementation or more type identity.

Interface vs. abstract class
Choosing interfaces and abstract classes is not an either/or proposition. If you need to change your design, make it an interface. However, you may have abstract classes that provide some default behavior. Abstract classes are excellent candidates inside of application frameworks.

Abstract classes let you define some behaviors; they force your subclasses to provide others. For example, if you have an application framework, an abstract class may provide default services such as event and message handling. Those services allow your application to plug in to your application framework. However, there is some application-specific functionality that only your application can perform. Such functionality might include startup and shutdown tasks, which are often application-dependent. So instead of trying to define that behavior itself, the abstract base class can declare abstract shutdown and startup methods. The base class knows that it needs those methods, but an abstract class lets your class admit that it doesn't know how to perform those actions; it only knows that it must initiate the actions. When it is time to start up, the abstract class can call the startup method. When the base class calls this method, Java calls the method defined by the child class.

Many developers forget that a class that defines an abstract method can call that method as well. Abstract classes are an excellent way to create planned inheritance hierarchies. They're also a good choice for nonleaf classes in class hierarchies.

ASP.NET - encrype your password with salt

2006-03-03T14:03:00.000-08:00

MD5CryptoServiceProvider md5Hasher = New MD5CryptoServiceProvider()

Byte[] hashedBytes = new Byte[];
UTF8Encoding encoder = New UTF8Encoding();

use

hashedBytes = md5Hasher.ComputeHash(encoder.GetBytes(txtPwd.Text & txtUsername.Text))

instead of

hashedBytes = md5Hasher.ComputeHash(encoder.GetBytes(txtPwd.Text))

Note: The Password field is of type binary and of length 16.

Technical Interview Questions

2006-02-13T20:01:00.000-08:00

The following is a list of questions which have been floating around some
Internet circles. They are excellent prep questions for a technical interview.

I haven't made any attempt to clean them up, spelling or organization wise.

Don't bother asking me for the answers,
1) I don't have an answer key.
2) It'd do you good to think.

1. Given a rectangular (cuboidal for the puritans) cake with a rectangular
piece removed (any size or orientation), how would you cut the remainder
of the cake into two equal halves with one straight cut of a knife ?

2. You're given an array containing both positive and negative integers and
required to find the subarray with the largest sum (O(N) a la KBL).
Write a routine in C for the above.

3. Given an array of size N in which every number is between 1 and N,
determine if there are any duplicates in it. You are allowed to destroy
the array if you like. [ I ended up giving about 4 or 5 different solutions
for this, each supposedly better than the others ].

4. Write a routine to draw a circle (x ** 2 + y ** 2 = r ** 2) without making
use of any floating point computations at all. [ This one had me stuck for
quite some time and I first gave a solution that did have floating point
computations ].

5. Given only putchar (no sprintf, itoa, etc.) write a routine putlong that
prints out an unsigned long in decimal. [ I gave the obvious solution of
taking % 10 and / 10, which gives us the decimal value in reverse order.
This requires an array since we need to print it out in the correct order.
The interviewer wasn't too pleased and asked me to give a solution which
didn't need the array ].

void print(unsigned n)
{
static c = 0;
if( n < 10)
{
putchar(n + 48);
return;
}
int m = n%10;
print(n/10);
if(++c%3 == 0) putchar(',');
putchar(48 + m);
}

6. Give a one-line C expression to test whether a number is a power of
2. [No loops allowed - it's a simple test.]

7. Given an array of characters which form a sentence of words, give an
efficient algorithm to reverse the order of the words (not characters)
in it.

8. How many points are there on the globe where by walking one mile south,
one mile east and one mile north you reach the place where you started.

9. Give a very good method to count the number of ones in a 32 bit number.
(caution: looping through testing each bit is not a solution).

10. What are the different ways to say, the value of x can be either a 0
or a 1. Apparently the if then else solution has a jump when written
out in assembly.
if (x == 0)
y=0
else
y =x

There is a logical, arithmetic and a datastructure soln to the above
problem.

11. Reverse a linked list.

12. Insert in a sorted list

13. In a X's and 0's game (i.e. TIC TAC TOE) if you write a program for
this give a gast way to generate the moves by the computer. I mean this
should be the fasteset way possible. The answer is that you need to store
all possible configurations of the board and the move that is associated
with that. Then it boils down to just accessing the right element and
getting the corresponding move for it. Do some analysis and do some more
optimization in storage since otherwise it becomes infeasible to get
the required storage in a DOS machine.

14. I was given two lines of assembly code which found the absolute value
of a number stored in two's complement form. I had to recognize what the
code was doing. Pretty simple if you know some assembly and some fundaes
on number representation.

15. Give a fast way to multiply a number by 7.

16. How would go about finding out where to find a book in a library. (You
don't know how exactly the books are organized beforehand).

17. Linked list manipulation.

18. Tradeoff between time spent in testing a product and getting into the
market first.

19. What to test for given that there isn't enough time to test everything
you want to.

20. First some definitions for this problem:
a) An ASCII character is one byte long and the most significant bit
in the byte is always '0'.
b) A Kanji character is two bytes long. The only characteristic of a
Kanji character is that in its first byte the most significant bit
is '1'.

Now you are given an array of a characters (both ASCII and Kanji) and,
an index into the array. The index points to the start of some character.
Now you need to write a function to do a backspace (i.e. delete the
character before the given index).

21. Delete an element from a doubly linked list.

22. Write a function to find the depth of a binary tree.

23. Given two strings S1 and S2. Delete from S2 all those characters which
occur in S1 also and finally create a clean S2 with the relevant characters
deleted.

24. Assuming that locks are the only reason due to which deadlocks can occur
in a system. What would be a foolproof method of avoiding deadlocks in
the system.

25. Reverse a linked list.

26. Write a small lexical analyzer - interviewer gave tokens. expressions like
"a*b" etc.

27. Besides communication cost, what is the other source of inefficiency in RPC?

(answer : context switches, excessive buffer copying).
How can you optimise the communication? (ans : communicate through shared
memory on same machine, bypassing the kernel _ A Univ. of Wash. thesis)

28. Write a routine that prints out a 2-D array in spiral order!

29. How is the readers-writers problem solved? - using semaphores/ada .. etc.

30. Ways of optimizing symbol table storage in compilers.

31. A walk-through through the symbol table functions, lookup() implementation
etc - The interv. was on the Microsoft C team.

32. A version of the "There are three persons X Y Z, one of which always lies"..

etc..

33. There are 3 ants at 3 corners of a triangle, they randomly start moving
towards another corner.. what is the probability that they don't collide.

34. Write an efficient algo and C code to shuffle a pack of cards.. this one
was a feedback process until we came up with one with no extra storage.

35. The if (x == 0) y = 0 etc..

36. Some more bitwise optimization at assembly level

37. Some general questions on Lex Yacc etc.

38. Given an array t[100] which contains numbers between 1..99.
Return the duplicated value. Try both O(n) and O(n-square).

39. Given an array of characters. How would you reverse it. ?
How would you reverse it without using indexing in the array.

40. GIven a sequence of characters. How will you convert the lower
case characters to upper case characters. ( Try using bit vector
- sol given in the C lib -> typec.h)

41. Fundas of RPC.

42. Given a linked list which is sorted. How will u insert in sorted
way.

43. Given a linked list How will you reverse it.

44. Tell me the courses you liked and why did you like them.

45. Give an instance in your life in which u were faced with a
problem and you tackled it successfully.

46. What is your ideal working environment. ( They usually
to hear that u can work in group also.)

47. Why do u think u are smart.

48. Questions on the projects listed on the Resume.

49. Do you want to know any thing about the company.( Try to ask some
relevant and interesting question).

50. How long do u want to stay in USA and why?

51. What are your geographical preference?

52. What are your expecctations from the job.

53. Give a good data structure for having n queues ( n not fixed) in a
finite memory segment. You can have some data-structure separate for
each queue. Try to use at least 90% of the memory space.

54. Do a breadth first traversal of a tree.

55. Write code for reversing a linked list.

56. Write, efficient code for extracting unique elements from
a sorted list of array. e.g. (1, 1, 3, 3, 3, 5, 5, 5, 9, 9, 9, 9) ->
(1, 3, 5, 9).

57. C++ ( what is virtual function ?
what happens if an error occurs in constructor or destructor.
Discussion on error handling, templates, unique features of C++.
What is different in C++, ( compare with unix).

58. Given a list of numbers ( fixed list) Now given any other list,
how can you efficiently find out if there is any element in the
second list that is an element of the first list (fixed list).

59. GIven 3 lines of assembly code : find it is doing. IT was to find
absolute value.

60. If you are on a boat and you throw out a suitcase, Will the level of
water increase.

61. Print an integer using only putchar. Try doing it without using extra
storage.

62. write C code for
deleting an element from a linked listy
traversing a linked list
efficient way of elimiating duplicates from an array

63. what are various problems unique to distributed databases

64. declare a void pointer
a) void *ptr;

65. make the pointer aligned to a 4 byte boundary in a efficient manner
a) assign the pointer to a long number
and the number with 11...1100
add 4 to the number

66. what is a far pointer (in DOS)

67. what is a balanced tree

68. given a linked list with the following property
node2 is left child of node1, if node2 < node1
els, it is the right child.

O P
|
|
O A
|
|
O B
|
|
O C

How do you convert the above linked list to the
form without disturbing the property. Write C code
for that.

O P
|
|
O B
/ / / O ? O ?

determine where do A and C go

69. Describe the file system layout in the UNIX OS
a) describe boot block, super block, inodes and data layout

70. In UNIX, are the files allocated contiguous blocks of data
a) no, they might be fragmented
how is the fragmented data kept track of
a) describe the direct blocks and indirect blocks in UNIX
file system

71. Write an efficient C code for 'tr' program. 'tr' has two command
line arguments. They both are strings of same length. tr reads an
input file, replaces each character in the first string with the
corresponding character in the second string. eg. 'tr abc xyz'
replaces all 'a's by 'x's, 'b's by 'y's and so on.
a) have an array of length 26.
put 'x' in array element corr to 'a'
put 'y' in array element corr to 'b'
put 'z' in array element corr to 'c'
put 'd' in array element corr to 'd'
put 'e' in array element corr to 'e'
and so on.

the code
while (!eof)
{
c = getc();
putc(array[c - 'a']);
}

72. what is disk interleaving

73. why is disk interleaving adopted

74. given a new disk, how do you determine which interleaving is the best
a) give 1000 read operations with each kind of interleaving
determine the best interleaving from the statistics

75. draw the graph with performace on one axis and 'n' on another, where
'n' in the 'n' in n-way disk interleaving. (a tricky question, should
be answered carefully)

76. I was a c++ code and was asked to find out the bug in that. The bug
was that he declared an object locally in a function and tried to
return the pointer to that object. Since the object is local to the
function, it no more exists after returning from the function. The
pointer, therefore, is invalid outside.

77. A real life problem - A square picture is cut into 16 sqaures and
they are shuffled. Write a program to rearrange the 16 squares to
get the original big square.

C++/C - convert an integer to string

2006-02-13T18:47:00.000-08:00

#include "stdafx.h"
#include [stdlib.h]
#include [iostream]

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
char buffer[20] ;
memset(buffer, '\0', 20);
cout << _itoa(2000, buffer, 10) << endl;
string str (buffer);
cout << str.size() << endl;
int i;
cin >> i;
return 0;
}

WinSock - simple Client/Server

2006-02-09T07:28:00.000-08:00

Program Flow of a simple TCP client
1. Initialize WinSock library using WSAStartup()
2. Create a IPPROTO_TCP SOCKET using socket()
3. Retrieve host information using gethostbyname()/gethostbyaddr()
4. Connect to the server using the socket we created, using connect()
5. Send and Receive data using send()/recv() till our tcp chat is over
6. Close the socket connection using closesocket()
7. De-Initialize WinSock using WSACleanup()

Program Flow of a simple TCP Server
1. Initialize WinSock library using WSAStartup()
2. Create a IPPROTO_TCP SOCKET using socket()
3. Use bind(), bind the socket to a special port
4. Using listen to wait for incoming connection
5. Use accept to set up a connection with client
6. Use send to send info to client
7. Use closesocket to close a connection
8. De-Initialize WinSock using WSACleanup()

Chinese characters - coding, storing and browsing

2006-02-07T12:27:00.000-08:00

Chinese characters are encoded different from English characters. There are some special steps you have to taken when coding, storing and browsing.

1. Visual studio
You can input Chinese characters in your source codes with IME. When you save the source codes, you have to use "save as", then in the popup window, chose "encode with UTF-8 with signature".
2. Database
In the table field where you store Chinese characters, under the "Collation" attribute, choose "Windows collation" then select "Chines PRC".

Visual Studio - Displaying an Assembly in the Add Reference Dialog Box

2006-02-02T10:45:00.000-08:00

The Add Reference dialog box does not automatically display every assembly, even if it has been installed to the Global Assembly Cache (GAC). The Add Reference dialog box is path based, and requires a registry key to be added that specifies the location of assemblies to display.

To display assemblies in the Add Reference dialog box

1. Add one of the following registry keys, where [AssemblyLocation] is the directory of the assemblies that you want to appear in the Add Reference dialog box, for example, C:\\MyAssemblies.

[HKEY_CURRENT_USER\SOFTWARE\Microsoft\.NETFramework\[version]\AssemblyFoldersEx\MyAssemblies]@="[AssemblyLocation]"

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\\AssemblyFoldersEx\MyAssemblies]@="[AssemblyLocation]"

Note
Creating the registry key under the HKEY_LOCAL_MACHINE hive allows all users to see the assemblies in the specified location in the Add Reference dialog box. Creating the registry key under the HKEY_CURRENT_USER hive only affects the setting for the current user.

If AssemblyFoldersEx does not work, change it to AssemblyFolders.

2. Restart Visual Studio.

http://msdn2.microsoft.com/en-us/library/ftcwa60a.aspx

Thread - background and fourground

2006-01-19T14:04:00.000-08:00

A thread is either a background thread or a foreground thread. Background threads are identical to foreground threads, except that background threads do not prevent a process from terminating. Once all foreground threads belonging to a process have terminated, the common language runtime ends the process by invoking Abort on any background threads that are still alive.

Call delegate - asynchronously and synchronously

2006-01-19T14:00:00.000-08:00

Use IAsyncResult BeginInvoke(
Delegate method,
object[] args
);

The delegate is called asynchronously, and this method returns immediately. You can call this method from any thread. If you need the return value from a process started with this method, call EndInvoke to get the value.

If you need to call the delegate synchronously, use the Invoke method instead.

C++ - static local variable

2006-01-18T19:54:00.000-08:00

Static local variables are not distroyed when out of scrope.
They are stored in stack but a permanent special section.

If the function is not called the first time, the initialization statement will be ignored and the value of previous call is kept.

If you have the address of the variable, you can manipulate it even you are not in the scope where it is define.

As such, they provide private and permanent storage for a function. When that function is invoked again, it will access the same calls variable.

CSS - Cascading Style Sheets

2006-01-16T15:05:00.000-08:00

About CSS the most important factors are:

3 Ways of defining CSS:
1. Directly associate it with HTML elements;
h1,h2,h3,h4,h5,h6
{
color: green
}
2. Associate it with class selector
p.right {text-align: right}
p.center {text-align: center}
When using,

This paragraph will be right-aligned.

You can omit the class selector here. Then it can be applied to all html elements.
3.Associate it with ID selector
#green {color: green}
The rule above will match both the h1 and the p element:

Some text

It does not have much different from the default class selector.
ID selector can be associated with the html elements also.
p#para1
{
text-align: center;
color: red
}

3 Places of putting CSS
1. External style sheet, defining the place inside the head element.

href="mystyle.css" />

2. Internal style sheet

3.Inline styles

This is a paragraph

Name conflicting styles from different places will be mixed and overrided.

Details of what can be defined with style sheet, see the reference:

http://www.w3schools.com/css/css_reference.asp

Abstract Classes vs. Interfaces

2006-01-15T13:05:00.000-08:00

If you anticipate creating multiple versions of your component, create an abstract class. Abstract classes provide a simple and easy way to version your components. By updating the base class, all inheriting classes are automatically updated with the change. Interfaces, on the other hand, cannot be changed once created. If a new version of an interface is required, you must create a whole new interface.

If the functionality you are creating will be useful across a wide range of disparate objects, use an interface. Abstract classes should be used primarily for objects that are closely related, whereas interfaces are best suited for providing common functionality to unrelated classes.

If you are designing small, concise bits of functionality, use interfaces. If you are designing large functional units, use an abstract class.

If you want to provide common, implemented functionality among all implementations of your component, use an abstract class. Abstract classes allow you to partially implement your class, whereas interfaces contain no implementation for any members.

Implement a binary search tree

2006-01-12T19:29:00.000-08:00

A sorted list make a search faster and easier. But maintaining a sorted list may be costly especially if you use a linked list.

In this case, a binary search tree will be very helpful. A binary search tree contains a root node, each node contains a data part and two pointers(left, right) pointing to its children nodes.(if not leaf nodes). Usually the right child is less than the parent node while the right pointer is bigger.

public class Tree_Node
{
public IComparable data
{
set{...};
get{...};
}IComparable _data;
public Tree_Node left
{
...
}Tree_Node _left;
poublic Tree_Node right
{
...
}Tree_Node _right;
public Tree_Node(Comparable x){ _data = x};
}

interface SearchTree
{
void insert(IComparable x);
void remove(IComparable x);
Tree_Node find(IComparable x);
}

public class BinarySearchTree : SearchTree
{
public Tree_Node root
{ ...
}Tree_Node _root;
pubic BinarySearchTree () {_root = null;}
void inert(IComparable x)
{
if(_root == null)
{
_root = new Tree_Node(x);
}else
{
insertNode(_root, x);
}
}
void insertNode(Tree_Node root, Icomparable x)
{
if(root.data.CompareTo(x) > 0)
{
if(root.left != null)
insertNode(root.left, x);
else
root.left = new Tree_Node(x);
}

if(root.data.CompareTo(x) < 0)
{
if(root.right != null)
insertNode(root.right, x);
else
root.right = new Tree_Node(x);
}

if(root.data.CompareTo(x) == 0) throw new Exception("Duplicated Item");
}

Tree_Node find(IComparable x)
{
Tree_Node current = root;
while(current != 0 && x.CompareTo(current.data) != 0)
{
if(current.CompareTo(x) > 0) current = current.right;
else current = current.left;
}
return current;
}

Tree_Node findMin(Tree_Node node)
{
if(node == null) throw Exception("");
while(node.left != null)
node = node.left;
return node;
}

void remove(IComparable x)
{
remove(x, root);
}
void removeMin(Tree_Node node)
{
TreeNode minNode = findMin(node);
TreeNode parent = findParent(minNode);
parent.left = minNode.right;
}
Tree_Node findParent(TreeNode node)
{
Tree_Node current = root;
Tree_Node parent = null;
if(node == null) throw ...;
while(current != 0 && node.data.CompareTo(current.data) != 0)
{
parent = current;
if(current.CompareTo(x) > 0) current = current.right;
else current = current.left;
}
return current;
}
void remove(Icomparable x, Tree_Node root)
{
if(root == null) throw Exception;
if(x.CompareTo(root.data) > 0)
remove(x, root.right);
else if(x.CompareTo(root.data) < 0)
remove(x, root.left);
else if(node.left != null && node.rgiht != null)
{
node.data = findMin(node.right);
removeMin(node.right);
}
else
{
node = (node.left == null) ? node.right : node.left;
}
}

}

Write a garbage collector for C++

2006-01-12T16:51:00.000-08:00

First you declare a smart pointer

templateclass auto_ptr
{
T* ptr;
public:
explicit auto_ptr(T* p = 0) : ptr(p){}
~auto_ptr{ delete ptr; }
T& operator*() { return *ptr;}
T* operator->() { return ptr; }
//
...
};

This simple smarter pointer will deallocate memory automatically when it is out of scope.

But if we just leave it like this, it will cause problems, mainly dangling pointers. For example, you assign the object, or you return this object in a function. In either case, default copy contructor will called and a shallow copy is made.

So we definitely need a copy structor. But this copy structor can do a deep copy, thus we wont have dangling pointers problem.(But we dont know the detail of T, or we need T itself has a copy contructor correctly implmented also?).

The above way does not use memory efficiently and has some uncertainities.

Thus we will consider the solution of shallow copy, at the same time add a reference counter, deallocate memory only if there is no reference.

First we need add a private struct counter in the smart pointer.

template class counted_ptr
{

private:
struct counter {
counter(X* p = 0, unsigned c = 1) : ptr(p), count(c) {}
X* ptr;
unsigned count;
}* itsCounter;
}

Then we need change the constructor, destructor

explicit counted_ptr(T* p = 0) // allocate a new counter
: itsCounter(0) {if (p) itsCounter = new counter(p);}

~counted_ptr{release();}

private :
release()
{
// decrement the count, delete if it is 0
if (itsCounter) {
if (--itsCounter->count == 0) {
delete itsCounter->ptr;
delete itsCounter;
}
itsCounter = 0;
}
}

Not enough yet, we need handle copy constructor and assignment operator, so that we will keep track the reference to the real pointer.

counted_ptr(const counted_ptr& r) throw()
{acquire(r.itsCounter);}

counted_ptr& operator=(const counted_ptr& r)
{
if (this != &r) {
release();
acquire(r.itsCounter);
}
return *this;
}

void acquire(counter* c) throw()
{ // increment the count
itsCounter = c;
if (c) ++c->count;
}

If you are careful, you will notice in the assignment operation, it checks to see whether it is same oject, other wise relasee the old one.

You can see that each possible way of referencing is tracked.

So far, the automactially memory management is done.

garbage collectors, tree, array, why, challenge

2006-01-12T13:31:00.000-08:00

http://msdn.microsoft.com/msdnmag/issues/1100/GCI/default.aspx

http://msdn.microsoft.com/msdnmag/issues/1200/GCI2/default.aspx

NextObjPtr

new operator

the global and static object pointers in an application are considered part of the application's roots.

http://ootips.org/yonat/4dev/smart-pointers.html

ASP.NET User control vs. Custom Control

2006-01-12T11:43:00.000-08:00

User control inherits from System.Web.UI.UserControl. It contains two parts a .ascx file and its code behind. All the code there follows same format of a normal aspx file.

To use a User control, you have to use a register directive that shows where the source file is. In the main code behind, you can treat it as a normal server control.

Custom control is derived from System.Web.UI.Control or System.Web.UI.WebControl. In each case, you have to override its Render method that takes one parameter that is System.Web.UI.HtmlTextWriter that will output the contents of the custom control. Web user control does not contain a visisble layout. You have to layaout the controls using html table yourself. You can either write html table as literals in CreateChildnControls or Put them in the Render method.

Deriving from web control makes ParseChildrenAttribute true.

Win32 - Summary of Synchronization Objects

2006-01-11T20:01:00.000-08:00

Critical Section
Critical sections are one of the more primitive synchronization objects in Win32. They synchronize exclusive access to shared data between threads within a single process. As long as no contention for gaining access to a critical section exists, the critical section code runs entirely in user mode, making it extremely fast. You don't have to pay the speed penalty of transitioning between user and kernel mode. When there is contention for a critical section, however, all is not lost; it simply falls back to using a kernel event object for synchronization. Because events are kernel objects, when there is contention, the relatively expensive transition to kernel mode must be made. But since the thread will block anyway, this transition time isn't usually very significant compared to the amount of time the thread is actually blocked. Because the critical section does not have a named kernel object associated with it, one of its main disadvantages is that it cannot synchronize access between processes.

Mutex
In Win32, a mutex is a kernel object. Implementing the mutex as a kernel object solves the critical section's main disadvantage. Mutexes can synchronize between processes, but this ability comes at the sake of speed. Each time a process calls a wait function such as WaitForSingleObject on a mutex, the relatively expensive transition between user mode and kernel mode is made. When there is no contention for the shared resource, and the mutex is waited on and released numerous times, the time for this transition can add up and increase the running time of the application. Like critical sections, mutexes can only be used to synchronize exclusive access.

Semaphore
Semaphores are very similar to mutexes. Like mutexes, semaphores are implemented as kernel objects. This gives them the same advantage of working across processes, and the same disadvantage of being relatively slow. However, a mutex and a semaphore differ in that a semaphore can do more than just provide exclusive access to shared data. Semaphores can be used for resource counting. Where mutexes and critical sections allow only one thread to gain access to a shared resource at a time, semaphores allow a set number of threads to gain access to a shared resource. Additionally, Windows CE does not currently support semaphores, which makes porting applications that rely heavily on semaphores to Windows CE more difficult.

Event
Events are primitive kernel synchronization objects on which other synchronization objects can be built. By themselves they are relatively slow, but they can synchronize access between processes by using named events. Depending on how they are used, events are capable of providing resource counting, but do not keep track of the count by themselves.

User-Level vs. Kernel Threads

2006-01-11T19:12:00.000-08:00

User-Level managed by application, while kernel-level managed by kernel.
Kernel not aware of user-level thread, while kernel-level consumes kernel resource
Context switching with user level thread is cheaper.
There is no limit on creating user level threads, but kernel-level is limited by kernel resources.
Kernel level is simpler to user.

OS - thread and process

2006-01-11T18:41:00.000-08:00

Process - unit of resource allocation.
A thread has no data segment or heap. A process has code/data/heap & other segments.
A thread cannot live on its own, it must live within a process. There must be at lease one thread in a process.
There can be more than one thread in a process, the first thread calls main & has the process's stack. Threads with a process share code/data/heap, share I/O, but each has its own stack®isters.
If a thread dies, its stack is reclaimed. If a process dies, its resources are reclaimed &all threads die.

Context switching is more expensive with process than thread.

Creating a new process is costly - all of the structures (eg. page tables) must be allocated.

Communicating between process is costly - most communication goes through the OS.

A thread is abound to a single process. Threads are the unit of scheduling. Processes are containers in which threads execute.

Demanding Security Permissions in C#

2006-01-10T13:48:00.000-08:00

There are two ways to demand security permissions in C#:

Imperatively: Using calls to permission classes in the .NET Framework
Declaratively: Using security permission attributes

Example 1: Imperative Security
The following is an example of using .NET Framework calls to deny the UnmanagedCode permission.

// ImperativeSecurity.cs
using System;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;

class NativeMethods
{
// This is a call to unmanaged code. Executing this method requires
// the UnmanagedCode security permission. Without this permission
// an attempt to call this method will throw a SecurityException:
[DllImport("msvcrt.dll")]
public static extern int puts(string str);
[DllImport("msvcrt.dll")]
internal static extern int _flushall();
}

class MainClass
{
private static void CallUnmanagedCodeWithoutPermission()
{
// Create a security permission object to describe the
// UnmanagedCode permission:
SecurityPermission perm =
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// Deny the UnmanagedCode from our current set of permissions.
// Any method that is called on this thread until this method
// returns will be denied access to unmanaged code.
// Even though the CallUnmanagedCodeWithPermission method
// is called from a stack frame that already
// calls Assert for unmanaged code, you still cannot call native
// code. Because you use Deny here, the permission gets
// overwritten.
perm.Deny();

try
{
Console.WriteLine("Attempting to call unmanaged code without permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code without permission. Whoops!");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code.");
}
}

private static void CallUnmanagedCodeWithPermission()
{
// Create a security permission object to describe the
// UnmanagedCode permission:
SecurityPermission perm =
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// Check that you have permission to access unmanaged code.
// If you don't have permission to access unmanaged code, then
// this call will throw a SecurityException.
// Even though the CallUnmanagedCodeWithPermission method
// is called from a stack frame that already
// calls Assert for unmanaged code, you still cannot call native
// code. Because you use Deny here, the permission gets
// overwritten.
perm.Assert();

try
{
Console.WriteLine("Attempting to call unmanaged code with permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code with permission.");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code. Whoops!");
}
}

public static void Main()
{
// The method itself will call the security permission Deny
// for unmanaged code, which will override the Assert permission
// in this stack frame.
SecurityPermission perm = new
SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
perm.Assert();
CallUnmanagedCodeWithoutPermission();

// The method itself will call the security permission Assert
// for unmanaged code, which will override the Deny permission in
// this stack frame.
perm.Deny();
CallUnmanagedCodeWithPermission();
}
}

Example 2: Declarative Security
This is the same example using attributes for the security permissions.

// DeclarativeSecurity.cs
using System;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;

class NativeMethods
{
// This is a call to unmanaged code. Executing this method requires
// the UnmanagedCode security permission. Without this permission,
// an attempt to call this method will throw a SecurityException:
[DllImport("msvcrt.dll")]
public static extern int puts(string str);
[DllImport("msvcrt.dll")]
internal static extern int _flushall();
}

class MainClass
{
// The security permission attached to this method will deny the
// UnmanagedCode permission from the current set of permissions for
// the duration of the call to this method:
// Even though the CallUnmanagedCodeWithoutPermission method is
// called from a stack frame that already calls
// Assert for unmanaged code, you still cannot call native code.
// Because this function is attached with the Deny permission for
// unmanaged code, the permission gets overwritten.
[SecurityPermission(SecurityAction.Deny, Flags =
SecurityPermissionFlag.UnmanagedCode)]
private static void CallUnmanagedCodeWithoutPermission()
{
try
{
Console.WriteLine("Attempting to call unmanaged code without permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code without permission. Whoops!");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code.");
}
}

// The security permission attached to this method will force a
// runtime check for the unmanaged code permission whenever
// this method is called. If the caller does not have unmanaged code
// permission, then the call will generate a Security Exception.
// Even though the CallUnmanagedCodeWithPermission method is called
// from a stack frame that already calls
// Deny for unmanaged code, it will not prevent you from calling
// native code. Because this method is attached with the Assert
// permission for unmanaged code, the permission gets overwritten.
[SecurityPermission(SecurityAction.Assert, Flags =
SecurityPermissionFlag.UnmanagedCode)]
private static void CallUnmanagedCodeWithPermission()
{
try
{
Console.WriteLine("Attempting to call unmanaged code with permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code with permission.");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code. Whoops!");
}
}

public static void Main()
{
SecurityPermission perm = new
SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// The method itself is attached with the security permission
// Deny for unmanaged code, which will override
// the Assert permission in this stack frame.
perm.Assert();
CallUnmanagedCodeWithoutPermission();

// The method itself is attached with the security permission
// Assert for unmanaged code, which will override the Deny
// permission in this stack frame.
perm.Deny();
CallUnmanagedCodeWithPermission();
}
}

HTTP module

2006-01-10T10:55:00.000-08:00

An HttpModule is an assembly that implements the IHttpModule interface and handles events.

[C#]
using System;
using System.Web;
using System.Collections;

public class HelloWorldModule : IHttpModule {
public String ModuleName {
get { return "HelloWorldModule"; }
}

// In the Init function, register for HttpApplication
// events by adding your handlers.
public void Init(HttpApplication application) {
application.BeginRequest += (new EventHandler(this.Application_BeginRequest));
application.EndRequest += (new EventHandler(this.Application_EndRequest));
}

// Your BeginRequest event handler.
private void Application_BeginRequest(Object source, EventArgs e) {
HttpApplication application = (HttpApplication)source;
HttpContext context = application.Context;
context.Response.Write("

HelloWorldModule: Beginning of Request

");
}

// Your EndRequest event handler.
private void Application_EndRequest(Object source, EventArgs e) {
HttpApplication application = (HttpApplication)source;
HttpContext context = application.Context;
context.Response.Write("

HelloWorldModule: End of Request

");
}

public void Dispose()
{
}
}

Libraries ---- ATL server, STL

2006-01-08T19:09:00.000-08:00

ATL Server :

. Active template Libary
. a set of native C++ classes
. To create high performance native code web applications and XML web services
. .SRF file means server response file. It is a tag file which is used togher with dlls written with ATL server.

STL:

.Standard template libraies

IP, UDP and TCP

2006-01-08T18:01:00.000-08:00

IP (Internet Protocol) belongs to newwork layer. Two most important fields in IP4 Datagram are: 32bit source IP Address and 32 bit Destination IP Address. The Data Field contains the tranport-layer segment - TCP or UDP) to be delivered to the destination.

UDP(User Datagram Protocol) Two most important fields in a UDP segment are Source port # and Dest Port #. These are very important information for (multiplexing and demultiplexing).

TCP (Transmission Control Protocol), comparing to UDP, TCP is a reliable protocol. In order to make the transmission more reliable, TCP adds more fields into its segment Header area. Some of the most important fields are:

32 bit sequence number
32 bit acknowledgement number - which is the next sequence nubmer of the next byte a host is expecting from the other host.
These two numbers are used for implementing a reliable data transfer service.

16bit window size field is used for flowing control so that it wont flood the receiver's buffer.
FLAG fields (RST, SYN, FIN...) are used for conection set up and teardonw. To establish a TCP connection, client sends a SYN request first with a sequence number (CSN), server replies with a SYNACK with a sequence number also and expecting client's CSN+1 byte, then client sends a ACk to SYNACK with a ack number (SSN + 1). This is called three-way handshake.

c++ -- constructor / destructor in inheritacne

2006-01-08T15:55:00.000-08:00

Constructors are not inherited. Base class has a constructor taking certain parameters does not mean that derived class will have this automatically. But constructors in parent class does impact the behaviors of derived classes. Each constructor in derived classes must call some constructor from its parent class. Each destructor in derived classes will automatically call destrctors from the parent class.

If you do not have any constructors defined, C++ will create a default constructor for you. But once you define a constructor, C++ compile will not give you the default constructor any more.

Default constructors are always called first in derived classes' contructors except for that you explicitly call a non-default constructor of the parent class.

If you defined a non-default contructor in your parent class and you did not define a default contructor, in your derived class, your constructor must explicitly call a constructor from the parent class. Otherwise, it will try to call default constructor and wont find it.

You can call a constructor in the parent like this:

class A : public B
{
A(int i) : B(i)
{};
}

Destructors are called always by derived classes's destructors. Just derived class's destructors are called first.

For constructors, C# inherits the same concept except for that when it call base constructors it does not go by name but use the keyword - "base".

Destructors is a totally different story in C# because of gabbage collection.

Inheritance - from C++ to C#

2006-01-08T09:04:00.000-08:00

Inheritance is a mechanism through which a subclass inherits the properties and behavior of its superclass.

Inheritance can be public, protected and private. Defalut inheritance is private. Developer can redeclare the "privated" members to public in derived class if that does not violate the encapsulation rule.

C++ allow multiple inheritance. It could easily cause ambiguities. One of the is caused by deriving from two classes that have same common base class. Your program might have two copies of the base class. To solve this ambiguity, C++ introduces virtual base class. On other words, you use the key word "virtual" when you inherit from base class.

Aother ambiguty caused by multiple inheritance is that parent classes may have same member names. When you program calls this function through the derived class, you have to point out from which parent you want the function from.

In addition to multiple inheritance, single inheritance could cause ambiguity also. Derived class could have a member function name the same as the one in its parent.

class A
{
public:
void foo()
{
cout << "A::foo"; } } class B : public class A { public: void foo() { cout << "B::foo"; } } A* a = new B; A* a = new A; b->foo(); C++ will simply call the foo function in base class. If you want to execute the function according to the real type of the instance, you have to use late binding that you declare the function as virtual in your base class.

C# gets rid of multiple inheritance. It introducts a new concept "interface". All members in interface is default to public and have to be public and without implementation. A class can implement more than one interfaces but can only inherit one parent class. This has eliminated lots of ambiguities but not all of them. For example, two interfaces could have mebers having the same name. Then, if you program implements those interfaces at the same time, you have to explicitly use the complete name. When you use this member, you have to convert the reference the related interface.

C# has only public inheritance.

c/c++ Pointers vs References

2006-01-07T20:31:00.000-08:00

Both pointers and References are used to hold memory addresses. There are three main differences:

1. Reference has to be initialized when you declare a reference variable. It must point to some variable.

2. Deference a pointer and reference are different.
For pinters, use *pt = 2;
For refences, directly use ref = 2;

3. Pointers can be involved in address calculation while reference can not.

In addition, reference is used often in operators overloading.

Casting operators in C++ and C#

2006-01-07T16:13:00.000-08:00

C++ support C style cast. It is also called explicitly cast. For example,

double d = 1.2;
int i = (int)d;

In the above case implicitly cast is not allowed by compiler because covert a double to int will lose information.

We treat the above explicitly casting operation as traditional explicit cast. It allows to to convert one type to any other type. And thus, if there is illegal cast, it depends on the run time to either return an error or throw out an exception. Sometimes, it could make the program in an undetermistic state.

To improve the cast opertion, C++ introduces for more cast operators:

reintepret_cast(expression), it acts just like triditional explicit cast. Thus it is not safe.

static_cast(expression), it casts between pointers that point to related classes, not only from children class to parent class but also from parent class to child class. It does not do run time check. Thus it improves performances comparing to dynamic_cast. But it is not safe and could leads to erros.

dynamic_cast(expression), just like static_cast, dynamic_cast casts pointers of related classes. But dynmaic_cast done run time checking, if a type mismatch is found, it will return a null. This is safer though it increases a little overhead. And dynamic cast can only cast pointers or references not like static_cast can cast numeric types also.

const_cast(expression), const_cast can remove const, volatile and _unaligned from types.

#include
class CCTest
{
public:
void setNumber( int );
void printNumber() const;
private:
int number;
};
void CCTest::setNumber( int num )
{ number = num; }

void CCTest::printNumber() const
{
cout << "\nBefore: " <<>( this )->number--;
cout << "\nAfter: " << number;
}

void main()
{
CCTest X;
X.setNumber( 8 );
X.printNumber();
}

C# is back to trditional casting, but it does not allow unrelated types casting. C# also introduce a new key work "as". If an cast can not be done, it returns a null. If we use explicit casting, we will get a run time exception at this case. C# also supplies a way of converting between value types and reference types called - boxing.

We can see that C# gives up arbitary casting and constant casting. From this, we can also see C# designers try to eliminate the possibles errors developer could made from language level.

"Case statement" - what has changed from C++ to C#

2006-01-06T12:57:00.000-08:00

Case statement has changed a little bit in C# than in C++.

The jump-statement is required after each block, including the last block whether it is a case statement or a default statement. Unlike the C++ switch statement, C# does not support an explicit fall through from one case label to another. If you want, you can use goto a switch-case, or goto default.

switch(n)
{
case 1:
cost += 25;
break;
case 2:
cost += 25;
goto case 1;
case 3:
cost += 50;
goto case 1;
default:
Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");
break;
}

Although fall through from one case label to another is not supported, it is allowed to stack case labels, for example:
case 0:
case 1:
// do something;

Then, why does c# act like this?

We know, on one hand, C++ is very flexible, it enables developer do lots of stuff, on the other hand, this creates some ambiguities and possible security problems. When designing C#, MS tried to ensure developers know what they are doing. For example, you can not override a method without the key word "override" and override is only associated with virtual functions. If a function is not virtual, you can not override it, instead, if developers really want to introduce new implementation, they have to use the key word "new".

We can see the "Clear Intention" principle in the language designing process. Bear this in mind, in the case statement case, we can see that c# is actually require developers clearly define what they want to go after the last statement in each case block. And applying this to the emplty case block senario, c# knows that if a developer intentionally leave a case block blank, clearly, the developer want sth, and it enables them to fall through to next case statement.

DataSet, DataReader and DataRelation

2006-01-05T15:29:00.000-08:00

DataReader is connected, forward-only, read-only.

DataSet uses SqlDataAdapter as a bridge between the connected and disconnected objects.DataSet can read and load itself from an XML document as well as export its rowset to an XML document.

DataRelation represents a parent/child relationship between two DataTable objects.

string and wstring

2006-01-04T07:36:00.000-08:00

Both string and wstring are created from a common template class called basic_string. wstring class is designed to support international character sets.

Why does the wireless network ask for a WEP key?

2005-12-19T07:51:00.000-08:00

You are try to connect your computer to a wireless network, but you can not get it because it asks you for a WEP key.

So, what is the WEP key?

WEP (wired equivalent privacy) is 802.11's optional encryption standard implemented in the MAC Layer that most radio network interface card (NIC) and access point vendors support. If a user activates WEP, the NIC encrypts the payload (frame body and CRC) of each 802.11 frame before transmission using an RC4 stream cipher provided by RSA Security. The receiving station, such as an access point or another radio NIC, performs decryption upon arrival of the frame. As a result, 802.11 WEP only encrypts data between 802.11 stations.

If a wireless is activating WEP, it will keep your computer out if you do not know the right WEP key.

Several valuable aspects from practice for coding

2005-12-14T12:56:00.000-08:00

1. Design

Design is always the first concern when coding. A good design should be less hard coding. A good design should be flexible. You should always think about questions like: what if there are changes, what if there are more functions to add, what if people want to reuse the piece you are writing......

2. Readability

Codes should be easily understoodable at least by your peer developers. You should always think, is the logic too tricky, are the names straightforward, are the names consistent with other codes......

3. Efficiency

Performance has to be a concern. Do you the big O of your implementation, is there something your can not tell in the codes, what if the load is huge...

4. Exception Handling

Codes have to handle exception nicely. "NULL" exception is the most frequently seen one. When ever you write come function or call some function with parameters, you have to think about, what if the parameter is null. Whereever there is a possibility of such thing, just do a condition checking. If there is something you are really not sure and can not do condition check easily, just use try and catch to handle it.

Some findings and Discussions about Moving From Crystal 9 to Crystal XI

2005-12-09T13:08:00.000-08:00

In the past couple of days, I've been evaluating Crystal XI with the following questions in my mind:
1) Does Crystal XI really have feature of "exporting reports to editable word documents"? If yes, how does it work?
2) Will our current crystal reports in IPlanner automatically work in the new Crystal XI environment?
3) Will our current crystal reports in Institution Equity automatically work in the new Crystal XI environment?
4) What have to be done to make our current Crystal reports work in Crystal XI environment?
5) Will the current reports still look the same in Crystal XI?
6) Can we develop reports in Crystal 9 now and lately run them in Crystal XI?
I did the evaluation in three ways: gooogling the internet, making some phone calls to Business Objects and most importantly testing and verifying the finding on the machine - iiss30ny1us12 where we've set up Crystal XI.
Here's What I find out. I will just go through them question by question.
1) Does Crystal XI really have feature of "exporting reports to editable word documents"? If yes, how does it work?
Crystal XI does start supporting making the exported reports editable in RTF format. This feature is very easy to use. It is just one more choice that you can make when you export the reports. However, editable RTF format right now have some limitations. One noticed thing is that editable RTF format can not contain lines and boxes in it. This has been confirmed from the supporting staff of Business Objects.
2) Will our current crystal reports from IPlanner automatically work in the new Crystal XI environment?
Crystal reports in IPlanner are written with Crystal managed APIs. The managed APIs are tied to version numbers. So the current reports won't automatically work in Crystal XI. However, ASP.NET allow us to redirect the dll dependency to difference versions. So, we can change the web.config file to redirect requests for Crystal 9 to Crystal 11. I tested the solution on iiss30ny1us12. It worked fine. But this is not all. One thing I noticed is that I have to tie the dataset schema to a file instead of a class from a project. This might be related to that the MS Visual Studio we are using now is not integrated with Crystal XI.
3) Will our current crystal reports from Institution Equity automatically work in the new Crystal XI environment?
The crystal reports in Institution Equity are delivered in an unmanaged way. This is no longer supported in Crystal XI (For more details about this, please reference the article (1)). Although those rpt files might be still useful, we have to find a managed way to deliver them in Crystal XI.
4) What have to be done to make our current Crystal reports work in Crystal XI environment?
This has been discussed in the above.
5) Will the current reports still look the same in Crystal XI?
Other than the editable RTF format, I compared a couple of reports in IPlanner generated with CR 9 and CR XI, I did not find any difference.
6) Can we develop reports in Crystal 9 now and lately run them on Crystal XI?
Yes, if we develop the reports by using managed API. But still there needs some extra steps that I mentioned in the discussion to question 2.

Some interesting links:
(1) Is URL reporting supported in Crystal Enterprise?, http://support.businessobjects.com/library/kbase/articles/c2016644.asp.
(2) Crystal Reports XI Feature Comparison by Version and Edition, http://www.businessobjects.com/pdf/products/crystalreports/crxi_feat_ver_ed.pdf

Issues and Solutions Related to Converting ASP.NET 1.x to ASP.NET2.0

2005-12-08T12:05:00.000-08:00

Common Web Project Conversion Issues and Solutions

change the dependency of a .Net assembly

2005-12-07T08:36:00.000-08:00

If an assembly references to other assemblies, those assemblies become dependencies of the assembly. These depenencies are written inside the meta data that are inserted when you build the assembly.

Those dependencies can be strong named asseblies. For a web application, you can change the dependencies between versions.

Here's what you have to do:

< runtime >
< assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
< dependentAssembly >
< assemblyIdentity name="CrystalDecisions.CrystalReports.Engine"
publicKeyToken="692fbea5521e1304"
culture="neutral" />
< bindingRedirect oldVersion="9.2.3300.0"
newVersion="11.0.3300.0"/>

Put this piece of instruction inside the web.config file, you can change the depencies between versions at runtime.

Design Pattern - One reason you better use a simple factory

2005-12-05T08:18:00.000-08:00

Sometimes for a little bit comlicated field in an object, you are not parameterize this field directly and in fact you need caculate from other fields and even more outside information. From time to time, you may need add such a field into your existed class. A simple way to add this would be:

YourClass yc = new YourClass();
yc.newField = Calculate();
......

The bad part about this method is that you have to add the line - yc.newField = Calculate() everywhere in your code where you have "new YourClass()". And in the future if you ever need add another such field, you need do this again. This is problematic, it is can cause some bug because it is very possible that you will miss one or places where you should do this.

Therefore, we should use the better way - A simple factory.

YourClass CreateYourClass()
{
YourClass yc = new YourClass();
yc.newField = Calculate();
......
return yc;
}

So if the client always use this method to generate instance, any time when you need add a new field, the client will automatically have it.

This sample should remind us that we better not create instances in the "hard code" way, instead, let's use factory.

Immigrate From Crystal 9 to Crystal 11

2005-12-02T09:29:00.000-08:00

We have two ways of using Crystal Report.

One is through CR integrated into .NET platform.

Here's the link I found that has feature comparison among different versions.

http://www.businessobjects.com/pdf/products/crystalreports/crxi_feat_ver_ed.pdf

My plan is to install the whole application on one machine, and then with the Crystal 11 already installed, we can test whether the current crystal report that is written in CR 9 still works fine in CR 11 environment.

Plan changed. Obviouse, CR9 report can not automatically run in CR11 environment. This is caused by "side by side" execution. So we change the dependency of current web application and instruct the web application to user CR11 instead of CR9.

This is the right step, but not the last step. CR11 has difficulty to find dataset which is previously put in web dll. So We told CR to use physically XSD file instead of the one in the dll. This fixed lots of problems.

Then another slight issue is to switch CR's own web documents.

Frequent used office compliment

2005-11-30T19:43:00.000-08:00

1.you look great today.（你今天看上去很棒。）【每天都可以用！】

2. you did a good job. （你干得非常好。）【国际最通用的表扬！】

3. we’re so proud of you.（我们十分为你骄傲。）【最高级的表扬！】

4. i’m very pleased with your work.（我对你的工作非常满意。）【正式、真诚的赞扬！】

5. this is really a nice place.（这真是个好地方！）【随口就说、但效果很好的表扬！】

6. you’re looking sharp!（你看上去真精神/真棒/真漂亮。）【与众不同的表扬！】

7. you always know the right thing to say.

= 8. you’re very eloquent.（你总是说话得体。）【高层次的表扬！】

9. nice going! = you did a good job.（干得好！）【极其地道的表扬！】

10. the food is delicious.（好吃！）【最普通、但非常重要的表扬！】

11. everything tastes great.（每样东西都很美味！）

12. your son/daughter is so cute.（你的孩子很可爱。）【外国人绝对喜欢听的表扬！】

13. what an adorable baby!（多么可爱的孩子。）【只管大胆用！】

14. i admire your work.

= 15. i respect your work.（我对你的工作表示敬意。）【世界通用！】

16. you’ve got a great personality.（你的个性很好。）【一个非常安全的表扬！】

17. you have a good sense of humor.（你真幽默。）【美国人极其喜欢的表扬！】

18. your chinese is really surprising.（你的中文令人惊讶。）【绝对和其他人不一样的表扬！】

19. your english is incredible.（我真不敢相信你的英语。）【用了六星级形容词！】

20. you have a very successful business.（你的事业很成功。）【现代人非常喜欢听！】

21. you’re very professional.（你非常专业。）【专业化的表扬！】

22. your company is very impressive.（你的公司给我留下深刻印象。）

23. you’re so smart.（你非常聪明。）

24. i envy you very much.（我非常羡慕你。）

25. your wife is very charming.（你的妻子很有魅力！）

26. you two make a lovely couple.（你们真是天生的一对！）

27. you’re really talented.（你很有天赋。）

28. you look nice in that color.（你穿那种颜色很好看。）

29. you have a good taste.（你很有品位。）

30. you look like a million dollars. = you look outstanding.=you look like a movie star.（你看上去帅呆了。）

Distributed computing is so easy with .Net Web Service

2005-11-01T15:11:00.000-08:00

Web Service in .Net is very easy to implement. It is a convenient way to provide functions and data to remote clients. And best of all, it is platform neutrol. You can use web service written in any language provided by any platform.

In .Net, to implement a web Service, you just need add an web service file (.asmx) into your web project. Then, you implement your methods with the attribute [WebMethod]. These methods will be available for remote clients.

For a client to consume web serice, in .Net it is very simple also. .Net provides a tool named wsdl.exe. You just need give the URI of a certain web service, the tool will generate a proxy locally for you to use. In your client, you use the proxy to create an instance of the web service, then you can call and method the web service provides.

Web Service is Cool!!!

The secret of crytal CUT-OFF

2005-11-01T11:31:00.000-08:00

Crystal sucks! Yes. It does! When it exports one report to MS Word format, it creates lots of problems. One of them is some of last line text gets cut-off.

Today, I believe I find the secret - the cause for this incident. When crystal exports its report document to MS Word format, it packs text into a series of text boxes. The sizes of the text boxes are procalculated and thus are fixed. Crystal does calculations based on the size of the text. However, MS seems to require some space pad in the right of box - there has to be some space between the text and the right border of the text box. And if a line of text is too long for the text box, it will wrap by MS to next line. But crystal does not seem to know this. So it calculates the height of box wrong at time when there is an exact wrap up - Cystal thinks there is space for a word in one line, but MS does not think so.

To solve this problem, I tried to pad an extra char at the end of the text. It works for right now.

Two new interesting features in ASP .NET 2.0

2005-10-31T14:23:00.000-08:00

ASP .NET 2.0 has introduced quite a few new features. Two of the interesting and very useful ones are: dynamically compiled classes and simplified code behind pages.

In ASP .NET 1.0 pre-compiled classes are either put in the BIN directory or in the GAC. This sometimes is very inconvenient for maintaining. For example, if you just need to fix a small thing in one code behind page, you have to rebuild the whole assembly to do a HOT FIX. This could bring undesired result to production environment because of reckless developers. Now, in ASP .NET 2.0, this is can be solved. It allows you to place shared class file sources in the App_Code directory, where they will be dynamically compiled just as ASPX pages. Thus, you can put frequently changing source classes here. So you don't have to rebuild the whole assembly when you have to do HOT FIXES.

Simplified code behind pages is also very convenient. In ASP .NET 1.0, aspx page is inherited from the class defined in code behind. So to access the controls defined in ASPX file, the code behind has to redefined it. If you have more than 15 controls, it will be very inconvenient. In ASP .NET 2.0, a new language feature called partial classes is used. The feature helps to make aspx and its code behind in one class when compiling. Now, you don't have to redefine controls in the aspx files.

Type Safe in C++, C# and Java

2005-10-27T07:39:00.000-07:00

Type Safe means data are accessed only in the way it allows to. This may be a little bit difficult to understand. Let's say more.

In OO language, encapsulation is one of the basic principle. Under this principle, data and the methods which are used to modify and access them are meld up together to form a type. Access modifiers such as "public, protected, private, internal, default, package and friend" are used to define who can or can not access the data. Data fields within a type are usually defined as private, that is, only members within the type can access them. By this, the outside of type can only access or modify the fields through publicly available interface. Therefore, the data fields can not randomly manipulated by outsiders, they can only be access and modify in certain ways that whose container defines. If these rules can be compromised, then the language is not type safe.

C++ is not type safe. This is mainly caused by that it gives developers so big powers to manipulate pointers. Look at the following example:

#include
using namespace std;

class A
{
private:
int i;
public:
A(){i=0;}
void Add_1(){i++;}
int Get_i()
{
return i;
}
};

class B
{
private:
int i;
public:
B(){i = 0;}
void Add_2()
{
i += 2;
}
int Get_i()
{
return i;
}
};

int _tmain(int argc, _TCHAR* argv[])
{
A* a = new A();
B* b = reinterpret_cast(a);
b->Add_2();
cout << a->Get_i() << "\n";
char ch;
cin >> ch;
return 0;
}

In the example above, integer i is a defined as private in type A. It should be accessed by clients only through the public methods defined in A, which in this case are Add and Get_i in A. However, the client, that is the main method, intentionally convert a pointer of type A's instance to a pointer pointing to an instance of type B. Then it calls B's method Add_2, that changes the value i that is origially defined as private in type A. This totally violates the intention of the designer of type A. Here data fields in type A can not avoid being manipulated by outsiders though it is defined as private. So it is not safe. In other words, C++ in not safe because it allows this happening.

C# is said to be verified type safe language. Though it will not allow cases like the example above happen.

Java was intended to be type safe. It does not allow randomly manipulate references. However, developers can find other ways to accomplish type-spoofing (1). Therefore, Java is not really type safe language.

(1)Vijay Saraswat, Java is not type-safe, http://www.cis.upenn.edu/~bcpierce/courses/629/papers/Saraswat-javabug.html.

A Comparative Overview of C#

2005-10-26T14:43:00.000-07:00

In June 2000, Microsoft announced both the .NET platform and a new programming language called C#. C# is a strongly-typed object-oriented language designed to give the optimum blend of simplicity, expressiveness, and performance. The .NET platform is centered around a Common Language Runtime (similar to a JVM) and a set of libraries which can be exploited by a wide variety of languages which are able to work together by all compiling to an intermediate language (IL). C# and .NET are a little symbiotic: some features of C# are there to work well with .NET, and some features of .NET are there to work well with C# (though .NET aims to work well with many languages). This article is mostly concerned with C#, but sometimes it is useful to discuss .NET too. The C# language was built with the hindsight of many languages, but most notably Java and C++. It was co-authored by Anders Hejlsberg (who is famous for the design of the Delphi language), and Scott Wiltamuth.

Contents

C# and Java

Properties

Indexers

Delegates

Events

Enums

Collections and the Foreach Statement

Structs

Type Unification

Operator Overloading

Polymorphism

Interfaces

Versioning

Parameter Modifiers

Attributes

Selection Statements

Predefined Types

Field Modifiers

Jump Statements

Assemblies, Namespaces & Access Levels

Pointer Arithmetic

Rectangular Arrays

Constructors and Destructors

Managed Execution Environments

Libraries

Interoperability

Conclusion

1. C# and Java

Below is a list of features C# and Java share, which are intended to improve on C++. These features are not the focus of this article, but it is very important to be aware of the similarities.

Compiles into machine-independent language-independent code which runs in a managed execution environment.

Garbage Collection coupled with the elimination of pointers (in C# restricted use is permitted within code marked unsafe)

Powerful reflection capabilities

No header files, all code scoped to packages or assemblies, no problems declaring one class before another with circular dependencies

Classes all descend from object and must be allocated on the heap with new keyword

Thread support by putting a lock on objects when entering code marked as locked/synchronized

Interfaces, with multiple-inheritance of interfaces, single inheritance of implementations

Inner classes

No concept of inheriting a class with a specified access level

No global functions or constants, everything belongs to a class

Arrays and strings with lengths built-in and bounds checking

The "." operator is always used, no more ->, :: operators

null and boolean/bool are keywords

All values are initialized before use

Can't use integers to govern if statements

Try Blocks can have a finally clause

2. Properties

Properties will be a familiar concept to Delphi and Visual Basic users. The motivation is for the language to formalize the concept of getter/setter methods, which is an extensively used pattern, particularly in RAD (Rapid Application Development) tools.

This is typical code you might write in Java or C++:

foo.setSize (getSize () + 1);
label.getFont().setBold (true); The same code you would write like this in C#: foo.size++;
label.font.bold = true; The C# code is immediately more readable by those who are using foo and label. There is similar simplicity when implementing properties:

Java/C++:

public int getSize() {
return size;
}
public void setSize (int value) {
size = value;
}
C#: public int Size {
get {return size;
}
set {size = value;
}
} Particularly for read/write properties, C# provides a cleaner way of handling this concept. The relationship between a get and set method is inherent in C#, while has to be maintained in Java or C++. There are many benefits of this approach. It encourages programmers to think in terms of properties, and whether that property is most natural as read/write vs read only, or whether it really shouldn't be a property at all. If you wish to change the name of your property, you only have one place to look (I've seen getters and setter several hundred lines away from each other). Comments only have to be made once, and won't get out of sync with each other. It is feasible that an IDE could help out here (and in fact I suggest they do), but one should remember an essential principle in programming is to try to make abstractions which model our problem space well. A language which supports properties will reap the benefits of that better abstraction.

One possible argument against this being a benefit is that you don't know if you're manipulating a field or a property with this syntax. However, almost all classes with any real complexity designed in Java (and certainly in C#) do not have public fields anyway. Fields typically have a reduced access level (private/protected/default) and are only exposed through getter/setters, which means one may as well have the nicer syntax. It is also totally feasible an IDE could parse the code, highlighting properties with a different color, or provide code completion information indicating if it is a property or not. It should also be noted that if a class is designed well, then a user of that class should only worry about the specification of that class, and not its implementation. Another possible argument is that it is less efficient. As a matter a fact, good compilers can in-line the default getter which merely returns a field, making it just as fast as field. Finally, even if using a field is more efficient that a getter/setter, it is a good thing to be able to change the field to a property later without breaking the source code which relies on the property.

3. Indexers

C# provides indexers allow objects to be treated like arrays, except that like properties, each element is exposed with a get and/or set method.

public class Skyscraper
{
Story[] stories;
public Story this [int index] {
get {
return stories [index];
}
set {
if (value != null) {
stories [index] = value;
}
}
}
...
}

Skyscraper empireState = new Skyscraper (...);
empireState [102] = new Story ("The Top One", ...); 4. Delegates

A delegate can be thought of as a type-safe object-oriented function pointer, which is able to hold multiple methods rather than just one. Delegates handle problems which would be solved with function pointers in C++, and interfaces in Java. It improves on the function pointer approach by being type safe and being able to hold multiple methods. It improves on the interface approach by allowing the invocation of a method without the need for inner-class adapters or extra code to handle multiple-method invocations. The most important use of delegates is for event handling, which is in the next section (which gives an example of how delegates are used).

5. Events

C# provides direct support for events. Although event handling has been a fundamental part of programming since programming began, there has been surprisingly little effort made by most languages to formalize this concept. If you look at how today's mainstream frameworks handle events, we've got examples like Delphi's function pointers (called closures), Java's inner class adaptors, and of course, the Windows API's message system. C# uses delegates along with the event keyword to provide a very clean solution to event handling. I thought the best way to illustrate this was to give an example showing the whole process of declaring, firing, and handling an event:

// The Delegate declaration which defines the signature of methods which can be invoked
public delegate void ScoreChangeEventHandler (int newScore, ref bool cancel);

// Class which makes the event
public class Game {
// Note the use of the event keyword
public event ScoreChangeEventHandler ScoreChange;

int score;

// Score Property
public int Score {
get {
return score;
}
set {
if (score != value) {
bool cancel = false;
ScoreChange (value, ref cancel);
if (! cancel)
score = value;
}
}
}
}

// Class which handles the event
public class Referee
{
public Referee (Game game) {
// Monitor when a score changes in the game
game.ScoreChange += new ScoreChangeEventHandler (game_ScoreChange);
}

// Notice how this method signature matches the ScoreChangeEventHandler's signature
private void game_ScoreChange (int newScore, ref bool cancel) {
if (newScore < cancel =" true;" game =" new" referee =" new" score =" 70;" score =" 110;">

In the GameTest we make a game, make a referee who monitors the game, then change the game's score to see what the referee does in response to this. With this system, the Game has no knowledge of the Referee at all, and simply lets any class listen and act on changes made to its score. The event keyword hides all the delegate's methods apart from += and -= to classes other than the class it is declared in. These operators allow you to add (and remove) as many event handlers as you want to the event.

You will probably first encounter this system in GUI frameworks, where the Game would be analogous to UI widgets which fire events according to user input, and the referee would be analogous to a form, which would process the events.

Delegates were first introduced in Microsoft's Visual J++ also designed by Anders Hejlsberg, and were a cause of much technical and legal dispute between Sun and Microsoft. James Gosling, the man who designed Java made a condescending though humorous comment about Anders Hejlsberg, saying his attachment to Delphi made him "Mr. Method Pointers". After examining the arguments against delegates made by Sun, I believe it would be fair to call Gosling "Mr. Everything's-a-Class". In the last few years of programming "make abstractions which try to model reality well" has been replaced by many people with "Reality is object-oriented, so we should model it with object oriented abstractions".

Sun's and Microsoft's arguments for and against delegates can be found at:

http://www.Javasoft.com/docs/white/delegates.html
http://msdn.microsoft.com/visualj/technical/articles/delegates/truth.asp

6. Enums

In case you don't know C, Enums let you specify a group of objects, e.g.:

Declaration:

public enum Direction {North, East, West, South};
Usage: Direction wall = Direction.North;
It's a nice construct, so perhaps the question is not why did C# decide to have them, but rather, why did Java choose to omit them? In Java, you would have to go:

Declaration:

public class Direction {
public final static int NORTH = 1;
public final static int EAST = 2;
public final static int WEST = 3;
public final static int SOUTH = 4;
}

Usage:

int wall = Direction.NORTH;
Despite the fact the Java version seems to express more, it doesn't, and is less type-safe, by allowing you to accidentally assign wall to any int value without the compiler complaining. To be fair, in my experience of Java programming I haven't wasted much time on writing a few extra tokens and tracking down an error because of lack of type-safety here, but nonetheless, this is nice to have. One benefit of C# is the nice surprise you get when debugging - if you put a break point on an enumeration which holds combined enumerations, it will automatically decode direction to give you a human readable output, rather than a number you have to decode:

Declaration:

public enum Direction {North=1, East=2, West=4, South=8};
Usage:
Direction direction = Direction.North Direction.West;
if ((direction & Direction.North) != 0)
....

If you put a breakpoint on the if statement, you'll get the human readable version for direction rather than the number 5.

The mostly likely reason why enums are absent in Java is that you can get by using classes instead. As I mentioned in previous sections, with classes alone we are not able to express a feature in the world as well as we could with another construct. What are the benefits of the Java philosophy of "if it can be done by a class, then don't introduce a new construct"? It would seem simplicity would be the biggest benefit - a shorter learning curve and the prevention of programmers having to think of multiple ways of doing things. Indeed the Java language has improved on C++ in many ways by aiming for simplicity, such as the elimination of pointers, the elimination of header files, and a single-rooted object hierarchy. However, a common aspect of all these simplifications is they actually make coding - uh - simpler. Leaving out constructs, we've looked at enums, properties and events so far, makes your coding more complicated.

7. Collections and the Foreach Statement

C# provides a shorthand for for-loops, which also encourages increased consistency for collections classes:

In Java or C++:

1. while (! collection.isEmpty()) {
Object o = collection.get();
collection.next();
...
2. for (int i = 0; i <>

In C#:

1. foreach (object o in collection)...
2. foreach (int i in array)...

The C# for-loop will work on collection objects (arrays implement a collection). Collection objects have a GetEnumerator() method which returns an Enumerator object. An Enumerator object has a MoveNext method and a Current property.

8. Structs

It is helpful to view C# structs as a construct which makes the C# type system work elegantly, rather than just "a way to write really efficient code if you need to".

In C++, both structs and classes (objects) can be allocated on the stack/in-line or on the heap. In C#, structs are always created on the stack/in-line, and classes (objects) are always created on the heap. Structs indeed allow more efficient code to be created:

public struct Vector {
public float direction;
public int magnitude;
}

Vector[] vectors = new Vector [1000];

This will allocate the space for all 1000 vectors in one lump, which is much more efficient that had we declared Vector as a class and used a for-loop to instantiate 1000 individual vectors. What we've effectively done is declared the array like we would declare an int array in C# or Java:

int[] ints = new ints [1000];

C# simply allows you to extend the primitive set of types built in to the language. In fact, C# implements all the primitive types as structs. The int type merely aliases System.Int32 struct, the long type aliases System.Int64 struct etc. These primitive types are of course able to be treated specially by the compiler, but the language itself does not make such a distinction. The next section shows how C# takes advantage of this.

9. Type Unification

Most languages have primitive types (int, long, etc), and higher level types which are ultimately composed of primitive types. It is often useful to be able to treat primitive types and higher level types in the same way. For instance, it is useful to have collections which can take both ints as well as strings. Smalltalk achieves this by sacrificing some efficiency and treating ints and longs as types like String or Form. Java tries to avoid sacrificing this efficiency, and treats primitive types like in C or C++, but provides corresponding wrapper classes for each primitive - int is wrapped by Integer, double is wrapped by Double. C++'s templates allow code to be written which takes any type, so long as the operations done on that type are provided by that type.

C# provides a different solution to this problem. In the previous section, I introduced C# structs, explaining how primitive types like int were merely aliases for structs. This allows code like this to be written, since structs have all the methods that the object class does:

int i = 5;
System.Console.WriteLine (i.ToString());

If we want to use a struct as an object, C# will box the struct in an object for you, and unbox the struct when you need it again:

Stack stack = new Stack ();
stack.Push (i); // box the int
int j = (int) stack.Pop(); // unbox the int

Apart from a type-cast required when unboxing structs, this is a seamless way to handle the relationship between structs and

classes. You should bare in mind that boxing does entail the creation of a wrapper object, though the CLR may provide additional optimization for boxed objects.

The designers of C# must have considered templates during their design process. I suspect there were two main reasons for not using templates. The first is messiness - templates can be difficult to mesh with object oriented features, they open up too many (confusing) design possibilities for programmers, and they are difficult to work with reflection. The second is that templates wouldn't be very useful unless the .NET libraries like the collection classes used them. However, if the .NET classes used them, then the 20+ languages which use the .NET classes would have to work with templates too, which may be technically very difficult to achieve.

It is interesting to note that templates (generics) are being considered for inclusion in the Java language by the Java Community Process. It may be that each company starts singing each other's tunes when Sun says that ".NET suffers from lowest common denominator syndrome", and Microsoft says "Java doesn't have cross-language support".

(Amended 10 August) From reading an interview with Anders Hejlsberg, it appears templates are on the horizon, but not for the first release, for the difficulties which were suggested above. It was very interesting to see that the IL specification was written so that the IL code could represent templates (in a non-destructive way so that reflection works well), while byte-code was not. I've also included a link to the Java Community Process for considering generics in java:

10. Operator Overloading

Operator overloading allows programmers to build types which feel as natural to use as simple types (int, long, etc.). C# implements a stricter version of operator overloading in C++, but it allows classes such as the quintessential example of operator-overloading, the complex number class, to work well.

In C#, the == operator is a non-virtual (operators can't be virtual) method of the object class which compares by reference. When you build a class, you may define your own == operator. If you are using your class with collections, then you should implement the IComparable interface. This interface has one method to implement, called the CompareTo (object) method, which should return positive, negative, or 0 if "this" is greater, less than, or the same value as the object. You may choose to define <, <=, >=, > methods if you want users of your class to have a nicer syntax. The numeric types (int, long, etc) implement the IComparable interface.

Here's a simple example of how to deal with equality and comparisons:

public class Score : IComparable
{
int value;

public Score (int score) {
value = score;
}

public static bool operator == (Score x, Score y) {
return x.value == y.value;
}

public static bool operator != (Score x, Score y) {
return x.value != y.value;
}

public int CompareTo (object o) {
return value - ((Score)o).value;
}
}

Score a = new Score (5);
Score b = new Score (5);
Object c = a;
Object d = b;

To compare a and b by reference:

System.Console.WriteLine ((object)a == (object)b; // false

To compare a and b by value:

System.Console.WriteLine (a == b); // true

To compare c and d by reference:

System.Console.WriteLine (c == d); // false

To compare c and d by value:

System.Console.WriteLine (((IComparable)c).CompareTo (d) == 0); // true

You could also add the <, <=, >=, > operators to the score class. C# ensures at compile time that operators which are logically paired (!= and ==, > and <, >= and <=), must both be defined.

11. Polymorphism

Virtual methods allow object oriented languages to express polymorphism. This means a derived class can write a method with the same signature as a method in its base class, and the base class will call the derived class's method. By default in Java, all methods are virtual. In C#, like C++, the virtual keyword must be used so that the method will be called by the base class.

In C#, it is also required that the override keyword is needed to specify that a method should override a method (or implement an abstract method) of its base class.

Class B {
public virtual void foo () {}
}

Class D : B {
public override void foo () {}
}

Attempting to override a non-virtual method will result in a compile-time error unless the "new" keyword is added to the declaration, indicating the method is intentionally hiding the base class's method.

Class N : D {
public new void foo () {}
}

N n = new N ();
n.foo(); // calls N's foo
((D)n).foo(); // calls D's foo
((B)n).foo(); // calls D's foo

In contrast to both C++ and Java, requiring the override keyword makes it more clear what methods are overridden when looking at source code. However, requiring the use of the virtual method has its pros and cons. The first pro is that is the slightly increased execution speed from avoiding virtual methods. The second pro is to make clear what methods are intended to be overridden. However, this pro can also be a con. Compare the default option of leaving out a final modifier in Java vs leaving out a virtual modifier in C++. The default option in Java may make your program slightly less efficient, but in C++ it may prevent extendibility, albeit unforeseen, by the implementer of the base class.

12. Interfaces

Interfaces in C# are similar to Java interfaces, but can be used with greater flexibility. A class may optionally "explicitly" implement an interface:

public interface ITeller
{
void Next ();
}

public interface IIterator
{
void Next ();
}

public class Clark : ITeller, IIterator
{
void ITeller.Next () {
}
void IIterator.Next () {
}
}

This gives a class two benefits. First, a class can implement several interfaces without having to worry about naming conflicts. Second, it allows a class to "hide" a method if it is not useful for general users of the class. Explicitly implemented methods are invoked by type-casting a class to the interface required:

Clark clark = new Clark ();
((ITeller)clark).Next();

13. Versioning

Solving versioning issues has been a major consideration in the .NET framework. Most of these considerations apply to assemblies. There are some quite impressive capabilities such as running multiple versions of the same assembly in the same process.

The C# language prevents software failures when new versions of code (most notably the .NET libraries) are made. The C# Language Reference explains this in detail, but I've summarized the problem with a highly condensed example:

In Java, supposing we deploy a class called D which derives a class distributed with the VM, called B. Class D has a method called foo which B does not have at the time of distribution. Later, an update is made to class B, which now includes a foo method, and the new VM is installed on the computer running software which uses class D. The software using class D may malfunction because the new implementation of class B will make a virtual call to class D, performing an action with an implementation totally unintended by class B. In C#, class D's foo would have been declared without the override modifier (which expresses the programmer's intention), so the runtime knows to make Class D's foo hide Class B's foo, rather than override it.

An interesting quote from the C# reference manual was: "C# addresses this versioning problem by requiring developers to clearly state their intent". Although the use of the word override is one way to state intention, it could also be automatically generated by the compiler by checking to see if a method performs (rather than declares) an override at the time of compilation. This means you can still have Java-like languages (which don't use virtual and override keywords) and still cope with versioning correctly.

Also see Field Modifiers

14. Parameter Modifiers

"ref" parameter modifier

C# (as opposed to Java) lets you pass parameters by reference. The most obvious example to illustrate the point of this is the general purpose swap method. Unlike in C++, you must specify when calling as well as when declaring a method which takes ref parameters:

public class Test
{
public static void Main ()
{
int a = 1;
int b = 2;
swap (ref a, ref b);
}

public static void swap (ref int a, ref int b) {
int temp = a;
a = b;
b = temp;
}
}

"out" parameter modifier

There is also an "out" keyword, which is a natural complement to the ref parameter modifier. While the ref modifier requires that a value is definitely assigned before passed into a method, the out modifier requires that the method's implementation definitely assigns the parameter a value before returning.

"params" parameter modifier

The params modifier may be added to the last parameter of a method so that the method accepts any number of parameters of a particular type. For example:

public class Test
{
public static void Main () {
Console.WriteLine (add (1, 2, 3, 4).ToString());
}

public static int add (params int[] array) {
int sum = 0;
foreach (int i in array)
sum += i;
return sum;
}
}

One of the most surprising things when you're learning Java is not being able to pass by reference. It turns out though that after a little while you seldom miss this functionality, and write code which doesn't use it it. When I went over the C# specification for the first time, I often thought "Why have they got this or that functionality, I can code without it". With a little introspection, I realized this wasn't really an argument to show some functionality wasn't useful, but was more an argument to show that you get conditioned into getting by without it.

Java did a good thing when it simplified how parameters could be passed when you consider what C++ does. In C++, parameters of a method and a method call pass in values or references, which in addition to having pointers, can lead to unnecessarily complicated code. C# makes passing by reference explicit for both the method and the method call, which greatly alleviates any confusion, thus achieving the same goal as Java, but with greater expressiveness. It is clearly a theme of C# to not hedge programmers into situations where they require a round-about way of achieving something. Remember those Java tutorials that suggest that to overcome the pass-by-reference problem, you should pass a 1-element array to holding your value, or make another class to hold that value?

15. Attributes

Both C# and Java contain information such as the access level of a field in the compiled code. C# generalizes this ability, so you can compile custom information about just about any element of code such as a class, method, field and even individual parameters. This information can be retrieved at run-time. Here is a very simple example of a class which makes use of attributes:

[AuthorAttribute ("Ben Albahari")]
class A
{
[Localizable(true)]
public String Text {
get {return text;
}
...
}
}

Java uses a combination of /** */ and @tag comments to include additional information about classes and methods, but this information (apart from the @deprecated) is not built into the byte code. C# uses the pre-defined attributes ObsoleteAttribute so the compiler can warn you against obsolete code (like @deprecated), and the ConditionalAttribute to enable conditional compilation. Microsoft's new XML libraries utilize attributes to express how fields should be serialized into XML, which means you can easily turn a class into XML and then reconstruct it again. Another apt use for attributes is for the creation of a really powerful class browsing tool. The C# Language Reference explains exactly how to create and use attributes.

16. Selection Statements

C# lets you govern a switch statement with an integral type, char, enum or (unlike C++ or Java) a string. In Java and C++ if you leave out a break after each case statement you risk having another case statement being executed. I have no idea why this rarely needed error-prone behavior was made the default behavior in Java and C++, and I'm glad to see C# doesn't do this.

17. Predefined Types

The C# primitive types are basically the same as the ones in Java except they add unsigned types to. We've got sbyte, byte, short, ushort, int, uint, long, ulong, char, float & double. The only surprise here is the 12-byte "decimal" floating point number which can take advantage of the latest processors.

18. Field Modifiers

Again, the field modifiers are basically the same as the ones in Java. To express fields which can't be modified, C# uses the const and readonly modifiers. A const field modifier is like the Java final field modifier, and compiles so that the actually value is part of the IL code. A readonly modifier compiles so that at run-time the value is evaluated. This allows an upgrade, say to one one of the standard C# libraries, without breaking your deployed code.

19. Jump Statements

Not many surprises here, apart from perhaps the infamous goto. However, it's really a distant relative of the evil goto statement we remember from basic 20 years ago. A goto statement must point to a label or one of the options in a switch statement. The first usage of pointing to a label is similar to the usage of a continue : label statement in Java, except with a little more freedom. Such a goto statement may point anywhere within its scope, which restricts it to the same method, or finally block if it is declared within one. It may not jump into a loop statement which it is not within, and it cannot leave a try block before the enclosing finally block(s) are executed. The continue statement in C# is equivalent to the continue statement in Java, except it can't point to a label.

20. Assemblies, Namespaces & Access Levels

In C#, you can organize the components of your source-code (classes, structs, delegates, enums, etc.) into files, namespaces & assemblies.

Namespaces are nothing but syntactic sugar for long class names. For instance, rather than calling a class Genamics.WinForms.Grid you can declare the class as Grid and enclose the class with:

namespace Genamics.WinForms {
public class Grid {
....
}
}

For classes which use Grid, you can import it using the "using" keyword instead of referring to its full class name Genamics.WinForms.Grid.

Assemblies are .exes or .dlls generated from compiling a project of files. The .NET runtime uses the configurable attributes and versioning rules built into assemblies to greatly simplify deployment - no more hacking the registry - just copy the assembly into a directory and it goes. Assemblies also form a type-boundary to deal with type-name collisions, to the extent that multiple versions of an assembly can co-exist in the same process. Each file can contain multiple classes and multiple namespaces. A namespace may also be spread across several assemblies, so there is high level of freedom with this system.

There are five access levels in C#, private, internal, protected, internal protected, and public. Private and public have the same meanings as in Java, noting that in C# the default access level is private, rather than package. Internal access is scoped to assemblies rather than namespaces (which would be more analogous to Java). Internal protected access is equivalent to Java's protected access, and protected access is equivalent to Java's private protected access made obsolete in Java some time ago.

21. Pointer Arithmetic

Pointer arithmetic can be performed in C# within methods marked with the unsafe modifier. When pointers point to garbage collected objects, the compiler enforces the use of the fixed word to pin the object. This is because garbage collectors rely on moving objects around to reclaim memory, but if this happens when you're dealing with raw pointers you'll be pointing at garbage. The choice of the word "unsafe" I believe is well chosen since it discourages developers from using pointers unless they really need to.

22. Rectangular Arrays

C# allows both jagged and rectangular arrays to be created. Jagged arrays are pretty much the same as Java arrays. Rectangular arrays allow a more efficient and accurate representation for certain problems. An example of such an array would be:

int [,,] array = new int [3, 4, 5]; // creates 1 array
int [1,1,1] = 5;

Using jagged arrays:

int [][][] array = new int [3][4][5]; // creates 1+3+12=16 arrays
int [1][1][1] = 5;

In combination with structs, C# can provide a level of efficiency making it a good choice for areas such as graphics and mathematics.

23. Constructors and Destructors

You can specify optional constructor parameters:

class Test
{
public Test () : this (0, null) {}
public Test (int x, object o) {
}
}

You can specify static constructors:

class Test
{
static int[] ascendingArray = new int [100];

static Test () {
for (int i = 0; i <>

Destructors are specified with the C++ naming convention using the ~ symbol. Destructors can only be made for references types and not value types, and cannot be overridden. A destructor can not be explicitly called, since it doesn't make much sense to do so when an object's lifetime is managed by the garbage collector. Each destructor in an object's hierarchy (from the most derived to the least derived) is called before the memory for the object is reclaimed.

Despite the naming similarity with C++, destructors in C# are much more like Java finalizers. This is because they are called by the garbage collector rather than explicitly called by the programmer. Furthermore, like Java finalizers, they cannot be guaranteed to be called in all circumstances (this always shocks everyone when they first discover this). If you are used to programming with deterministic finalization (you know when an object's destructor is called), then you have to adapt to a different model when moving to Java or C#. The model Microsoft recommends and implements throughout the .NET framework is the dispose pattern, whereby you define a dispose() method to for classes which manage foreign resources such as graphics handles or database connections. For distributed programming, the .NET framework provides a leased based model to improve upon DCOM reference counting.

24. Managed Execution Environments

The comparison between [C#/IL Code/CLR] and [Java/Byte-Code/JVM] is an inevitable and valid comparison to make. I thought the best way to make sense of these comparisons was to explain why these technologies were made in the first place.

With C and C++ programs, you generally compile the source code to assembly language code which will only run on a particular processor and a particular OS. The compiler needs to know which processor it is targeting, because processors vary in their instruction sets. The compiler also needs to know what OS it is targeting, because OSs vary in ways such as how executables work and how they implement some basic C/C++ constructs such as allocating memory. This C/C++ model has been very successful (most software you're using probably has been compiled like this), but has its limitations:

Does not provide a program with a very rich interface to interact with other programs (Microsoft's COM was built to address this limitation)
Does not allow a program to be distributed in a form which can be used as is on different platforms
Does not allow a program's execution to be limited to a sand box of safe operations

Java addressed these problems in the same way Smalltalk had done before it by having Java compile to byte-code which then runs on a virtual machine. Byte-code maintains the basic structure of a program before it is compiled, thus making it possible for a Java program to richly interact with another program. Byte-code is also machine-independent, which means the same class file can be used on a number of platforms. Finally, the fact that the Java language did not have explicit memory manipulation (via pointers) made it well suited to writing sand-boxed programs.

Originally virtual machines had an interpreter which converted a stream of byte-code instructions to machine code on the fly, but this dreadfully slow process was never appealing to the performance conscious programmer. Today most Java Virtual Machines use a Just-In-Time compiler which basically compiles to machine-code class skeletons just before they enter scope and method bodies just before they are executed. It is also possible to convert a Java program to assembly language before it runs to eliminate the overhead in start-up time and memory of a Just-In-Time compiler. As with compiling a Visual C++ program, this process does not necessarily remove the program's dependence on a runtime. The Java runtime (also covered by the term "Java Virtual Machine") will handle many vital parts of the programs execution such as garbage collection and security. This runtime is referred to as a managed execution environment.

Though somewhat obscured by terminology, the basic model .NET uses is the same as described above, though it was built to never use intepreting. Important improvements .NET will offer will come from the IL design itself, since the only way Java can match such improvements is by changing the byte-code specification which would generate serious compatibility issues. I don't want to discuss in detail these improvements - it should be left to those rare developers who understand both byte-code and IL-code. For the 99% of developers like myself who realistically aren't going to be studying the IL-Code specification, here are some of the design decisions for IL which are intended to improve upon byte-code:

To provide greater type neutrality (helps implementing templates)
To provide greater language neutrality
To always be compiled to assembly language before executing, and never interpreted
To allow additional declarative information to be added to classes, methods, etc., see 15. Attributes

Currently the CLR has yet to provide multi-OS support, but provides greater interoperability to JVMs in other areas (See 26. Interoperability)

25. Libraries

A language is pretty much useless without libraries. C# has remarkably few core libraries, but utilizes the libraries of the .NET framework (some of which were built with C#). This article is mainly concerned with addressing the C# language in particular, rather than on .NET, which is best dealt with in a separate article. Briefly, the .NET libraries come with a rich set of libraries including Threading, Collection, XML, ADO+, ASP+, GDI+ & WinForms libraries. Some of these libraries are cross-platform, while others are Windows dependent, but see the next section for a discussion on platform support.

26. Interoperability

I thought it would be useful to group interoperability into three divisions: Language interoperability, Platform interoperability, and Standards interoperability. While Java has its defining strength in platform interoperability, C# has it's strength in language interoperability. Both have strengths and weaknesses in standards interoperability.

Language Interoperability:

This is the level and ease of integration with other languages. Both the Java Virtual Machine and the Common Language Runtime allow you to write code in many different languages, so long as they compile to byte code or IL code respectively. However, the .NET platform has done much more than just allow other languages to be compiled to IL code. NET allows multiple languages to freely share and extend each others libraries to a great extent. For instance, an Eiffel or Visual Basic programmer could import a C# class, override a virtual method of that class, and the C# object would now use the Visual Basic method (polymorphism). In case you were wondering, VB.NET has been massively upgraded (at the expense of compatibility with VB6) to have modern object oriented features.

Languages written for .NET will generally plug into the Visual Studio.NET environment and use the same RAD frameworks if needed, thus overcoming the "second rate citizen" effect of using another language.

C# provides P/Invoke, which is a much simpler (no-dlls) way to interact with C code than Java's JNI. This feature is very similar to J/Direct, which is a feature of Microsoft Visual J++.

Platform Interoperability:

Generally this means OS interoperability, but over the last few years the internet browser has emerged as a platform in itself.

C# code runs in a managed execution environment, which is the most important technological step to making C# run on different operating systems. However, some of the .NET libraries are based on Windows, particularly the WinForms library which depends on the nitty gritty details of the Windows API. There is a project to port the Windows API to Unix systems, but this isn't here now and Microsoft have not given any firm indication of their intentions in this area.

However, Microsoft hasn't ignored platform interoperability. The .NET libraries provide extensive capabilities to write HTML/DHTML solutions. For solutions which can be implemented with a HTML/DHTML client, C#/.NET is a good choice. For cross-platform projects which require a more complex client interface, Java is a good choice. Kylix, a version of Delphi which allows the same code to compile to both Windows and Linux may also be a good choice for rich cross-platform solutions in the future.

Microsoft has submitted the C# specification as well as parts of the .NET specification to the ECMA standards body.

Standards Interoperability:

These are all the standards like databases systems, graphics libraries, internet protocols, and object communication standards like COM and CORBA, that the language can access. Since Microsoft owns or plays a big role in defining many of these standards, they are in a very good position to support them. They of course have business motivations (I'm not saying they are or are not justified) to provide less support for standards which compete with their own - for instance - CORBA competes with COM and OpenGL competes with DirectX. Similarly, Sun's business motivations (again I'm not saying they are or are not justified) means Java doesn't provide as good support for Microsoft standards as it could.

C# objects, since they are implemented as .NET objects, are automatically exposed as COM objects. C# thus has the ability to expose COM objects as well as to use COM objects. This will allow the huge base of COM code to be integrate with C# projects. .NET is a framework which can eventually replace COM - but there is so much deployed COM code that by the time this happens I'm sure .NET will be replaced by the next wave of technology. Anyway, expect .NET to have a long and interesting history!

27. Conclusion

I hope this has given you a feel for where C# stands in relation to Java and C++. Overall, I believe C# provides greater expressiveness and is more suited to writing performance-critical code than Java, while sharing Java's elegance and simplicity, which makes both much more appealing than C++.

Author: Ben Albahari
Company: Genamics

ASP.NET projects in Visual Studio .NET 2005

2005-10-26T09:24:00.000-07:00

In Visual Studio .Net 2003 and its below, an ASP .Net project is tied to IIS server. This creates lots of problems.

In Visual Studio .Net 2005, there is not a dependency on IIS. Developers will be able to create Web applications on their hard disk. When the developers browse or debug the applications from the IDE, a small Web server is started on a unique port to serve the requests.

How composite web controls keep the state of children controls

2005-10-25T15:07:00.000-07:00

Composite controls contain a set of children controls. How do these children controls's state get updated in a postback event?

All the children 's state is saved in viewstate according to the index that the child control in the child control tree. When recreating the page, all children controls are recreated by calling CreateChildrenControl(); After the children control are created, the values in viewstate will be restored. Any child control that is addes to the control, its state will be updated according the value in viewstate.

One thing is very important is that in viewstart child control is referenced by its index when it is added to the control tree. Later it is restored according to the index in the control tree also. So if for some reason the indexes are different between not postback and postback, there will be a problem. (For example, render is not called in a postback senario but is called in a not postback senario. If the indexes are changed inside render function, there will be a problem.) To prevent this from happening, you need override the property "Controls" in the control like the following:

public override ControlCollection Controls
{
Get {
EnsureChildControls();
return base.Controls;
}
}

This code causes the child controls that you created in CreateChildControls to be added to the control tree before other other controls(if any) are added by user code. The child controls you created in CreateChildControls are thus recreated pm postback in the same order in which they were saved. This allows the page framework to restore their state by using view state.

Custom Attributes

2005-10-23T08:10:00.000-07:00

Custom attribute allows you to define some information that can be applied to any type in the metadata table. Using these information, you can change the way your codes execute.

To define a custom attribute, you just need to inherit the System.Atribute class and name your class XXXAttribute as a convention. Your attribute will be normally used by calling its constructor. Most time, the state is set by the the parameters passed from the constructor.

Use attribute is not like using normal types. You basically put it before the type which you want to control later. For example,

[XXAttribute("something", "something else")]
Yourclass
{
///
}

Using reflection, you can check the presence of attributes. Each type has a method called "IsDefined", it can take an attribute type as a parameter, if the attribute type is associated with it, it will return true.

IsDefined can help you check the presence of an attribute. But if you want to check the state of an attribute, you must construct an instance of an attribute. To do this, you must either call GetCustomAttributes or GetCustomAttribute. Pay attention here, these methods really take time. If you need frequently use value from an attribute, you better think of caching it somewhere.

There are some frequently used attributes such as serializable. Emitting the full attribute inforation into the metadata would increase the size of the managed module significantly. When comiling, these attribute are specially emitted in the metadata as bits. We call these attibute as pseudo-custom attribute.

Strong Name and Assembly

2005-10-21T18:30:00.000-07:00

A strong name consists of the assembly's identity — its simple text name, version number, and culture information (if provided) — plus a public key and a digital signature.

To create a strong name, you need a crytographic key pair. A Security Name tool (sn.exe) can be used to generate a key pair. The ke pair can be kept in a file or in your local machine's Crytographic Service Provider. This command

sn -k Testkey.snk

will generate a file.

For keys stored in a file, use System.Reflection.AssemblyKeyFileAttribute. For keys stored in the CSP use System.Reflection.AssemblyKeyNameAttribute.

If you do not have access to the private key you need to generate the strong name, you can choose to delay sign your assembly.

Since the assembly in the example does not have a valid signature, the signature validation performed by the common language runtime will fail when you try to install the assembly into the global assembly cache or load it from an application directory. However, the Strong Name tool can be used to disable signature verification of a particular assembly by using the -Vr option: sn -Vr DelaySign.dll

A valid signature must be generated before the assembly is shipped to customers using sn -R. This is typically done by the company signing entity. You must supply the full key pair to create a valid signature.

sn -R DelaySign.dll Testkey.snk

Module, Assembly and AppDomain

2005-10-21T15:41:00.000-07:00

A managed module contains PE header(indicates the type of files:GUI, CUI or DLL; and so on), CLR header(includes CLR version, strong name, and so on), Metadata(includes two main tables: table describing the types and members, table describing the types and members referenced by the source code). By module itselt, CLR can not load it. Module has to be in an assembly to let CLR load it.

The command "csc /t:module RUT.cs" will tell the compiler to compile RUT.cs into a managed modul - RUT.netmodule.

An assemby is a logical grouping of one or more managed modules or resource files. It is the smallest unit of reuse, security, and versioning. An assembly must contains a block of data called manifest which contains tables decribing the files that make up the assembly, and so on.

The command "csc /out:JeffTypes.dll /t:libray /addmodule:RUT.netmodule FUT.cs" will produce an assembly which consists of JeffTypes.dll and the RUT.netmodule.

An AppDomain is a logical container for a set of assemblies. Code in a managed assembly can tell the CLR to create additional AppDomains. AppDomains are isolated from one another. AppDomains can be unloaded. AppDomains can be individually secured and configured(By using a secure-related feature that determines the maximum rights granted to assemblies running in the AppDomain. SetAppDomainPolicy method can also set a security policy for the domain.)

The first AppDomain created when the CLR initializes is called the default AppDomain; this AppDomain is destroyed only when the Windows process terminates.

Strongly named assemblies are loaded in a domain-neutral fashion to conserve operating system resources. The CLR maintains a special loader heap for assemblies that are loaded in a domain-neutral fashion. Assemblies loaded this way can't be unloaded until the process terminates. That's why whenever we update some strongly named assemblies, we have to do an iisreset to have those updates in use.

Thread's static GetDomain method can obtain a reference to the System.AppDomain object to identify the AppDomain that the thread is currently executing in.

System.AppDomain's static CurrentDomain can get a reference to an AppDomain object that identifies the AppDomain containing the calling code. The AppDomain object's GetAssembles method returns an array of System.Reflection.Assembly elements. Each assembly has a method GetModules that returns an array of System.Reflection.Module classes. Each module has a method GetTypes that returns an array of System.Reflection.MemberInfo elements which identifies a member(constructor, method, field, property, event, or nested type) of the type.

Error Handling in C#, Java and C++

2005-10-21T11:43:00.000-07:00

All these languages has throw, try, catch and finally key words.

Java has another key word throws which is used when declaring fuctions. If a function is defined with throws certain exception, all the users of the function have either rethrow the exception or catch the exception. But both C++ and C# does not have this function.

If there any exception happening inside a catch block or finally block, if that block gets executed (in finally case, finally block always gets executed.) An unhandled exception will throw and the process with exit.

Unhandled C++ Exceptions

If a matching handler (or ellipsis catch handler) cannot be found for the current exception, the predefined terminate function is called. (You can also explicitly call terminate in any of your handlers.) The default action of terminate is to call abort. If you want terminate to call some other function in your program before exiting the application, call the set_terminate function with the name of the function to be called as its single argument. You can call set_terminate at any point in your program. The terminate routine always calls the last function given as an argument to set_terminate. For example:

#include // For function prototypes
//...
void term_func() { // ... }
int main()
{
try
{
// ...
set_terminate( term_func );
// ...
throw "Out of memory!"; // No catch handler for this exception
}
catch( int )
{
cout << "Integer exception raised.";
}
return 0;
}

The term_func function should terminate the program or current thread, ideally by calling exit. If it doesnt, and instead returns to its caller, abort is called.

For more information about C++ exception handling, see the C++ Annotated Reference Manual by Margaret Ellis and Bjarne Stroustrup.

ASP.NET

The UnhandledExceptionEventHandler Delegate
The UnhandledExceptionEventHandler delegate can be used as a means to handle exceptions that are not handled by your application code. The method you associate with the UnhandledExceptionEventHandler delegate will be executed when an unhandled exception occurs.

In most ASP.NET Web applications, your application will use Application_Error, instead of the UnhandledExceptionEventHandler, to serve as your application's last chance to handle the exception.

What is "marshal"?

2005-10-20T07:38:00.000-07:00

In distributed computing, the word "marshal" is used a lot. What does it really mean by computer scientist?

This concept is actually related to the "object" concept in OO design. In OO desigh, we use object to as the unit to describle the real world. In computing, an object instance can be accessed by referencing its address in the memory. In distributed computing, sometimes, we want to pass an object instance from one application domain or process to another one. To do this, we can not actually give out the instance address not only because of security concern but also in most case it does not make sense to give the memory address on one machine to another machine. Therefore, the really process is we package all the field values and properties of that intance into a string or an bit array. This process is called serialization. On the receiver side, it will use the information to construct a new instance of that object. This process is called deserialization. The whole process of serialization and deserialization is called "marshaling".

.Net Delegate, Event and Function Pointer

2005-10-18T08:57:00.000-07:00

.Net introduce a new concept of Delegate. It looks just like function pointer in C++/C. But it is not really the same. Both delegate and function pointer can be used to reference some function address. Thus, given the right parameters, delegate and function pointer can both be used to invoke targeted function get executed. This feature has been used a lot in callback function seneriao which applies to both cases. However, delegate has been given more features than function pointers. The notest one is multcast delegate. User can chain multiple function reference together and when the delegate is invoked, all the chained function will be called and executed. User can also remove function reference from the list.
In software engineering, event is usually used for implementing observer pattern. There are publisher and subscriber. Publisher has knowledge about certain events and exposes events. Subscribers are interested in knowing whether certain event has happened and if yes, it might do something. In .Net, event is defined based on delegate. The publisher exposes an event and subcribers can subscribe the event by registering its own delegate instance (which references to a function it knows) to the event. Subscribers can also unregister its interest. When certain event happens, the publisher will call all the functions which the subscribers supply.
Event basically packets some features of delegates related to publisher and subscriber. Only publisher has fully control to the list of event handlers. Subscriber can only register or unregister its own event handler.

bottom line text cut off by crystal report

2005-10-17T13:27:00.000-07:00

Crystal keeps messing up with text blocks when exporting ot word format. I have a text block which is encoded with HTML. The block contains bold and plain text. And I set the font size to 8.5(Thanks to Crystal for this messing up also. It cuts the font size 0.5 pt off when exporting to MS Word). Crystal keeps cutting the bottom line text off. It looks like it calculates the size of the box wrong. If I give the font size an integer, the problem disappears. But it sticking there if I set the font size to 8.5 or something alike. I tried lots of ways to get rid of this problem, but did not work. Finally, I had to add a border around the block and make the border color invisible. This does helps. Just hope it works in all cases!!!

Building a complete COM+ Server component using C# and .NET

2005-10-14T12:27:00.000-07:00

Each .NET class that's supposed to run under COM+ needs to derive from the System.ServicedComponent class. This base class provides default implementations of the classic MTS/COM+ interface IObjectControl - Activate(), Deactivate(), and CanBePooled(). You can override the default implementations if you wish to do so.

.Net uses attributes to define many COM+ fetures. The Belowing is a snippet written with C#.

////////////////////////////////////////////////////////////////////////////////////
using System;
using System.Runtime.InteropServices;
using System.EnterpriseServices;
// Include the following for the Trace class
using System.Diagnostics;
// Include the following for Windows Message Box
using System.Windows.Forms;

namespace COMPlus
{
/// Specify a name for your serviced component
[ ProgId( "COM+ Sample" ) ]
/// Add content to hosting COM+ App's description field
[ Description( "COM+ Sample Server With C#" ) ]
/// Configure component's Transaction Option
[ Transaction( TransactionOption.Required ) ]
/// Configure component's object pooling
[ ObjectPooling( MinPoolSize = 5, MaxPoolSize = 10, CreationTimeout = 20 ) ]
/// Specify COM+ Context Attributes
[ MustRunInClientContext( false ) ]
/// Enable event tracking
[ EventTrackingEnabled( true ) ]
/// Enable JITA for the component
[ JustInTimeActivation( true ) ]
/// Enable Construction String Support for the component
[ ConstructionEnabled( Enabled=true, Default="Hong Server" ) ]
/// Configure activity-based Synchronization for the component
[ Synchronization( SynchronizationOption.Required ) ]
/// Indicate the type of class interface that will be generated for this class
[ ClassInterface( ClassInterfaceType.AutoDual ) ]
///
public class AccountManager : ServicedComponent
{
///

/// Public No-argument Default Constructor
///

public AccountManager()
{
}
public string Hello()
{
return "Hello";
}
///

/// Do context specific initialization in this method
///

override protected void Activate ()
{
MessageBox.Show ("Bank::Activate() invoked...");
}
///

/// Do context specific cleanup in this method
///

override protected void Deactivate ()
{
MessageBox.Show ("Bank::Deactivate() invoked...");
}
///

/// Object Pooling support method
///

/// true if pooling is supported, false if not
override protected bool CanBePooled ()
{
MessageBox.Show ("Bank::CanBePooled() invoked...");
return true;
}
}
}
////////////////////////////////////////////////////////////////////////////////

A managed COM+ component needs be put into the GAC. So you need give a strong name to your assemply. Use the tool "sn -k keyfile.key" to generated a pair of keys for you and then reference the key files in your assemblyInfo.cs file. In the project properties window, under the "General" tab, there is a box labelled "Wrap Assemply for Active/COM objects, put the key file full name there also.

After you get ready of your key pair, use "gacutil /your.dll" to put your assemply in the GAC so that COM+ service has a shared place to locate your assemply.

Now we have an assemply in the GAC, we need configuring it in the COM+ Catalog. We need generate a COM Type Library(tlbexp.exe). and register the type in the system registry(regasm.exe). We also have to make sure that we enter the right information into the COM+ Catalog(RegDB). Forturnately, we dont have to walk those many steps. The .Net SDK provides an additional tool called Register Services uitility(regsvcs.exe). This utility simplifies the process by making sure that all required details are taken care of in a simple step. It performs the following functions:
1) Our Assempley is loaded into memory
2) Our Assempley is registered( just like using regasm.exe)
3) A COM Type Library(.tlb file) is generated and registered( just like using tlbexp.exe)
4) The generated COM Type library is installed in the specified COM+ application.
5) Our Components are configured according to the attributes that we specified in the type definitions.

We can use "/fc" option to instruct the tool to build a new COM+ application if one does not currently exist.

After all this, a managed COM+ server is done.

You can then enjoy the "transaction, pool" fearures that COM+ container supplies.

Crystal Report - The bottom Line Text Are Cut Off

2005-08-26T12:49:00.000-07:00

I have a text box, in which "allow grow" has been set to 0 that means the box can grow to the full length of the text. Unfortunately, the bottom line text are always get cut. If I change the font size to smaller ones, or add a border around, it looks fine. But this is annoying and at most time it is not acceptable. I almost told the production that I was going to gave up, though this would disappoint them another time. But, suddenly, I ran to the idea that why I just delete the shitting one and create a new one. Yes, it works!!! Weired crystal again.

I really should not disappoint my colleagues, neither does my friends. Offerring an endless effort is alway better than simply giving up.