ஏஞ்சல் பதிவுகள்!

Agile Methodology

2010-05-19T09:19:00.000-07:00

Agile Methodology – An Overview

Gartner defines Agility as "the ability of an organization to sense environmental change and respond efficiently and effectively to that change." Sensing the need for change also includes the proactive initiation of change.

Rapidity of business change is driving a need for agility to respond more effectively to change.Organizations needed to make development process changes should strongly consider using Agile rapid applications development methodologies as part of moving to service-oriented development of applications.

Any enterprise that aspires to respond in real time must have the ability to be agile when needed. Agile is successful because it:
Stresses customer satisfaction
Emphasizes team work (simple, yet effective way to enable groupware style development)
Allows agile programmers communicate with their customers and fellow programmers quite regularly and empowers them to confidently respond to changing customer requirements, even late in the life cycle
Why Agile
Traditionally, software development has been process-centric.
Agile methodologies change the face of software development by giving it a human touch (people over processes).
Customers value ROI and time-to-market.
Agile methodologies help in increasing ROI as well as reduce time-to-market. (incremental working software)
Customers see quality, productivity and turn-around time as a risk when it comes to off-shore software development.
Agile methodologies build trust and confidence as the customer is part of the team and the techniques used reduce the offshore risks. (customer collaboration and embracing change)
Development Firm
Critical Success Factors
Use Continuous Integration to Avoid Integration Headaches
Have Each Site Send Ambassadors to the Other Sites
Use Contact Visits to build trust
Don't Underestimate the Culture Change
Use wikis to contain common information
Use Test Scripts to Help Understand the Requirements
Use Regular Builds to Get Feedback on Functionality
Use Regular Short Status Meetings
Use Short Iterations
Use an Iteration Planning Meeting that's Tailored for Remote Sites
When Moving a Code Base, Bug Fixing Makes a Good Start
Separate teams by functionality not activity
Expect to need more documents.
Get multiple communication modes working early.

Client : A leading supplier of media and technology solutions to connect Health care professionals to customers

Salient Features
The Core / Remote Team Model
Phased Requirements
Project Transitioning
Multiple Technical Approach
Agile Source Control
Agile Testing
Daily & Weekly Meetings
Change Request Management

Agile Requirements & Implementation
1. Planning requires user/programmer cooperation in defining feature benefits and costs. - The Core Team Model, The Remote Team Model.
2. Small releases put out a simple system early and update it often. - Phased Requirements.
3. Simple design value comes from the simplest program that meets requirements. - Multiple Technical approch.
4. Re-factoring has Agile teams correct system design defects and recode as necessary - Multiple approch & Agile source control.
5. Testing has programmers write tests first, and then create software to fulfill test requirements. - Agile Testing
6. On-site customers set priorities, answer programmers' questions and cut documentation costs. - Daily & weekly status meeting.
7. Pair programming has programmers write all production code in pairs, sharing a single machine. - Agile source control
8. Collective ownership implies shared responsibility for code function and quality. - Daily & Weekly Meetings,
Project Transitions, Change Request
Management, The Core Team Model, The Remote Team Model.

Get the Row Count

2010-04-19T05:09:00.000-07:00

Get the Row Count using procedure, insted of select count (*) table Name

