Basic Knowledge in Microsoft Technology and Data Science with Python

Hive Partitions, Types of Hive Partitioning with Examples

2020-03-14T09:56:00.000-07:00

1. Objective

The Hive tutorial explains about the Hive partitions. This blog will help you to answer what is Hive partitioning, what is the need of partitioning, how it improves the performance? Partitioning is the optimization technique in Hive which improves the performance significantly. Apache Hive is the data warehouse on the top of Hadoop, which enables ad-hoc analysis over structured and semi-structured data. Let’s discuss Apache Hive partitioning in detail.

So, let’s start the Hive Partitions tutorial.

2. What are the Hive Partitions?

Apache Hive organizes tables into partitions. Partitioning is a way of dividing a table into related parts based on the values of particular columns like date, city, and department. Each table in the hive can have one or more partition keys to identify a particular partition. Using partition it is easy to do queries on slices of the data.

3. Why is Partitioning Important?

In the current century, we know that the huge amount of data which is in the range of petabytes is getting stored in HDFS. So due to this, it becomes very difficult for Hadoop users to query this huge amount of data.
The Hive was introduced to lower down this burden of data querying. Apache Hive converts the SQL queries into MapReduce jobs and then submits it to the Hadoop cluster. When we submit a SQL query, Hive read the entire data-set. So, it becomes inefficient to run MapReduce jobs over a large table. Thus this is resolved by creating partitions in tables. Apache Hive makes this job of implementing partitions very easy by creating partitions by its automatic partition scheme at the time of table creation.
In Partitioning method, all the table data is divided into multiple partitions. Each partition corresponds to a specific value(s) of partition column(s). It is kept as a sub-record inside the table’s record present in the HDFS. Therefore on querying a particular table, appropriate partition of the table is queried which contains the query value. Thus this decreases the I/O time required by the query. Hence increases the performance speed.

4. How to Create Partitions in Hive?

To create data partitioning in Hive following command is used-

CREATE TABLE table_name (column1 data_type, column2 data_type) PARTITIONED BY (partition1 data_type, partition2 data_type,….);

5. Hive Data Partitioning Example

Now let’s understand data partitioning in Hive with an example. Consider a table named Tab1. The table contains client detail like id, name, dept, and yoj( year of joining). Suppose we need to retrieve the details of all the clients who joined in 2012. Then, the query searches the whole table for the required information. But if we partition the client data with the year and store it in a separate file, this will reduce the query processing time. The below example will help us to learn how to partition a file and its data-
The file name says file1 contains client data table:

tab1/clientdata/file1
id, name, dept, yoj
1, sunny, SC, 2009
2, animesh, HR, 2009
3, sumeer, SC, 2010
4, sarthak, TP, 2010

Now, let us partition above data into two files using years

tab1/clientdata/2009/file2
1, sunny, SC, 2009
2, animesh, HR, 2009
tab1/clientdata/2010/file3
3, sumeer, SC, 2010
4, sarthak, TP, 2010

Now when we are retrieving the data from the table, only the data of the specified partition will be queried. Creating a partitioned table is as follows:

CREATE TABLE table_tab1 (id INT, name STRING, dept STRING, yoj INT) PARTITIONED BY (year STRING);
LOAD DATA LOCAL INPATH tab1’/clientdata/2009/file2’OVERWRITE INTO TABLE studentTab PARTITION (year='2009');
LOAD DATA LOCAL INPATH tab1’/clientdata/2010/file3’OVERWRITE INTO TABLE studentTab PARTITION (year='2010');

6. Types of Hive Partitioning

Till now we have discussed Introduction to Hive Partitions and How to create Hive partitions. Now we are going to introduce the types of data partitioning in Hive. There are two types of Partitioning in Apache Hive-

Static Partitioning
Dynamic Partitioning

Let’s discuss these types of Hive Partitioning one by one-

i. Hive Static Partitioning

Insert input data files individually into a partition table is Static Partition.
Usually when loading files (big files) into Hive tables static partitions are preferred.
Static Partition saves your time in loading data compared to dynamic partition.
You “statically” add a partition in the table and move the file into the partition of the table.
We can alter the partition in the static partition.
You can get the partition column value from the filename, day of date etc without reading the whole big file.
If you want to use the Static partition in the hive you should set property set hive.mapred.mode = strict This property set by default in hive-site.xml
Static partition is in Strict Mode.
You should use where clause to use limit in the static partition.
You can perform Static partition on Hive Manage table or external table.

ii. Hive Dynamic Partitioning

Single insert to partition table is known as a dynamic partition.
Usually, dynamic partition loads the data from the non-partitioned table.

Dynamic Partition takes more time in loading data compared to static partition.
When you have large data stored in a table then the Dynamic partition is suitable.
If you want to partition a number of columns but you don’t know how many columns then also dynamic partition is suitable.
Dynamic partition there is no required where clause to use limit.
we can’t perform alter on the Dynamic partition.
You can perform dynamic partition on hive external table and managed table.
If you want to use the Dynamic partition in the hive then the mode is in non-strict mode.
Here are Hive dynamic partition properties you should allow

7. Hive Partitioning – Advantages and Disadvantages

Let’s discuss some benefits and limitations of Apache Hive Partitioning-

a) Hive Partitioning Advantages

Partitioning in Hive distributes execution load horizontally.
In partition faster execution of queries with the low volume of data takes place. For example, search population from Vatican City returns very fast instead of searching entire world population.

b) Hive Partitioning Disadvantages

There is the possibility of too many small partition creations- too many directories.
Partition is effective for low volume data. But there some queries like group by on high volume of data take a long time to execute. For example, grouping population of China will take a long time as compared to a grouping of the population in Vatican City.
There is no need for searching entire table column for a single record.

So, this was all in Hive Partitions. Hope you like our explanation.

8. Conclusion – Hive Partitions

Hope this blog will help you a lot to understand what exactly is partition in Hive, what is Static partitioning in Hive, What is Dynamic partitioning in Hive. We have also covered various advantages and disadvantages of Hive partitioning. If you have any query related to Hive Partitions, so please leave a comment. We will be glad to solve them.

Hive Installation and Launch !

2020-02-28T09:04:00.002-08:00

Hive installation on Windows 10

Hive Introduction

In reference to Hadoop and HBase outline as well installation over Windows environment, already we have been talked and gone through the same in my previous post. We came to know that Hadoop can perform only batch processing, and data will be accessed only in a sequential manner. It does mean one has to search the entire data-set even for the simplest of jobs.

In such scenario, a huge data-set when processed results in another huge data set, which should also be processed sequentially. At this point, a new solution is needed to access any point of data in a single unit of time (random access). Here the HBase can store massive amounts of data from terabytes to petabytes and allows fast random reads and writes that cannot be handled by the Hadoop.

HBase is an open source non-relational (NoSQL) distributed column-oriented database that runs on top of HDFS and real-time read/write access to those large data-sets. Initially, it was Google Big Table, afterwards it was re-named as HBase and is primarily written in Java, designed to provide quick random access to huge amounts of the data-set.

Next in this series, we will walk through Apache Hive, the Hive is a data warehouse infrastructure work on Hadoop Distributed File System and MapReduce to encapsulate Big Data, and makes querying and analyzing stress-free. In fact, it is an ETL tool for Hadoop ecosystem, enables developers to write Hive Query Language (HQL) statements very similar to SQL statements.

Hive Installation

In brief, Hive is a data warehouse software project built on top of Hadoop, that facilitate reading, writing, and managing large datasets residing in distributed storage using SQL. Honestly, before moving ahead, it is essential to install Hadoop first, I am considering Hadoop is already installed, if not, then go to my previous post how to install Hadoop on Windows environment.

I went through Hive (2.1.0) installation on top of Derby Metastore (10.12.1.1), though you can use any stable version.

Download Hive 2.1.0

https://archive.apache.org/dist/hive/hive-2.1.0/

Download Derby Metastore 10.12.1.1

https://archive.apache.org/dist/db/derby/db-derby-10.12.1.1/

Download hive-site.xml

https://mindtreeonline-my.sharepoint.com/:u:/g/personal/m1045767_mindtree_com1/EbsE-U5qCIhIpo8AmwuOzwUBstJ9odc6_QA733OId5qWOg?e=2X9cfX
https://drive.google.com/file/d/1qqAo7RQfr5Q6O-GTom6Rji3TdufP81zd/view?usp=sharing

STEP - 1: Extract the Hive file

Extract file apache-hive-2.1.0-bin.tar.gz and place under "D:\Hive", you can use any preferred location –

[1] You will get again a tar file post extraction –

[2] Go inside of apache-hive-2.1.0-bin.tar folder and extract again –

[3] Copy the leaf folder “apache-hive-2.1.0-bin” and move to the root folder "D:\Hive" and removed all other files and folders –

STEP - 2: Extract the Derby file

Similar to Hive, extract file db-derby-10.12.1.1-bin.tar.gz and place under "D:\Derby", you can use any preferred location –

STEP - 3: Moving hive-site.xml file

Drop the downloaded file “hive-site.xml” to hive configuration location “D:\Hive\apache-hive-2.1.0-bin\conf”.

STEP - 4: Moving Derby libraries

Next, need to drop all derby library to hive library location –

[1] Move to library folder under derby location D:\Derby\db-derby-10.12.1.1-bin\lib.

[2] Select all and copy all libraries.

[3] Move to library folder under hive location D:\Hive\apache-hive-2.1.0-bin\lib.

[4] Drop all selected libraries here.

STEP - 5: Configure Environment variables

Set the path for the following Environment variables (User Variables) on windows 10 –

HIVE_HOME - D:\Hive\apache-hive-2.1.0-bin
HIVE_BIN - D:\Hive\apache-hive-2.1.0-bin\bin
HIVE_LIB - D:\Hive\apache-hive-2.1.0-bin\lib
DERBY_HOME - D:\Derby\db-derby-10.12.1.1-bin
HADOOP_USER_CLASSPATH_FIRST - true

This PC - > Right Click - > Properties - > Advanced System Settings - > Advanced - > Environment Variables

STEP - 6: Configure System variables

Next onward need to set System variables, including Hive bin directory path –

HADOOP_USER_CLASSPATH_FIRST - true

Variable: Path

Value:

D:\Hive\apache-hive-2.1.0-bin\bin
D:\Derby\db-derby-10.12.1.1-bin\bin

STEP - 7: Working with hive-site.xml

Now need to do a cross check with Hive configuration file for Derby details –

hive-site.xml

[1] Edit file D:/Hive/apache-hive-2.1.0-bin/conf/hive-site.xml, paste below xml paragraph and save this file.

<name>javax.jdo.option.ConnectionURL</name>

<value>jdbc:derby://localhost:1527/metastore_db;create=true</value>

<description>JDBC connect string for a JDBC metastore</description>

</property>

<name>javax.jdo.option.ConnectionDriverName</name>

<value>org.apache.derby.jdbc.ClientDriver</value>

<description>Driver class name for a JDBC metastore</description>

</property>

<name>hive.server2.enable.impersonation</name>

<description>Enable user impersonation for HiveServer2</description>

</property>

<name>hive.server2.authentication</name>

<description> Client authentication types. NONE: no authentication check LDAP: LDAP/AD based authentication KERBEROS: Kerberos/GSSAPI authentication CUSTOM: Custom authentication provider (Use with property hive.server2.custom.authentication.class) </description>

</property>

<name>datanucleus.autoCreateTables</name>

</property>

</configuration>

STEP - 8: Start the Hadoop

Here need to start Hadoop first -

Open command prompt and change directory to “D:\Hadoop\hadoop-2.8.0\sbin" and type "start-all.cmd" to start apache.

It will open four instances of cmd for following tasks –

Hadoop Datanaode
Hadoop Namenode
Yarn Nodemanager
Yarn Resourcemanager

It can be verified via browser also as –

Namenode (hdfs) - http://localhost:50070
Datanode - http://localhost:50075
All Applications (cluster) - http://localhost:8088 etc.

Since the ‘start-all.cmd’ command has been deprecated so you can use below command in order wise -

“start-dfs.cmd” and
“start-yarn.cmd”

STEP - 9: Start Derby server

Post successful execution of Hadoop, change directory to “D:\Derby\db-derby-10.12.1.1-bin\bin” and type “startNetworkServer -h 0.0.0.0” to start derby server.

STEP - 10: Start the Hive

Derby server has been started and ready to accept connection so open a new command prompt under administrator privileges and move to hive directory as “D:\Hive\apache-hive-2.1.0-bin\bin” –

[1] Type “jps -m” to check NetworkServerControl

[2] Type “hive” to execute hive server.

Congratulations, Hive installed !! 😊

STEP-11: Some hands on activities

[1] Create Database in Hive -

CREATE DATABASE IF NOT EXISTS TRAINING;

[2] Show Database -

SHOW DATABASES;

[3] Creating Hive Tables -

CREATE TABLE IF NOT EXISTS testhive(col1 char(10), col2 char(20));

[4] DESCRIBE Table Command in Hive -

Describe Students

[5] Usage of LOAD Command for Inserting Data Into Hive Tables

Create a sample text file using ‘|’ delimiter –

[6] Hive Select Data from Table -

SELECT * FROM STUDENTS;

Stay in touch for more posts.

MVC

2014-03-24T07:55:00.002-07:00

The Model-View-Controller (MVC) architecture separates the modeling of the domain, the presentation, and the actions based on user input into three separate classes.

Unfortunately, the popularity of this pattern has resulted in a number of faulty usages; each technology (Java, ASP.NET, etc.) has defined it in their own way making it difficult to understand. In particular, the term "controller" has been used to mean different things in different contexts. The definitions given bellow are the closes possible ones I found for ASP.NET version of MVC.

Model: DataSet and typed DataSet (some times business object, object collection, XML, etc.) are the most common uses of the model.

View: The ASPX and ASCX files generally handle the responsibilities of the view.
Controllers: The handling of events or the controlling is usually done in the code-behind class.

In a complex n-tier distributed system the MVC architecture place the vital role of organizing the presentation tier of the system.

Webmind Services

To getting the IT Services like Mobile Apps, Websites , Ecommerce Website and Software development , please visit :- Website :- http://www.webmindservices.com

2013-11-15T13:29:00.002-08:00

View State:

- View state is maintained in page level only.
- View state of one page is not visible in another page.
- View state information stored in client only.
- View state persist the values of particular page in the client (browser) when post back operation done.
- View state used to persist page-instance-specific data. (Read more)

Session State:

- Session state is maintained in session level.
- Session state value is available in all pages within a user session.
- Session state information stored in server.
- Session state persist the data of particular user in the server. This data available till user close the browser or session time completes.
- Session state used to persist the user-specific data on the server side. (Read more)

Difference between an EXE and a DLL

2013-11-15T12:38:00.003-08:00

hi,
DLL:
1)it has versioning
2)it is not self executable
3)it runs in application process memory
4)it has no entry point
5)it is reusable
6)Out Process Server

Exe:
1)it is self executable
2)it has no versioning
3)it runs in own memory
4)it have main function(Entry point)
5)it is self executable
6) In Process Server

Note:DLL is Superset of Exe

Freelancer

2013-11-08T13:30:00.002-08:00

Web Search Freelancer

What is Inheritance in C#

2013-08-03T04:53:00.000-07:00

Inheritance can be classified to 5 types.
1.Single Inheritance
2.Hierarchical Inheritance
3.Multi Level Inheritance
4.Hybrid Inheritance
5.Multiple Inheritance

1. Single Inheritance when a single derived class is created from a single base class then the inheritance is called as single inheritance.

Single Inheritance Example Program

2. Hierarchical Inheritance
when more than one derived class are created from a single base class, then that inheritance is called as hierarchical inheritance.

Hierarical Inheritance

3. Multi Level Inheritance
when a derived class is created from another derived class, then that inheritance is called as multi level inheritance.

Multi level Inheritance

4. Hybrid Inheritance
Any combination of single, hierarchical and multi level inheritances is called as hybrid inheritance.

Hybrid inheritance in C#

5. Multiple Inheritance
when a derived class is created from more than one base class then that inheritance is called as multiple inheritance. But multiple inheritance is not supported by .net using classes and can be done using interfaces.

Multiple inheritance in C# Multiple Inheritance Example

Handling the complexity that causes due to multiple inheritance is very complex. Hence it was not supported in dotnet with class and it can be done with interfaces.

Create Your Password Protected Folder

2013-07-29T14:19:00.001-07:00