USE [DBName]
GO
/****** Object: StoredProcedure [dbo].[Sp_RowCount] Script Date: 04/19/2010 17:40:36 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE Proc [dbo].[Sp_RowCount]( @Tname as varchar(100)) As
Declare @SQL Varchar(500)
Set @SQL='Select Object_Name(Id) As [Table Name], Rows From sysindexes Where indid < 2 And Id=' + Str(Object_Id(@Tname)) // the case if u want only count u remove the first colum of (table name).
Exec (@SQL)

Design Patterns

2010-02-28T10:10:00.001-08:00

Design patterns are recurring solutions to software design problems you find again and again in real-world application development. Patterns are about design

and interaction of objects, as well as providing a communication platform.
Design patterns categorized as Creational,Structural,Behavioral.

Creational pattern
Abstract Factory --->Creates an instance of several families of classes
(Provide an interface for creating families of related or dependent objects without specifying their concrete classes.)

Builder --->Separates object construction from its representation
(Separate the construction of a complex object from its representation so that the same construction process can create different representations..)
/>

Factory Method--->Creates an instance of several derived classes
(Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses)

Prototype--->A fully initialized instance to be copied or cloned.
(Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prototype.)
/>

Singleton--->A class of which only a single instance can exist.
(Ensure a class has only one instance and provide a global point of access to it.)
/>

Structural pattern
Adapter--->Match interfaces of different classes
(Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible
interfaces.)

Bridge--->Separates an object’s interface from its implementation
(Decouple an abstraction from its implementation so that the two can vary independently.)

Composite--->A tree structure of simple and composite objects
(Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

)
/>

Decorator--->Add responsibilities to objects dynamically
(Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.)
/>

Facade--->A single class that represents an entire subsystem
(Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher-level interface that makes the subsystem easier to use.)

Flyweight---> A fine-grained instance used for efficient sharing
(Use sharing to support large numbers of fine-grained objects efficiently.)
/>

Proxy--->An object representing another object
(Provide a surrogate or placeholder for another object to control access to it.)
/>

Behavioral pattern
Chain of Resp--->A way of passing a request between a chain of objects
(Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the

request along the chain until an object handles it.)
/>

Command--->Encapsulate a command request as an object
(Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations. )
/>

Interpreter--->A way to include language elements in a program
(Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.)
/>

Iterator --->Sequentially access the elements of a collection
(Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.)

Mediator--->Defines simplified communication between classes
(Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly,

and it lets you vary their interaction independently.)

Memento--->Capture and restore an object's internal state
(Without violating encapsulation, capture and externalize an object's internal state so that the object can be restored to this state later.)

Observer--->A way of notifying change to a number of classes
(Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.)

State--->Alter an object's behavior when its state changes
(Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.)

Strategy---> Encapsulates an algorithm inside a class
(Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.)

Template Method--->Defer the exact steps of an algorithm to a subclasse.
(Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an

algorithm without changing the algorithm's structure.)

Visitor--->Defines a new operation to a class without change
(Represent an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the
elements on which it operates.)

Testing Methodology

2010-01-31T09:03:00.001-08:00

MVC & 3 Tire Architecture

2010-01-20T12:05:00.000-08:00

Model View Controller (MVC)
Introduction:

Design patterns are very useful to solve complex design problems if used properly. This article explains the basic concept of the Model View Controller (MVC) Design pattern and also shows how closely.

Prerequisites

Object Oriented-programming concepts, .NET Framework, ADO.NET, C#, XSD.

Definition/Description: Model View Controller (MVC)

View renders the data from the Model in response to the request made to the model by controlled events made by user interaction.

Model View Controller is a design approach to separate the application object model from GUI, originally invented around 80s. Then later on it has become a widely accepted common design pattern. The main objective behind this pattern is to decouple the view of the data (presentation layer) from the actual data processing so that the same model can be used for various views. This is achieved by using three different types of objects that interact with each other in loosely coupled manner with their discreet set of tasks.

These three objects are known as Model, View and Controller. We will learn for each of them here.

VIEW:

View is the graphical data presentation (outputting) irrespective of the real data processing. View is the responsible for look and feel, some custom formatting, sorting etc. View is completely isolated from actual complex data operations. For example, Online product catalog view is completely separated from database connection, query, tables etc. It simply gets final row-data from the model and puts some cosmetics and formatting before displaying it in browser. View provides interface to interact with the system. The beauty of MVC approach is that it supports any kind of view, which is challenging in todays distributed and multi-platform environment.

A MVC model can have multiple views, which are controlled by controller. View interface can be of WEB-FORMS, HTML, XML/XSLT, XTML, and WML or can be Windows forms etc.

MODEL:

Model is responsible for actual data processing, like database connection, querying database, implementing business rules etc. It feeds data to the view without worrying about the actual formatting and look and feel. Data provided by Model is display-neutral so it can be interfaced with as many views without code redundancy; this eases your code maintenance and reduces bugs and allows code -reuse at good extent. Model responds to the request made by controllers and notifies the registered views to update their display with new data.

CONTROLLER:

Controller is responsible for Notice of action. Controller responds to the mouse or keyboard input to command model and view to change. Controllers are associated with views. User interaction triggers the events to change the model, which in turn calls some methods of model to update its state to notify other registered views to refresh their display.

Benefits:

Following are the few of the benefits of MVC design pattern.

Since MVC handles the multiple views using the same enterprise model it is easier to maintain, test and upgrade the multiple system.

It will be easier to add new clients just by adding their views and controllers.

Since the Model is completely decoupled from view it allows lot of flexibilities to design and implement the model considering reusability and modularity. This model also can be extended for further distributed application.

It is possible to have development process in parallel for model, view and controller.

This makes the application extensible and scalable.

Drawbacks:

Requires high skilled experienced professionals who can identify the requirements in depth at the front before actual design.

It requires the significant amount of time to analyze and design.

This design approach is not suitable for smaller applications. It Overkills the small applications.

.NET and MVC:

Lets try to find out how closely ASP.NET allows architecting application to meet MVC concept.

Model: Dataset/Business Entities, DataAccess components
View: .ASPX pages

Controller: Code-behind .vb/.cs files

Typed dataset is one of the greatest features in .NET, which holds the application data in memory and represents the application business entity model, which bridges the UI components with Service Interface and Data Access layer.

So, service interface and Data Access components populate these typed Datasets. Now, these filled datasets can be bound to any view in UI layer.

.ASPX and ASCX pages server as view and mean to interface with application, while the code behind classes for these files server as the controller functions.

ASP.NET doesnt have central controller function, instead the code-behind file can directly make request to the Model and can update the dataset. But lot of controller function can be implemented in code behind class events in .aspx or .ascx pages, like Page_Onload(), OnItem_Created() etcevents.

.NET Framework has all Object-oriented features like code reuse, encapsulation etcSo, proper design of your model can make your user interface and view completely separated from model which can server multiple views.

Reference

3. Architecture

2009-12-13T10:43:00.000-08:00

.Net 3.0 runtime
Contains the core pillars (WPF, WWF etc) and runtime components. If we wish only to run any .net 3.0 application, installing .net 3.0 runtime is enough.

While the .NET Framework 2.0 class library is partially superseded by the new components (WF, WCF, and WPF) added in version 3.0, many portions of the original class library are still crucial to developers. The technologies of version 2.0 (ASP.NET, WinForms, ADO.NET, XML etc.) largely remain the elementary part of the new release; however, .NET framework 3.0 developers may now prefer using WPF over Windows Forms for writing a native Windows GUI.

Windows Workflow Foundation (WF)
WF broadly comprises of the following assorted components:

Activity: A unit of work ranging from very simple to quite complex.
Workflow: A group of activities that partially or completely implements a business process.
WF Designers: The graphical tools to create and modify workflows and activities.
WF Base Activity Library: A fundamental group of activities (IfElse, While, Listen etc. design constructs) used to create workflows. These are quite similar to the BizTalk Orchestration shapes.
WF Runtime Engine: A library that executes workflows. It also provides other services, such as communicating with software outside the workflow.
Host process: A Windows application that hosts the Windows Workflow Foundation runtime engine, workflows, and runtime services for persisting a workflow's state, handling transactions, etc.

WF provides the Workflow Designer, a Visual Studio-hosted graphical tool for creating workflows. The activities in a workflow can be drawn using the Base Activity Library (BAL) provided with WF.

Windows Communication Foundation (WCF)
However applications are built (using workflow or otherwise), most of them need to communicate with each other. This inter-application communication has taken a big leap forward in the last few years. After a perpetual era of disagreement, all of the major vendors agreed to support SOAP based Web services which makes interoperability between applications built on different technology platforms, such as J2EE and the .NET Framework, significantly simpler. So, this also makes the idea of service-oriented architecture much more plausible for most organizations.

A lot of communication approaches exist in the .NET Framework 2.0 such as ASP.NET Web Services, .NET Remoting, System.Messaging supporting queued messaging through MSMQ, Web Services Enhancements (WSE) - an extension to ASP.NET Web Services that supports WS-Security etc. However, instead of requiring developers to use a different technology with a different application programming interface for each kind of communication, WCF provides a common approach and API. "WCF is actually an old wine in new bottle", and was previously called as Indigo. In the .NET Framework 3.0 environment, most applications that might have used one of the communication technologies listed above will instead use WCF.

WCF provides strong support for interoperable communication through SOAP. This includes support for several specifications, including WS-Security, WS-ReliableMessaging, and WS-AtomicTransaction. WCF doesn't itself require SOAP, so other approaches can also be used, including optimized binary protocol and queued messaging using MSMQ. WCF also takes an explicit service-oriented approach to communication, and loosens some of the tight couplings that can exist in distributed object systems, making interaction less error-prone and easier to change. Thus, WCF addresses a range of communication problems for applications. Three of its most important aspects that clearly stand out are:

Unification of Microsoft�s communication technologies.
Support for cross-vendor interoperability, including reliability, security, and transactions.
Rich support for service orientation development.
To sum up, communication between applications, whether within an organization or across, is a fundamental part of any modern software. The .NET Framework 3.0 attempts to address enduring communication challenges by using the service-oriented approach of WCF.

Windows CardSpace (WCS) Digital identities are the way how people electronically represent themselves today on the Internet. In the majority of cases, a person's digital identity is expressed as a simple username, and when its combined with a password, it is used to access web sites, email servers, e-merchants, online banks etc. Yet, despite their simplicity and popularity, usernames and passwords haunt people. Many of us have a hard time remembering all of the usernames and passwords of different sites. Thus, some people use the same values for different sites, easing the memory problem but increasing the security risk.

Usernames, passwords, and other personal information can be stolen by phishers. By sending delusory emails, phishers entice their victims to log in to their Web site that looks just like, say, the site of the victim's bank. So once the victim enters his username and password, the phisher can use this information to masquerade as the user on the real site.

Reducing occurrences and severity of these problems requires an entirely new approach to managing digital identities. WCS (originally called InfoCard) provides this. It helps people keep track of their digital identities as distinct information cards. If a Web site accepts WCS logins, users attempting to log in to that site will see a WCS selection. By choosing a card, users also choose a digital identity that will be used to access this site. Rather than remembering a plethora of usernames and passwords, users need only recognize the card they wish to use.

The identities represented by these cards are created by one or more identity providers. These identities will typically use stronger cryptographic mechanisms to allow users to prove their identity. WCS itself also includes a self-issued identity provider that runs on client machines. With this provider, users can create their own identities that don't rely on passwords for authentication.

So if passwords aren't used to log in to a site, phishers can inflict no harm either. Well, not really! Phishers, if somehow, can trick a user to log into a bogus site, might be still able to acquire personal information of the user, such as sensitive medical information etc. Preventing this requires that users be able to distinguish real sites from the look-alike fakes created by phishers. To allow this, the organization that owns a Web site can get a high-assurance certificate. Unlike today's simple SSL certificates, acquiring this new kind of certificate involves a much more rigorous process, including stronger proof that the organization applying for it actually is who it claims to be. A high-assurance certificate can also carry a company's logo and other information to help the user correctly determine whether a site using this certificate is legitimate. When a user accesses a new site, WCS always displays the information in that site's certificate using a standard screen. Based on the strength of the certificate received, this screen will indicate different levels of assurance of the site's identity.

Windows Presentation Foundation (WPF)

User interfaces are an important part of most Windows applications. No matter how much software evolves, traditional menu-driven GUIs are here to stay for some more time. Similarly, the need to display video, run animations, use 2/3D graphics, and work with different document formats also cannot be superseded. And all of this must be possible whether the application is a stand-alone desktop client or is accessed through a Web browser.

So far, all of these aspects of the user interface have been provided in different ways on Windows. For example, a developer needs to use Windows Forms to build a Windows GUI, or HTML/ASPX/Applets/JavaScript etc. to build a web interface, Windows Media Player or software such as Adobe's Flash Player for displaying video etc. The challenge for developers is certainly clear: building a coherent user interface for different kinds of clients using diverse technologies isn't a simple job.

A primary goal of WPF (originally called Avalon) is to address this challenge! By offering a consistent platform for these entire user interface aspects, WPF makes life simpler for developers. By taking a more modern approach, including support for video, animation, 2/3D graphics, and various kinds of documents, WPF can let users work with information in new ways. And by providing a common foundation for desktop clients and browser clients, WPF makes it easier to build applications that address both.

Another challenge that has long faced the creators of user interfaces stems from the different roles required for building effective interfaces. Software developers are needed to create the logic behind the interface, and Designers are required to define the interface's look and feel. Yet older technologies such as Windows Forms are focused entirely on the developer. There's no truly effective way for developers and designers to collaborate. To address this issue, WPF relies on the eXtensible Application Markup Language (XAML). An XML-based language, XAML allows specifying a user interface declaratively rather than in code. This makes it much easier for user interface design tools like MS Expression Blend (originally branded as MS Expression Interactive Designer and code named as Sparkle) to generate and work with an interface specification based on the visual representation created by a designer. Designers will be able to use such tools to create the look of an interface and then have a XAML definition of that interface generated for them. The developer imports this definition into Visual Studio, then creates the logic the interface requires.

Developers can also build a XAML browser application (XBAP) to create a remote client that runs inside a Web browser. Built on the same foundation as a stand-alone WPF application, an XBAP allows presenting the same style of user interface within a downloadable browser application. The best part is that the same code can potentially be used for both kinds of applications, which means that developers no longer need different skill sets for desktop and browser clients. The downloaded XBAP from the Internet runs in a secure sandbox (like Java applets), and thus it limits what the downloaded application can do.

Burp, GUI is a complex but an important part of the modern applications. Through WPF, the .NET Framework 3.0 presents a more complete and consistent solution to the challenges these interfaces present. The goal is to let people who create user interfaces (both developers and designers) effectively collaborate and do their jobs more expeditiously. So beware, because when your boss hears all this, she/he will certainly start expecting more from you.. : ( But I guess, that is the flip side of adopting any new technology.

Cocktails
�As an ideal meal cannot conclude without cocktails, so cannot a technology review without addressing criticism�.

Of late, I have came across some criticism of .NET 3.0 release and its branding on grounds that the new release doesn't accommodate .Net 2.0 bugs or language enhancements (like LINQ). It is also said that it does not add up anything substantial (other than WinFx lib) and that there shall be no performance gains too. Some even envisage the .Net 3.0 release as an improvised marketing ploy to hype up the forthcoming Vista release.

On the contrary, the re-branding from WinFx to .NET Framework and regrouping of the various technologies, "now", under a unified .NET Framework 3.0 banner, is a far better measure than it can be any later. This will not only avert another round of marketing confusion in future but also prevent the ever expanding branding namespace from getting further convoluted. After all, haven't we long forgotten the Longhorn for Vista (even though there was so much of brick-batting initially over it)? Plausibly, forgetting demands lesser efforts or time than remembering does.

The fact that .Net framework 3.0 is not introducing anything sour at this stage that will require redesigning or recoding the existing applications, is ostensibly welcome. It, otherwise, could have stirred the development community and their trust. Now that our lives are simplified (or at least are less complicated); bug fixes and fancy enhancements can shortly arrive (as patches/SPs). Similarly, major performance gains can be targeted with every new CPU/architecture release.

The aforesaid concerns and the resultant inertia, to a certain extent, were predictable at the time of announcement of the .Net release 3.0!! So, the ensuing confusion is obvious and is owing to the fact that from the very first release, till thus far; the .Net Framework has primarily grown vertically upwards and its now (with the new 3.0 release) attempting to expand horizontally outwards. This, however, indicates the overall maturity of the platform and is by far a healthy sign. So, instead of remaining dubious anymore, lets wisely step forward to accept the new version as an "additive" release (or more simply put the "production" release of WPF, WCF, WF, and WCS technologies), which is veritably colossal enough to be understated.

Basic Query

2009-12-12T07:30:00.000-08:00

SQL SELECT statement has the widest variety of query options, which are used to control the way data is returned.

ORDER BY—A clause that returns the result set in a sorted order based on specified columns.
example:
SELECT * FROM Contacts ORDER BY first_name;
You are free to use ORDER BY with any select statement that might return multiple rows. You can also use it in conjunction with other clauses:

SELECT first_name, last_name FROM Contacts WHERE first_name BETWEEN ‘a’ AND ‘k’ ORDER BY last_name;

When you use DISTINCT, it applies to all requested columns. If you want a list of all the salespeople in your table and the companies they represent but not every sales entry, you can use the following statement. Note that this may return several entries from the same company, etc. DISTINCT applies to the entire requested result set.

DISTINCT—A keyword that returns only unique rows within a result set

SELECT DISTINCT company, last_name, first_name FROM Sales;

COUNT—A function that returns a numeric value which equals the number of rows matching your query

The COUNT function tells you how many rows are in a result set. As with all functions, it accepts one parameter. This basic example will tell you how many rows are in your table:
SELECT COUNT(*) FROM Sales;

You can also use it to count the number of rows in any result set.
SELECT COUNT(*) FROM Sales WHERE net_amount > 100;

AVG—A function that returns the numeric value that equals the average of the numbers in a specified column

AVG returns the average of all the fields in a column with a numeric data type. It accepts one column name as its parameter, and it will return “0” if it's used on a non-numeric column.

SELECT AVG(net_amount) FROM Sales;
SELECT AVG(net_amount) FROM Sales WHERE company LIKE ‘%ABCD Co%’;

SUM—A function that adds the numbers in a specified column
SUM works just like AVG, except it returns the sum of values in all fields in the result set.
SELECT SUM(net_amount) FROM Sales WHERE net_amount > 100;

MIN—A function that returns the lowest non-null value in a column
MIN returns the lowest, non-null value in the specified column. If the column is a numeric data type, the result will be the lowest number. If it's a string data type, it will return the value that comes first alphabetically.
SELECT MIN(net_amount) FROM Sales WHERE last_name = “Smith”;
SELECT MIN(last_name) FROM Sales;

MAX—A function that returns the largest value in a column
MAX works just like MIN, only it returns the highest non-null value. It too can be used on strings or numbers.
SELECT MAX(net_amount) FROM Sales;
SELECT MAX(company) FROM Sales WHERE net_amount > 100;
The MAX function is sometimes used on columns containing an auto-incremented key field to determine what the next entry’s key ID will be. Unless you’re running a nonpublic database, be wary of using this information to insert the next entry, in case another user beats you to the punch.

GROUP BY— Group by keyword is used to give records in same column rows in grouped manner. Group by can be used on one column name and more than one column name in SQL query

Example using the SUM function
For example, you could also use the SUM function to return the name of the department and the total sales (in the associated department). The HAVING clause will filter the results so that only departments with sales greater than $1000 will be returned.

SELECT department, SUM(sales) as "Total sales"
FROM order_details
GROUP BY department
HAVING SUM(sales) > 1000;
Example using the COUNT function

For example, you could use the COUNT function to return the name of the department and the number of employees (in the associated department) that make over $25,000 / year. The HAVING clause will filter the results so that only departments with more than 10 employees will be returned.

SELECT department, COUNT(*) as "Number of employees"
FROM employees
WHERE salary > 25000
GROUP BY department
HAVING COUNT(*) > 10;

Example using the MIN function
For example, you could also use the MIN function to return the name of each department and the minimum salary in the department. The HAVING clause will return only those departments where the starting salary is $35,000.

SELECT department, MIN(salary) as "Lowest salary"
FROM employees
GROUP BY department
HAVING MIN(salary) = 35000;

Example using the MAX function
For example, you could also use the MAX function to return the name of each department and the maximum salary in the department. The HAVING clause will return only those departments whose maximum salary is less than $50,000.

SELECT department, MAX(salary) as "Highest salary"
FROM employees
GROUP BY department
HAVING MAX(salary) < 50000;
Joins
A join in SQL is a clause that allows` merging of records from one or more than one tables in database. The records from the tables are fetched based on some values that are common to each.

SELECT * from Employees e JOIN Salary s ON e.employeeid=s.employeeid;
Inner JoinTwo tables getting join result set display which is matched records only
Explicit type
SELECT *from shooters s INNER JOIN guntypes g ON s.guntype = g.guntype ;
Implicit type
SELECT *from shooters s , guntypes g WHERE s.guntype = g.guntype ;
Cross join
Is also called Cartesian join. Result of joining each row of the table with each row of the other table
Left outer join - unmatched left table records and matched right table records.
SELECT *from shooters s LEFT OUTER JOIN guntypes g ON s.guntype = g.guntype ;
Right outer join – unmatched right table and matched left table
SELECT *from shooters s RIGHT OUTER JOIN guntypes g ON s.guntype = g.guntype ;
Full outer join merged the result fetched from left and right
SELECT *from shooters s FULL OUTER JOIN guntypes g ON s.guntype = g.guntype ;

It is a simple sql join condition which uses the equal sign as the comparison operator.
Equi joins are SQL Outer join and SQL Inner join.
SQL Non Equi Join:
A Non Equi Join is a SQL Join whose condition is established using all comparison operators except the equal (=) operator. Like >=, <=, <, >
SELECT first_name, last_name, subject
FROM student_details
WHERE subject != 'Maths

Keys, Cosntraints, index

2009-12-11T21:32:00.000-08:00

A constraint is a property assigned to a column or the set of columns in a table that prevents certain types of inconsistent data values from being placed in the column(s). Constraints are used to enforce the data integrity. This ensures the accuracy and reliability of the data in the database. The following categories of the data integrity exist
Entity Integrity ensures that there are no duplicate rows in a table.
Domain Integrity enforces valid entries for a given column by restricting the type, the format, or the range of possible values.
Referential integrity ensures that rows cannot be deleted, which are used by other records (for example, corresponding data values between tables will be vital).
User-Defined Integrity enforces some specific business rules that do not fall into entity, domain, or referential integrity categories.

A PRIMARY KEY constraint is a unique identifier for a row within a database table. Every table should have a primary key constraint to uniquely identify each row and only one primary key constraint can be created for each table. The primary key constraints are used to enforce entity integrity

CREATE TABLE employee(
EmployeeId INT NOT NULL CONSTRAINT pk_employee PRIMARY KEY (EmployeeId)
,
LName VARCHAR(30) NOT NULL,
FName VARCHAR(30) NOT NULL,
Address VARCHAR(100) NOT NULL,
HireDate DATETIME NOT NULL,
Salary MONEY NOT NULL CONSTRAINT check_sale CHECK (salary > 0)
)
Constraints Enhancements

When you attempt to update or delete a key to which existing foreign keys point. You can control it by using the new ON DELETE and ON UPDATE clauses in the REFERENCES clause of the CREATE TABLE and ALTER TABLE statements. For example, in the previous versions of SQL Server if you wanted to do a cascade delete from the referenced table when the appropriate record in the parent table is deleted, you had to create a trigger which executed on delete of the parent table, but now you can simply specify the ON DELETE clause in the REFERENCES clause.
CREATE TABLE Books (
BookID INT NOT NULL PRIMARY KEY,
AuthorID INT NOT NULL,
BookName VARCHAR(100) NOT NULL,
Price MONEY NOT NULL
)
GO

CREATE TABLE Authors (
AuthorID INT NOT NULL PRIMARY KEY,
Name VARCHAR(100) NOT NULL
)
GO

ALTER TABLE Books
ADD CONSTRAINT fk_author
FOREIGN KEY (AuthorID)
REFERENCES Authors (AuthorID) ON DELETE CASCADE
GO

Constraints are the built-in mechanism for enforcing data integrity. Using constraints is preferred to using triggers, rules, and defaults because built-in integrity features use much less overhead and perform faster than the ones you can create. When you write your own code to realize the same actions the constraints can make you can make some errors, so the constraints are not only faster, but also are more consistent and reliable. So, you should use triggers and rules only when the constraints do not provide all the needed functionality.

Candidate Key - A Candidate Key can be any column or a combination of columns that can qualify as unique key in database. There can be multiple Candidate Keys in one table. Each Candidate Key can qualify as Primary Key.
Primary Key - A Primary Key is a column or a combination of columns that uniquely identify a record. Only one Candidate Key can be Primary Key.

Select a key that does not contain NULL
It may be possible that there are Candidate Keys that presently do not contain value (not null) but technically they can contain null. In this case, they will not qualify for Primary Key. In the following table structure, we can see that even though column [name] does not have any NULL value it does not qualify as it has the potential to contain NULL value in future
A table can have multiple Candidate Keys that are unique as single column or combined multiple columns to the table. They are all candidates for Primary Key. Candidate keys that follow all the three rules - 1) Not Null, 2) Unique Value in Table and 3) Static - are the best candidates for Primary Key. If there are multiple candidate keys that are satisfying the criteria for Primary Key

When you use the multiple-column constraint format, you can create a composite key. A composite key specifies multiple columns for a primary-key or foreign-key constraint.
The next example creates two tables. The first table has a composite key that acts as a primary key, and the second table has a composite key that acts as a foreign key.
CREATE TABLE accounts (
acc_num INTEGER,
acc_type INTEGER,
acc_descr CHAR(20),
PRIMARY KEY (acc_num, acc_type))

CREATE TABLE sub_accounts (
sub_acc INTEGER PRIMARY KEY,
ref_num INTEGER NOT NULL,
ref_type INTEGER NOT NULL,
sub_descr CHAR(20),
FOREIGN KEY (ref_num, ref_type) REFERENCES accounts
(acc_num, acc_type))
Cluster index & Non cluster index
Primary_Key column is a monotonically increasing integer and that the last three columns are VARCHAR columns. Let's also assume that there is a clustered index on the Primary_Key column, and that there are no nonclustered indexes on the table.

Now, let's assume we run the following query:

SELECT Customer_No, Customer_Name, Customer_Address
FROM Table_Name
WHERE Primary_Key = 1001

When the query optimizer analyzes this query, it will know that the Primary_Key column is the key to a clustered index. So the clustered index will (most likely) be used to locate the Primary_Key of 1001 very quickly using a clustered index lookup. In addition, since the other three columns are part of the clustered index, the values for these three columns are immediately available and can be immediately displayed after the query finishes executing. Keep in mind that all the columns in a clustered index are stored at the leaf level of the clustered index, so SQL Server, in this example, does not have to look elsewhere to find the data to be returned.

Non cluster
Now, let's take a look at the following query:

SELECT Customer_No, Customer_Name, Customer_Address
FROM Table_Name
WHERE Customer_No = 'ABC123'

In this case, when this query is analyzed by the query optimizer, there is no index on the column Customer_No. Because of this, SQL Server will perform a clustered index scan to look for the designated record to return. Since this column is not indexed or unique, every row in the table will have to be scanned until the record is found. Once it is found, the rest of the record (because it is a clustered index and each row's data is part of the leaf index), is immediately available and the data is returned.

If we need to perform the above query often, it would be to our advantage to add a nonclustered index to the Customer_No column. This way, when we run a query like the one above, instead of performing a time-consuming clustered index scan, it can use the nonclustered index on Customer_No to perform an index lookup, which is much faster than a clustered table scan. But is this all we need to do to optimize the above query? Actually, we have forgotten something. If we run the query, let's look at it again below, something else has to happen before our data is returned.

SELECT Customer_No, Customer_Name, Customer_Address
FROM Table_Name
WHERE Customer_No = 'ABC123'

When this query runs, it will use the nonclustered index on the Customer_No column to quickly identify the record using an index lookup. But unlike a clustered index, a nonclustered index only contains the data stored in the index, which is, in this case, only the Customer_No column. On the other hand, our query wants to return three columns: Customer_No, Customer_Name, and Customer_Address, not just key Customer_No. Because of this, SQL Server will now have to perform another step before it can return our data. Once it has located the correct row in the nonclustered index, then SQL Server must then look up the values of the other two columns from the clustered index, where this data is stored
Covering indexes, if used judiciously, can be used to speed up many types of commonly run queries. But covering indexes have some limitations. For example, they are limited to a maximum of 16 columns; they have a 900-character maximum width; certain datatypes cannot be included in them; and adding additional columns to an index makes the index wider, which in turn requires more disk I/O to read and write the rows, potentially hurting performance, especially if the table is subject to many INSERTs, UPDATEs, and DELETEs.

"nonkey column nonclustered indexes." This new feature is a variation of the standard covering index we have been talking about up to this point, but with some advantages over covering indexes.

Let's go back to our example query.

SELECT Customer_No, Customer_Name, Customer_Address
FROM Table_Name
WHERE Customer_No = 'ABC123'

Let's assume, as before, that there is a clustered index on Primary_Key. Now, instead of creating a covering index as described above, what we can do is create a nonclustered index on Customer_No, but instead of adding Customer_Name and Customer_Address as additional key columns to the index, we instead add Customer_Name and Customer_Address as nonkey columns to the nonclustered index.

nonkey column nonclustered index over using a covering index. The benefits include:

All data types are supported, except text, ntext, and image. So you have more datatype options than a covering index.
The maximum number of columns is 1,023, not 16 as with covering indexes.
Because the actual index is narrower, the key is more efficient and can offer better performance over a covering index where all of the columns are part of the key.
Yes, these are small differences, but lots of small differences add up and can help boost the performance of your SQL Server. In fact, you may want to review all of your currently existing covering indexes and change them to nonkey column nonclustered indexes to see if your query performance increases. Depending on the circumstances, performance could indeed increase.

Nonkey columns are created using the INCLUDE clause of the CREATE INDEX statement. For example:

CREATE INDEX IX_Table ON Table (Key_Index_Column) INCLUDE (Column1, Column2, Column3)

More space is required to store indexes with nonkey columns. Nonkey column data is stored at both the leaf level of the index and in the table itself.
Larger indexes mean fewer rows can fit on a page, potentially increasing disk I/O.
Index maintenance is increased for data modifications, potentially hurting performance if nonkey columns are large and the database experiences a high level of data modifications.

WebPart Creation & Deployment

2009-11-12T00:48:00.000-08:00

Custom Web Part Creation and Deployment

Creating Web User Control in VS2005 or VS2008.
Step 1: Create new project (Web application Project)
Note: Do not use new Web Site when creating project.
Step 2: Name the Project with good name. Since this becomes our DLL.
Step 3: Create Web User Control, with complete UI and Logic.
Step 4: Build the project. Which will create a DLL.

Create Web Part Project Library:
This project is our Web part Library. Usually we will create only one Library project for all the web parts we develop.
Step 1: Open new dev VS2005. Create New Library Project.
Step 2: Name the project with Good name. (This becomes Dll)
Step 3: Add a reference system.web to the project. This contains all the related name space for web part to work in share point.
Step 4: Add a Class. Name it. This becomes the WebPart.
Step 5: Import below name space.
using System.Web.UI.WebControls.WebParts;
Step 6: Inherit WebPart Class.

namespace BasicWebParts
{
public class HelloWorld:WebPart
{

}
}
Step 6: Override Create control method .And modify the code to reflect the user control file name.

Example class code:
using System;
using System.Collections.Generic;
using System.Text;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI;

namespace BasicWebParts
{
public class UserControlWebPart:WebPart
{
Control cntrl;
protected override void CreateChildControls()
{
this.cntrl = this.Page.LoadControl(@"~/usercontrols/ucDisplay.ascx");
this.Controls.Add(this.cntrl);
}
}
}

Change only the ucDisplay.ascx only to your user control.

Step 7: (Important)
Add the below line to AssemblyInfo file located under Properties folder .
[assembly: System.Security.AllowPartiallyTrustedCallers]
Better Add it at the end.

Information: This related to security issue while inporting the Webpart by sharepoint.

Step 8: Creating snk file.
1.Open Application Properties as shown below Image.

2. Click on signing  Choose Strong name key  as shown in below.

3. Enter Project Name as snk file name and uncheck the Protect my key file with password.
4. Click ok. And save the changes. snk file got created.

Step 9: Build the Project. Get the Dll.
Step 10: Extract public Key token.
Open visual studio 2005 command prompt.
Enter sn –T “Path of the dll”
Example: sn -T “C:\Project1\bin\debug\Test.dll”
Note the Public Key Token: it will be like example “fa29fd297c3b296b”
Step 11:
Add Safe Control Tag in Web.config of the site. To find web.config go to IIS server virtual directory and explore the same.
By Default Location is like : C:\inetpub\wwwroot\wss\virtualdirectories\siteport
Open Web.config . Copy paste one safe control tag from their and modify the Assembly PublicKey token, Namespace.
Example:

Step 12: Deploy dlls and supporting files.
1. Deploying User Control s
2. Create a folder “usercontrol s” in the site root .
Assume 1001 is the site port we created. Create the directory like below
C:\inetpub\wwwroot\wss\virtualdirectories\1001\usercontrols.
Step 13: Place ASCX controls to this folder.
Step 14: Place WebpartDlls, WebUserControl dlls created from above steps into bin folder.

Adding web part to the site:

Step 1: Open site - Click Site Actions - Site Settings - Webparts  Webpart gallery will open
Step 2: Click New . New ly created webpart are displayed. Check the web part to add into current site.
Step 3: Add web part from web part pane to any webpart page.

Note:
rest of the activities whatever functionality/design we can change as it Usercontrols update to reference folder.

SharePoint Architecture

2009-11-12T00:04:00.001-08:00

Server Architecture:

1. The SPFarm object is the highest object within the Windows SharePoint Services object model hierarchy. The Servers property gets a collection representing all the servers in the deployment, and the Services property gets a collection representing all the services.
2. Each SPServer object represents a physical server computer. The ServiceInstances property provides access to the set of individual service instances that run on the individual computer.
3. Each SPService object represents a logical service or application installed in the server farm. A service object provides access to server farm-wide settings of the load-balanced service that a respective service instance implements. Derived types of the SPService class include, for example, objects for Windows services, such as the timer service, search, Microsoft SQL Server, the database service, etc. and also objects for Web services, such as Windows SharePoint Services or services in the Microsoft Office system.
4. An SPWebService object provides access to configuration settings for a specific logical service or application. The WebApplications property gets the collection of Web applications that run the service.
5. An SPDatabaseServiceInstance object represents a single instance of a database service running on the server computer. The SPDatabaseServiceInstance class derives from the SPServiceInstance class and thus inherits the Service property, which provides access to the service or application that the instance implements. The Databases property gets the collection of content databases used in the service.
6. Each SPWebApplication object represents a load-balanced Web application based in Internet Information Services (IIS). The SPWebApplication object provides access to credentials and other server farm wide application settings. The Sites property gets the collection of site collections within the Web application, and the ContentDatabases property collection of content databases used in the Web application. The SPWebApplication class replaces the obsolete SPVirtualServer class; but it can still be helpful to think of a SPWebApplication object as a virtual server; that is, a set of one or more physical servers that appear as a single server to users.
7. An SPContentDatabase object inherits from the SPDatabase class and represents a database that contains user data for a SharePoint Web application. The Sites property gets the collection of site collections for which the content database stores data, and the WebApplication property gets the parent Web application.
8. An SPSiteCollection object represents the collection of site collections within the Web application. The Item property or indexer gets a specified site collection from the collection, and the Add method creates a site collection within the collection.
Site Architecture

1. Each SPSiteobject, despite its singular name, represents a set of logically related SPWeb objects (see below). Such a set is commonly called a "site collection," but SPSite is not a standard Microsoft .NET collection class, in contrast to SPWebCollection. Rather, it has members that can be used to manage the site collection. The AllWebs property provides access to the SPWebCollection object that represents the collection of all Web sites within the site collection, including the top-level site. The Microsoft.SharePoint.SPSite.OpenWebmethod of the SPSite class returns a specific Web site.
2. Each site collection includes any number of SPWeb objects, and each object has members that can be used to manage a site, including its template and theme, as well as to access files and folders on the site. The Webs property returns an SPWebCollection object that represents all the subsites of a specified site, and the Lists property returns an SPListCollection object that represents all the lists in the site.
3. Each SPList object has members that are used to manage the list or access items in the list. The GetItems method can be used to perform queries that return specific items. The Fields property returns an SPFieldCollection object that represents all the fields, or columns, in the list, and the Items property returns an SPListItemCollection object that represents all the items, or rows, in the list.
4. Each SPField object has members that contain settings for the field.
5. Each SPListItem object represents a single row in the list.

Culture Specifcation, Activate PageworkFlow

2009-11-11T22:34:00.000-08:00

1) To enable the culture, activate pageworkFlow

2).cs file
using System;
using System.Web.UI.WebControls;
using Telerik.Workflow;
using System.Collections.Generic;
using Telerik.Workflow.WebControls;
using Telerik.Cms.Engine;
using System.Net.Mail;
using Telerik.Cms;
using Telerik.Security;

public partial class Sitefinity_Admin_ControlTemplates_Pages_PageViewer : System.Web.UI.UserControl
{

protected void Page_Load(object sender, EventArgs e)
{
if (this.workflow.Controls.Count > 0)
notificationArea.Visible = true;

workflow.Command += new CommandEventHandler(PageWorkflowMenu_Command);

}

void PageWorkflowMenu_Command(object sender, CommandEventArgs e)
{

WorkflowInstance workflow = ((WorkflowMenu)sender).GetWorkflow();

if (workflow != null)
{

List commands = new List();

this.LoadCommands(commands, workflow.Activity.Activities);

int idx = int.Parse((string)e.CommandArgument);

string strRole = string.Empty;

Telerik.Cms.CmsManager manager = new Telerik.Cms.CmsManager();

Telerik.Cms.ICmsPage page = manager.Provider.GetPageByWorkflow(workflow.ID);

System.Net.Mail.MailMessage mailMsg = new System.Net.Mail.MailMessage();

mailMsg.IsBodyHtml = true;

switch (idx)
{

case 0:
mailMsg.Subject = "page pending approval";
strRole = "administrators";
string relativeurl = page.DefaultUrl.Url;
mailMsg.Body += String.Format("The '{0}' page has been sent for approval. Comments:" + hiddenTextArea.Value + " To approve the page, please go to URL: http://{1}{2}?cmspagemode=edit", page.Name, System.Web.HttpContext.Current.Request.Url.Host, relativeurl.Substring(1));
break;

case 1:

mailMsg.Subject = "page approved";
strRole = "Content Editor";
mailMsg.Body += String.Format("The '{0}' page has been approved. Comments:" + hiddenTextArea.Value + " To approve the page, please go to URL: http://{1}/Sitefinity/Admin/Pages.aspx", page.Name, System.Web.HttpContext.Current.Request.Url.Host);

break;

case 2:

mailMsg.Subject = "page declined";
strRole = "Content Editor";
mailMsg.Body += String.Format("The '{0}' page has been declined. Comments:" + hiddenTextArea.Value + " ", page.Name, System.Web.HttpContext.Current.Request.Url.Host);

break;

}

if (!mailMsg.Subject.Equals(string.Empty))
{

string[] usernames = Telerik.Security.UserManager.Default.GetUsersInRole(strRole);
//For every user, send him or her an e-mail
foreach (string username in usernames)
{
System.Web.Security.MembershipUser user = Telerik.Security.UserManager.Default.GetUser(username);
mailMsg.To.Add(user.Email);
}

// Init SmtpClient and send
System.Net.Mail.SmtpClient smtpClient = new System.Net.Mail.SmtpClient();
if (mailMsg.To.Count <= 0)
mailMsg.To.Add(mailMsg.From);

smtpClient.Send(mailMsg);
}

}

}

private void LoadCommands(List commands, IList activities)
{

foreach (Activity act in activities)
{

if (act is EventActivity)

commands.Add((EventActivity)act);

this.LoadCommands(commands, act.Activities);

}

}

}

Adding Control to Module & Data Fetch

2009-11-11T22:02:00.000-08:00

If you would like to add the key value. in any inbuilt sitefinity module
say for example. active check box on the module. while fetching a value based on the check pull the data.

1)

2) while fetching the data to your userControl

Namespace
using Telerik.Cms;
using Telerik.Newsletters;
using Telerik.Notifications.Newsletters;
using System.Collections;
using Telerik.Cms.Engine;
using Telerik.Cms.Web;

3).cs

void GetAllNews()
{

NewsManager objnewsManager = new NewsManager("News");
IMetaSearchInfo[] filters = new IMetaSearchInfo[4];
filters[0] = new MetaSearchInfo(MetaValueTypes.DateTime, "Expiration_Date", DateTime.Now, SearchCondition.GreaterOrEqual);
filters[1] = new MetaSearchInfo(MetaValueTypes.ShortText, "Category", ConfigurationManager.AppSettings["NewsandPressrelease"].ToString());
filters[2] = new MetaSearchInfo(MetaValueTypes.Boolean, "Active",true);
filters[3] = new MetaSearchInfo(MetaValueTypes.Boolean, "English", false);
IList lstListOfNewsItems = objnewsManager.Content.GetContent("Publication_Date DESC", filters);
DataTable dtNewsValue = new DataTable();
dtNewsValue.Columns.Add("MoreURL");
dtNewsValue.Columns.Add("Publication_Date");
dtNewsValue.Columns.Add("Title");
dtNewsValue.Columns.Add("Thumbnail");
int icnt = 0;
QFCLib objQFCLib = new QFCLib();

try
{

if (lstListOfNewsItems.Count > 0)
{
foreach (IContent ICntNews in lstListOfNewsItems)
{
string strImageURL = "";

if (ICntNews.GetMetaData("Thumbnail").ToString() != "" && ICntNews.GetMetaData("Thumbnail").ToString() != null)
{
strImageURL = objQFCLib.GetThumbnailURL(ICntNews.GetMetaData("Thumbnail").ToString()) + "?width=87&height=79&proportional=false&decreaseOnly=true";
}
DateTime strPDate = Convert.ToDateTime(ICntNews.GetMetaData("Publication_Date"));
if (strPDate < DateTime.Now)
{
icnt = icnt + 1;
dtNewsValue.Rows.Add(ConfigurationManager.AppSettings["NewsDetails"].ToString() + "?sNewsID=" + ICntNews.ID, strPDate.ToString("MM.dd.yyyy"), ICntNews.GetMetaData("Title"), strImageURL);

}
if (icnt == 5) break;
}
}

if (dtNewsValue.Rows.Count > 0)
{
repeater.DataSource = dtNewsValue;
repeater.DataBind();
dtNewsValue.Dispose();

}
else
{
lblMsg.Text = Resources.ARCommonResource.NoDataFound;
}
}
catch (Exception ex)
{
AppLogger.LogError("GetAllNews Mediacenter() " + ex.Message, AppLogger.Severity.Error);
}

}

4) protected void repeater_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
try
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
HtmlGenericControl newsThumbnailImgContainer = (HtmlGenericControl)e.Item.FindControl("newsThumbnailImgContainer");

if (((System.Data.DataRowView)(e.Item.DataItem)).Row.ItemArray[3].ToString() != "")
{
newsThumbnailImgContainer.Visible = true;
}
}
}
catch (Exception ex)
{
AppLogger.LogError("DataBound MediaArchive() " + ex.Message, AppLogger.Severity.Error);
}

}
5)if the content level if any images to get the image
Add to the cs file
#region " Sitefinity Method GetItemUrl "
public string GetItemUrl(string provider, Guid id, bool resolveAsAbsoluteUrl)
{
if (ContentManager.Providers.ContainsKey(provider))
{
IContent cnt = ContentManager.Providers[provider].GetContent(id);
if (cnt != null)
return VirtualPathUtility.ToAbsolute(cnt.UrlWithExtension, HttpContext.Current.Request.ApplicationPath);
}
else
{
ICmsUrlContext urlContext = UrlHelper.GetUrl(id);
if (urlContext != null)
{
SiteMapNode node = urlContext.GetSiteMapNode();
if (node != null)
return VirtualPathUtility.ToAbsolute(node.Url,HttpContext.Current.Request.ApplicationPath);
}
}
return String.Concat("Item not found: [", provider, "]", id);
}
#endregion

#region " Get Thumbnail URL "
public string GetThumbnailURL(string pstrThumbnail)
{

string[] strImage = pstrThumbnail.Split(']');
string strImageURL=string.Empty;
if (strImage.Length == 2)
{
Guid idImage = new Guid(strImage[1]);
strImageURL = GetItemUrl(strImage[0].Substring(1).ToString(), idImage, true);
}
else
{
return pstrThumbnail.Replace("~","");
}
return strImageURL;
}
#endregion
strImageURL = objQFCLib.GetThumbnailURL(ICntNews.GetMetaData("Thumbnail").ToString()) + "?width=87&height=79&proportional=false&decreaseOnly=true";

6) Upload the above ascx on the page leve add controls via and drag.

Sitefinity Admin Tools

2009-11-11T21:30:00.000-08:00

Telerik Sitefinity is an ASP.NET 2.0-based Content Management System (CMS) that enables the construction of dynamic, fully editable Web sites.
Sitefinity's out-of-the-box functionality, creating custom modules, and incorporating any ASP.NET 2.0 component in the site could be achieved by using Sitefinity APIs in the Visual Studio development environment.

Default Modules provided by them we can edit add our own controls in the tools.

Adding a Tools(Nothing but an customized module): our own control
1) Create a table in the DB access the link via.

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[QFC_Module](
[ModuleID] [int] IDENTITY(1,1) NOT NULL,
[ModuleName] [nvarchar](255) NULL, -- UserMangement
[ModulePath] [nvarchar](500) NULL, -- /ApplicationPath/Folder/UserList.aspx
[Priority] [int] NULL, -- sequence
CONSTRAINT [PK_QFC_Module] PRIMARY KEY CLUSTERED
(
[ModuleID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

2) Add a Values manually
ex; 1, UserMangement, /ApplicationPath/Folder/UserList.aspx, Order
customized all modules admin would like to get in a CMS when login.

3)Write sp to get the Modules.

4).cs back based on the role also we can hide the link position. should control in DB level

if (!IsPostBack)
{
QFCLib objQFCLib = new QFCLib();
DataTable dtModules = objQFCLib.GetModules();
string strhtml = "";
try
{
if (dtModules.Rows.Count > 0)
{
foreach (DataRow dr in dtModules.Rows)
{
string strModuleName = dr["ModuleName"].ToString();
Telerik.WebControls.RadWindow rw = new Telerik.WebControls.RadWindow();
rw.Title = strModuleName;
rw.ID = "RW" + dr["ModuleID"].ToString();
rw.Height = Unit.Pixel(600);
rw.Width = Unit.Pixel(800);
rw.VisibleStatusbar = false;
RadWindowManager1.Windows.Add(rw);
strhtml += "

" + strModuleName + "

";

}
}
}
catch (Exception ex)
{
AppLogger.LogError("PageLoad ModuleBinding() " + ex.Message, AppLogger.Severity.Error);
}
dtModules.Dispose();
ul_container.InnerHtml = strhtml;

}
5)Drag and drop the Usercontrol on sitefinity tools.aspx page. just deactivate all controls placed on the Page.

Common Methods Arrange as a Tools

2009-10-23T02:25:00.000-07:00

Write the common Methods instead refering every time on the class file just drag and drop/ click on the method any .cs file it refers later can make as object (scenario for many parameters)

DropdownList Apply Colors for Category

2009-10-19T23:09:00.000-07:00

if(!ispostback)
{
BindDll()
}

void BindDll()
{
SqlConnection mycn;
SqlDataAdapter myda;
DataTable dt;
String strConn;
strConn = ConfigurationManager.ConnectionStrings["connString"].ConnectionString;
mycn = new SqlConnection(strConn);
myda = new SqlDataAdapter ("Select * FROM Category", mycn);
dt = new DataTable();
myda.Fill(dt);
DropDownList1.DataSource = dt;
DropDownList1.DataTextField = "CategoryName";
DropDownList1.DataValueField ="CategoryId";
DropDownList1.DataBind () ;
for (int i =0;i < DropDownList1.Items.Count ;i++ )
{
DropDownList1.Items[i].Attributes.Add("style", "color:" + dt.Rows[i]["Color"].ToString());
}
}

If the ddl is available in a grid set the property on grid onRowDatabound.

.Csv File Reader

2009-10-13T04:58:00.000-07:00

Read .csv File add to dataTable

Create a CSVReader.cs

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.IO;
using System.Text;
using System.Collections;

public class CSVReader

{
private Stream objStream;
private StreamReader objReader;

#region CSVFileReader
// CSV File Read
public CSVReader(Stream filestream) : this(filestream, null) { }

public CSVReader(Stream filestream, Encoding enc)
{
try
{

this.objStream = filestream;
if (!filestream.CanRead)
{
return;
}
objReader = (enc != null) ? new StreamReader(filestream, enc) : new StreamReader(filestream);
}
catch(Exception ex)
{
AppLogger.LogError("CSVReader" + ex.Message, AppLogger.Severity.Error);
}
}

public string[] GetCSVLine()
{
string data = objReader.ReadLine();
data = data.Replace("\t", "\",\"");
if (!data.StartsWith("\""))
{
data = "\"" + data + "\"";
}

if (data == null) return null;
if (data.Length == 0) return new string[0];
ArrayList result = new ArrayList();
ParseCSVData(result, data);
return (string[])result.ToArray(typeof(string));
}

private void ParseCSVData(ArrayList result, string data)
{
try
{
int position = -1;
while (position < data.Length)
result.Add(ParseCSVField(ref data, ref position));
}
catch(Exception ex)
{
AppLogger.LogError("ParseCSVData" + ex.Message, AppLogger.Severity.Error);
}
}

private string ParseCSVField(ref string data, ref int StartSeperatorPos)
{
if (StartSeperatorPos == data.Length - 1)
{
StartSeperatorPos++;
return "";
}
int fromPos = StartSeperatorPos + 1;
if (data[fromPos] == '"')
{
int nextSingleQuote = GetSingleQuote(data, fromPos + 1);
int lines = 1;
while (nextSingleQuote == -1)
{
data = data + "\n" + objReader.ReadLine();
nextSingleQuote = GetSingleQuote(data, fromPos + 1);
lines++;
if (lines > 20)

throw new Exception("lines overflow: " + data);
}

StartSeperatorPos = nextSingleQuote + 1;
string tempString = data.Substring(fromPos + 1, nextSingleQuote - fromPos - 1);
tempString = tempString.Replace("'", "''");
return tempString.Replace("\"\"", "\"");
}

int nextComma = data.IndexOf(',', fromPos);
if (nextComma == -1)
{
StartSeperatorPos = data.Length;
return data.Substring(fromPos);
}
else
{
StartSeperatorPos = nextComma;
return data.Substring(fromPos, nextComma - fromPos);
}
}

private int GetSingleQuote(string data, int SFrom)
{
try
{
int i = SFrom - 1;
while (++i < data.Length)
if (data[i] == '"')
{
if (i < data.Length - 1 && data[i + 1] == '"')
{
i++;
continue;
}
else
{
return i;
}
}
}
catch(Exception ex)
{
AppLogger.LogError("GetSingleQuote" + ex.Message, AppLogger.Severity.Error);
}

return -1;

}

#endregion

#region destructor
~CSVReader()
{}
#endregion
}

DataTable dtUser = new DataTable();

int[] iColumns = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int iUpdate = 0;
try
{
//fexport.PostedFile.InputStream --> Directly reading .csv file from .net file uploader.
CSVReader objreader = new CSVReader(fexport.PostedFile.InputStream);
string[] strheaders = objreader.GetCSVLine();

foreach (string strHeader in strheaders)
{
dtUser.Columns.Add(strHeader);
}
string[] struserData;
while ((struserData = objreader.GetCSVLine()) != null)
dtUser.Rows.Add(struserData);
}
catch (Exception exe)
{
lblMsg.Text = "Check the CSV Data Sheet Format.";
AppLogger.LogError("csv sheet DataRead()QNews " + exe.Message, AppLogger.Severity.Error);
}

SQL Paging

2009-09-11T00:13:00.000-07:00

Using Stored Procedure Managing Pagination
CREATE PROCEDURE SPName
@PageNum int,
@PageSize int
AS
BEGIN
SET NOCOUNT ON;
WITH OrdersRN
AS
(
SELECT ROW_NUMBER() OVER(ORDER BY createdatetime desc) AS RowNum ,NewsId,Title,createdatetime
FROM bdl_news
)

SELECT * FROM OrdersRN WHERE RowNum BETWEEN ((@PageNum - 1) * @PageSize + 1 ) AND (@PageNum * @PageSize ) ORDER BY createdatetime desc

end

Remoting

2009-08-26T05:29:00.000-07:00

http://www.devx.com/dotnet/Article/7002
Introduction:

Remoting is a means by which one operating system process, or program, can communicate with another process. The two processes can exist on the same computer or on two computers connected by a LAN or the Internet. Communicating between two programs may seem like a big "so what," but it's a rather involved process.

In any operating system, two paramount goals are security and stability. One way to achieve these goals is to load each executing program into its own process. By design, processes are isolated from each other—the code in one process cannot access the code or data of another process. That design enhances security by preventing one program from snooping around where it does not have access rights, and it enhances stability by ensuring that problems in one program cannot inadvertently corrupt the memory space of another program or of the operating system itself. The .NET Framework provides an additional level of isolation with application domains, which permit two or more programs to run within the same process, maintaining the same level of isolation as if they were in separate processes while minimizing the overhead of multiple processes.

Web services are probably the best known type of remoting, but they are not your only option.

While the need for isolation between processes is clear, the fact remains that separate programs sometimes do need to communicate. The emphasis on distributed computing and scalability makes this need even more prevalent today. The .NET Framework provides several method for cross-process communication, collectively called remoting. Web services are probably the best known type of remoting, but they are not your only option. In this article you'll see an overview of .NET remoting technologies that may help you choose between the various remoting options

Marshal by Value or by Reference :

Marshal by value: the server creates a copy of the object passes the copy to the client.
Marshal by reference: the client creates a proxy for the object and then uses the proxy to access the object.

When a client makes a call to an object marshaled by value (MBV), the server creates an exact copy and sends that copy to the client. The client can then use the object's data and executable functionality directly within its own process or application domain without making additional calls to the server. To implement MBV you must either implement the ISerializable interface in your classes, or mark them with the attribute.

In contrast, when a client makes a call to an object marshaled by reference (MBR), the .NET framework creates a proxy in the client's application domain and the client uses that proxy to access the original object on the server. To implement MBR a class must, at minimum, extend the System.MarshalByRefObject class. Figure 1 illustrates the differences between MBV and MBR.

Given the differences between MBV and MBR, how do you decide which to use when you're programming a remotable class? In some situations you have no choice—you must use MBR, such as when the remote component must run in its own original app domain, in order to access local files or use operating system handles. These operations could not be carried out by a copy of the object running in the client's app domain. You would also need to use MBR when the client must be made aware of changes in the object. When using MBV the copy of the object that is sent to the client is static, and does not reflect subsequent changes to the state of the object on the server.

In many situations, however, either MBV or MBR will work, and the question is which is better? The concern here is that old bugaboo—bandwidth. Ask yourself which technique places fewer demands on the transport between server and client? With MBV you need move the object copy from the server to the client one time. While that can be a significant task with large objects, after the copy is at the client, calls to it are all within the client's app domain and do not involve the transport mechanism at all.

In contrast, MBR does not require a copy of the entire object to be transported to the client—but each and every time the client accesses the remote object it requires either a one-way or round-trip transport of information. Individually these calls may not place a heavy demand on communication, but hundreds or thousands of calls can add up.

Channels:

HttpChannel: Implements a channel that uses the HTTP protocol.
TcpChannel: Implements a channel that uses the TCP protocol (Transmission Control Protocol).
Both of these classes are dual-purpose in that they implement both a client channel, used on the client side to communicate with remote objects, and a server channel, used on the server side to communicate with clients. The HttpChannel class formats messages using the SOAP protocol, which encodes communications as XML. In contrast the TcpChannel class uses a binary format for messages. While binary formatting is more efficient (formatted messages are smaller), the plain text format of SOAP is much less likely to have problems with firewalls and other network security measures.

When you create a server—that is, a remotable class—you also define and register one or more channels for the class and associate each channel with a specific port. By registering a channel/port combination you tell the .NET infrastructure to listen on that port for messages intended for that channel. When a message arrives, the framework routes it to the correct server object. Figure 2 illustrates how the client and server communicate. Note that when you're using remoting on a single system, the port numbers used by the client and server cannot be the same, because you can use a given port only once.

Demonstration:

This demonstration program presents a simple remoting example. It illustrates the basic tasks involved in creating a remotable class, a server, and a client. To help keep things easy to understand, the demo makes use of .NET command line applications and the command-line compiler, but the same principles apply when you use remoting with other application types. To work with the demo, open a Visual Studio .NET (VS.NET) command prompt from the Start menu by selecting Microsoft Visual Studio .NET, then selecting Visual Studio .NET Tools, and finally Visual Studio .NET Command Prompt. The Command Prompt window opened by this command is like any other Windows command prompt but has the necessary environment and path variables set to let you use the VS.net command line compilers. Create a folder for the project, and make that folder current.

The remotable class (called RemoteClass) contains a single method that returns a "secret" word to the caller. The class constructor displays a console message when a client activates the class. I've included the console message for demonstration purposes only; it's not required for the class to function. Listing 1 shows the source code for the RemoteClass. Note that the only aspect of the class related to remoting is that it inherits from MarshalByRefObject. You can create the demo code using any text editor and then save it in the project folder under the name RemoteClass.cs. Then, from the command prompt, compile the class using the following command (enter the command on a single line):

csc /t:library /debug /r:System.Runtime.Remoting.dll
RemoteClass.cs
The class compiles to the file RemoteClass.dll.

Creates a new TcpChannel on port 8085. Note that this is the same channel on which the client will look for the remotable class.
Registers the channel with the .NET infrastructure.
Registers the remotable class using a call to the RemotingConfiguration.RegisterWellKnownServiceType() method. The arguments to this call are:
The first argument identifies the class being registered.
The second argument specifies the URI for the class. A client will use this URI when looking for the class.
The third argument specifies that if there are multiple calls to the class (from more than one client), they will all be services by the same instance of the class.
Display a message to the user and then pause until the user presses Enter.

Step 4 is required because the server must be executing to do its job. In other words, only while the server program is running will it "listen" for client requests for the remotable class.

To complete the server, save the code from Listing 3 as Server.cs and compile it with the following command line (enter the command on a single line):

csc /debug /r:remoteclass.dll
/r:System.Runtime.Remoting.dll Server.cs
Assuming all three parts of the project compiled successfully, you can test the program as follows.

Open a second Command Prompt window and change to the project folder. You will now have two Command Prompt windows open (the need for this will become clear in a moment).
In one of the windows enter "Server" to execute the server program. It will display the message "Hit to exit...". The server is now waiting, listening for client requests for the remotable class.
In the other Command prompt window enter "Client" to execute the client program. You'll see two things happen:
The client window displays the message "The secret word is REMOTING", and the client program terminates.
The server window displays the message "MyRemoteClass activated", signaling that a client activated the remote class.
To terminate the server, switch to the server window and press Enter.
You've seen a simple example introducing you to the .NET Framework's remoting capabilities. Given the power of remoting, the relative ease with which you can accomplished it comes as a welcome surprise to many developers. While few real-world scenarios are as simple as the demonstration program presented here, the principles remain the same.

Return XML File

2009-07-27T02:31:00.000-07:00

Get the data from datatable/list, write it in a xml format.

using System.Data.SqlClient;
using System.IO;
using System.Xml;
using System.Text;

protected void Page_Load(object sender, EventArgs e)
{
ReturnProductDetailsCollections();
}
void ReturnProductDetailsCollections()
{
Response.Cache.SetExpires(DateTime.Now.AddSeconds(-60));
PGILib objPGLib = new PGILib();
try
{
int CollectionID;
StringWriter sw = new StringWriter();
XmlTextWriter writer = new XmlTextWriter(sw);
if (Request.QueryString["ProductID"] != null && Request.QueryString["LanguageID"] != null)
{
CollectionID = Convert.ToInt32(Request.QueryString["ProductID"]);
int iLanguageID = Convert.ToInt32(Request.QueryString["LanguageID"]);

string Currentlang = "";
DataTable dtCurrentlang = new DataTable();
dtCurrentlang = objPGLib.Script_GetLanguageName(iLanguageID);
if (dtCurrentlang.Rows.Count > 0)
{
foreach (DataRow dr in dtCurrentlang.Rows)
{
Currentlang = dr["LanguageShortName"].ToString();
}
}

int CategoryID = objPGLib.getCollectionCategoryIDByMarket(iLanguageID);

writer.WriteStartElement("designgallery");
writer.WriteAttributeString("Result", "Success");
DataTable dtProductCollection = new DataTable();

dtProductCollection = objPGLib.Script_GetDesignerCollections(CollectionID,CategoryID);
if (dtProductCollection.Rows.Count > 0)
{
foreach (DataRow dr1 in dtProductCollection.Rows)
{
string strpPath = ConfigurationManager.AppSettings["UploadLocation"].ToString() + dr1["SmallThumbnailPath"].ToString();
writer.WriteStartElement("product");
writer.WriteAttributeString("productid", dr1["ProductID"].ToString());
writer.WriteAttributeString("smallthumbnail", strpPath);
writer.WriteAttributeString("name", dr1["ProductName"].ToString());
writer.WriteAttributeString("designer", dr1["FirstName"].ToString());
writer.WriteEndElement();
}
}
}
else
{
writer.WriteStartElement("designgallery");
writer.WriteAttributeString("Result", "Failure");

}

writer.WriteEndElement();
Response.ContentType = "text/xml";
Response.ContentEncoding = Encoding.UTF8;
Response.Write(sw);
}
catch (Exception ex)
{
AppLogger.LogError("Designer Gallery Product ReturnProductDetailsCollections(based on designerid) " + ex.Message, AppLogger.Severity.Error);
}

}

Rss Feeds in asp.net

2009-07-27T02:07:00.000-07:00

To write the Rss Contents from list/datatable.

steps to follow:

Get the all the item (ex: news in a list/datatable loop through the items bind in the rss feeds format)

refer the attached image.

image 1

image 2

C#Code:

protected void Page_Load(object sender, EventArgs e)
{
this.Context.Response.ContentType = "text/xml";
this.Context.Response.ContentEncoding = Encoding.UTF8;
ShowHeader(this.Context);
NewsManager newsManager = new Telerik.News.NewsManager("News");
IList listOfNewsItems = newsManager.Content.GetContent();
if (listOfNewsItems.Count > 0)
{
foreach (IContent ICntNews in listOfNewsItems)
{
DateTime strPDate = Convert.ToDateTime(ICntNews.GetMetaData("Publication_Date"));
if (strPDate < DateTime.Now)
{
ShowItem(this.Context, ICntNews);
}
}
}

ShowFooter(this.Context);
}

private void ShowItem(HttpContext context, Telerik.Cms.Engine.IContent content)
{
context.Response.Write("");
context.Response.Write(string.Format("{0}", content.GetMetaData("Title")));
DateTime dtPubdate = Convert.ToDateTime(content.GetMetaData("Publication_Date"));
context.Response.Write(string.Format("{0}", dtPubdate.ToString("ddd, dd MMM yyyy hh:mm:ss GMT")));
context.Response.Write(string.Format("{0}", content.GetMetaData("Summary")));
context.Response.Write(string.Format("{0}://{1}{2}", context.Request.Url.Scheme, context.Request.Url.Authority, ConfigurationManager.AppSettings["NewsDetails"].ToString() + "?sNewsID=" + content.ID));
context.Response.Write(string.Format("{0}", content.ID));
context.Response.Write("");
}

private void ShowHeader(HttpContext context)
{
context.Response.Write("");
context.Response.Write("");
context.Response.Write("");
context.Response.Write("QFC Authority news ");
context.Response.Write("News headlines ");
context.Response.Write("http://www.qfc.com.qa/ ");
context.Response.Write("http://backend.userland.com/rss ");
context.Response.Write(Environment.NewLine);
}

private void ShowFooter(HttpContext context)
{
context.Response.Write("");
context.Response.Write("");
}

Open outlook and add reciepient emailid

2009-07-10T01:43:00.000-07:00

To send mail call the below method in .Net.
1)
using System.Web.Mail;
public Boolean SendMail(string pstrFrom, string pstrTo, string pstrSubject, string pstrBody)
{
Boolean Result = false;
try
{
MailMessage omsg = new MailMessage();
omsg.From = pstrFrom;
omsg.To = pstrTo;
omsg.Subject = pstrSubject;
omsg.Body = pstrBody;
omsg.Priority = MailPriority.High;
omsg.BodyFormat = MailFormat.Html;
SmtpMail.SmtpServer = "";
SmtpMail.Send(omsg);
Result = true;
}
catch (Exception ex)
{
Result = false;
AppLogger.LogError("SendMail(4 parameters): " + ex.Message, AppLogger.Severity.Error);

}
return Result;

}

2)To open a outlook.

DateFormat

2009-07-08T22:55:00.000-07:00

Standard Formats:
The following table lists the standard format characters for internationally accepted standard patterns. The format characters are case-sensitive; for example, 'g' and 'G' represent slightly different patterns. Note that on the whole the format handling of the DateTimePicker is almost identical to that of the associated Culture.DateTimeFormatInfo instance, the main exception being that day names "dddd" are not used anywhere.

Custom Formats:

Passing Data/Parameter/Value/ from one page to another page (.aspx/.ascx)

2009-07-03T02:14:00.000-07:00

Passing Data/Parameter/Value/ from one page to another page (.aspx/.ascx)
Passing parameters from one page to another page is a very common task in Web development. Especially when you develop a project & redirects or navigates from one ASP.NET Web page to another, you will frequently want to pass information from the source page to the target page . In this post, I will show you some ways of transferring data/parameters/values between one page to another page which is also termed as State Management. The pages I created to show you the example is really simple which consists of a text field and a button in the first page named as page1 and a blank second page named as page2.

According to the characteristics of aspx page lifecycle web form do not retain their value after a page is displayed. To solve this problem, ASP.NET provides the following ways to retain variables between pages:
Query Strings
Cookies
Session variables
Server.Transfer
Post Back URL

Using Query String:
The most common & easiest way of passing data is query string. Usually we pass value(s) through query string of the page and then this value is pulled from Request object in another page. One thing keep in mind that user can view query string value any time(from brwser address, View source, even on mouse over of a link etc.). So never pass information which is secure like password through query string. Drawback of Query string appear after a question mark of a URL.

Example:
Suppose you want to pass the txtName TextBox value from page1 to page2 on button click event:

protected void btn_Click(object sender, EventArgs e)
{
Response.Redirect("page2.aspx?name=" + txtName.Text);
}

Now the question is how we can read/retrieve my name from page2.aspx page? The way is:

string name = Request.QueryString["name"];

Now more advance is if you want to transfer special charaters or a line with spaces then you must have to use Server.UrlEncode method before transfer & Server.UrlDecode method to read data from page2.aspx:

protected void btn_Click(object sender, EventArgs e)
{
Response.Redirect("page2.aspx?name=" + Server.UrlEncode(txtName.Text));
}

and to read from page2:

string name = Server.UrlDecode(Request.QueryString["name"]);

Now i want to show you how you can transfer more data:

protected void cmdTransfer_Click(object sender, EventArgs e)
{
Response.Redirect("page2.aspx?name="+Server.UrlEncode(txtName.Text)+"&age="+txtAge.Text);
}

Now read both name & age from page2 in the same way:

string name = Request.QueryString["name"];
string age = Request.QueryString["age"];

now you can check the both parameter (with null value then write it).

Cookies:
Developers use cookies to store small amounts of information on the client. Drawback if user set the browser status cookie not supported won’t help. It’s stored only client machine. From the server we can check the page load event.
Example:
Now we create a cookie from page1 & read from page2:
for page1 button click event:

protected void cmdTransfer_Click(object sender, EventArgs e)
{
if(Request.Browser.Cookies) // To check that the browser support cookies
{
HttpCookie cookie = new HttpCookie("myname");
cookie.Value = txtName.Text;
cookie.Expires = DateTime.Now.AddDays(1);
Response.Cookies.Add(cookie);
Response.Redirect("page2.aspx");
}
else
{
// You have to follow other option.
}
}

Now read from page2:
if(Request.Cookies["myname"] != null)
Response.Write(Request.Cookies["myname"].Value);

Using Session Variables:
By default, session variables are stored in the web server memory. Session variables are unique per each user. If you open same url in two browser then server will create two independent sessions for you. Keep in mind that each session has a expire time. You can configure session time from IIS. Also one another thing is, you can receive session value form any pages after assigning. Write the below code under page1 button:

protected void btn_Click(object sender, EventArgs e)
{
Session["name"] = txtName.Text;
Response.Redirect("page2.aspx");
}

Now read session variable value from page2:

string name ="";
if(Session["name"]!=null)
name=Session["name"].ToString();

Using Server.Transfer:
We will use Server. Transfer to send the control to a new page. Note that Server.Transfer only transfers the control to the new page and does not redirect the browser to it, which means you will see the address of the old page in your URL. If the user clicks Refresh on his browser, the browser prompt a message warning that the page can not be refreshed without resending information. Write the below code under page1 button click event:

protected void btn_Click(object sender, EventArgs e)
{
Server.Transfer("page2.aspx", true);
}

And write the below code in page2 load event:

if (Request.Form["txtEmail"])
Response.Write(Request.Form["txtNamel"]);

Now run the page1, enter your name & click. You will see your name in page2. Merits of using the above it won’t give any blank page or any warnings.

Using Post Back URL:
ASP.NET 2.0 has been introduced Cross page posting. By PreviousPage object you can search controls value from which page you are redirected here. To implement Cross page posting you have to define the PostBackUrl property of page1 button to page2. Like:

aspx/ascx design page btn propery called PostBackUrl="page2.aspx"

Now write the below code in page2 load event:

TextBox txtName = (TextBox)(PreviousPage.FindControl("txtName"));
string myname =txtName.Text;
Or
If you use usercontrol the previouspage// prpery won’t support.
TextBox txtName = (TextBox)Page.PreviousPage.FindControl("txtName"));
string myname =txtName.Text;

Asp.Net questions&Ans

2009-06-23T01:29:00.000-07:00

What are the parts of the .NET Framework?
.NET Framework has two main parts:
The common language runtime (CLR)
The .NET Framework class library
What are the ways to persistent data in a web application?
Data can be persisted in the web application using any of the following mechanism.
ApplicationState
SessionState
ViewState.
How does classes are organized in the .NET Framework?
The .NET Framework has organized its classes using namespaces.
What is the point to remember about Transfer method in ASP.NET?
Transfer method can't be used with HTML pages. It works only with .aspx pages.
What are the different exception-handling approaches in ASP.NET Web applications?
Exceptions can be handled using any of the following approaches:
Try, Catch, and Finally keywords in VB.NET or the try, catch, and finally keywords in C#.
Error event procedures at the Global, Application, or Page levels.
Describe the purpose of error pages and why they are needed.
Error page is used to trap exceptions occur outside the scope of the application.
The exceptions of these types are identified by HTTP response codes.
These exceptions are handled by IIS by displaying custom error pages listed in your application’s Web.config file.
Explain how tracing helps in handling exceptions.
Tracing helps developer by recording an unusual event while application is running. The developer can trace the unexpected events in the trace log, thus can fix the problem.
Difference between Windows and Forms authentication user lists in Web.config
User lists for Windows authentication are included in the element of Web.config.
User lists for Forms authentications are included in the element of Web.config.
Explain how to require authentication using the Web.config file in ASP.NET.
We can include element to require authentication as shown below:

What is the difference between the Debug and Trace classes?
Code using the Debug class is stripped out of release builds.
Code using the Trace class is left in.
Write a directive to cache responses for a Web form for 30 seconds.
<%@ OutputCache Duration=”30” VaryByParam=”me” %>
Explain how to detect when application data is about to be removed from the cache.
We can detect using onRemoveCallback delegate.
CurrentCulture property vs. Current¬UICulture property.
The CurrentCulture property states how the .NET Framework handles dates, currencies, sorting, and formatting issues.
The CurrentUICulture property determines which satellite assembly is used when loading resources.
What is the purpose of MVC patter?
MVC pattern separates the GUI from the data. It helps in providing multiple views for the same data.
Explain how to enable and disable connnection pooling.
Set pooling = true in the connectionstring. By default, it is true.
Set pooling = false to disable connection pooling.
Dataset.clone vs. Dataset.copy
Dataset.clone copies the structure only whereas dataset copy copies both structure and data.
Explain how to configure WebGarden in ASP.NET.
WebGarden can be configured using process model setting in "machine.config" or "web.config".
What is Webfarm?
Webform consist of two or more web server of same configuration. When any request is made, the router logic of webform decides which web server from the farm handles the request.
Explain the advantages of having webfarm.
Webfarm allows the application to run even if a server is down, since request can be served by other web server of the farm.
What is windows service?
Windows service has the capability to start automatically when the computer boots. It can be manually paused, stopped or even restarted.
Explain how to remove anonymous access to the IIS web application.

How to enable tracing in ASP.NET
Tracing can be enabaled as shown below:
<%@Page Trace = "True"%>
Name the major events in Global.aspx file.
-Application_Init
-Application_Disposed
-Application_Error
-Application_Start
-Application_End
-Application_BeginRequest
-Application_EndRequest
-Application_PreRequestHandlerExecute
-Application_PostRequestHandlerExecute
-Application_PreSendRequestHeaders
-Application_PreSendContent
-Application_AcquireRequestState
-Application_ReleaseRequestState
-Application_ResolveRequestCache
-Application_UpdateRequestCache
-Application_AuthenticateRequest
-Application_AuthorizeRequest
-Session_Start
-Session_End
What are authentication techniques in ASP.NET?
-Windows authentication
-Passport authentication
-Forms authentication
Authentication vs. authorization
-Authentication is varying the identity of the user.
-Authorization is the process of allowing an authenticated user access to resources.
Explain the uses of Global.asax file.
-using this we can set application-level variables
-we can use application-level events.
How many types of validation controls are provided by ASP.NET? Explain them.
There are 6 validation controls in ASP.NET:
1. RequiredFieldValidator: It is for mandatory field.
2. RegularExpressionValidator: It checks the match with a given regularexpression.
3. CompareValidator: It checks that the value in the validated control matches with the value of another control or with a specific value.
4. RangeValidator: It checks the validated control value with a specified range.
5.. CustomValidator: Require to do custom validation on any control after writing required code.
6. ValidationSummary:This control is used to display a summary of all validation errors raised in a particular Web page.
What is impersonation in ASP.NET?
Impersonation is used to decide whether a user request in an ASp.NET application can run under the authenticated identity received from IIS or under a specific identity specified in web.config file when impersonation is enabled.When it is disabled the user request will run under the ASPNET account( the process identity of the application worker process) .By default it is disabled.

or

or

Explain how a web application works.
Answer - A web application resides in the server and serves the client™s requests over internet. The client access the web page using browser from his machine. When a client makes a request, it receives the result in the form of HTML which are interpreted and displayed by the browser.

A web application on the server side runs under the management of Microsoft Internet Information Services (IIS). IIS passes the request received from client to the application. The application returns the requested result in the form of HTML to IIS, which in turn, sends the result to the client.
Application State
Data stored in the application object can be shared by all the sessions of the application. Application object stores data in the key value pair.
Session State
Session State stores session-specific information and the information is visible within the session only. ASP.NET creates unique sessionId for each session of the application. SessionIDs are maintained either by an HTTP cookie or a modified URL, as set in the application's configuration settings. By default, SessionID values are stored in a cookie.
ASP.NET session vs Classic ASP
ASP session variables are recycled when IIS restarts. ASP.NET session is maintained even if IIS reboots.
With ASP session, we can’t have web farms. ASP.NET session supports multiple servers since it can be stored in state server and SQL server.
ASP session is compatible to only those browsers that support cookies.
What is event bubbling?
In ASP.NET, we can have child controls inside server control like Datagrid, Datalist, Repeater. Example, combo box can be placed inside Datagrid. The child can’t raise their events by himself; they send events to their parent which pass to the page as “Itemcommand” event. This processing is called event bubbling.

SQL Qustion and Answers

2009-06-22T23:50:00.001-07:00

What is RDBMS?
Relational Data Base Management Systems (RDBMS) are database management systems that maintain data records and indices in tables. Relationships may be created and maintained across and among the data and tables. In a relational database, relationships between data items are expressed by means of tables. Interdependencies among these tables are expressed by data values rather than by pointers. This allows a high degree of data independence. An RDBMS has the capability to recombine the data items from different files, providing powerful tools for data usage.

What is normalization?
Database normalization is a data design and organization process applied to data structures based on rules that help build relational databases. In relational database design, the process of organizing data to minimize redundancy. Normalization usually involves dividing a database into two or more tables and defining relationships between the tables. The objective is to isolate data so that additions, deletions, and modifications of a field can be made in just one table and then propagated through the rest of the database via the defined relationships.

What are different normalization forms?

1NF: Eliminate Repeating Groups
Make a separate table for each set of related attributes, and give each table a primary key. Each field contains at most one value from its attribute domain.
2NF: Eliminate Redundant Data
If an attribute depends on only part of a multi-valued key, remove it to a separate table.
3NF: Eliminate Columns Not Dependent On Key
If attributes do not contribute to a description of the key, remove them to a separate table. All attributes must be directly dependent on the primary key
BCNF: Boyce-Codd Normal Form
If there are non-trivial dependencies between candidate key attributes, separate them out into distinct tables.
4NF: Isolate Independent Multiple Relationships
No table may contain two or more 1:n or n:m relationships that are not directly related.
5NF: Isolate Semantically Related Multiple Relationships
There may be practical constrains on information that justify separating logically related many-to-many relationships.
ONF: Optimal Normal Form
A model limited to only simple (elemental) facts, as expressed in Object Role Model notation.
DKNF: Domain-Key Normal Form
A model free from all modification anomalies.

Remember, these normalization guidelines are cumulative. For a database to be in 3NF, it must first fulfill all the criteria of a 2NF and 1NF database.

What is Stored Procedure?
A stored procedure is a named group of SQL statements that have been previously created and stored in the server database. Stored procedures accept input parameters so that a single procedure can be used over the network by several clients using different input data. And when the procedure is modified, all clients automatically get the new version. Stored procedures reduce network traffic and improve performance. Stored procedures can be used to help ensure the integrity of the database.
e.g. sp_helpdb, sp_renamedb, sp_depends etc.

What is Trigger?
A trigger is a SQL procedure that initiates an action when an event (INSERT, DELETE or UPDATE) occurs. Triggers are stored in and managed by the DBMS.Triggers are used to maintain the referential integrity of data by changing the data in a systematic fashion. A trigger cannot be called or executed; the DBMS automatically fires the trigger as a result of a data modification to the associated table. Triggers can be viewed as similar to stored procedures in that both consist of procedural logic that is stored at the database level. Stored procedures, however, are not event-drive and are not attached to a specific table as triggers are. Stored procedures are explicitly executed by invoking a CALL to the procedure while triggers are implicitly executed. In addition, triggers can also execute stored procedures.
Nested Trigger: A trigger can also contain INSERT, UPDATE and DELETE logic within itself, so when the trigger is fired because of data modification it can also cause another data modification, thereby firing another trigger. A trigger that contains data modification logic within itself is called a nested trigger.

What is View?
A simple view can be thought of as a subset of a table. It can be used for retrieving data, as well as updating or deleting rows. Rows updated or deleted in the view are updated or deleted in the table the view was created with. It should also be noted that as data in the original table changes, so does data in the view, as views are the way to look at part of the original table. The results of using a view are not permanently stored in the database. The data accessed through a view is actually constructed using standard T-SQL select command and can come from one to many different base tables or even other views.

What is Index?
An index is a physical structure containing pointers to the data. Indices are created in an existing table to locate rows more quickly and efficiently. It is possible to create an index on one or more columns of a table, and each index is given a name. The users cannot see the indexes, they are just used to speed up queries. Effective indexes are one of the best ways to improve performance in a database application. A table scan happens when there is no index available to help a query. In a table scan SQL Server examines every row in the table to satisfy the query results. Table scans are sometimes unavoidable, but on large tables, scans have a terrific impact on performance.

Clustered indexes define the physical sorting of a database table’s rows in the storage media. For this reason, each database table may have only one clustered index.
Non-clustered indexes are created outside of the database table and contain a sorted list of references to the table itself.

What is the difference between clustered and a non-clustered index?
A clustered index is a special type of index that reorders the way records in the table are physically stored. Therefore table can have only one clustered index. The leaf nodes of a clustered index contain the data pages.

A nonclustered index is a special type of index in which the logical order of the index does not match the physical stored order of the rows on disk. The leaf node of a nonclustered index does not consist of the data pages. Instead, the leaf nodes contain index rows.

What are the different index configurations a table can have?
A table can have one of the following index configurations:

No indexes
A clustered index
A clustered index and many nonclustered indexes
A nonclustered index
Many nonclustered indexes

What is cursors?
Cursor is a database object used by applications to manipulate data in a set on a row-by-row basis, instead of the typical SQL commands that operate on all the rows in the set at one time.

In order to work with a cursor we need to perform some steps in the following order:

Declare cursor
Open cursor
Fetch row from the cursor
Process fetched row
Close cursor
Deallocate cursor

What is the use of DBCC commands?
DBCC stands for database consistency checker. We use these commands to check the consistency of the databases, i.e., maintenance, validation task and status checks.
E.g. DBCC CHECKDB – Ensures that tables in the db and the indexes are correctly linked.
DBCC CHECKALLOC – To check that all pages in a db are correctly allocated.
DBCC CHECKFILEGROUP – Checks all tables file group for any damage.

What is a Linked Server?
Linked Servers is a concept in SQL Server by which we can add other SQL Server to a Group and query both the SQL Server dbs using T-SQL Statements. With a linked server, you can create very clean, easy to follow, SQL statements that allow remote data to be retrieved, joined and combined with local data.
Storped Procedure sp_addlinkedserver, sp_addlinkedsrvlogin will be used add new Linked Server.

What is Collation?
Collation refers to a set of rules that determine how data is sorted and compared. Character data is sorted using rules that define the correct character sequence, with options for specifying case-sensitivity, accent marks, kana character types and character width.

What are different type of Collation Sensitivity?
Case sensitivity
A and a, B and b, etc.

Accent sensitivity
a and á, o and ó, etc.

Kana Sensitivity
When Japanese kana characters Hiragana and Katakana are treated differently, it is called Kana sensitive.

Width sensitivity
When a single-byte character (half-width) and the same character when represented as a double-byte character (full-width) are treated differently then it is width sensitive.

What’s the difference between a primary key and a unique key?
Both primary key and unique enforce uniqueness of the column on which they are defined. But by default primary key creates a clustered index on the column, where are unique creates a nonclustered index by default. Another major difference is that, primary key doesn’t allow NULLs, but unique key allows one NULL only.

How to implement one-to-one, one-to-many and many-to-many relationships while designing tables?
One-to-One relationship can be implemented as a single table and rarely as two tables with primary and foreign key relationships.
One-to-Many relationships are implemented by splitting the data into two tables with primary key and foreign key relationships.
Many-to-Many relationships are implemented using a junction table with the keys from both the tables forming the composite primary key of the junction table.

What is a NOLOCK?
Using the NOLOCK query optimiser hint is generally considered good practice in order to improve concurrency on a busy system. When the NOLOCK hint is included in a SELECT statement, no locks are taken when data is read. The result is a Dirty Read, which means that another process could be updating the data at the exact time you are reading it. There are no guarantees that your query will retrieve the most recent data. The advantage to performance is that your reading of data will not block updates from taking place, and updates will not block your reading of data. SELECT statements take Shared (Read) locks. This means that multiple SELECT statements are allowed simultaneous access, but other processes are blocked from modifying the data. The updates will queue until all the reads have completed, and reads requested after the update will wait for the updates to complete. The result to your system is delay(blocking).

What is difference between DELETE & TRUNCATE commands?
Delete command removes the rows from a table based on the condition that we provide with a WHERE clause. Truncate will actually remove all the rows from a table and there will be no data in the table after we run the truncate command.

TRUNCATE
TRUNCATE is faster and uses fewer system and transaction log resources than DELETE.
TRUNCATE removes the data by deallocating the data pages used to store the table’s data, and only the page deallocations are recorded in the transaction log.
TRUNCATE removes all rows from a table, but the table structure and its columns, constraints, indexes and so on remain. The counter used by an identity for new rows is reset to the seed for the column.
You cannot use TRUNCATE TABLE on a table referenced by a FOREIGN KEY constraint.
Because TRUNCATE TABLE is not logged, it cannot activate a trigger.
TRUNCATE can not be Rolled back using logs.
TRUNCATE is DDL Command.
TRUNCATE Resets identity of the table.

DELETE
DELETE removes rows one at a time and records an entry in the transaction log for each deleted row.
If you want to retain the identity counter, use DELETE instead. If you want to remove table definition and its data, use the DROP TABLE statement.
DELETE Can be used with or without a WHERE clause
DELETE Activates Triggers.
DELETE Can be Rolled back using logs.
DELETE is DML Command.
DELETE does not reset identity of the table.

Difference between Function and Stored Procedure?
UDF can be used in the SQL statements anywhere in the WHERE/HAVING/SELECT section where as Stored procedures cannot be.
UDFs that return tables can be treated as another rowset. This can be used in JOINs with other tables.
Inline UDF’s can be though of as views that take parameters and can be used in JOINs and other Rowset operations.

When is the use of UPDATE_STATISTICS command?
This command is basically used when a large processing of data has occurred. If a large amount of deletions any modification or Bulk Copy into the tables has occurred, it has to update the indexes to take these changes into account. UPDATE_STATISTICS updates the indexes on these tables accordingly.

What types of Joins are possible with Sql Server?
Joins are used in queries to explain how different tables are related. Joins also let you select data from a table depending upon data from another table.
Types of joins: INNER JOINs, OUTER JOINs, CROSS JOINs. OUTER JOINs are further classified as LEFT OUTER JOINS, RIGHT OUTER JOINS and FULL OUTER JOINS.

What is the difference between a HAVING CLAUSE and a WHERE CLAUSE?
Specifies a search condition for a group or an aggregate. HAVING can be used only with the SELECT statement. HAVING is typically used in a GROUP BY clause. When GROUP BY is not used, HAVING behaves like a WHERE clause. Having Clause is basically used only with the GROUP BY function in a query. WHERE Clause is applied to each row before they are part of the GROUP BY function in a query. HAVING criteria is applied after the the grouping of rows has occurred.

What is sub-query? Explain properties of sub-query.
Sub-queries are often referred to as sub-selects, as they allow a SELECT statement to be executed arbitrarily within the body of another SQL statement. A sub-query is executed by enclosing it in a set of parentheses. Sub-queries are generally used to return a single row as an atomic value, though they may be used to compare values against multiple rows with the IN keyword.

A subquery is a SELECT statement that is nested within another T-SQL statement. A subquery SELECT statement if executed independently of the T-SQL statement, in which it is nested, will return a result set. Meaning a subquery SELECT statement can standalone and is not depended on the statement in which it is nested. A subquery SELECT statement can return any number of values, and can be found in, the column list of a SELECT statement, a FROM, GROUP BY, HAVING, and/or ORDER BY clauses of a T-SQL statement. A Subquery can also be used as a parameter to a function call. Basically a subquery can be used anywhere an expression can be used.

Properties of Sub-Query
A subquery must be enclosed in the parenthesis.
A subquery must be put in the right hand of the comparison operator, and
A subquery cannot contain a ORDER-BY clause.
A query can contain more than one sub-queries.

What are types of sub-queries?
Single-row subquery, where the subquery returns only one row.
Multiple-row subquery, where the subquery returns multiple rows,.and
Multiple column subquery, where the subquery returns multiple columns.

What is SQL Profiler?
SQL Profiler is a graphical tool that allows system administrators to monitor events in an instance of Microsoft SQL Server. You can capture and save data about each event to a file or SQL Server table to analyze later. For example, you can monitor a production environment to see which stored procedures are hampering performance by executing too slowly.

Use SQL Profiler to monitor only the events in which you are interested. If traces are becoming too large, you can filter them based on the information you want, so that only a subset of the event data is collected. Monitoring too many events adds overhead to the server and the monitoring process and can cause the trace file or trace table to grow very large, especially when the monitoring process takes place over a long period of time.

What is User Defined Functions?
User-Defined Functions allow to define its own T-SQL functions that can accept 0 or more parameters and return a single scalar data value or a table data type.

What kind of User-Defined Functions can be created?
There are three types of User-Defined functions in SQL Server 2000 and they are Scalar, Inline Table-Valued and Multi-statement Table-valued.

Scalar User-Defined Function
A Scalar user-defined function returns one of the scalar data types. Text, ntext, image and timestamp data types are not supported. These are the type of user-defined functions that most developers are used to in other programming languages. You pass in 0 to many parameters and you get a return value.

Inline Table-Value User-Defined Function
An Inline Table-Value user-defined function returns a table data type and is an exceptional alternative to a view as the user-defined function can pass parameters into a T-SQL select command and in essence provide us with a parameterized, non-updateable view of the underlying tables.

Multi-statement Table-Value User-Defined Function
A Multi-Statement Table-Value user-defined function returns a table and is also an exceptional alternative to a view as the function can support multiple T-SQL statements to build the final result where the view is limited to a single SELECT statement. Also, the ability to pass parameters into a T-SQL select command or a group of them gives us the capability to in essence create a parameterized, non-updateable view of the data in the underlying tables. Within the create function command you must define the table structure that is being returned. After creating this type of user-defined function, It can be used in the FROM clause of a T-SQL command unlike the behavior found when using a stored procedure which can also return record sets.

Which TCP/IP port does SQL Server run on? How can it be changed?
SQL Server runs on port 1433. It can be changed from the Network Utility TCP/IP properties –> Port number.both on client and the server.

What are the authentication modes in SQL Server? How can it be changed?
Windows mode and mixed mode (SQL & Windows).

To change authentication mode in SQL Server click Start, Programs, Microsoft SQL Server and click SQL Enterprise Manager to run SQL Enterprise Manager from the Microsoft SQL Server program group. Select the server then from the Tools menu select SQL Server Configuration Properties, and choose the Security page.

Where are SQL server users names and passwords are stored in sql server?
They get stored in master db in the sysxlogins table.

Which command using Query Analyzer will give you the version of SQL server and operating system?
SELECT SERVERPROPERTY('productversion'), SERVERPROPERTY ('productlevel'),
What is SQL server agent?
SQL Server agent plays an important role in the day-to-day tasks of a database administrator (DBA). It is often overlooked as one of the main tools for SQL Server management. Its purpose is to ease the implementation of tasks for the DBA, with its full-function scheduling engine, which allows you to schedule your own jobs and scripts.

Can a stored procedure call itself or recursive stored procedure? How many level SP nesting possible?
Yes. Because Transact-SQL supports recursion, you can write stored procedures that call themselves. Recursion can be defined as a method of problem solving wherein the solution is arrived at by repetitively applying it to subsets of the problem. A common application of recursive logic is to perform numeric computations that lend themselves to repetitive evaluation by the same processing steps. Stored procedures are nested when one stored procedure calls another or executes managed code by referencing a CLR routine, type, or aggregate. You can nest stored procedures and managed code references up to 32 levels.

What is @@ERROR?
The @@ERROR automatic variable returns the error code of the last Transact-SQL statement. If there was no error, @@ERROR returns zero. Because @@ERROR is reset after each Transact-SQL statement, it must be saved to a variable if it is needed to process it further after checking it.

What is Raiseerror?
Stored procedures report errors to client applications via the RAISERROR command. RAISERROR doesn’t change the flow of a procedure; it merely displays an error message, sets the @@ERROR automatic variable, and optionally writes the message to the SQL Server error log and the NT application event log.

What is log shipping?
Log shipping is the process of automating the backup of database and transaction log files on a production SQL server, and then restoring them onto a standby server. Enterprise Editions only supports log shipping. In log shipping the transactional log file from one server is automatically updated into the backup database on the other server. If one server fails, the other server will have the same db can be used this as the Disaster Recovery plan. The key feature of log shipping is that is will automatically backup transaction logs throughout the day and automatically restore them on the standby server at defined interval.

What is the difference between a local and a global variable?
A local temporary table exists only for the duration of a connection or, if defined inside a compound statement, for the duration of the compound statement.

A global temporary table remains in the database permanently, but the rows exist only within a given connection. When connection are closed, the data in the global temporary table disappears. However, the table definition remains with the database for access when database is opened next time.
What command do we use to rename a db?
sp_renamedb ‘oldname’ , ‘newname’
If someone is using db it will not accept sp_renmaedb. In that case first bring db to single user using sp_dboptions. Use sp_renamedb to rename database. Use sp_dboptions to bring database to multi user mode.

What is sp_configure commands and set commands?
Use sp_configure to display or change server-level settings. To change database-level settings, use ALTER DATABASE. To change settings that affect only the current user session, use the SET statement.

What are the different types of replication? Explain.
The SQL Server 2000-supported replication types are as follows:

Transactional
Snapshot
Merge
Snapshot replication distributes data exactly as it appears at a specific moment in time and does not monitor for updates to the data. Snapshot replication is best used as a method for replicating data that changes infrequently or where the most up-to-date values (low latency) are not a requirement. When synchronization occurs, the entire snapshot is generated and sent to Subscribers.

Transactional replication, an initial snapshot of data is applied at Subscribers, and then when data modifications are made at the Publisher, the individual transactions are captured and propagated to Subscribers.

Merge replication is the process of distributing data from Publisher to Subscribers, allowing the Publisher and Subscribers to make updates while connected or disconnected, and then merging the updates between sites when they are connected.

What are the OS services that the SQL Server installation adds?
MS SQL SERVER SERVICE, SQL AGENT SERVICE, DTC (Distribution transac co-ordinator)

What are three SQL keywords used to change or set someone’s permissions?
GRANT, DENY, and REVOKE.

What does it mean to have quoted_identifier on? What are the implications of having it off?
When SET QUOTED_IDENTIFIER is ON, identifiers can be delimited by double quotation marks, and literals must be delimited by single quotation marks. When SET QUOTED_IDENTIFIER is OFF, identifiers cannot be quoted and must follow all Transact-SQL rules for identifiers.

What is the STUFF function and how does it differ from the REPLACE function?
STUFF function to overwrite existing characters. Using this syntax, STUFF(string_expression, start, length, replacement_characters), string_expression is the string that will have characters substituted, start is the starting position, length is the number of characters in the string that are substituted, and replacement_characters are the new characters interjected into the string.
REPLACE function to replace existing characters of all occurance. Using this syntax REPLACE(string_expression, search_string, replacement_string), where every incidence of search_string found in the string_expression will be replaced with replacement_string.

Using query analyzer, name 3 ways to get an accurate count of the number of records in a table?
SELECT *
FROM table1
SELECT COUNT(*)
FROM table1
SELECT rows
FROM sysindexes
WHERE id = OBJECT_ID(table1)
AND indid < 2
How to rebuild Master Database?
Shutdown Microsoft SQL Server 2000, and then run Rebuildm.exe. This is located in the Program Files\Microsoft SQL Server\80\Tools\Binn directory.
In the Rebuild Master dialog box, click Browse.
In the Browse for Folder dialog box, select the \Data folder on the SQL Server 2000 compact disc or in the shared network directory from which SQL Server 2000 was installed, and then click OK.
Click Settings. In the Collation Settings dialog box, verify or change settings used for the master database and all other databases.
Initially, the default collation settings are shown, but these may not match the collation selected during setup. You can select the same settings used during setup or select new collation settings. When done, click OK.
In the Rebuild Master dialog box, click Rebuild to start the process.
The Rebuild Master utility reinstalls the master database.
To continue, you may need to stop a server that is running.
Source: http://msdn2.microsoft.com/en-us/library/aa197950(SQL.80).aspx

What is the basic functions for master, msdb, model, tempdb databases?
The Master database holds information for all databases located on the SQL Server instance and is the glue that holds the engine together. Because SQL Server cannot start without a functioning master database, you must administer this database with care.
The msdb database stores information regarding database backups, SQL Agent information, DTS packages, SQL Server jobs, and some replication information such as for log shipping.
The tempdb holds temporary objects such as global and local temporary tables and stored procedures.
The model is essentially a template database used in the creation of any new user database created in the instance.

What are primary keys and foreign keys?
Primary keys are the unique identifiers for each row. They must contain unique values and cannot be null. Due to their importance in relational databases, Primary keys are the most fundamental of all keys and constraints. A table can have only one Primary key.
Foreign keys are both a method of ensuring data integrity and a manifestation of the relationship between tables.

What is data integrity? Explain constraints?
Data integrity is an important feature in SQL Server. When used properly, it ensures that data is accurate, correct, and valid. It also acts as a trap for otherwise undetectable bugs within applications.

A PRIMARY KEY constraint is a unique identifier for a row within a database table. Every table should have a primary key constraint to uniquely identify each row and only one primary key constraint can be created for each table. The primary key constraints are used to enforce entity integrity.

A UNIQUE constraint enforces the uniqueness of the values in a set of columns, so no duplicate values are entered. The unique key constraints are used to enforce entity integrity as the primary key constraints.

A FOREIGN KEY constraint prevents any actions that would destroy links between tables with the corresponding data values. A foreign key in one table points to a primary key in another table. Foreign keys prevent actions that would leave rows with foreign key values when there are no primary keys with that value. The foreign key constraints are used to enforce referential integrity.

A CHECK constraint is used to limit the values that can be placed in a column. The check constraints are used to enforce domain integrity.

A NOT NULL constraint enforces that the column will not accept null values. The not null constraints are used to enforce domain integrity, as the check constraints.
When is the use of UPDATE_STATISTICS command?
This command is basically used when a large processing of data has occurred. If a large amount of deletions any modification or Bulk Copy into the tables has occurred, it has to update the indexes to take these changes into account. UPDATE_STATISTICS updates the indexes on these tables accordingly.

Which TCP/IP port does SQL Server run on? How can it be changed?
SQL Server runs on port 1433. It can be changed from the Network Utility TCP/IP properties �> Port number.both on client and the server.

What is Identity?
Identity (or AutoNumber) is a column that automatically generates numeric values. A start and increment value can be set, but most DBA leave these at 1. A GUID column also generates numbers, the value of this cannot be controled. Identity/GUID columns do not need to be indexed.

XML Question & Ans

2009-06-22T05:13:00.000-07:00

Where should I use XML?
Its goal is to enable generic SGML to be served, received, and processed on the Web in the way that is now possible with HTML. XML has been designed for ease of implementation and for interoperability with both SGML and HTML.
Despite early attempts, browsers never allowed other SGML, only HTML (although there were plugins), and they allowed it (even encouraged it) to be corrupted or broken, which held development back for over a decade by making it impossible to program for it reliably. XML fixes that by making it compulsory to stick to the rules, and by making the rules much simpler than SGML.
But XML is not just for Web pages: in fact it's very rarely used for Web pages on its own because browsers still don't provide reliable support for formatting and transforming it. Common uses for XML include:
Information identification
because you can define your own markup, you can define meaningful names for all your information items. Information storage
because XML is portable and non-proprietary, it can be used to store textual information across any platform. Because it is backed by an international standard, it will remain accessible and processable as a data format. Information structure
XML can therefore be used to store and identify any kind of (hierarchical) information structure, especially for long, deep, or complex document sets or data sources, making it ideal for an information-management back-end to serving the Web. This is its most common Web application, with a transformation system to serve it as HTML until such time as browsers are able to handle XML consistently. Publishing
The original goal of XML as defined in the quotation at the start of this section. Combining the three previous topics (identity, storage, structure) means it is possible to get all the benefits of robust document management and control (with XML) and publish to the Web (as HTML) as well as to paper (as PDF) and to other formats (e.g. Braille, Audio, etc) from a single source document by using the appropriate style sheets. Messaging and data transfer
XML is also very heavily used for enclosing or encapsulating information in order to pass it between different computing systems which would otherwise be unable to communicate. By providing a lingua franca for data identity and structure, it provides a common envelope for inter-process communication (messaging). Web services
Building on all of these, as well as its use in browsers, machine-processable data can be exchanged between consenting systems, where before it was only comprehensible by humans (HTML). Weather services, e-commerce sites, blog newsfeeds, AJAX sites, and thousands of other data-exchange services use XML for data management and transmission, and the web browser for display and interaction.
Why is XML such an important development?

It removes two constraints which were holding back Web developments:
1. dependence on a single, inflexible document type (HTML) which was being much abused for tasks it was never designed for;
2. the complexity of full SGML, whose syntax allows many powerful but hard-to-program options.
XML allows the flexible development of user-defined document types. It provides a robust, non-proprietary, persistent, and verifiable file format for the storage and transmission of text and data both on and off the Web; and it removes the more complex options of SGML, making it easier to program for.
Describe the role that XSL can play when dynamically generating HTML pages from a relational database.
Even if candidates have never participated in a project involving this type of architecture, they should recognize it as one of the common uses of XML. Querying a database and then formatting the result set so that it can be validated as an XML document allows developers to translate the data into an HTML table using XSLT rules. Consequently, the format of the resulting HTML table can be modified without changing the database query or application code since the document rendering logic is isolated to the XSLT rules.
What is SGML?
SGML is the Standard Generalized Markup Language (ISO 8879:1986), the international standard for defining descriptions of the structure of different types of electronic document. There is an SGML FAQ from David Megginson at http://math.albany.edu:8800/hm/sgml/cts-faq.htmlFAQ; and Robin Cover's SGML Web pages are at http://www.oasis-open.org/cover/general.html. For a little light relief, try Joe English's ‘Not the SGML FAQ’ at http://www.flightlab.com/~joe/sgml/faq-not.txtFAQ.
SGML is very large, powerful, and complex. It has been in heavy industrial and commercial use for nearly two decades, and there is a significant body of expertise and software to go with it.
XML is a lightweight cut-down version of SGML which keeps enough of its functionality to make it useful but removes all the optional features which made SGML too complex to program for in a Web environment.
Aren't XML, SGML, and HTML all the same thing?
Not quite; SGML is the mother tongue, and has been used for describing thousands of different document types in many fields of human activity, from transcriptions of ancient Irish manuscripts to the technical documentation for stealth bombers, and from patients' clinical records to musical notation. SGML is very large and complex, however, and probably overkill for most common office desktop applications.
XML is an abbreviated version of SGML, to make it easier to use over the Web, easier for you to define your own document types, and easier for programmers to write programs to handle them. It omits all the complex and less-used options of SGML in return for the benefits of being easier to write applications for, easier to understand, and more suited to delivery and interoperability over the Web. But it is still SGML, and XML files may still be processed in the same way as any other SGML file (see the question on XML software).
HTML is just one of many SGML or XML applications—the one most frequently used on the Web.
Technical readers may find it more useful to think of XML as being SGML-- rather than HTML++.
Who is responsible for XML?
XML is a project of the World Wide Web Consortium (W3C), and the development of the specification is supervised by an XML Working Group. A Special Interest Group of co-opted contributors and experts from various fields contributed comments and reviews by email.
XML is a public format: it is not a proprietary development of any company, although the membership of the WG and the SIG represented companies as well as research and academic institutions. The v1.0 specification was accepted by the W3C as a Recommendation on Feb 10, 1998.
Why is XML such an important development?
It removes two constraints which were holding back Web developments:
1. dependence on a single, inflexible document type (HTML) which was being much abused for tasks it was never designed for;
2. the complexity of full question A.4, SGML, whose syntax allows many powerful but hard-to-program options.
XML allows the flexible development of user-defined document types. It provides a robust, non-proprietary, persistent, and verifiable file format for the storage and transmission of text and data both on and off the Web; and it removes the more complex options of SGML, making it easier to program for.

Why should I use XML?
Here are a few reasons for using XML (in no particular order). Not all of these will apply to your own requirements, and you may have additional reasons not mentioned here (if so, please let the editor of the FAQ know!).
* XML can be used to describe and identify information accurately and unambiguously, in a way that computers can be programmed to ‘understand’ (well, at least manipulate as if they could understand).
* XML allows documents which are all the same type to be created consistently and without structural errors, because it provides a standardised way of describing, controlling, or allowing/disallowing particular types of document structure. [Note that this has absolutely nothing whatever to do with formatting, appearance, or the actual text content of your documents, only the structure of them.]
* XML provides a robust and durable format for information storage and transmission. Robust because it is based on a proven standard, and can thus be tested and verified; durable because it uses plain-text file formats which will outlast proprietary binary ones.
* XML provides a common syntax for messaging systems for the exchange of information between applications. Previously, each messaging system had its own format and all were different, which made inter-system messaging unnecessarily messy, complex, and expensive. If everyone uses the same syntax it makes writing these systems much faster and more reliable.
* XML is free. Not just free of charge (free as in beer) but free of legal encumbrances (free as in speech). It doesn't belong to anyone, so it can't be hijacked or pirated. And you don't have to pay a fee to use it (you can of course choose to use commercial software to deal with it, for lots of good reasons, but you don't pay for XML itself).
* XML information can be manipulated programmatically (under machine control), so XML documents can be pieced together from disparate sources, or taken apart and re-used in different ways. They can be converted into almost any other format with no loss of information.
* XML lets you separate form from content. Your XML file contains your document information (text, data) and identifies its structure: your formatting and other processing needs are identified separately in a stylesheet or processing system. The two are combined at output time to apply the required formatting to the text or data identified by its structure (location, position, rank, order, or whatever).
Describe the differences between XML and HTML.
It's amazing how many developers claim to be proficient programming with XML, yet do not understand the basic differences between XML and HTML. Anyone with a fundamental grasp of XML should be able describe some of the main differences outlined in the table below.
Differences Between XML and HTML
Table 1.
XML HTML
User definable tags Defined set of tags designed for web display
Content driven Format driven
End tags required for well formed documents End tags not required
Quotes required around attributes values Quotes not required
Slash required in empty tags Slash not required

Describe the role that XSL can play when dynamically generating HTML pages from a relational database.
Even if candidates have never participated in a project involving this type of architecture, they should recognize it as one of the common uses of XML. Querying a database and then formatting the result set so that it can be validated as an XML document allows developers to translate the data into an HTML table using XSLT rules. Consequently, the format of the resulting HTML table can be modified without changing the database query or application code since the document rendering logic is isolated to the XSLT rules.
Give a few examples of types of applications that can benefit from using XML.
There are literally thousands of applications that can benefit from XML technologies. The point of this question is not to have the candidate rattle off a laundry list of projects that they have worked on, but, rather, to allow the candidate to explain the rationale for choosing XML by citing a few real world examples. For instance, one appropriate answer is that XML allows content management systems to store documents independently of their format, which thereby reduces data redundancy. Another answer relates to B2B exchanges or supply chain management systems. In these instances, XML provides a mechanism for multiple companies to exchange data according to an agreed upon set of rules. A third common response involves wireless applications that require WML to render data on hand held devices.
What is DOM and how does it relate to XML?
The Document Object Model (DOM) is an interface specification maintained by the W3C DOM Workgroup that defines an application independent mechanism to access, parse, or update XML data. In simple terms it is a hierarchical model that allows developers to manipulate XML documents easily Any developer that has worked extensively with XML should be able to discuss the concept and use of DOM objects freely. Additionally, it is not unreasonable to expect advanced candidates to thoroughly understand its internal workings and be able to explain how DOM differs from an event-based interface like SAX.
What is SOAP and how does it relate to XML?
The Simple Object Access Protocol (SOAP) uses XML to define a protocol for the exchange of information in distributed computing environments. SOAP consists of three components: an envelope, a set of encoding rules, and a convention for representing remote procedure calls. Unless experience with SOAP is a direct requirement for the open position, knowing the specifics of the protocol, or how it can be used in conjunction with HTTP, is not as important as identifying it as a natural application of XML.
Can you walk us through the steps necessary to parse XML documents?
Superficially, this is a fairly basic question. However, the point is not to determine whether candidates understand the concept of a parser but rather have them walk through the process of parsing XML documents step-by-step. Determining whether a non-validating or validating parser is needed, choosing the appropriate parser, and handling errors are all important aspects to this process that should be included in the candidate's response.
Give some examples of XML DTDs or schemas that you have worked with.
Although XML does not require data to be validated against a DTD, many of the benefits of using the technology are derived from being able to validate XML documents against business or technical architecture rules. Polling for the list of DTDs that developers have worked with provides insight to their general exposure to the technology. The ideal candidate will have knowledge of several of the commonly used DTDs such as FpML, DocBook, HRML, and RDF, as well as experience designing a custom DTD for a particular project where no standard existed.
Using XSLT, how would you extract a specific attribute from an element in an XML document?
Successful candidates should recognize this as one of the most basic applications of XSLT. If they are not able to construct a reply similar to the example below, they should at least be able to identify the components necessary for this operation: xsl:template to match the appropriate XML element, xsl:value-of to select the attribute value, and the optional xsl:apply-templates to continue processing the document.
Extract Attributes from XML Data
Example 1.

Attribute Value:

When constructing an XML DTD, how do you create an external entity reference in an attribute value?
Every interview session should have at least one trick question. Although possible when using SGML, XML DTDs don't support defining external entity references in attribute values. It's more important for the candidate to respond to this question in a logical way than than the candidate know the somewhat obscure answer.
How would you build a search engine for large volumes of XML data?
The way candidates answer this question may provide insight into their view of XML data. For those who view XML primarily as a way to denote structure for text files, a common answer is to build a full-text search and handle the data similarly to the way Internet portals handle HTML pages. Others consider XML as a standard way of transferring structured data between disparate systems. These candidates often describe some scheme of importing XML into a relational or object database and relying on the database's engine for searching. Lastly, candidates that have worked with vendors specializing in this area often say that the best way the handle this situation is to use a third party software package optimized for XML data.
Obviously, some important areas of XML technologies were not included in this list -- namespaces, XPointer, XLink, and so on -- and should be added to the interviewer's set of questions if applicable to the particular position that the candidate is applying for. However, these questions in conjunction with others to assess soft skills (communication skills, ability to work on teams, leadership ability, etc.) will help determine how well candidates understand the fundamental principles of XML.
What is Xpath?

What is Xpath?
XPath is used to navigate through elements and attributes in an XML document.

What is XSL?

XSLT - a language for transforming XML documents
XSLT is used to transform an XML document into another XML document, or another type of document that is recognized by a browser, like HTML and XHTML. Normally XSLT does this by transforming each XML element into an (X)HTML element.

XPath - a language for navigating in XML documents
XSL-FO - a language for formatting XML documents

How Schemas Differ from DTDs?
The first, and probably most significant, difference between XML Schemas and XML DTDs is that XML Schemas use XML document syntax. While transforming the syntax to XML doesn’t automatically improve the quality of the description, it does make those descriptions far more extensible than they were in the original DTD syntax. Declarations can have richer and more complex internal structures than declarations in DTDs, and schema designers can take advantage of XML’s containment hierarchies to add extra information where appropriate — even sophisticated information like documentation. There are a few other benefits from this approach. XML Schemas can be stored along with other XML documents in XML-oriented data stores, referenced, and even styled, using tools like XLink, XPointer, and XSL.

The largest addition XML Schemas provide to the functionality of the descriptions is a vastly improved data typing system. XML Schemas provide data-oriented data types in addition to the more document-oriented data types XML 1.0 DTDs support, making XML more suitable for data interchange applications. Built-in datatypes include strings, booleans, and time values, and the XML Schemas draft provides a mechanism for generating additional data types. Using that system, the draft provides support for all of the XML 1.0 data types (NMTOKENS, IDREFS, etc.) as well as data-specific types like decimal, integer, date, and time. Using XML Schemas, developers can build their own libraries of easily interchanged data types and use them inside schemas or across multiple schemas.

The current draft of XML Schemas also uses a very different style for declaring elements and attributes to DTDs. In addition to declaring elements and attributes individually, developers can create models — archetypes — that can be applied to multiple elements and refined if necessary. This provides a lot of the functionality SOX had developed to support object-oriented concepts like inheritance. Archetype development and refinement will probably become the mark of the high-end schema developer, much as the effective use of parameter entities was the mark of the high-end DTD developer. Archetypes should be easier to model and use consistently, however.

XML Schemas also support namespaces, a key feature of the W3C’s vision for the future of XML. While it probably wouldn’t be impossible to integrate DTDs and namespaces, the W3C has decided to move on, supporting namespaces in its newer developments and not retrofitting XML 1.0. In many cases, provided that namespace-prefixes don’t change or simply aren’t used, DTD’s can work just fine with namespaces, and should be able to interoperate with namespaces and schema processing that relies on namespaces. There will be a few cases, however, where namespaces may force developers to use the newer schemas rather than the older DTDs.

Validation - RegularExpression

2009-06-12T04:36:00.001-07:00

Validation:
.Net inbuilt validation control custmaization
1)Create .cs class
#region LoadREVforLongText1
public RegularExpressionValidator LoadREVforLongText1(string controlName, string errorMsg, bool isValidationSummary, string valGroup)
{
RegularExpressionValidator revControl = new RegularExpressionValidator();
revControl.ValidationGroup = valGroup;
revControl.ControlToValidate = controlName;
revControl.ValidationExpression = @"(?!.*?\b\w{31,}).*";
revControl.ErrorMessage = "Please enter " + errorMsg + " words length max 30";

if (isValidationSummary == true)
{
revControl.Display = ValidatorDisplay.None;
}

return revControl;
}
#endregion

2)Create a instance for the class on .aspx.cs/.ascx.cs
ValidationControls vc = new ValidationControls();
protected void RegisterValidationControls()
{
RegularExpressionValidator revFullName = vc.LoadREVforLongText1 ("txtFullName", "full name", true, "2");
div_fullname.Controls.Add(revFullName);
}
3)call the above method on the page load event.

4)validating text should have div block. where the error message will display.

5)Need's to put validation summary in design page. set the properties ValidationGroup="2" DisplayMode="List"

Regular Expression:
for Phone no:
= @"^[\{\}\[\] a-zA-Z0-9''+,-]{0,100}$"
for Email with hypen
= @"^([0-9a-zA-Z]([-.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$";
for Email without hypen
= @"^([0-9a-zA-Z]([.\w]*[0-9a-zA-Z])*@([0-9a-zA-Z][\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,9})$";
for Long text without space
= @"(?!.*?\b\w{31,}).*";

#region is Valid word
public bool isValid(string strText, int maxchars)
{
if (strText.Trim().Length > 0)
{
strText = strText.Trim();

string[] strLines = strText.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
int cnt = 0;
for (int i = 0; i < strLines.Length; i++)
{
string[] strWords = strLines[i].Split(' ');
cnt += strWords.Length;
for (int j = 0; j < strWords.Length; j++)
{
if (strWords[j].Length > maxchars)
{
return false;
}
}
}
}
return true;
}
#endregion

SilverLight

2009-06-12T02:59:00.000-07:00

What is Silverlight?

Silverlight is a new cross-browser, cross-platform implementation of the .NET Framework for building and delivering the next generation of media experiences and Rich Interactive Applications(RIA) for the web. It runs in all popular browsers, including Microsoft Internet Explorer, Mozilla Firefox, Apple Safari, Opera. The plugin required to run Silverlight is very small in size hence gets installed very quickly.

It is combination of different technolgoies into a single development platform that allows you to select tools and the programming language you want to use. Silverlight integrates seamlessly with your existing Javascript and ASP.NET AJAX code to complement functionality which you have already created.

Silverlight aims to compete with Adobe Flash and the presentation components of Ajax. It also competes with Sun Microsystems' JavaFX, which was launched a few days after Silverlight.

Currently there are 2 major versions of Silverlight:

Silverlight 1.0 and Silverlight 2.0( previously referred to as version 1.1).

Silverlight 1.0 :

Silverlight 1.0 consists of the core presentation framework, which is responsible for UI, interactivity and user input, basic UI controls, graphics and animation, media playback, DRM support, and DOM integration.

Main features of Silverlight 1.0 :

1. Built-in codec support for playing VC-1 and WMV video, and MP3 and WMA audio within a browser.
2. Silverlight supports the ability to progressively download and play media content from any web-server.
3. Silverlight also optionally supports built-in media streaming.
4. Silverlight enables you to create rich UI and animations, and blend vector graphics with HTML to create compelling content experiences.
5. Silverlight makes it easy to build rich video player interactive experiences.

Silverlight 2.0 :

Silverlight 2.0 includes a version of the .NET Framework, with the full Common Language Runtime as .NET Framework 3.0; so it can execute any .NET language including VB.NET and C# code. Unlike the CLR included with .NET Framework, multiple instances of the CoreCLR included in Silverlight can be hosted in one process. With this, the XAML layout markup file (.xaml file) can be augmented by code-behind code, written in any .NET language, which contains the programming logic.

This version ships with more than 30 UI controls(including TextBox, CheckBox, Slider, ScrollViewer, and Calendar controls), for two-way databinding support, automated layout management (by means of StackPanel, Grid etc) as well as data-manipulation controls, such as DataGrid and ListBox. UI controls are skinnable using a template-based approach.

Main features of Silverlight 2.0 :

1. A built-in CLR engine that delivers a super high performance execution environment for the browser. Silverlight uses the same core CLR engine that we ship with the full .NET Framework.
2. Silverlight includes a rich framework library of built-in classes that you can use to develop browser-based applications.
3. Silverlight includes support for a WPF UI programming model. The Silverlight 1.1 Alpha enables you to program your UI with managed code/event handlers, and supports the ability to define and use encapsulated UI controls.
4. Silverlight provides a managed HTML DOM API that enables you to program the HTML of a browser using any .NET language.
5. Silverlight doesn't require ASP.NET to be used on the backend web-server (meaning you could use Silverlight with with PHP on Linux if you wanted to).
6. Silverlight 2 includes Deep Zoom, a technology derived from Microsoft Live Labs Seadragon. It allows users to zoom into, or out of, an image (or a collage of images), with smooth transitions, using the mouse wheel. The images can scale from 2 or 3 megapixels in resolution into the gigapixel range, but the user need not wait for it to be downloaded entirely; rather, Silverlight downloads only the parts in view, optimized for the zoom level being viewed.
7. Silverlight 2 also allows limited filesystem access to Silverlight applications. It can use the operating system's native file dialog box to browse to any file (to which the user has access).

How Silverlight would change the Web:

1. Highest Quality Video Experience : prepare to see some of the best quality videos you have seen in your life, all embedded in highly graphical websites. The same research and technology that was used for VC-1, the codec that powers BluRay and HD DVD, is used by Microsoft today with its streaming media technologies.
2. Cross-Platform, Cross-Browser : Finally build web applications that work on any browser, and on any operating system. At release, Silverlight will work with Mac as well as Windows! The Mono project has also already promised support for Linux!.
3. Developers and Graphic Designers can play together! : Developers familiar with Visual Studio, Microsoft.net will be able to develop amazing Silverlight applications very quickly, and they will work on Mac's and Windows. Developers will finally be able to strictly focus on the back end of the application core, while leaving the visuals to the Graphic Design team using the power of XAML.
4. Cheaper : Silverlight is now the most inexpensive way to stream video files over the internet at the best quality possible. Licensing is dead simple, all you need is IIS in Windows Server, and you’re done.
5. Support for 3rd Party Languages : Using the power of the new Dynamic Language Runtime, developers will now be able to use Ruby, Python, and EcmaScript! This means a Ruby developer can develop Silverlight applications, and leverage the .net Framework!
6. Cross-Platform, Cross-Browser Remote Debugging : If you are in the need to debug an application running on a Mac, no problem! You can now set breakpoints, step into/over code, have immediate windows, and all that other good stuff that Visual Studio provides.
7. The best development environment on the planet : Visual Studio is an award winning development platform! As it continues to constantly evolve, so will Silverlight!
8. Silverlight offers copy protection : Have you noticed how easy it is to download YouTube videos to your computer, and save them for later viewing ? Silverlight will finally have the features enabling content providers complete control over their rich media content! Streaming television, new indie broadcast stations, all will now be possible!
9. Extreme Speed :There is a dramatic improvement in speed for AJAX-enabled websites that begin to use Silverlight, leveraging the Microsoft .net framework.

Excel File Import to Gridview (HTML Format/normal)

2009-06-11T04:38:00.000-07:00

Excel file directly read and fill the value into Gridview.
below code read the file from application physicalpath/upload control posted file.

DataSet ds = new DataSet();

void BindtheGrid()
{
string path = "C\\Projects\\LogicTest\\Report.xls";
string strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" +
"Data Source=" + path + "Extended Properties='Excel 8.0;IMEX=1;'";
//You must use the $ after the object you reference in the spreadsheet
//OleDbDataAdapter myCommand = new OleDbDataAdapter("SELECT * FROM [Report$] ", strConn);
OleDbDataAdapter myCommand = new OleDbDataAdapter();
DataTable dt;
try
{
myCommand.Fill(ds, "Report");
dt = ds.Tables["Report"];
}
catch (Exception ex)
{
//when the excel file could not read ie file is not in format
/* HttpPostedFile httpUploadedCSV = uploadgroup.PostedFile;
StreamReader sr = new StreamReader(httpUploadedCSV.InputStream); if the file is posed by file control*/

string filename = Server.MapPath("Report.xls"); // it is reading directly from the server location
StreamReader sr = default(StreamReader);
sr = File.OpenText(filename);

string s = sr.ReadToEnd();

DataSet ds = ConvertHTMLTablesToDataSet(s);
//dt = ds.Tables[0];
GridView1.DataSource = ds;
GridView1.DataBind();
}
}
Some time imported file may be HTML format it would have been stored. needs to read and get the proper dataset/datatable:

protected DataSet ConvertHTMLTablesToDataSet(string HTML)
{
//' Declarations

try
{

MatchCollection Tables = Regex.Matches(HTML, TableExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);

// ' Get a match for all the tables in the HTML

foreach (Match table in Tables)
{

// ' Reset the current row counter and the header flag
iCurrentRow = 0;
HeadersExist = false;

//' Add a new table to the DataSet
dt = new DataTable();

//' Create the relevant amount of columns for this table (use the headers if they exist, otherwise use default names)

if (table.Value.Contains(" {
// ' Set the HeadersExist flag
HeadersExist = true;

//' Get a match for all the rows in the table
MatchCollection Headers = Regex.Matches(table.Value, HeaderExpression, (RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase));

// ' Loop through each header element
foreach (Match Header in Headers)
{
dt.Columns.Add(Header.Groups[1].ToString());
}
}
else
{
for (int iColumns = 1; iColumns < Regex.Matches(Regex.Matches(Regex.Matches(table.Value, TableExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase).ToString(), RowExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase).ToString(), ColumnExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase).Count; iColumns++)
{
dt.Columns.Add("Column " + iColumns);
}
}

//' Get a match for all the rows in the table
MatchCollection Rows = Regex.Matches(table.Value, RowExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);

//' Loop through each row element
foreach (Match Row in Rows)
{

// ' Only loop through the row if it isn't a header row

if (!(iCurrentRow == 0 & HeadersExist == true))
{

// ' Create a new row and reset the current column counter
dr = dt.NewRow();
iCurrentColumn = 0;

// ' Get a match for all the columns in the row
MatchCollection Columns = Regex.Matches(Row.Value, ColumnExpression, RegexOptions.Multiline | RegexOptions.Singleline | RegexOptions.IgnoreCase);

// ' Loop through each column element
foreach (Match Column in Columns)
{
if (Column.Groups[1].ToString().Trim() == " ")
{
dr[iCurrentColumn] = "";
}
else
{
dr[iCurrentColumn] = Column.Groups[1].ToString().Trim();
}
// ' Increase the current column
iCurrentColumn += 1;
}

// ' Add the DataRow to the DataTable
dt.Rows.Add(dr);

}

// ' Increase the current row counter
iCurrentRow += 1;
}

//' Add the DataTable to the DataSet
ds.Tables.Add(dt);

}

}
catch (Exception e)
{
//lblerr.Text = "File is not in the Expected Format. Save the File as 'Excel 97-2003 Workbook' Format, then try Import.";
if (ds.Tables.Count == 0)
{
DataTable dt = new DataTable();
ds.Tables.Add(dt);
}
}
return ds;
}

GridView Export into excel & Generate XML Dataset Values

2009-06-09T03:48:00.000-07:00

DAL - Data Access Layer

static SqlConnection GetConnectionObject()
{
SqlConnection con = new SqlConnection();
string connectionstring;
try
{
connectionstring = ConfigurationManager.ConnectionStrings["logictest"].ConnectionString; ;
con.ConnectionString = connectionstring;

return con;
}
catch (Exception ex)
{
throw ex;
}

}

public static DataSet ExecuteSQLReturnDataSet(string strSQL)
{
DataSet ds = new DataSet("DataSet");
SqlConnection con = GetConnectionObject();
SqlDataAdapter da = new SqlDataAdapter(strSQL, con);
try
{
da.Fill(ds);
return ds;
}
catch (Exception ex)
{
throw ex;
}
finally
{
con.Close();
con.Dispose();
da.Dispose();
ds.Dispose();
}
}

GridView Export into excel:
Method to GeneratetheReport:

public void ReportGeneration(DataSet dset, string filename)
{

GridView gv = new GridView();
gv.DataSource = dset;
gv.DataBind(); //Read the grid value however the report format may be excel/pdf
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.OutputStream.Write(new byte[] { 0xef, 0xbb, 0xbf }, 0, 3);
HttpContext.Current.Response.Buffer = true;
HttpContext.Current.Response.AddHeader("content-disposition", "attachment;filename=" + filename + "");
HttpContext.Current.Response.ContentType = "application/ms-excel";
StringWriter oStringWriter = new StringWriter();
HtmlTextWriter oHtmlTextWriter = new HtmlTextWriter(oStringWriter);
gv.RenderControl(oHtmlTextWriter);
HttpContext.Current.Response.Write(oStringWriter.ToString());
HttpContext.Current.Response.End();
HttpContext.Current.Response.Flush();
HttpContext.Current.ApplicationInstance.CompleteRequest();
}

On btnclic/load event call the below method

void BindGridView()
{
DataSet ds = new DataSet();
ds = ExecuteSQLReturnDataSet("select * from tablename");
grd.DataSource = ds;
grd.DataBind();
if (ds.Tables[0].Rows.Count > 0)
{
ReportGeneration(ds, "Report.xls");
}
}
Generate XML Dataset Values:
public void XMLGenarate()
{
string XMLFileName = "C:/Projects/XMLGenerate" + DateTime.Now.ToString("dd-mm-yyyy") +""; // can set it in web.config
DataSet ds = new DataSet();
ds = ExecuteSQLReturnDataSet("select * from tableName"); // can pass it as a parameter of(string) / from Data Access Layer which has coding standard.
FileStream fs = null;
if (ds.Tables[0].Rows.Count > 0)
{
fs = new FileStream(XMLFileName + ".xml", FileMode.OpenOrCreate, FileAccess.Write);
ds.WriteXml(fs);
fs.Close();
}

}

on btnclick/load event call the above method.

Using the FOR XML Clause to Return Query Results as XML

2009-06-09T00:38:00.000-07:00

SQL Server lets you retrieve data as XML by supporting the FOR XML clause, which can be included as part of your query. You can use the FOR XML clause in the main (outer) query as well as in subqueries. The clause supports numerous options that let you define the format of the XML data.

When you include the FOR XML clause in your query, you must specify one of the four supported modes—RAW, AUTO, EXPLICIT, or PATH. The options available to each mode vary according to that mode; however, many of the options are shared among the modes. In this article, I explain how to use each of these modes to retrieve data as XML and provide examples that demonstrate how they use the various options.

The RAW Mode

The RAW mode generates a single XML element for each row in the result set returned by the query.

To use the FOR XML clause in RAW mode, you simply append the clause and RAW keyword to your SELECT statement, as shown in the following example:

it return row's in a form of xml.

SELECT e.EmployeeID, c.FirstName, c.MiddleName, c.LastName
FROM HumanResources.Employee e INNER JOIN Person.Contact c
ON c.ContactID = e.ContactID
WHERE c.FirstName = 'Rob'
FOR XML RAW;

row's get the id basix (ie name)

SELECT e.EmployeeID, c.FirstName, c.MiddleName, c.LastName
FROM HumanResources.Employee e INNER JOIN Person.Contact c
ON c.ContactID = e.ContactID
WHERE c.FirstName = 'Rob'
FOR XML RAW ('Employee');

can specify only roots/ elements to

SELECT e.EmployeeID, c.FirstName, c.MiddleName, c.LastName
FROM HumanResources.Employee e INNER JOIN Person.Contact c
ON c.ContactID = e.ContactID
WHERE c.FirstName = 'Rob'
FOR XML RAW ('Employee'), ROOT ('Employees'), ELEMENTS;

no elements are created for a column whose value is null. However, you can override this behavior by adding the XSINIL keyword to the ELEMENTS option:

SELECT e.EmployeeID, c.FirstName, c.MiddleName, c.LastName
FROM HumanResources.Employee e INNER JOIN Person.Contact c
ON c.ContactID = e.ContactID
WHERE c.FirstName = 'Rob'
FOR XML RAW ('Employee'), ROOT ('Employees'), ELEMENTS XSINIL;

Image Resize (on fly thumbnail image generation)

2009-05-26T02:01:00.000-07:00

1)web.config