Before you get started you need to create a folder that will house your password protected folder, this is just an ordinary folder and can be located anywhere and named anything. Navigate into your newly created folder and create a new Text Document. This can easily be done from the context menu. Open the document, now paste the following code into the contents of the document: cls @ECHO OFF title Folder Private if EXIST "HTG Locker" goto UNLOCK if NOT EXIST Private goto MDLOCKER :CONFIRM echo Are you sure you want to lock the folder(Y/N) set/p "cho=>" if %cho%==Y goto LOCK if %cho%==y goto LOCK if %cho%==n goto END if %cho%==N goto END echo Invalid choice. goto CONFIRM :LOCK ren Private "HTG Locker" attrib +h +s "HTG Locker" echo Folder locked goto End :UNLOCK echo Enter password to unlock folder set/p "pass=>" if NOT %pass%== PASSWORD_GOES_HERE goto FAIL attrib -h -s "HTG Locker" ren "HTG Locker" Private echo Folder Unlocked successfully goto End :FAIL echo Invalid password goto end :MDLOCKER md Private echo Private created successfully goto End :End Change the PASSWORD_GOES_HERE text to the password you want to set. Now go ahead and save the file as locker.bat. Once the file is saved as a batch file you can delete the original text file. Now run your batch file by double clicking on it–the first time you run it, it will create a folder called Private. This is where you can store all your secret things. When you have finished adding all your stuff to the Private folder, run locker.bat again. This time you will be asked if you sure that you want to lock the folder, press the “Y” key and hit enter to lock your folder. You will see that your Private folder quickly disappears. If you run the script yet again, you will prompted for a password. If you enter the same password as you set in the script the Private folder will reappear if you enter the incorrect password the script will just Terminate.

System Development Life

2013-07-24T12:47:00.002-07:00

System Development Life Cycles fall into a number of different system development models, iterative being the most common but they also include waterfall, spiral and chaos models. They all encompass the full project life cycle. Common software development methodologies include Agile/Scrum, Structured Systems Analysis and Design Method (SSADM) and Microsoft Solutions Framework (MSF). Each step in a systems life cycle can be broken down into many smaller sub-steps or processes. Each stage follows logically after the previous, but it is an oversimplification to say that one stage is a distinct step after another. It is important to understand that the system lifecycle is iterative as well as the stages involved along the way. Different methodologies will have different variations of this lifecycle model. A common iterative lifecycle is show in the diagram below and each stage is described after the diagram. Stages of a system life cycle

1. Initial Idea
2. Feasibility Study
3. Requirements Analysis
4. Systems Analysis and Specification
5. Systems Design
6. Development
7. Testing
8. Implementation
9. Maintenance and Review
Initial Idea
All projects must start with an initial idea. Usually this consists of a brief definition on what is the project all about, what is its purpose and what the project aims to accomplish. How will the success of the project be measured?

Feasibility Study
Expanding on the Initial Idea, the Feasibility Study involves drawing up the terms of reference, which state the objectives and scope of the project, how long it should take and how the results should be presented. The terms of reference are usually drawn up by senior management. The feasibility study must determine if development of the project is justified in terms of economic and organisational terms. The main role of the analyst in the feasibility study is to analyse the current system at a high level. Data Flow Diagrams (DFD) are used to describe how the current system performs and to illustrate known problems. Feasibility studies are not carried out for all projects, and smaller projects omit this stage.

Requirements Analysis
The Requirements Analysis stage defines a series of possible solutions to the problem and presents them to management in terms of business options. These options may be supported by technical documents such as high-level DFD’s, Logical Data Models (LDM) and Work Practise Models. The requirements analysis report must also contain financial and risk assessments to be presented and supported by outline implementation descriptions. The steps involved within the requirements analysis will define the flow of data in the system, deriving system functions and to develop user role specifications, prototypes and process specifications.

Systems Analysis and Specification
The Systems Analysis stage is an extension to the feasibility study. If the project has a feasibility study then the bulk of the work has already been done. A terms of reference will also be required if one does not exist. The output from this stage is the System Specification which gives precise details of what the new system is required to do, but does not go into how it does it. It provides a logical model of the new system. Once agreed, the specification is the basis for the work done by the system designers.

Systems Design
This stage deals with how the requirements of the new system are carried out (how the logical model is implemented as a physical system). The system designer will develop a number of design options and test them against the requirements specification and design criteria. The one that comes closest to the design brief with the most cost effective use of equipment and personnel is selected and broken down into more detailed specs. Because of this the design stage has two phases: produce outline designs based on requirements specification with input from users and the detailed designs produced from the selected design.

Development
This is the only stage in the development where program code is written. The designs and specifications provide enough detail for the programmer to code and test individual modules. Each unit is tested to ensure that it meets the requirements of the specification.

Testing
Within the life cycle there are various levels of testing as well as the unit testing performed in the development stage. Link testing ensures that programs work together, e.g. the data passed from one program to another has the correct format. System testing ensures that the system as a whole performs according to the design specification. Recovery procedures must be tested as well as normal operation procedures. Finally user acceptance testing is carried out by the users in stages to ensure that the system is usable. Any modifications are passed back to the design stage where changes are made as necessary and passed to the development team.

Implementation
When the testing has been carried out to the users satisfaction the system, or parts of it, are put live. The “put live” phase can also be known as implementation, cut over or production. This is when the users start using the system to carry out their business activities.
There are two main approaches to implementation a project:
 Phased: Stand-alone subsets of the system are implemented over a period of time.
 Big Bang: The whole system is put live in one go.
Some systems will require special programs or tasks to convert existing data to a format usable by the new system. The process of changing data from the old system to the new is called conversion.

Maintenance and Review
Once the system is put into place, maintenance is required to ensure satisfactory operation. Maintenance should include regular reviews and evaluations to ensure that it is achieving its objectives, identify any aspects that can be improved or any operational problems. Maintenance falls into two categories, implementation of new features or elimination of errors.

Tray Application

2012-03-03T22:19:00.000-08:00

If you are a .NET developer, you will probably be used to creating several different types of application. You’ll be familiar with either WPF or WinForms as the primary technology for desktop applications with a graphical user interface (GUI). You may also have required a console application for special needs such as batch processing or automated workflow. Finally, for more advanced applications, you may have needed to create a Windows service application, a type that, technically, does not even have a user interface.

There is one interesting type remaining: the system tray application.

This type of application is a kind of hybrid: it acts like a service, in that it sits in the background until you give it focus, then it acts like a GUI, allowing you to interact with it like a WinForms or WPF application.

You can find quite a number of articles on tray applications, just as I did when I needed to create my first one. I hit two problems during my self-edification: first, I did not find any single article that had all the necessary details. I collected bits and pieces from several to achieve a useful and usable solution. Second, many of these articles provide a kludge disguised as a solution: it is workable but certainly not the best way to create a system tray application.

In this article I’ll describe the best practice for creating a tray application, complete with a tray application framework in C# that you can put to immediate use.

Because I didn’t like being told by one source that tray applications could exist only in WinForms, but not WPF, I’ll show you how you may choose to use either WinForms, WPF or both together with this framework. For those WPF purists, it turns out that there are also independently developed libraries created by industrious developers that allow you to create strictly a WPF solution.

As I believe it is easier to learn with real code rather than study academic exercises, I present in this article a complete, open-source, tray application built on my framework. While it is possible that only a fraction of the readership needs this particular utility, you should still find it valuable as a real-world example.

Introducing HostSwitcher: A Tray App for Some of You

My tray application, HostSwitcher, lets you re-route entries in your hosts file with a single click on the context menu attached to the icon in the system tray. I needed this myself because my work involved a network application that communicated with several servers at any given time. Frequently, sometimes several times a day, I need to reroute entries in my host file among several sets of servers: one set of servers is for production, one for the current development effort, one for the legacy development effort, and one for scratch work. Thus, several times a day I edit the hosts file, commenting out one group of lines and uncommenting a second group. Each developer on the project has to do this same silly procedure. I wanted a simple, easy, and fast way to do that automatically.

Requirements

I needed two things to make this work: Firstly, a tray application framework (that I could tailor to access servers from its context menu), and, secondly, a mechanism to drive the generation of the contents of the context menu from the hosts file. I did not find any plug-and-play library components for the tray application framework so I needed to craft my own. My requirements were:
•First and foremost, the app must exist as a tray application. Many of the solutions, as I hinted earlier, are really WinForms applications coerced into being tray applications (akin to forcing a square peg into a round hole!).
•Only one instance of the app may run. Attempting to start a second instance immediately terminates.
•The app, from the icon in the system tray, must be able to open a WinForms or WPF window as needed.
•Closing the tray application also closes any open windows.
•The system tray icon must easily support dynamic context menus.

The last requirement in the list directly supports the second facet of this application, converting hosts file data to context menu choices. I quickly settled on adding meta-comments to overlay on existing hosts file entries. Since these are comments, they are completely transparent to other consumers of the hosts file. Because there is markup on IP addresses right in the hosts file, this reduces maintenance by avoiding duplication with some external resource, and makes it very simple to modify hosts entries and groupings at any time.

Instrumenting Your Hosts File