2)Create Folder called images (on application physical path)

3)Create .cs

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;

///

/// Summary description for Lib
///

public class Lib
{
public Lib()
{
//
// TODO: Add constructor logic here
//
}

#region Thumbnail Functions
public bool ThumbnailCallback()
{
return false;
}

private float DeterminePercentageForResize(int height, int width)
{
int highestValue;
if (height > width)
highestValue = height;
else
highestValue = width;

float percent = (float)int.Parse(ConfigurationManager.AppSettings["ThumbSize"].ToString()) / (float)highestValue;

if (percent > 1 && percent != 0)
throw new Exception("Percent cannot be greater than 1 or equal to zero");
else
return percent;
}

private static System.Drawing.Image FixedSize(System.Drawing.Image imgPhoto, int Width, int Height)
{
int sourceWidth = imgPhoto.Width;
int sourceHeight = imgPhoto.Height;
int sourceX = 0;
int sourceY = 0;
int destX = 0;
int destY = 0;

float nPercent = 0;
float nPercentW = 0;
float nPercentH = 0;

nPercentW = ((float)Width / (float)sourceWidth);
nPercentH = ((float)Height / (float)sourceHeight);
if (nPercentH < nPercentW)
{
nPercent = nPercentH;
destX = System.Convert.ToInt16((Width -
(sourceWidth * nPercent)) / 2);
}
else
{
nPercent = nPercentW;
destY = System.Convert.ToInt16((Height -
(sourceHeight * nPercent)) / 2);
}

int destWidth = (int)(sourceWidth * nPercent);
int destHeight = (int)(sourceHeight * nPercent);

Bitmap bmPhoto = new Bitmap(Width, Height,
PixelFormat.Format24bppRgb);
bmPhoto.SetResolution(imgPhoto.HorizontalResolution,
imgPhoto.VerticalResolution);

Graphics grPhoto = Graphics.FromImage(bmPhoto);
grPhoto.Clear(Color.White);
grPhoto.InterpolationMode =
InterpolationMode.HighQualityBicubic;

grPhoto.DrawImage(imgPhoto,
new Rectangle(0, 0, destWidth, destHeight),
new Rectangle(0, 0, sourceWidth, sourceHeight),
GraphicsUnit.Pixel);

grPhoto.Dispose();
return bmPhoto;
}

public bool SaveAsThumbnail(string largeimage)
{
bool status = false;
try
{
string strPathPrefix = ConfigurationManager.AppSettings["UploadPrefix"].ToString();
string strPath = ConfigurationManager.AppSettings["UploadLocation"].ToString();

string strFilename = System.IO.Path.GetFileNameWithoutExtension(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + largeimage));
string strThumbnail = strFilename + "_small.jpg";

int intThumbnailSize = int.Parse(ConfigurationManager.AppSettings["ThumbSize"].ToString());
int intWidth, intHeight;
Bitmap photo;

try
{
photo = new Bitmap(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + largeimage));
}
catch (ArgumentException)
{
throw new HttpException(404, "Photo not found.");
}

if (photo.Width > intThumbnailSize)
{
if (photo.Width > photo.Height)
{
intWidth = intThumbnailSize;
intHeight = photo.Height * intThumbnailSize / photo.Width;
}
else
{
intWidth = photo.Width * intThumbnailSize / photo.Height;
intHeight = intThumbnailSize;
}
}
else
{
intWidth = photo.Width;
intHeight = photo.Height;
}

System.Drawing.Image imgPhotoVert = System.Drawing.Image.FromFile(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + largeimage));
System.Drawing.Image imgPhoto = null;

imgPhoto = FixedSize(imgPhotoVert, intWidth, intHeight);
imgPhoto.Save(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + strThumbnail), ImageFormat.Jpeg);
imgPhoto.Dispose();
imgPhotoVert.Dispose();
photo.Dispose();
status = true;

}
catch (Exception ex)
{
//AppLogger.LogError("SaveAsThumbnail(): " + ex.Message, AppLogger.Severity.Error);
ex.Message.ToString();
}

return status;
}

public bool SaveAsImage(string largeimage, int ResizeImageSize, string FileNameRef)
{
bool status = false;
try
{
string strPathPrefix = ConfigurationManager.AppSettings["UploadPrefix"].ToString();
string strPath = ConfigurationManager.AppSettings["UploadLocation"].ToString();

string strFilename = System.IO.Path.GetFileNameWithoutExtension(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + largeimage));
string strThumbnail = strFilename + "_" + FileNameRef + ".jpg";

int intThumbnailSize = ResizeImageSize;
int intWidth, intHeight;
Bitmap photo;

try
{
photo = new Bitmap(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + largeimage));
}
catch (ArgumentException)
{
throw new HttpException(404, "Photo not found.");
}

if (photo.Width > intThumbnailSize)
{
if (photo.Width > photo.Height)
{
intWidth = intThumbnailSize;
intHeight = photo.Height * intThumbnailSize / photo.Width;
}
else
{
intWidth = photo.Width * intThumbnailSize / photo.Height;
intHeight = intThumbnailSize;
}
}
else
{
intWidth = photo.Width;
intHeight = photo.Height;
}