HostSwitcher is simple to operate; almost everything you need to know is on the one-page introduction (Figure 1) that appears automatically upon first launch if you have not yet decorated your hosts file. (You can also open that introduction page from the context menu.) As shown in the figure, you start with the servers listed in your host file. Organize these into server groups, where all servers in a group should operate in unison; that is, since each server group is bound to a single context menu entry they all are enabled or all disabled together. Next you can cluster your server groups with other related server groups to form a project where each server group in the project should be mutually exclusive of its sibling groups. (They are mutually exclusive within the perspective of HostSwitcher but there is, of course, nothing preventing you from editing your hosts file manually and corrupting it however you please. Projects appear as top-level entries in the context menu; server groups appear as children of their parent project.

In the example in Figure 1, only a small portion of the hosts file is shown. (I happen to have thousands of lines in this host file as a protective measure on my computer.) HostSwitcher is only aware of these 16 lines, though, because they are the ones I have decorated with meta-comments (shown in green). Each meta-comment indicates a project/server group pair in brackets with a virgule separating them. You may use any other characters you please for both the project name and the server group name. Each time you open HostSwitcher’s context menu it rereads the hosts file. That way, if you do edit it externally it will pick up on your most current changes. Thus, as soon as you save the newly decorated hosts file you can open the context menu and it will correctly reflect your projects; no need to restart the application.

Figure 1 HostSwitcher Information Page

This shows how to decorate your hosts file and how that manifests in the context menu attached to the icon in the system tray.

Usage

HostSwitcher, as mentioned earlier, automates the process of commenting and uncommenting specific lines in your host file simply by selecting a server group from the context menu of the system tray icon. It operates on all the relevant host file lines of a project at once, resolved down to its constituent server groups. When it enables one server group it just uncomments the lines of the host file containing the servers in that group. Similarly, when it disables a server group it comments out the respective lines in the hosts file. At the user level, selecting a server group in the context menu enables that server group and disables all other server groups in the project.

The example in Figure 1 defines two projects: Project-1 and Other Project. The screen shot of the context menu at the bottom shows the Project-1 submenu opened and the three server groups contained therein. Observe how these come directly from the hosts file. Each server group has a colored icon indicating its state: green for enabled, red for disabled, and yellow for mixed. Technically speaking mixed is bad. You do not want a server group to have both enabled and disabled servers because that violates the cardinal rule of servers in a server group—they should always operate in unison. By the way, when you hover over a server group name without selecting it, its tooltip indicates how many individual servers are enabled and how many are disabled. So you may determine from the tooltips how many servers you have in any particular group.

Another bad condition is having more than one server group enabled within a single project; i.e. you should never have more than one green icon in a project. Remember the cardinal rule of server groups within a project: they are mutually exclusive.

Fortunately, it is trivial to clean up any bad states—just select a server group in a “corrupt” project on HostSwitcher's context menu. Remember: selecting a server group enables that server group and disables all other server groups in the project. It follows, therefore, if you need to have “corrupt” entries (as far as HostSwitcher is concerned) for performing other tasks on your computer, when you want to come back to HostSwitcher just select your target server group and you are ready to go.

Features

Besides activating a server group, HostSwitcher’s context menu also allows you to:
•Open the hosts file itself (in Notepad).
•Open the folder containing the hosts file (in Explorer).
•View a server details page showing the results of parsing your hosts file (Figure 2)—this is handy to debug your hosts file setup.
•View the introductory page (Figure 1) to remind yourself how to instrument your hosts file.
•The HostSwitcher icon itself has these features:
•Double-clicking the icon in the system tray re-opens the introduction/help page.
•Hovering over the icon identifies the selected server group for your first few projects. (A .NET limitation restricts this tooltip to just 63 characters.)

Host Details View

Particularly when you first attempt to decorate your hosts file, the host details window comes in very handy to check the results of your work. As Figure 2 shows, you see both the actual host file entries and the meta-comments attached to them. Note that this includes all instrumented lines, whether or not the entire line is commented out or not. In fact, it tells you which lines are completely commented out in the Status column. Active (i.e. uncommented) lines are marked as enabled; commented lines are marked as disabled.

This window into your hosts file provides one additional feature that occasionally comes in quite handy: you can sort the table by clicking on any of the column headers. In Figure 1 notice that the entries are written sorted by server group. In Figure 2 I have clicked on the project name column header to resort the entries for a different perspective. Here you see for each host name the different IPs it will point to depending on your choice of server group.

Figure 2 Host Details View

This window lets you check whether you have instrumented your hosts file correctly, showing you what HostSwitcher’s parsing ends up with.

Running on Windows 7

Just for completeness, here is a tip for running under Windows 7. A new tray icon is set by default to only appear when it “has something to say”, i.e. when it issues a notification. It is still in the tray, but you have to click the leftmost icon to reveal the hidden tray icons, then—in the case of HostSwitcher—right-click its icon to open its context menu (bottom left, Figure 3). All terribly cumbersome. You can adjust the properties easily, though. Click the Customize link at the bottom of the hidden icon panel to open the Notification Area Icons control panel. Scroll until you find HostSwitcher and change its setting from Only show notifications to Show icon and notifications (top, Figure 3) to migrate the icon down to the main tray (bottom right, Figure 3).

Figure 3 Adjusting the Tray Icon Properties

The new icon for HostSwitcher is hidden in the tray by default, but you can adjust it to sit in the main tray.

Execution Has Its Privileges

Because the Hosts file in Windows is in a protected, system directory you must have administrative privileges to run HostSwitcher. Even with administrator privileges, on Windows 7 you can still choose to run your applications normally or with administrative rights. HostSwitcher must be run as the latter. If you use the installer accompanying this article, or even if you compile the project in Visual Studio yourself, it automatically attempts to run with administrative rights. If for some reason you like to explicitly invoke Run as Administrator when you launch a program requiring it, you can turn off the automatic setting in the app.manifest file in the HostSwitcher project directory: comment out the line for requestedExecutionLevel then recompile the solution.

The Tray Application Framework

The Secret of the Tray

The secret to tray applications is… Well, it is obvious as soon as you read it. I found assorted articles on the web that were ignorant of it, and others that were not, but none realized the gem of knowledge they had to convey to their readers.

"I thought at first that you had done something clever, but I see that there was nothing in it, after all."
The Red-Headed League, A. Conan Doyle

Many of the articles you find on tray applications use a form-centric focus: you start with your form, then minimize it to the system tray and hide it from the taskbar. That approach mostly works but it is backwards. The key to applying best practices to designing a tray application is shifting your perspective to a tray-centric focus: instead of thinking of your form (be it WinForms or WPF) as the master controller of your application, think of the little tiny tray icon as the master controller. It runs right in the system tray, spawning child windows only when needed.

As I was experimenting with the form-centric approach I found one significant deficiency: it is challenging to start an application in the tray. You could click a button on the form to send it to the tray, but actually starting it there—with the form completely hidden—is difficult. Either way you need to make sure to remove your app from the taskbar when you go to the tray and rematerialize it when you restore your app. This bookkeeping hassle is not even relevant in the tray-centric approach: you start in the tray, which has no taskbar presence, and only open a form at an appropriate point. Opening the form puts it in the taskbar; closing it again removes it, all automatically.

The Master Controller of a Tray App: The NotifyIcon

With either a form-centric or a tray-centric approach, you still use the same mechanism—the NotifyIcon. Instantiating a NotifyIcon creates your tray icon. You do not have to hook up the NotifyIcon to anything; simply instantiating it is all you need. This method, then, is the entire code to create a system tray icon with a custom icon, tooltip, (empty) context menu, and a couple event handlers:

private void InitializeContext()
{

components = new System.ComponentModel.Container();

notifyIcon = new NotifyIcon(components)

{

ContextMenuStrip = new ContextMenuStrip(),

Icon = new Icon(IconFileName),

Text = DefaultTooltip,

Visible = true

};

notifyIcon.ContextMenuStrip.Opening += ContextMenuStrip_Opening;

notifyIcon.DoubleClick += notifyIcon_DoubleClick;

}

Tailoring Your Program Entry Point: The ApplicationContext

When you create a normal WinForms application, Visual Studio auto-generates part of the code for the form itself (stored in YourForm.designer.cs) but it also generates an even more crucial portion of code that is less exposed, stored in Program.cs. This file provides an entry point for your entire application—the Application object. For a form-centric application, the key line of code that launches your form as the mainstay of the application is:

Application.Run(new Form1());

Jessica Fosler, in her article Creating Applications with NotifyIcon in Windows Forms, breaks down that single statement into this equivalent code to provide a better understanding of what happens:

Form1 form1 = new Form1();
ApplicationContext applicationContext = new ApplicationContext();

applicationContext.MainForm = form1;

Application.Run(applicationContext);

This sequence reveals the hidden intermediary component between your Form and the central Application.Run method—the ApplicationContext object. Attaching the form to the MainForm property of the ApplicationContext does two things. First, calling Application.Run invokes the form’s Show method, opening your form to begin processing events. Second, it ensures the entire application terminates when the form closes. Those two actions describe just how a form-centric application behaves. For a tray-centric application, on the other hand, the entry point code is just as simple but significantly different:

ApplicationContext applicationContext = new CustomApplicationContext();
Application.Run(applicationContext);

This code creates a custom ApplicationContext, which you will see next. Notably there is no mention of any Form here. It (or they) will be instantiated as needed by the custom ApplicationContext. When you pass the custom ApplicationContext to the Run method, rather than open a form, here you are just passing control to the ApplicationContext. The final bit of code you need to get from there to the InitializeContext method shown earlier is just the constructor for the custom ApplicationContext:

public CustomApplicationContext()
{

InitializeContext();

hostManager = new HostManager(notifyIcon);

hostManager.BuildServerAssociations();

if (!hostManager.IsDecorated) { ShowForm(); }

The first statement materializes the user interface—in this case, the icon in the system tray. The remaining lines of the constructor are specific to the HostSwitcher application; yours will be tailored to your own application. For this application, the code creates a HostManager (the workhorse of HostSwitcher) and does an initial pass of parsing the hosts file. Finally, if the parsing step indicated that the file has no decoration—probably indicating this is the first time the application has been launched—it displays the form showing basic program operation (see Figure 1).

Rounding Out the ApplicationContext

The web of connections is starting to materialize: the ApplicationContext constructor is called from the Main method in Program.cs. The constructor in turn invokes InitializeContext, which creates the NotifyIcon. InitializeContext also adds a couple event handlers to the NotifyIcon, notably the one that fires when the user opens the context menu. This event handler code, shown here, is specific to HostSwitcher, except for the important first line. Whenever you are dynamically generating a context menu you must set the e.Cancel flag to false: that allows the context menu to continue opening even if it is empty at the moment of clicking. (By the time it opens, the code in the event handler should have populated it, of course.)

private void ContextMenuStrip_Opening(
object sender, System.ComponentModel.CancelEventArgs e)

{

e.Cancel = false;

hostManager.BuildServerAssociations();

hostManager.BuildContextMenu(notifyIcon.ContextMenuStrip);

notifyIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());

notifyIcon.ContextMenuStrip.Items.Add(hostManager

.ToolStripMenuItemWithHandler("Show &Details", showDetailsItem_Click));

notifyIcon.ContextMenuStrip.Items.Add(hostManager

.ToolStripMenuItemWithHandler("&Help/About", showHelpItem_Click));

notifyIcon.ContextMenuStrip.Items.Add(new ToolStripSeparator());

notifyIcon.ContextMenuStrip.Items.Add(hostManager

.ToolStripMenuItemWithHandler("&Exit", exitItem_Click));

}

For HostSwitcher, I reread the hosts file each time the user opens the context menu (BuildServerAssociations) to keep it current. The hostManager then builds the custom portion of the context menu and the remaining lines here finish up the menu with commands to open different child windows.

These next methods comprise the rest of the generic portion of the custom ApplicationContext, mostly verbatim from Fosler’s Creating Applications with NotifyIcon in Windows Forms. They take care of proper cleanup in the class:

private void exitItem_Click(object sender, EventArgs e)
{

ExitThread();

}

protected override void Dispose(bool disposing)

{

if ( disposing && components != null) { components.Dispose(); }

}

protected override void ExitThreadCore()

{

if (mainForm != null) { mainForm.Close(); }

notifyIcon.Visible = false; // should remove lingering tray icon!

base.ExitThreadCore();

}

Customizing WinForm Connections

The only remaining portions of the custom ApplicationContext involve hooking up any child forms you may need. First you need a method to display the form if it already exists, or create one if it does not. You should use the code shown here as a template for your own child forms, changing the one line that indicates the Form name and optionally, its arguments. You may also want to change the variable name; I use detailsForm here because it shows the details view for HostSwitcher.

private void ShowDetailsForm()
{

if (detailsForm == null)

{

detailsForm = new DetailsForm {HostManager = hostManager};

detailsForm.Closed += detailsForm_Closed;

detailsForm.Show();

}

else { detailsForm.Activate(); }

}

With this method in hand you need to invoke it from your tray icon’s context menu and clean it up when closed:

// attach to context menu items

void showDetailsItem_Click(object sender, EventArgs e) { ShowDetailsForm(); }

// null out the forms so we know to create a new one.

void detailsForm_Closed(object sender, EventArgs e) { detailsForm = null; }

WPF Can Play, Too!

The NotifyIcon, as neutral as it may seem, exists in the WinForms namespace. I was wondering if it could play well with WPF too since WPF does not have its own. In my previous article on WPF and WinForms interoperability (Mixing WPF and WinForms) I came to appreciate the enormous size and complexity of making these two technologies play well together and kudos to Microsoft for making it a reality. Because of the support from the Framework, it is trivial to use a WPF window instead of a WinForms window. First, create a WPF window. (Do this in a new, separate project because Visual Studio does not let you put a WPF window in a WinForms project. The project should be a WPF Custom Control Library. See Johan Danforth's blog entry Open a WPF Window from WinForms that shows you the step by step procedure in a very clear and concise article!) With that in hand you then use this slightly different method to display the form:

private void ShowIntroForm()
{

if (introForm == null)

{

introForm = new WpfFormLibrary.IntroForm();

introForm.Closed += mainForm_Closed;

ElementHost.EnableModelessKeyboardInterop(introForm);

introForm.Show();

}

else { introForm.Activate(); }

}

The only difference from the WinForms version, discounting names, is the additional line invoking the EnableModelessKeyboardInterop method. Danforth explains that this line is important to properly handle keyboard input; further details are available in the MSDN forum post Windows Form opening WPF window as well.

Then, just as with the WinForms version, you need to hook up the child form with event handlers. The first line is unique here only because I chose this child form to respond to double-clicking the tray icon; you could just as easily let it display the WinForm child.

void notifyIcon_DoubleClick(object sender, EventArgs e) { ShowIntroForm(); }

// attach to context menu items

void showHelpItem_Click(object sender, EventArgs e) { ShowIntroForm(); }

// null out the forms so we know to create a new one.

void mainForm_Closed(object sender, EventArgs e) { introForm = null; }

As you can see, it is just as easy to use a WPF window as it is a WinForms window, even though the NotifyIcon is a WinForms class. While WPF does not have a NotifyIcon native to the .NET framework, thanks to Philipp Sumi (the same industrious developer who created Sketchables for SketchFlow), there is a NotifyIcon available in pure WPF, enhancing the display capabilities of your tray icon with rich tool tips instead of just text, WPF context menus, flexible data binding, and rich balloon messages. It looks so enticing I am eager to convert HostSwitcher over to it at some point! Read Philipp’s article, simply titled WPF NotifyIcon, and download his code to try it out.

Ensuring Only One Instance Executes: Mutual Exclusion

There are three commonly used techniques for enforcing only one instance of your application may execute. Regardless of the technique, though, the algorithm is the same: very early in its startup each instance checks to see if any other instances are running and terminates if there are. The first instance, finding none, continues initialization while any subsequent ones obediently disappear.

Technique 1: Native .NET Support

The .NET framework includes a class (WindowsFormsApplicationBase) that you subclass to create a single instance manager. It is relatively simple to hook up. The only odd thing about it is that it exists in a Visual Basic namespace even though you are free to use it in other .NET languages just as readily. Thus, you must include a reference to Microsoft.VisualBasic.dll. Michael Kuehl has a good article on this approach which may be used for WinForms or WPF despite the title: WPF - Writing a Single Instance Application. This is his code sample; I refer you to his article for details on what it does:

public sealed class SingleInstanceManager : WindowsFormsApplicationBase
{

[STAThread]

public static void Main(string[] args)

{ (new SingleInstanceManager()).Run(args); }

public SingleInstanceManager()

{ IsSingleInstance = true; }

public ExampleApplication App { get; private set; }

protected override bool OnStartup(StartupEventArgs e)

{

App = new ExampleApplication();

App.Run();

return false;

}

protected override void OnStartupNextInstance(

StartupNextInstanceEventArgs eventArgs)

{

base.OnStartupNextInstance(eventArgs);

App.MyWindow.Activate();

App.ProcessArgs(eventArgs.CommandLine.ToArray(), false);

}

}

Technique 2: The Process Table

With this technique you check if your application appears in the list of running processes on your machine. This takes only a few lines of code in your Main() method. Bob Powell describes this technique succinctly in The Single Instance Application. This is his code sample:

static void Main()
{

string appProcessName =

Path.GetFileNameWithoutExtension(Application.ExecutablePath);

Process[] RunningProcesses = Process.GetProcessesByName(appProcessName);

if (RunningProcesses.Length == 1) // just me, so run!

{

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

Application.Run(new CustomApplicationContext());

}

else // switch to the first instance and exit

{

ShowWindowAsync(RunningProcesses[0].MainWindowHandle,

(int)ShowWindowConstants.SW_SHOWMINIMIZED);

ShowWindowAsync(RunningProcesses[0].MainWindowHandle,

(int)ShowWindowConstants.SW_RESTORE);

}

}

Technique 3: The Mutex Primitive

This technique uses the .NET Mutex (short for mutual exclusion) synchronization primitive. A mutex object allows you to obtain a resource and then lock it so that others may not obtain it until you release the lock. The application is obvious: here you want to allow the first instance of your application to run, and then create a lock so that other instances may not run. In this code sample the Mutex object is embedded in the SingleInstance class: the Start method requests the mutex lock while the Stop method releases it. If the lock is not obtainable, i.e. this is not the first instance, the program terminates. Otherwise it continues to run and upon conclusion releases the lock.

static void Main()
{

if (!SingleInstance.Start()) { return; } // mutex not obtained so exit

Application.EnableVisualStyles();

Application.SetCompatibleTextRenderingDefault(false);

try

{

Application.Run(new CustomApplicationContext());

}

catch (Exception ex)

{

MessageBox.Show(ex.Message, "Program Terminated Unexpectedly",

MessageBoxButtons.OK, MessageBoxIcon.Error);

}

SingleInstance.Stop(); // all finished so release the mutex

}

This technique—the one I chose to apply to HostSwitcher—is thoroughly detailed in C# Single Instance App With the Ability To Restore From System Tray written by a developer with the moniker of “devzoo”. This has the clear benefit of only a couple lines of code added to your application once you reference the MutexManager library included in the HostSwitcher solution as a separate DLL. (My MutexManager library is a simple repackaging of devzoo’s nicely encapsulated classes.) Note that the all-encompassing error trapping is important here—you want to ensure that you release the mutex even if your program throws an exception.

Strengths and Weaknesses of Mutex Techniques

There are a variety of factors to consider in deciding which technique to use to enforce the single instance principle. The WindowsFormsApplicationBase seems a bit more complex in instrumenting your code. The process list approach requires very simple coding and no additional libraries, but it does have some weaknesses, as K. Scott Allens describes in the blog entry on The Misunderstood Mutex. Because of those weaknesses I prefer the Mutex approach.

On the other hand, notice in the code samples that the Mutex technique is the only one of the three where you cannot activate the first instance from subsequent instances. For a form-centric application, re-activating the first instance when the user attempts to launch a second instance is clearly a good usability goal. But for a tray-centric application like HostSwitcher there is little benefit—the “application” is in the system tray so there is not even a concept of bringing it to the foreground. I will admit, though, that some tray-centric applications would find it a benefit—those where the user operates primarily in child windows (e.g., a firewall or antivirus program). These typically live in your system tray but at any time you can open up a main window as long lasting as any normal desktop application.

I have a solution in mind to strength the Mutex approach (though I have not yet implemented it): use the standard Mutex for enforcing a single instance, but then use the process table technique to find the first instance and activate it as demonstrated in the code sample above.

Conclusion

When I first had the thought “I need a small application to manage my host routing” I had little notion of the nuances and trade-offs involved in creating a well-designed tray app. And, just like the oft-stated comment that “If one person has a question, probably many others in the audience do, too,” I believe that if one developer realizes “Oh, that’s how it is done,” then there are probably many other developers who may appreciate the knowledge as well.

About the only thing I could not come to a good resolution when designing this application is its name. HostSwitcher seems like a reasonable choice but I am not convinced it is the best choice. Thus, I would like to encourage you, dear reader, to post a comment at the bottom to state whether you think HostSwitcher succinctly conveys the intent of the program or to offer an alternative if you have something else in mind. SoftSwitch? HostRouter? HostOnToast? IpHop? NetSpinner? Let me hear from you!

Session Vs Application variable

2011-01-31T03:58:00.000-08:00

Session Vs Application variable

Application Variables:
Application variables are the variables which remain common for the whole application for all the users… Their value can be used across the whole application by any user… And they die only when the application stops or probably when they are killed forcibly… The ideal example for these kind of variables are site counter… We can find out how many people accessed a particular site since the time it went live via application variables and incrementing the same on ever session start.

Session Variables:
Session variables are variables which remain common for the whole application but for one particular user. They also can be used across the whole application but each user will have a copy… But they die when a particular user session ends or probably when they are killed forcibly… The ideal example for this kind of variable are user id… You might want to show "Welcome Meetu Choudhary " on every page of your site till Meetu Choudhary logs off… So in session start you set a variable to "Welcome Meetu Choudhary" and kill it on end of session…

All these events session start, session end, application start, application end are found in global.asax and that’s the reason global.asax is one for the whole ASP.Net application…

General Page Life-cycle Stages in ASP.Net

2011-01-05T22:46:00.000-08:00

Page request:

The page request occurs before the page life cycle begins. When the page is requested by a user, ASP.NET determines whether the page needs to be parsed and compiled or whether a cached version of the page can be sent in response without running the page.

Start:

In the start step, page properties such as Request and Response are set. At this stage, the page also determines whether the request is a postback or a new request and sets the IsPostBack property. Additionally, during the start step, the page's UICulture property is set.

Page initialization:

During page initialization, controls on the page are available and each control's UniqueID property is set. Any themes are also applied to the page. If the current request is a postback, the postback data has not yet been loaded and control property values have not been restored to the values from view state.

Load:

During load, if the current request is a postback, control properties are loaded with information recovered from view state and control state.

Validation:

During validation, the Validate method of all validator controls is called, which sets the IsValid property of individual validator controls and of the page.

Postback event handling:

If the request is a postback, any event handlers are called.

Rendering:

Before rendering, view state is saved for the page and all controls. During the rendering phase, the page calls the Render method for each control, providing a text writer that writes its output to the OutputStream of the page's Response property.

Unload:

Unload is called after the page has been fully rendered, sent to the client, and is ready to be discarded. At this point, page properties such as Response and Request are unloaded and any cleanup is performed.

How does IIS communicate at runtime with ASP.NET

2010-10-14T00:34:00.000-07:00

When an aspx requested, IIS checks the file extension in its metabase.

To view the metabase Start> Run > inetmgr
In the Internet Information Services window right click in 'Web sites' > Properties
Select 'Home Directory' tab and click the Configuration button
Now you can see a table with 3 columns.
aspx is mapped to aspnet_isapi.dll

When IIS find the extension aspx, then it loads the aspnet_isapi.dll and pass all the request details to it.

aspnet_isapi.dll then loads the CLR and pass all the request details that received.

CLR then create HttpRuntime engine.

The begining of the runtime engine is HttpRunTime class. It creates the HttpContext object and stores all the request details.

From there HttpContext object passes through a pipeline which consists of HttpApplication object, HttpModule objects and finally HttpHandler object ( that is our page class).

HttpHandler object creates the html page

Hope so you get ur answer

How to SAVE and RETRIEVE image in DataBase SQL with LINQ

2010-09-03T03:22:00.000-07:00

public void SaveImage()
{
byte[] pic = null;
int len = FUImage.PostedFile.ContentLength;
pic = new byte[len];
FUImage.PostedFile.InputStream.Read(pic, 0, len);

Table_Name tab_name = new Table_Name()
{
Image = pic,
};
_data.odatacontext.Table_Name.InsertOnSubmit(tab_registration);
_data.odatacontext.SubmitChanges();
}
}

public void RETRIEVEImage()
{
try
{
System.IO.MemoryStream stream = new MemoryStream();
SqlConnection connection = new
SqlConnection(@"Data Source=(local);Initial Catalog=DataBaseName;User ID=sa;Password=123");

connection.Open();
SqlCommand command = new
SqlCommand("select top(1) Image from Table_Name order by RID desc", connection);
byte[] image = (byte[])command.ExecuteScalar();
stream.Write(image, 0, image.Length);
System.Drawing.Bitmap bitmap = new Bitmap(stream);
Response.ContentType = "image/gif";
bitmap.Save(Response.OutputStream, ImageFormat.Gif);
}
finally
{
connection.Close();

}
}

Contact

2010-05-24T22:36:00.000-07:00

Contact

Brajendra Shukla

brajendrashukla25@gmail.com

brajendra@janpratinidhi.com

XML with LINQ

2010-02-05T02:59:00.000-08:00

Parent child Relationship:
public static object GetMLAMemberDetailsByConstituency(string Id) {
XDocument Xdoc = XDocument.Load("Root.Data/DataXML/MLAXML.xml");
var settingElement = from us in Xdoc.Elements("root").Elements ("State").Elements("PC").Elements("Constituency").Elements("PM").Elements("PT")
where us.Parent.Parent.Attribute ("ConstituencyId").Value == Id
select new
{
FirstName = us.Parent.Attribute ("FirstName").Value,
LastName = us.Parent.Attribute("LastName").Value,
State = us.Parent.Parent.Parent.Parent.Attribute("StateName").Value,
PC = us.Parent.Parent.Parent.Attribute("PCName").Value,
constituency = us.Parent.Parent.Attribute("ConstituencyName").Value,
ConstituencyId = us.Parent.Parent.Attribute("ConstituencyId").Value,
PartyName = us.Attribute("PartyName").Value,
};
return settingElement.ToList();
}
More Details:
http://www.aspnettutorials.com/tutorials/xml/linq-to-xml-adding-cs.aspx

AutoComplete Textbox

2010-01-24T22:20:00.001-08:00

Introduction:

This article explains to fill a AutoComplete Textbox from the data fetched from database.

Description:
Everyone knows about the AutoComplete Textbox. It is an ASP.NET AJAX extender that can be attached to any TextBox control. When the user types some letters in the Textbox, a popup panel will come to action and displayed the related words. So that the user can choose exact word from the popup panel. Here I tried to explain how this AutoComplete fetches data from the database through a Webservice.

Open Microsoft Visual Studio, click on New Website. Then choose ASP.NET Ajax Enabled Website and change the location to point your http://localhost/AutoComplete folder. Obviously, Default.aspx is added to your solution explorer.

Now drag and drop a Textbox from your Toolbox. Then drag and drop a ScriptManager and AutoCompleteExtender to your Default.aspx page. Then add a webservice to your project as WebService.asmx. First thing you have to do is to add the ScriptService reference to the webserive as follows.

System.Web.Script.Services.ScriptService

[WebMethod]
public string[] GetCountryInfo(string prefixText)
{
int count = 10;
string sql = "Select * from Country Where Country_Name like @prefixText";
SqlDataAdapter da = new SqlDataAdapter(sql,"Your Connection String Comes Here"));
da.SelectCommand.Parameters.Add("@prefixText", SqlDbType.VarChar, 50).Value = prefixText+ "%";
DataTable dt = new DataTable();
da.Fill(dt);
string[] items = new string[dt.Rows.Count];
int i = 0;
foreach (DataRow dr in dt.Rows)
{
items.SetValue(dr["Country_Name"].ToString(),i);
i++;
}
return items;
}

The above webmethod takes prefixText as argument, sends it to the query to fetch only the related words that starts with the prefixText values. Then it returns the result as an array of strings.

Now, it's time to run the project. Select the Default.aspx and click on View in Browser. You can see the excellent application starts to run. Type your country's first letter. See all the countries starts with that letter will appear in the popup.

SqlCacheDependency Caching in Detail

2010-01-21T02:11:00.000-08:00

Caching with filtration:

private void Bind()
{
try
{
DataSet DS_district = new DataSet();
DataTable _table = new DataTable();
if (Cache["CachingName"] == null)
{
DS_district = Common.GetAllDistrict();
SqlCacheDependency dependency = new SqlCacheDependency ("DataBaseName", "TableName");
Cache.Insert("CachingName", DS_district, dependency, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(10));
_table = DS_district.Tables[0];
var query = from _district in _table.AsEnumerable()
where _district.Field("Id").Equals(Convert.ToInt64 (Dropdown2.SelectedValue))
select _district;

DataView _view = query.AsDataView();
Dropdown1.DataSource = _view;
Dropdown1.DataTextField = "Name";
Dropdown1.DataValueField = "Id";
Dropdown1.DataBind();
}
else
{
DS_district = (DataSet)Cache["CachingName"];
_table = DS_district.Tables[0];
var query = from _district in _table.AsEnumerable()
where _district.Field("Id").Equals(Convert.ToInt64 (Dropdown2.SelectedValue))
select _district;

DataView _view = query.AsDataView();
Dropdown1.DataSource = _view;
Dropdown1.DataTextField = "GeographicName";
Dropdown1.DataValueField = "GeographicId";
Dropdown1.DataBind();
}
}

catch (Exception ex)
{
lblError.Text = ex.Message.ToString();
}
}