System.Drawing.Image imgPhotoVert = System.Drawing.Image.FromFile(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + largeimage));
System.Drawing.Image imgPhoto = null;

imgPhoto = FixedSize(imgPhotoVert, intWidth, intHeight);
imgPhoto.Save(HttpContext.Current.Server.MapPath(strPathPrefix + strPath + strThumbnail), ImageFormat.Jpeg);
imgPhoto.Dispose();
imgPhotoVert.Dispose();
photo.Dispose();
status = true;

}
catch (Exception ex)
{
//AppLogger.LogError("SaveAsImage(): " + ex.Message, AppLogger.Severity.Error);
ex.
}

return status;
}

#endregion
}

4).aspx/ascx

5).aspx.cs/.ascx.cs
on btn_click event
string strpPath = ConfigurationManager.AppSettings["UploadLocation"].ToString();
string strpPathPrefix = ConfigurationManager.AppSettings["UploadPrefix"].ToString();
string extenstion = DateTime.Now.ToString("ddMMyy-HHmm");
string filepath = "", strResizeFilename = "", strFullFilename = "";
bool ResizeImage = false;

Lib objlib = new Lib();

if (fPhotUpload.FileName != "")
{
if (fPhotUpload.HasFile)
{

if (fPhotUpload.HasFile)
{
filepath = extenstion + fPhotUpload.FileName.Replace(" ", "_");
strFullFilename = Server.MapPath(strpPathPrefix + strpPath) + filepath;
fPhotUpload.SaveAs(strFullFilename);
ResizeImage = objlib.SaveAsImage(filepath, Convert.ToInt16(ConfigurationManager.AppSettings["LargeThumbSize"]), "large");
}
if (ResizeImage == true)
{

strResizeFilename = System.IO.Path.GetFileNameWithoutExtension(filepath);
hdnbigimage.Value = strResizeFilename + "_large.jpg";

ResizeImage = false;
ResizeImage = objlib.SaveAsImage(filepath, Convert.ToInt16(ConfigurationManager.AppSettings["ThumbSize"]), "small");

if (ResizeImage == true)
{
strResizeFilename = "";
strResizeFilename = System.IO.Path.GetFileNameWithoutExtension(filepath);
hdnsmallimage.Value = strResizeFilename + "_small.jpg";
}
}
else
{
lblMsg.Text = "Image path cannot be found";
return;
}
}
}