Implement Caching

2010-01-07T02:51:00.000-08:00

In SQL Server DataBase
:
Run this command:

Exp:
aspnet_regsql.exe -S localhost -U sa -P sa -d NewDataBase -ed
This command Enable your Data Base, now You need to enable using table , for this command is...
aspnet_regsql.exe -S localhost -U sa -P sa -d NewDataBase -t tableName -et
After this go to SQL server , you get a new table "AspNet_SqlCacheTablesForChangeNotification".

coding on web.conf file
system.web
caching
sqlCacheDependency enabled="true"
databases
add name="NewTest" connectionStringName="Connection" pollTime="500"
/databases
/sqlCacheDependency
/caching
/system.web

Coding on .cs file
DataSet geography = new DataSet();
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
try
{
SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Connection"].ConnectionString);
SqlDataAdapter adapter = new SqlDataAdapter("Select * from Users", conn);

adapter.Fill(geography);
SqlCacheDependency dependency = new SqlCacheDependency("NewTest", "Users"); Cache.Insert("Geo", geography, dependency,System.Web.Caching.Cache.NoAbsoluteExpiration,TimeSpan.FromMinutes(20));
GridView1.DataSource = geography;
GridView1.DataBind();
lblMessage.Text = "Categories retrieved from the Data Base";
}
catch { }
}
}
protected void Button1_Click(object sender, EventArgs e)
{
DataSet ds = (DataSet)Cache["Geo"]; lblMessage.Text = "Categories retrieved from the Cached data base";
GridView1.DataSource = ds;
GridView1.DataBind();
}

The benefits Of LINQ

2009-12-07T03:58:00.001-08:00

While the title of this article may seem misleading, you actually can achieve incredible performance gains by updating your web application to use LINQ. This article will dispell some common myths about LINQ and demonstrate how LINQ can practically increase performance. The examples in this article will be using LINQ to SQL, but the principles apply to LINQ to Entities as well.

First of all, it's important to realize what LINQ is and what it isn't. LINQ is a language feature you'll see in Visual Studio 2008 (Visual Studio Orcas) and beyond. It's not dependant on any particular .NET language as you can use it in C# or VB.NET. LINQ stands for "Language Integrated Query", but its usage goes beyond language capabilities alone.

It is true that the language speeds up development by allowing you to use a simple query-syntax in C# or VB.NET to query data from a HashTable, XML file or SQL Database. And it's also true that you can have Visual Studio 2008 write tons of code for you to build classes for your data tables (or even to build SQL tables from your classes). However, this article will demonstrate runtime performance gains you'll see by using some built in features that come with the language as well.

The benefits we'll discuss are:

Intelligent query translations (such as faster data pagination).
Redundant query checking to prevent needless data hits.
Redundant update checking to ensure minimal data transfers.
Intelligent Query Translations
One of the built-in benefits of using LINQ is that methods that are deemed "best practice" are used in the underlying technologies. For instance, if you were to use a standard ASP.NET 2.0 SqlDataSource, and you bound that data to a GridView with pagination turned on, you might not realize that you're transferring your entire data table just to use a few rows at a time in your paginated GridView. This results in some heavy queries, heavy data transfers and often times slow page loads.

The best place to do pagination would be on the SQL server itself. That way you are only transferring the few rows that are desired, saving you much network bandwidth and time. Ultimately, LINQ isn't doing anything that you couldn't do yourself, but most developers do not know how to do Pagination In SQL Server 2005, or they may not have time to change all of their queries to do so.

Again, if you take that simple "SqlDataSource" example above, but this time bind two ASP.NET controls to it (let's say a GridView and a DropDownList), then you'll be hitting your SQL server twice, and download all that data twice. This brings us to the next performance gain in LINQ.

Redundant Query Checking
Some of the biggest performance gains that I've benefited from by switching to LINQ is it's ability to look at the "context" of your request to determine if it needs to hit the database again. If you've already started to use LINQ yourself, but you don't know what I'm talking about, then you'll probably have a new appreciation for LINQ in a few minutes.

LINQ uses a "DataContext" object to determine what connection string to use, what objects to map to and other internal things. But you should be careful not to think of the LINQ data context class as you would think of a traditional "SqlConnection". If you are transitioning from using SqlConnections and SqlCommands you'll probably code something like this:

// Example of doing your own straight SQL query:
public static IEnumerable GetMyData()
{
using (SqlConnection myConnection = new SqlConnection(myConnectionString))
{
using (SqlCommand myCommand = myConnection.CreateCommand())
{
myCommand.CommandText = "SELECT * FROM dbo.myTable";

using (SqlDataAdapter myAdapter = new SqlDataAdapter(myCommand))
{
DataTable resultTable = new DataTable();

myAdapter.Fill(resultTable);

return resultTable.Rows;
}
}
}
}
If you translated the above method into LINQ, then your method might look something like this:

// Example of using LINQ to query the "Clients" table:
public static IEnumerable GetMyData()
{
using (MyDataContext myContext = new MyDataContext())
{
return from myRow in myContext.Clients select myRow;
}
}
This at first seems like an acceptable conversion from using a SqlConnection to using LINQ, but you're missing out on so much (which you'll see in a minute).