Crystal Reports

2009-05-22T01:39:00.000-07:00

CRYSTAL REPORT STEPS TO GENERATE:

1) "Add New Item" dialog box, select "Crystal Report" as the template, provide the name "SampleRpt01.rpt" and click on the "Add" button

2) Crystal Reports Gallery

3)Connect with DB.

Once the report gets added, you should be able to see the Visual Studio layout with "Field Explorer," the new "Crystal Reports" menu and an "Embedded Crystal Report Designer" with two modes ("Main Report" and "Main Report Preview" at the bottom) as shown below.

The "Field Explorer" can be used to drag and drop the columns onto the report, add new, add new tables to the report, add new formula oriented columns, running totals, and so on.

The report designer is initially divided into five sections (Report Header, Report Footer, Page Header, Page Footer and Details). Report Header gets displayed only on the first page. Report Footer gets displayed only on the last page. Page Header gets displayed on top of every page. Page Footer gets displayed at the bottom of every page. The Detail section is the body of the report where all of the rows get displayed.

Using the formatting toolbar, properties windows and tools in toolbox, we can format the report in the required manner. Try playing with formatting the report (and preview it simultaneously without executing the project).

Displaying Crystal Report on the ASP.NET 2.0 web page

To display the report on the web page, we need to work with Crystal Report Viewer control. The following are the steps required to attach the Crystal Report to the ASP.NET 2.0 web page:

Using the ToolBox, drag and drop the CrystalReportViewer control.

Using the Smart tag of the CrystalReportViewer control, select "New Report Source."

This leads you to a new dialog box, "Crystal Report Source." Every CrystalReportViewer gets associated with the CrystalReportSource control. You can directly drag and drop the CrystalReportSource control from the toolbox as well and assign the same in a smart tag. Provide the details and click OK.

The moment you hit OK, you should be previewing the report. Just hit F5 to execute your web site. Once the web page gets displayed, provide logon information for the report and click on "Logon."

using CrystalDecisions.CrystalReports.Engine;
using CrystalDecisions.Shared;
using System.Data.SqlClient;

protected void Page_Load(object sender, EventArgs e)
{
ConnectionInfo ConnInfo = new ConnectionInfo();

{
ConnInfo.ServerName = ".sqlexpress";

ConnInfo.DatabaseName = "Northwind";

ConnInfo.UserID = "sa";

ConnInfo.Password = "eXpress2005";
}

foreach (TableLogOnInfo cnInfo in this.CrystalReportViewer1.LogOnInfo)
{

cnInfo.ConnectionInfo = ConnInfo;
}
}

//
/*
Directly bind the report to the viewr control on Page Load event

CrystalDecisions.CrystalReports.Engine.ReportDocument rd =
new CrystalDecisions.CrystalReports.Engine.ReportDocument();

rd.Load(Server.MapPath("CrystalReport.rpt"));
rd.SetDataSource(ds);
CrystalReportViewer1.ReportSource = rd;
CrystalReportViewer1.DataBind();

*/

Pagination Custamization

2009-05-22T00:16:00.000-07:00

Pagination Custamization:

1).aspx/.ascx Design View

2).aspx.cs/.ascx.cs

private int intCurrentselectPage;

#region CurrentselectPage
public int CurrentSelectPage
{
get
{
return intCurrentselectPage;
}
set
{
intCurrentselectPage = value;
}
}
#endregion

protected void grdNewsList_DataBound(object sender, EventArgs e)
{
if (grdNewsList.Rows.Count > 0)
{
GridViewRow gNavFooter = grdNewsList.BottomPagerRow;
LinkButton lbP = gNavFooter.FindControl("lbPrev") as LinkButton;
LinkButton lbN = gNavFooter.FindControl("lbNext") as LinkButton;
try
{
if (grdNewsList.PageIndex == 0)
{
lbP.Enabled = false;
}

int iStartIndex = 0;
int iCurrentPage = CurrentSelectPage + 1;

int iCalc = (iCurrentPage / 5) + ((iCurrentPage % 5) >= 1 ? 1 : (iCurrentPage % 5));

if (iCalc > 1)
{
iStartIndex = (((iCalc * 5) - 5) + 1);
}
else
{
iStartIndex = 1;
}

for (int i = 1; i <= 5; i++)
{
LinkButton lb = gNavFooter.FindControl("lb" + i.ToString()) as LinkButton;

lb.Text = iStartIndex.ToString();
lb.CommandArgument = iStartIndex.ToString();
if (iStartIndex > grdNewsList.PageCount)
{
lb.Visible = false;
}
if (iStartIndex == grdNewsList.PageIndex + 1)
{
lb.Enabled = false;
}
iStartIndex++;
}

if (grdNewsList.PageIndex == grdNewsList.PageCount - 1)
{
lbN.Enabled = false;
}
}
catch (Exception ex)
{
throw (ex);
}
}
}

protected void grdNewsList_PageIndexChanging(object sender, GridViewPageEventArgs e)
{
CurrentSelectPage = e.NewPageIndex;
grdNewsList.PageIndex = e.NewPageIndex;
DisplayFromListPublishedNews(); // Bind the Method again.
}

Error Log

2009-05-21T22:25:00.000-07:00

XML Format.

1)Create a .cs file.

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Xml;
using System.IO;
using System.Text;

///

/// Summary description for AppLogger
///

public static class AppLogger
{
// Fields
private static XmlDocument LogDoc;
private static XmlElement LogElement;
private static XmlNode LogNode;

// Methods
static AppLogger()
{
try
{
LogDoc = new XmlDocument();
string path = HttpContext.Current.Server.MapPath(ConfigurationManager.AppSettings["ErrorFolder"] +"\\"+ DateTime.Now.ToString("dd-MM-yyyy") + ".xml");

if (!File.Exists(path))
{
XmlTextWriter writer = new XmlTextWriter(path, Encoding.Unicode);
writer.WriteStartDocument(true);
writer.WriteStartElement("LOGGER");
writer.WriteEndElement();
writer.Close();
}
try
{
LogDoc.Load(path);
}
catch
{

}
}
catch
{
}
}

public static void LogError(string Message, Severity severity)
{
try
{
if(Message!="Thread was being aborted.")
{
//in the web config specify the path(where to store log file like ()).
string path = HttpContext.Current.Server.MapPath(ConfigurationManager.AppSettings["ErrorFolder"] + "\\" + DateTime.Now.ToString("dd-MM-yyyy") + ".xml");

if (!File.Exists(path))
{
XmlTextWriter writer = new XmlTextWriter(path, Encoding.Unicode);
writer.WriteStartDocument(true);
writer.WriteStartElement("LOGGER");
writer.WriteEndElement();
writer.Close();
LogDoc = new XmlDocument();
LogDoc.Load(path);
}
LogNode = LogDoc.DocumentElement;
LogElement = LogDoc.CreateElement("ELOG");
Message = Message.Replace("&", "&");
Message = Message.Replace("<", "<");
Message = Message.Replace(">", ">");
LogElement.InnerXml = "" + DateTime.Now.ToLongTimeString() + "" + severity.ToString() + "" + Message + "";
LogNode.AppendChild(LogElement);

LogDoc.Save(path);
}
}
catch
{
}

}

// Nested Types
public enum Severity
{
Error = 2,
Failure = 3,
Informational = 1
}
}

on the aspx/ascx in a catch block write below lines

2) AppLogger.LogError("User Edit Profile, Sending Mail() " + ex.Message, AppLogger.Severity.Error);

TXT format
1)Create .cs file

public static void ErrorLogFile(string strErrorMessage)
{
try
{
string strPath = "~/LogFile/ErrorDetails/" + DateTime.Today.ToString("dd-mm-yy") + ".txt";
if (!File.Exists(System.Web.HttpContext.Current.Server.MapPath(strPath)))
{
File.Create(System.Web.HttpContext.Current.Server.MapPath(strPath)).Close();
}
using (StreamWriter sWriter = File.AppendText(System.Web.HttpContext.Current.Server.MapPath(strPath)))
{
sWriter.WriteLine("\r\nLog Entry : ");
sWriter.WriteLine("{0}", DateTime.Now.ToString(CultureInfo.InvariantCulture));
string strError = "Error in: " + System.Web.HttpContext.Current.Request.Url.ToString() +
". Error Message:" + strErrorMessage;
sWriter.WriteLine(strError);
sWriter.WriteLine("__________________________");
sWriter.Flush();
sWriter.Close();
}
}
catch (Exception ex)
{
ErrorLogFile(ex.Message);
}

}
2)call this file catch block
clsLogFile.ErrorLogFile(ex.Message);

The same way we can track the mail sent details from the server.

Optimization

2009-05-21T22:21:00.000-07:00

# Try to restrict the queries result set by using the WHERE clause.
This can results in good performance benefits, because SQL Server will return to client only particular rows, not all rows from the table(s). This can reduce network traffic and boost the overall performance of the query.

# Try to restrict the queries result set by returning only the particular columns from the table, not all table's columns.
This can results in good performance benefits, because SQL Server will return to client only particular columns, not all table's columns. This can reduce network traffic and boost the overall performance of the query.

# Use views and stored procedures instead of heavy-duty queries.
This can reduce network traffic, because your client will send to server only stored procedure or view name (perhaps with some parameters) instead of large heavy-duty queries text. This can be used to facilitate permission management also, because you can restrict user access to table columns they should not see.

# Try to avoid using SQL Server cursors, whenever possible.
SQL Server cursors can result in some performance degradation in comparison with select statements. Try to use correlated subquery or derived tables, if you need to perform row-by-row operations.

# If you need to return the total table's row count, you can use alternative way instead of SELECT COUNT(*) statement.
Because SELECT COUNT(*) statement make a full table scan to return the total table's row count, it can take very many time for the large table. There is another way to determine the total row count in a table. You can use sysindexes system table, in this case. There is ROWS column in the sysindexes table. This column contains the total row count for each table in your database. So, you can use the following select statement instead of SELECT COUNT(*): SELECT rows FROM sysindexes WHERE id = OBJECT_ID('table_name') AND indid < 2 So, you can improve the speed of such queries in several times.
See this article for more details:
Alternative way to get the table's row count.

# Try to use constraints instead of triggers, whenever possible.
Constraints are much more efficient than triggers and can boost performance. So, you should use constraints instead of triggers, whenever possible.

# Use table variables instead of temporary tables.
Table variables require less locking and logging resources than temporary tables, so table variables should be used whenever possible. The table variables are available in SQL Server 2000 only.

# Try to avoid the HAVING clause, whenever possible.
The HAVING clause is used to restrict the result set returned by the GROUP BY clause. When you use GROUP BY with the HAVING clause, the GROUP BY clause divides the rows into sets of grouped rows and aggregates their values, and then the HAVING clause eliminates undesired aggregated groups. In many cases, you can write your select statement so, that it will contain only WHERE and GROUP BY clauses without HAVING clause. This can improve the performance of your query.

# Try to avoid using the DISTINCT clause, whenever possible.
Because using the DISTINCT clause will result in some performance degradation, you should use this clause only when it is necessary.

# Include SET NOCOUNT ON statement into your stored procedures to stop the message indicating the number of rows affected by a T-SQL statement.
This can reduce network traffic, because your client will not receive the message indicating the number of rows affected by a T-SQL statement.

# Use the select statements with TOP keyword or the SET ROWCOUNT statement, if you need to return only the first n rows.
This can improve performance of your queries, because the smaller result set will be returned. This can also reduce the traffic between the server and the clients.

# Use the FAST number_rows table hint if you need to quickly return 'number_rows' rows.
You can quickly get the n rows and can work with them, when the query continues execution and produces its full result set.

# Try to use UNION ALL statement instead of UNION, whenever possible.
The UNION ALL statement is much faster than UNION, because UNION ALL statement does not look for duplicate rows, and UNION statement does look for duplicate rows, whether or not they exist.

# Do not use optimizer hints in your queries.
Because SQL Server query optimizer is very clever, it is very unlikely that you can optimize your query by using optimizer hints, more often, this will hurt performance.

Localization

2009-05-21T04:23:00.000-07:00

To specify the culture (language basis to load the text) follow the below steps:

Default Folder which it's get creat by vs.net

App_GlobalResources

1)Create a resource file (Contactus.resx) it is common for English. based on the langeuage needs to specify the culture text name like (Contactus.it.resx- for itally,Contactus.de.resx - for detuch)
how ever the label's specify
2)
void Loadtext()
{
lblfname.Text = Resources.Contactus.lblfname;
lblsurname.Text = Resources.Contactus.lblsname;
lblemail.Text = Resources.Contactus.lblemail;
lblGender.Text = Resources.Contactus.lblgender;
lblphone.Text = Resources.Contactus.lblphone;
}

3) Call the above method on your page load event. based on the culture it's read from the App_GlobalResources.