This is pretty much a 1 to 1 switch from writing your own SQL query to writing a query in LINQ. It is noteworthy that it takes a lot less code to query a database. However, these two code blocks will do the same thing, and you won't gain any performance from calling the LINQ method instead of calling the straight SQL method. Even if you call both of these functions twice in a row, you won't gain any performance because we are not utilizing the LINQ context correctly.

If we extend the range of our context to last for the entire web request (not just for the life of the function call) then we will begin to see performance increases. Before we examine how to do that, let's look at this next example that should help explain how the context works. We'll change our above method, "GetMyData", so that we can pass in our own context. Here's the code:

// Change the GetMyData method to take in an existing context.
public static IEnumerable GetMyData(MyDataContext myContext)
{
return from myRow in myContext.Clients select myRow;
}

// This will demonstrate how we are going to gain performance with LINQ:
protected void Page_Load(object sender, EventArgs e)
{
// First, we create our data context just like we did before.
MyDataContext myContext = new MyDataContext();

// Calling this function the first time will hit SQL and query the data.
GetMyData(myContext);

// LINQ is smart enough to realize that we've already used this query
// against this data context, so it won't hit SQL again. Instead it will
// simply return the same result set as last time.
GetMyData(myContext);

// This is a bit ridiculous, but you get the idea.
for (int i = 0; i < 100; i++)
{
GetMyData(myContext);
}
}
The way to achieve the performance benefits of using the same data context during the entire page request is to store your data context instance in the HttpContext Items collection (which is alive for the duration of the thread). We'll make a static property that will give us a data context instance, but because we are using the current HttpContext, we won't have cross thread issues. You can read a little more about the HttpContext in this article: Connect Your Site With HttpContext Items. Let's look at the code to see how to achieve this:

public static class DataAccessLayer
{
// This object is a "key" to the HttpContext Items dictionary.
private static object _eelsContextKey = new object();

// This will always return an instance of the MyDataContext
// (which was created by a LINQ wizard in Visual Studio 2008). It
// will return the SAME instance if you call it twice during the
// same HTTP request.
private static MyDataContext Context
{
get
{
if (HttpContext.Current.Items.Contains(DataAccessLayer._eelsContextKey) == false)
{
MyDataContext context = new MyDataContext("Connection String Here...");

HttpContext.Current.Items.Add(DataAccessLayer._eelsContextKey, context);

return context;
}
else
{
return (MyDataContext)HttpContext.Current.Items[DataAccessLayer._eelsContextKey];
}
}
}

// Now we can make very simple DataAccessLayer functions like these:

public static IEnumerable GetClients()
{
return from myRow in DataAccessLayer.Context.Clients select myRow;
}

public static IEnumerable GetProjects()
{
return from myRow in DataAccessLayer.Context.Projects select myRow;
}

public static IEnumerable GetThePoint()
{
return from myRow in DataAccessLayer.Context.You_Get_The_Point select myRow;
}
}
Let's now look at the last area of performance gain from using LINQ that we will discuss.

Redundant Update Checking
The last place where you can see performance gains is with writing back to your data source. The LINQ data context not only remembers if you have already queried some data before, but it also keeps track of any changes that are made. This means that if you call the "save" function, but no changes were made first, then LINQ will ignore the request to save. Likewise, if you only change one property (such as "FirstName"), then LINQ will build an UPDATE statement that only contains that one column (again saving time and bandwidth).

Hiding SQL code

2009-12-01T04:45:00.000-08:00

Problem
I am required to restrict the access to some users to view the definition of specific SQL Server database objects. I am aware of the WITH ENCRYPTION clause that is used to encrypt the code for objects like views, stored procedures and functions. It sort of fulfills my purpose and is easy to implement, but it does not cover all SQL Server objects. In this tip we look at another option to restrict users from viewing the definition/code of any SQL Server object.

Solution
The WITH ENCRYPTION clause is used to encrypt the definition of SQL Server objects (views, stored procedures, functions ), so that no one may be able to view the definition/code of that specific object. Using the clause while creating an object is fairly easy, but there are some serious points and possible complications.

Before discussing the complications, let us go through the simple use of this clause for defining a view, stored procedure and UDF.

Linq Use

2009-11-27T03:31:00.000-08:00

public IQueryable BindQualificationDetail(int startRowIndex, int maximumRows)
{
var qulaificationTypes = from QD in Common.dataContext.QualificationDetails
where QD.UpdaterRef.Equals(User.Identity.Name)
orderby QD.UpdatedOn descending
select new
{
QD.ProfileID,
QD.QualificationDetails,
QD.UpdaterRef
};
ViewState["BindQualificationDetailRows"] = qulaificationTypes.Count();
return qulaificationTypes.Skip(startRowIndex).Take(maximumRows);
}
public int GetQualificationDetailCount()
{
return (int.Parse(ViewState["BindQualificationDetailRows"].ToString()));
}

Coolite Intro

2009-11-26T02:12:00.000-08:00

We are pleased to announce the release of the Coolite Toolkit Version 0.6. This release is the most feature packed Coolite Toolkit version to date and ships with 20+ new web controls, new Ajax functionality and dozens of new features to help impress your boss and clients.

New Features

Examples Explorer

Coolite Toolkit Examples Explorer We're thrilled with our new "Examples Explorer" and over time we will be filling the explorer with hundreds of working code samples. The explorer is a great place to jump start your introduction into the Coolite Toolkit and simplify adding new functionality to your own projects. Each example also includes a real time "Source Code" viewer, .zip download of the files and "Direct Link" option.

New Slate Theme

The popular ExtJS Slate Theme originally developed by J.C. Bize is now included along with the original "Default" and "Gray" Themes. Just set Theme="Slate" in your . As well, continuing with our commitmen

Linq Carries Value from One PAge to another

2009-11-12T01:06:00.000-08:00

private void BindForm()
{
MemberYear original = GetMemberYearDetail(Convert.ToByte(Request.QueryString["ID"]));

foreach (ListItem lst in drpState.Items)
{
long GeographicId = Convert.ToInt64(ViewState["GeographicId"].ToString());
if (GeographicId == Convert.ToInt16(lst.Value))
{
drpState.ClearSelection();
lst.Selected = true;

}
}

foreach (ListItem lst in drpConstituency.Items)
{
if (original.GeographicId == Convert.ToInt16(lst.Value))
{
drpConstituency.ClearSelection();
lst.Selected = true;
BindMemberProfile(Convert.ToInt64(drpConstituency.SelectedValue.ToString()));
}
}

foreach (ListItem lst in drpMember.Items)
{
if (original.ProfileId == Convert.ToInt16(lst.Value))
{
drpMember.ClearSelection();
lst.Selected = true;
}
}

foreach (ListItem lst in drpElectionYear.Items)
{
if (original.ElectionYearId == Convert.ToInt16(lst.Value))
{
drpElectionYear.ClearSelection();
lst.Selected = true;
}
}
}

Linq Sumbit

2009-11-12T01:05:00.000-08:00

protected void btnSubmit_Click(object sender, EventArgs e)
{
try
{
DataClassesDataContext dataContextAdd = new DataClassesDataContext(ConfigurationManager.ConnectionStrings["ConnRootDataBase"].ConnectionString);

MemberYear memberYear = new MemberYear
{
MemberYearId = GenerateID(),
ProfileId = Convert.ToInt64(drpMember.SelectedValue),
GeographicId = Convert.ToInt64(drpConstituency.SelectedValue),
ElectionYearId = Convert.ToInt64(drpElectionYear.SelectedValue)

};
dataContextAdd.MemberYears.InsertOnSubmit(memberYear);
dataContextAdd.SubmitChanges();
dataContextAdd.Dispose();
lblError.Text = "your Information Inserted Succesfully!!";
lblError.ForeColor = System.Drawing.Color.Green;
}
catch (Exception ex)
{
lblError.Text = ex.Message.ToString();
}

}